GObject properties can still be set and accessed using get_gtk_property and set_gtk_property!. However, properties are now mapped onto Julia properties, so one can set a window title using win.title = "My title". Also, the submodule GAccessor no longer exists. In Gtk4.jl, getter and setter methods are in the main Gtk4 module, but most are not exported. Whereas in Gtk.jl one uses GAccessor.title(win, "My title") to set the title, in Gtk4.jl the equivalent is Gtk4.title(win, "My title").
GTK constants in Gtk4.jl are in the main module instead of a Constants submodule.
In Gtk.jl, GTK's enum and flags constants are turned into integers. In Gtk4.jl, these are now mapped onto Julia enums, specifically the implementations CEnum.jl for enums and BitFlags.jl for flags. This improves understandability when a function returns an enum or flag, but the downside is the sometimes extreme length of the enum's name. To mitigate this, convert methods are defined for commonly used enums so that shorter symbols can be used instead of the full enum name. For example, :h can be used instead of Gtk4.Orientation_HORIZONTAL in GtkBox(orientation, spacing).
In Gtk.jl, the submodule Gtk.GAccessor contains getter and setter methods, which often correspond to object properties. In Gtk4.jl, the submodule Gtk4.G_ contains automatically generated methods, which include all methods in GAccessor and many more. These methods directly call the C functions in libgtk and thus use 0-based indexing. Where possible, they translate between Julia types and C types, for example converting nothing to C_NULL and vice versa.
For consistency, the getter and setter methods in G_ keep their full names, including "set" and "get". For example, to set the title of a window in Gtk4.jl use G_.set_title(w, "text") rather than GAccessor.title(w, "text") as in Gtk.jl.
The equivalent of Gtk.ShortNames doesn't exist. All GObject types are mapped onto Julia types with the same name. Leaving out the namespace, as is done in the Python pygobject bindings, would have led to name collisions between Gtk types and Julia types or between Gtk and other GObject libraries.
In GTK 4, widgets are shown by default, so showall does not exist, and calling show is no longer necessary in most situations. Exceptions include GtkDialogs and GtkApplicationWindows.
In GTK 4, GtkContainer has been removed and most widgets derive directly from GtkWidget. Each class that can contain child widgets has its own functions for adding and/or removing them. In Gtk4.jl, collection interface methods like push! have been defined for containers that hold many widgets, such as GtkBox. For widgets that have one child, such as GtkWindow, getindex and setindex! have been defined, so that one can set a child widget using window[] = child.
The GTK docs have a migration guide with detailed recommendations for migrating C code from GTK version 3 to version 4. Much of that advice applies to Julia code.
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
Creates a binding between source_property on source and target_property on target. When source_property is changed, target_property will be updated to the same value. Returns a GBinding object that can be used to release the binding using unbind_property.
Add a Julia function f that will be called when there are no higher priority GTK events to be processed. This function can be used from any thread. The optional priority argument, which is an integer, sets the priority of the event source (smaller is higher priority). The GLib main loop uses this priority value to decide what sources to handle next.
Remove the event source identified by id from the GLib main loop. The id is returned by g_idle_add and g_timeout_add. The main loop reuses id's so care should be taken that the source intended to be removed is still active.
Add a function f that will be called every interval milliseconds by the GTK main loop. The function is expected to return a Cint. If it returns a nonzero value, the function will be called again after another interval milliseconds. Otherwise it will not be called again. The optional priority argument, which is an integer, sets the priority of the event source (smaller is higher priority). The GLib main loop uses this priority value to decide what sources to handle next.
This function returns an event source ID that can be used with g_source_remove to stop the timeout.
Create a function from an expression ex that will be called when there are no higher priority GTK events to be processed. This function can be used from any thread.
Change Gtk4.jl's libuv loop integration setting. The argument s should be "auto" to use Gtk4.jl's default setting or "enabled" or "disabled" to override this. This setting will take effect after restarting Julia.
Enabling libuv loop integration may improve REPL response on some platforms (Mac) but negatively impacts multithreaded performance. This function has no effect when running on Windows.
Stops the default GLib main loop after the next iteration. Does not affect loop operation if GApplication's run() method is being used instead of GLib.start_main_loop().
Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual.
Indicates a hint from the file system whether files should be previewed in a file manager. Returned as the value of the key %GFILEATTRIBUTEFILESYSTEMUSE_PREVIEW.
Integrating the launch with the launching application. This is used to handle for instance startup notification and launching the new application on the same screen as the launching window.
A #GApplication is the foundation of an application. It wraps some low-level platform-specific services and is intended to act as the foundation for higher-level application classes such as #GtkApplication or #MxApplication. In general, you should not use this class outside of a higher level framework.
#GApplicationCommandLine represents a command-line invocation of an application. It is created by #GApplication and emitted in the #GApplication::command-line signal and virtual function.
#GBinding is the representation of a binding between a property on a #GObject instance (or source) and another property on another #GObject instance (or target).
The #GCredentials type is a reference-counted wrapper for native credentials. This information is typically used for identifying, authenticating and authorizing other processes.
#GDBusActionGroup is an implementation of the #GActionGroup interface that can be used as a proxy for an action group that is exported over D-Bus with gdbusconnectionexportaction_group().
The #GDBusAuthObserver type provides a mechanism for participating in how a #GDBusServer (or a #GDBusConnection) authenticates remote peers. Simply instantiate a #GDBusAuthObserver and connect to the signals you are interested in. Note that new signals may be added in the future
The #GDBusConnection type is used for D-Bus connections to remote peers such as a message buses. It is a low-level API that offers a lot of flexibility. For instance, it lets you establish a connection over any transport that can by represented as a #GIOStream.
#GDBusMenuModel is an implementation of #GMenuModel that can be used as a proxy for a menu model that is exported over D-Bus with gdbusconnectionexportmenu_model().
Instances of the #GDBusMethodInvocation class are used when handling D-Bus method calls. It provides a way to asynchronously return results and errors.
#GDBusObjectManagerClient is used to create, monitor and delete object proxies for remote objects exported by a #GDBusObjectManagerServer (or any code implementing the org.freedesktop.DBus.ObjectManager interface).
#GDBusObjectManagerServer is used to export #GDBusObject instances using the standardized org.freedesktop.DBus.ObjectManager interface. For example, remote D-Bus clients can get all objects and properties in a single call. Additionally, any change in the object hierarchy is broadcast using signals. This means that D-Bus clients can keep caches up to date by only listening to D-Bus signals.
A #GDBusObjectProxy is an object used to represent a remote object with one or more D-Bus interfaces. Normally, you don't instantiate a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient is used to obtain it.
A #GDBusObjectSkeleton instance is essentially a group of D-Bus interfaces. The set of exported interfaces on the object may be dynamic and change at runtime.
#GDBusProxy is a base class used for proxies to access a D-Bus interface on a remote object. A #GDBusProxy can be constructed for both well-known and unique names.
#GDBusServer is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the org.freedesktop.DBus interface.
#GEmblem is an implementation of #GIcon that supports having an emblem, which is an icon with additional properties. It can than be added to a #GEmblemedIcon.
#GEmblemedIcon is an implementation of #GIcon that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured via gemblemediconaddemblem().
#GFileEnumerator allows you to operate on a set of #GFiles, returning a #GFileInfo structure for each file enumerated (e.g. gfileenumerate_children() will return a #GFileEnumerator for each of the children within a directory).
Functionality for manipulating basic metadata for files. #GFileInfo implements methods for getting information that all files should contain, and allows for manipulation of extended attributes.
Completes partial file and directory names given a partial string by looking in the file system for clues. Can return a list of possible completion strings for widget implementations.
Base class for input stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
Base class for output stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.
GIOStream represents an object that has both read and write streams. Generally the two streams act as separate input and output streams, but they share some common resources and state. For instance, for seekable streams, both streams may use the same position.
#GInetAddress represents an IPv4 or IPv6 internet address. Use gresolverlookupbyname() or gresolverlookupbynameasync() to look up the #GInetAddress for a hostname. Use gresolverlookupbyaddress() or gresolverlookupbyaddressasync() to look up the hostname for a #GInetAddress.
#GInetAddressMask represents a range of IPv4 or IPv6 addresses described by a base address and a length indicating how many bits of the base address are relevant for matching purposes. These are often given in string form. Eg, "10.0.0.0/8", or "fe80::/10".
#GInputStream has functions to read from a stream (ginputstreamread()), to close a stream (ginputstreamclose()) and to skip some content (ginputstream_skip()).
Structure used for scatter/gather data input. You generally pass in an array of #GInputVectors and the operation will store the read data starting in the first buffer, switching to the next as needed.
#GMenuModel represents the contents of a menu – an ordered list of menu items. The items are associated with actions, which can be activated through them. Items can be grouped in sections, and may have submenus associated with them. Both items and sections usually have some representation data, such as labels or icons. The type of the associated action (ie whether it is stateful, and what kind of state it has) can influence the representation of the item.
#GMountOperation provides a mechanism for interacting with the user. It can be used for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations. It can also be used to ask the user questions or show a list of applications preventing unmount or eject operations from completing.
#GNetworkAddress provides an easy way to resolve a hostname and then attempt to connect to that host, handling the possibility of multiple IP addresses and multiple address families.
Like #GNetworkAddress does with hostnames, #GNetworkService provides an easy way to resolve a SRV record, and then attempt to connect to one of the hosts that implements that service, handling service priority/weighting, multiple IP addresses, and multiple address families.
#GNotification is a mechanism for creating a notification to be shown to the user – typically as a pop-up notification presented by the desktop environment shell.
A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with goptioncontextaddmainentries() or goptiongroupadd_entries().
#GOutputStream has functions to write to a stream (goutputstreamwrite()), to close a stream (goutputstreamclose()) and to flush pending writes (goutputstream_flush()).
Structure used for scatter/gather data output. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.
#GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator and wraps them in #GProxyAddress instances, using the given #GProxyAddressEnumerator:proxy-resolver.
#GResolver provides cancellable synchronous and asynchronous DNS resolution, for hostnames (gresolverlookupbyaddress(), gresolverlookupbyname() and their async variants) and SRV (service) records (gresolverlookup_service()).
Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance #GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files, icons, etc. These are often shipped as files in $datadir/appname, or manually included as literal strings in the code.
Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token.
The #GSettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for #GSettings, you need to implement the #GSettingsBackend interface and then make it implement the extension point %GSETTINGSBACKENDEXTENSIONPOINT_NAME.
The #GSettingsSchemaSource and #GSettingsSchema APIs provide a mechanism for advanced control over the loading of schemas and a mechanism for introspecting their content.
A #GSimpleAction is the obvious simple implementation of the #GAction interface. This is the easiest way to create an action for purposes of adding it to a #GSimpleActionGroup.
GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and #GOutputStream. This allows any pair of input and output streams to be used with #GIOStream methods.
#GSimplePermission is a trivial implementation of #GPermission that represents a permission that is either always or never allowed. The value is given at construction and doesn't change.
#GSimpleProxyResolver is a simple #GProxyResolver implementation that handles a single default proxy, multiple URI-scheme-specific proxies, and a list of hosts that proxies should not be used for.
A #GSocket is a low-level networking primitive. It is a more or less direct mapping of the BSD socket API in a portable GObject based API. It supports both the UNIX socket implementations and winsock2 on Windows.
#GSocketAddress is the equivalent of struct sockaddr in the BSD sockets API. This is an abstract class; use #GInetSocketAddress for internet sockets, or #GUnixSocketAddress for UNIX domain sockets.
#GSocketAddressEnumerator is an enumerator type for #GSocketAddress instances. It is returned by enumeration functions such as gsocketconnectable_enumerate(), which returns a #GSocketAddressEnumerator to list each #GSocketAddress which could be used to connect to that #GSocketConnectable.
#GSocketConnection is a #GIOStream for a connected socket. They can be created either by #GSocketClient when connecting to a host, or by #GSocketListener when accepting a new client.
A #GSocketControlMessage is a special-purpose utility message that can be sent to or received from a #GSocket. These types of messages are often called "ancillary data".
A #GSocketService is an object that represents a service that is provided to the network or over local sockets. When a new connection is made to the service the #GSocketService::incoming signal is emitted.
SRV (service) records are used by some network protocols to provide service-specific aliasing and load-balancing. For example, XMPP (Jabber) uses SRV records to locate the XMPP server for a domain; rather than connecting directly to "example.com" or assuming a specific server hostname like "xmpp.example.com", an XMPP client would look up the "xmpp-client" SRV record for "example.com", and then connect to whatever host was pointed to by that record.
This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more.
A #GTcpWrapperConnection can be used to wrap a #GIOStream that is based on a #GSocket, but which is not actually a #GSocketConnection. This is used by #GSocketClient so that it can always return a #GSocketConnection, even when the connection it has actually created is not directly a #GSocketConnection.
#GThemedIcon is an implementation of #GIcon that supports icon themes. #GThemedIcon contains a list of all of the icons present in an icon theme, so that icons can be looked up quickly. #GThemedIcon does not provide actual pixmaps for icons, just the icon names. Ideally something like gtkiconthemechooseicon() should be used to resolve the list of names so that fallback icons work nicely with themes that inherit other themes.
A #GThreadedSocketService is a simple subclass of #GSocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the #GThreadedSocketService::run signal in the new thread.
A certificate used for TLS authentication and encryption. This can represent either a certificate only (eg, the certificate received by a client from a server), or the combination of a certificate and a private key (which is needed when acting as a #GTlsServerConnection).
#GTlsConnection is the base TLS connection class type, which wraps a #GIOStream and provides TLS encryption on top of it. Its subclasses, #GTlsClientConnection and #GTlsServerConnection, implement client-side and server-side TLS, respectively.
#GTlsDatabase is used to look up certificates and other information from a certificate or key store. It is an abstract base class which TLS library specific subtypes override.
#GTlsInteraction provides a mechanism for the TLS connection and database code to interact with the user. It can be used to ask the user for passwords.
This #GSocketControlMessage contains a #GCredentials instance. It may be sent using gsocketsendmessage() and received using gsocketreceivemessage() over UNIX sockets (ie: sockets in the %GSOCKETFAMILY_UNIX family).
This section introduces the GVariant type system. It is based, in large part, on the D-Bus type system, with two major changes and some minor lifting of restrictions. The D-Bus specification, therefore, provides a significant amount of information that is useful when working with GVariant.
#GVolumeMonitor is for listing the user interesting devices and volumes on the computer. In other words, what a file selector or file manager would show in a sidebar.
Return values from #GLogWriterFuncs to indicate whether the given log entry was successfully handled by the writer, or whether there was an error in handling it (and hence a fallback writer should be used).
A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %GMARKUPCOLLECT_OPTIONAL.
Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them.
The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: -x arg, with a long option: --name arg or combined in a single argument: --name=arg.
The type of record that gresolverlookuprecords() or gresolverlookuprecords_async() should retrieve. The records are returned as lists of #GVariant tuples. Each record type has different values in the variant tuples returned.
Flags used in gsocketreceivemessage() and gsocketsendmessage(). The flags listed in the enum are some commonly available flags, but the values used for them are the same as on the platform, and any other flags are passed in/out as is. So to use a platform specific flag, just include the right system header and pass in the flag.
A protocol identifier is specified when creating a #GSocket, which is a family/type specific identifier, where 0 means the default protocol for the particular family/type.
A set of flags describing TLS certification validation. This can be used to describe why a particular certificate was rejected (for example, in #GTlsConnection::accept-certificate).
The type of TLS channel binding data to retrieve from #GTlsConnection or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The tls-unique-for-telnet binding type is not currently implemented.
The TLS or DTLS protocol version used by a #GTlsConnection or #GDtlsConnection. The integer values of these versions are sequential to ensure newer known protocol versions compare greater than older known versions. Any known DTLS protocol version will compare greater than any SSL or TLS protocol version. The protocol version may be %GTLSPROTOCOLVERSIONUNKNOWN if the TLS backend supports a newer protocol version that GLib does not yet know about. This means that it's possible for an unknown DTLS protocol version to compare less than the TLS protocol versions.
The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript.
The type of name used by a #GUnixSocketAddress. %GUNIXSOCKETADDRESSPATH indicates a traditional unix domain socket bound to a filesystem path. %GUNIXSOCKETADDRESSANONYMOUS indicates a socket not bound to any name (eg, a client-side socket, or a socket created with socketpair()).
Flags describing what parts of the URI to hide in guritostringpartial(). Note that %GURIHIDEPASSWORD and %GURIHIDEAUTH_PARAMS will only work if the #GUri was parsed with the corresponding flags.
These are logical ids for special directories which are defined depending on the platform used. You should use ggetuserspecialdir() to retrieve the full path associated to the logical id.
A good size for a buffer to be passed into gasciidtostr(). It is guaranteed to be enough for all output of that function on systems with 64bit IEEE-compatible doubles.
The value returned by handlers of the signals generated by the gdbus-codegen tool to indicate that a method call has been handled by an implementation. It is equal to %TRUE, but using this macro is sometimes more readable.
The value returned by handlers of the signals generated by the gdbus-codegen tool to indicate that a method call has not been handled by an implementation. It is equal to %FALSE, but using this macro is sometimes more readable.
A key in the "standard" namespace for checking if the file is a symlink. Typically the actual type is something else, if we followed the symlink to get the type.
A key in the "standard" namespace for checking if a file is volatile. This is meant for opaque, non-POSIX-like backends to indicate that the URI is not persistent. Applications should look at %GFILEATTRIBUTESTANDARDSYMLINK_TARGET for the persistent URI.
A key in the "time" namespace for getting the nanoseconds of the time the file was last accessed. This should be used in conjunction with #GFILEATTRIBUTETIMEACCESS. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.
A key in the "time" namespace for getting the nanoseconds of the time the file was last changed. This should be used in conjunction with #GFILEATTRIBUTETIMECHANGED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.
A key in the "time" namespace for getting the nanoseconds of the time the file was created. This should be used in conjunction with #GFILEATTRIBUTETIMECREATED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.
A key in the "time" namespace for getting the nanoseconds of the time the file was last modified. This should be used in conjunction with #GFILEATTRIBUTETIMEMODIFIED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.
This is the platform dependent conversion specifier for scanning and printing values of type #gint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier.
The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint16 or #guint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier and append a conversion specifier.
The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint32 or #guint32. It is a string literal. See also %GGINT16MODIFIER.
The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gintptr or #guintptr. It is a string literal.
The position of the first bit which is not reserved for internal use be the #GHook implementation, i.e. 1 << G_HOOK_FLAG_USER_SHIFT is the first bit which can be used for application-defined flags.
The name of the main group of a desktop entry file, as defined in the Desktop Entry Specification. Consult the specification for more details about the meanings of the keys below.
A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the command line to execute. It is only valid for desktop entries with the Application type.
A key under %GKEYFILEDESKTOPGROUP, whose value is a string containing the working directory to run the program in. It is only valid for desktop entries with the Application type.
A key under %GKEYFILEDESKTOPGROUP, whose value is string identifying the WM class or name hint of a window that the application will create, which can be used to emulate Startup Notification with older applications.
A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the file name of a binary on disk used to determine if the program is actually installed. It is only valid for desktop entries with the Application type.
The menu item attribute which holds the action name of the item. Action names are namespaced with an identifier for the action group in which the action resides. For example, "win." for window-specific actions and "app." for application-wide actions.
The name of the link that associates a menu item with a section. The linked menu will usually be shown in place of the menu item, using the item's label as a header.
If a long option in the main group has this name, it is not treated as a regular option. Instead it collects all non-option arguments which would otherwise be left in argv. The option must be of type %GOPTIONARGCALLBACK, %GOPTIONARGSTRINGARRAY or %GOPTIONARGFILENAME_ARRAY.
Creates a unique temporary directory for each unit test and uses gsetuserdirs() to set XDG directories to point into subdirectories of it for the duration of the unit test. The directory tree is cleaned up after the test finishes successfully. Note that this doesn’t take effect until gtestrun() is called, so calls to (for example) ggetuserhome_dir() will return the system-wide value when made in a test program’s main() function.
If passed to GVALUECOLLECT(), allocated data won't be copied but used verbatim. This does not affect ref-counted types like objects. This does not affect usage of gvaluecopy(), the data will be copied if it is not ref-counted.
A macro that should be defined by the user prior to including the glib.h header. The definition should be one of the predefined GLib version macros: %GLIBVERSION226, %GLIBVERSION228,...
Create a dialog with a message question and two buttons "No" and "Yes". Returns true if "Yes" is selected and false if "No" is selected or the dialog (or its parent window parent) is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and false will be returned.
Sets a cursor c when the mouse pointer is over a widget w, where c can be a GdkCursor or a string to specify a name. If c is nothing, use the default cursor for w.
Set win to fullscreen mode on a particular monitor mon. The windowing system (outside GTK's control) may not allow this, so it may not work on some platforms.
Create a dialog with an informational message message. Returns when the dialog (or its parent window parent) is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and false will be returned.
Create a dialog with a message message and a text entry. Returns the string in the entry when the "Accept" button is pressed, or entry_default if "Cancel" is pressed or the dialog or its parent window parent is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and entry_default will be returned.
Create a dialog for choosing a file or folder to be opened. Returns the path chosen by the user, or "" if "Cancel" is pressed or the dialog or its parent window parent is closed. The dialog title is set using title. The argument filters can be used to show only directory contents that match certain file extensions.
Keyword arguments: timeout: The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and "" will be returned. multiple: if true, multiple files can be selected, and a list of file paths is returned rather than a single path. start_folder: if set, the dialog will start out browsing a particular folder. Otherwise GTK will decide.
Presents a window to the user. Usually means move it to the front. According to the GTK docs, this function "should not be used" without including a timestamp for the user's request.
Create a dialog for choosing a file to be saved to. Returns the path chosen by the user, or "" if "Cancel" is pressed or the dialog or its parent window parent is closed. The window title is set using title. The argument filters can be used to show only directory contents that match certain file extensions.
Keyword arguments: timeout: The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and "" will be returned. start_folder: if set, the dialog will start out browsing a particular folder. Otherwise GTK will decide.
Returns a tuple (width,height) that gives the primary monitor size for the display where widget is being displayed, or the default display if widget is unrealized or not given.
search(buffer::GtkTextBuffer, str::AbstractString, direction = :forward,
+ flag = GtkTextSearchFlags.GTK_TEXT_SEARCH_TEXT_ONLY)
Search text str in buffer in direction :forward or :backward starting from the cursor position in the buffer.
Returns a tuple (found, start, stop) where found indicates whether the search was successful and start and stop are _GtkTextIters containing the location of the match.
Returns a tuple (selected, start, stop) indicating if text is selected in the buffer, and if so sets the _GtkTextIter start and stop to point to the selected text.
Loads all GtkBuildable objects from a GtkBuilder object and assigns them to Julia variables in the current scope. GtkBuilder ID's are mapped onto Julia variable names.
find_controller(w::GtkWidget, ::Type{T}) where T <: GtkEventController
Returns an event controller of type T connected to a widget, or nothing if one doesn't exist. This function is intended for testing purposes (to simulate events) and is not recommended otherwise, as there is a performance penalty for creating a list of a widget's event controllers.
Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a natural size for children calling. See [func@distributenaturalallocation].
The GtkTreeIter is the primary structure for accessing a GtkTreeModel. Models are expected to put a unique integer in the @stamp member, and put model-specific data in the three @user_data members.
The sizing method the column uses to determine its width. Please note that %GTKTREEVIEWCOLUMNAUTOSIZE are inefficient for large views, and can make columns appear choppy.
Like [func@getinterfaceage], but from the headers used at application compile time, rather than from the library linked against at application run time.
Like [func@getmajorversion], but from the headers used at application compile time, rather than from the library linked against at application run time.
Like [func@getmicroversion], but from the headers used at application compile time, rather than from the library linked against at application run time.
Like [func@getminorversion], but from the headers used at application compile time, rather than from the library linked against at application run time.
It is possible to perform background computation without interfering with user interface responsiveness either using multithreading or using separate processes. Use of a separate process includes slightly more overhead but also ensures user interface responsiveness more robustly.
Here is an example using threads. Notice that this example will freeze the UI during computation unless Julia is run with two or more threads (julia -t2 on the command line).
using Gtk4
+
+btn = GtkButton("Start")
+sp = GtkSpinner()
+ent = GtkEntry()
+
+grid = GtkGrid()
+grid[1,1] = btn
+grid[2,1] = sp
+grid[1:2,2] = ent
+
+signal_connect(btn, "clicked") do widget
+ start(sp)
+ Threads.@spawn begin
+
+ # Do work
+ stop_time = time() + 3
+ counter = 0
+ while time() < stop_time
+ counter += 1
+ end
+
+ # Interacting with GTK from a thread other than the main thread is
+ # generally not allowed, so we register an idle callback instead.
+ Gtk4.GLib.g_idle_add() do
+ stop(sp)
+ ent.text = "I counted to $counter in a thread!"
+ Cint(false)
+ end
+ end
+end
+
+win = GtkWindow(grid, "Threads", 200, 200)
Here is an example using a separate process to offload the work. This toy example is fairly straightforward, but things can get more complex if the offloaded task is more complex. See the manual for details.
using Gtk4, Distributed
+
+btn = GtkButton("Start")
+sp = GtkSpinner()
+ent = GtkEntry()
+
+grid = GtkGrid()
+grid[1,1] = btn
+grid[2,1] = sp
+grid[1:2,2] = ent
+
+id = addprocs(1)[1]
+
+signal_connect(btn, "clicked") do widget
+ start(sp)
+ @async begin
+
+ # Offload work to a separate process and block until it is done.
+ counter = @fetchfrom id begin
+ stop_time = time() + 3
+ counter = 0
+ while time() < stop_time
+ counter += 1
+ end
+ counter
+ end
+
+ # We are still in the main thread so it is okay to directly access widgets
+ stop(sp)
+ ent.text = "I counted to $counter in a separate process!"
+ end
+end
+
+win = GtkWindow(grid, "Distributed", 200, 200)
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
diff --git a/v0.4.2/howto/nonreplusage/index.html b/v0.4.2/howto/nonreplusage/index.html
new file mode 100644
index 00000000..b41ed70a
--- /dev/null
+++ b/v0.4.2/howto/nonreplusage/index.html
@@ -0,0 +1,33 @@
+
+Using Gtk4 outside the REPL · Gtk4.jl
If you're using Gtk4 from command-line scripts, the following design prevents Julia from quitting before you have a chance to see or interact with your windows:
using Gtk4
+win = GtkWindow("gtkwait")
+
+# Put your GUI code here
+
+if !isinteractive()
+ c = Condition()
+ signal_connect(win, :close_request) do widget
+ notify(c)
+ end
+ @async Gtk4.GLib.glib_main()
+ wait(c)
+end
By waiting on a Condition, Julia will keep running until a signal handler calls notify(c). This pattern allows for multiple events to trigger the condition, such as a button press, or one of many windows to be closed. Program flow will resume at the wait line, after which it would terminate in this example.
In the common case that we simply wish to wait for a single window to be closed, this can be shortened by using waitforsignal:
using Gtk4
+win = GtkWindow("gtkwait")
+
+# Put your GUI code here
+
+if !isinteractive()
+ @async Gtk4.GLib.glib_main()
+ Gtk4.GLib.waitforsignal(win,:close_request)
+end
For larger projects, you may want to use GtkApplication, which enables useful functionality based around GtkApplicationWindow, GAction, GActionMap, etc. For that you can use the following pattern:
In the activate function, you can create your windows, widgets, etc. and connect them to signals. When all GtkApplicationWindows have been closed, the script will exit.
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
This package was adapted from Gtk.jl, which was written by Jameson Nash and others and supported GTK versions 2 and 3. With version 4 there were so many changes to the GTK API that it would have been messy to try to support it and previous versions in the same package. Note that much of the GLib/GObject functionality that underlies GTK is largely the same code as in Gtk.jl. Some changes were made to try to take better advantage of GObject introspection or to remove old code that was no longer necessary in recent versions of Julia.
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
Until now we have created and arranged all widgets entirely using Julia code. While this works fine for small examples, it has the issue that we are tightly coupling the appearance of our application with the logic of our program code.
There is an alternative way to design user interfaces that strictly separates the layout from the code. This is done by an XML based file format that allows for describing any arrangement of widgets. In order to use the interface in your Julia Gtk4 application you will need GtkBuilder.
For GTK version 3 and earlier, Glade is often used as a GUI tool for creating GtkBuilder XML files in a WYSIWYG (what you see is what you get) manner, but Glade wasn't ported to GTK version 4. Instead Cambalache can be used (or the XML can be created by hand).
Once we have created the XML interface the result can be stored in an XML file that usually has the extension .ui. Let's assume we have created a file myapp.ui that looks like
In order to access the widgets from Julia we first create a GtkBuilder object that will serve as a connector between the XML definition and our Julia code.
b = GtkBuilder("path/to/myapp.ui")
Alternatively, if we store the above XML definition in a Julia string myapp we can initialize the builder by
b = GtkBuilder(myapp, -1)
Now we want to access a widget from the XML file in order to actually display it on the screen. To do so we can call
win = b["window1"]
for each widget we want to access in our Julia code. Widgets that we don't need to access from Julia, for example layout widgets like GtkBox that are being used only to arrange more interesting widgets for input or display, do not need to be loaded. You can thus see your builder as a kind of a widget store that you use when you need access to your widgets.
Note
If you are developing the code in a package you can get the package directory using the @__DIR__ macro. For instance, if your UI file is located at MyPackage/src/builder/myuifile.ui, you can get the full path using uifile = joinpath(@__DIR__, "builder", "myuifile.ui").
In Gtk4.jl a macro @load_builder is defined that iterates over the GtkWidgets in a GtkBuilder object and automatically assigns them to Julia variables with the same id. For example, if a GtkEntry with an id entry1 and two GtkButtons with id's button1 and button2 are present in myapp.ui, calling
Note that this only works for GtkWidgets that implement the interface GtkBuildable, which excludes some objects often defined in UI files, for example GtkAdjustment. Those objects will have to be fetched using calls to get_object.
The XML file lets us only describe the visual structure of our widgets and not their behavior when the using is interacting with it. For this reason, we will have to add callbacks to the widgets which we do in Julia code as it was described in Signals and Callbacks.
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
diff --git a/v0.4.2/manual/canvas/index.html b/v0.4.2/manual/canvas/index.html
new file mode 100644
index 00000000..7ca21a9a
--- /dev/null
+++ b/v0.4.2/manual/canvas/index.html
@@ -0,0 +1,44 @@
+
+Drawing with Cairo · Gtk4.jl
Cairo based drawing can be done on Gtk4.jl's GtkCanvas widget, which is based on GTK's GtkDrawingArea. The canvas widget comes with a backing store (a Cairo image surface). You control what is drawn on this backing store by defining a draw function:
This draw function will be called each time the window is resized or otherwise needs to refresh its display. If you need to force a redraw of the canvas, you can call reveal on the canvas widget.
Errors in the draw function can corrupt Gtk4's internal state; if this happens, you have to quit julia and start a fresh session. To avoid this problem, the @guarded macro wraps your code in a try/catch block and prevents the corruption. It is especially useful when initially writing and debugging code.
Mouse events can be handled using event controllers. The event controller for mouse clicks is GtkGestureClick. We first create this event controller, then add it to the widget using push!.
This will draw a green circle on the canvas at every mouse click. Resizing the window will make them go away; they were drawn on top of the canvas one by one, but they weren't added to the draw function, which is what is called when the widget is refreshed.
In the example above, the canvas was the direct child of the window, and its size is determined by the window size. If you instead make the canvas a child of one of GTK's layout widgets, like GtkBox or GtkGrid, it doesn't appear because by default, the drawing area widget does not expand to fill the space available. You can override this by setting the canvas's properties vexpand and hexpand to true. Alternatively, if you want to set the canvas to have a minimum width and height in pixels, you can set its properties content_width and content_height.
You can perform computations only when the widget is resized by connecting to the "resize" signal.
A more complicated example can be found in the "examples" subdirectory. For interactive plots, you can try Gtk4Makie.jl, which draws GLMakie plots onto GTK's GtkGLArea widget.
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
A simple option that was introduced in GTK version 4 is GtkDropDown. An example is shown below.
using Gtk4
+
+choices = ["one", "two", "three", "four"]
+dd = GtkDropDown(choices)
+# Let's set the active element to be "two", keeping in mind that the "selected" property uses 0 based indexing
+dd.selected = 1
+
+signal_connect(dd, "notify::selected") do widget, others...
+ # get the active index
+ idx = dd.selected
+ # get the active string
+ str = Gtk4.selected_string(dd)
+ println("Active element is \"$str\" at index $idx")
+end
+
+win = GtkWindow("DropDown Example",400,200)
+push!(win, dd)
A search entry can be added using Gtk4.enable_search(dd, true).
To change the list of options after the dropdown widget is created, you can use
The older API for dropdown menu functionality is GtkComboBox. The full, generic GtkComboBox widget is powerful but harder to use and won't be covered here. The simpler GtkComboBoxText subtype allows the user to select from text options.
The following example shows how to fill a GtkComboBoxText with elements and listen on the changed event (this example is functionally equivalent to the example above for GtkDropDown):
using Gtk4
+
+cb = GtkComboBoxText()
+choices = ["one", "two", "three", "four"]
+for choice in choices
+ push!(cb,choice)
+end
+# Let's set the active element to be "two"
+cb.active = 1
+
+signal_connect(cb, "changed") do widget, others...
+ # get the active index
+ idx = cb.active
+ # get the active string
+ str = Gtk4.active_text(cb)
+ println("Active element is \"$str\" at index $idx")
+end
+
+win = GtkWindow("ComboBoxText Example",400,200)
+push!(win, cb)
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
Gtk4.jl supports GtkMessageDialog and provides several convenience functions: info_dialog, ask_dialog, warn_dialog, and error_dialog. Each takes a string for a message to show and an optional parent container, and returns nothing, except for ask_dialog which returns true if the user clicks the button corresponding to yes.
For all dialog convenience functions, there are two ways of using them. For use in the REPL or an interactive script, the following forms can be used:
info_dialog("Julia rocks!")
+ask_dialog("Do you like chocolate ice cream?", "Not at all", "I like it") && println("That's my favorite too.")
+warn_dialog("Oops!... I did it again")
These take an optional argument timeout (in seconds) that can be used to make the dialog disappear after a certain time.
In callbacks (for example when a user clicks a button in a GUI), you can use a different form, which takes a callback as the first argument that will be called when the user closes the dialog. A full example:
If you are using these functions in the context of a GUI, you should set the third argument of info_dialog, parent, to be the top-level window. Otherwise, for standalone usage in scripts, do not set it.
The callback can alternatively be constructed using Julia's do syntax:
info_dialog("Julia rocks!", win) do
+ println("message received")
+end
A common reason to use a dialog is to allow the user to pick a file to be opened or saved to. For this Gtk4.jl provides the functions open_dialog for choosing an existing file or directory to be opened and save_dialog for choosing a filename to be saved to. These use GtkFileChooserNative, which uses the operating system's native dialogs where possible. The syntax of these functions is similar to the message dialogs. For a callback in a GUI (for an "Open File" button, for example), you can use
function f(filename)
+ # do something with the file
+end
+
+open_dialog(f, "Pick a file to open", parent)
The function f is called with the file's path as its argument when the user selects the file and clicks "OK". If the user clicks "Cancel", f is called with "" as its argument. Julia's do syntax can be used to construct the function f in a convenient way:
open_dialog("Pick a file to open", parent) do filename
+ # call a function here to do something with the file
+end
Multiple files can be opened by setting the multiple keyword argument:
open_dialog("Pick files to open", parent; multiple = true) do filenames
+ # call a function here to do something with files
+end
In this case filenames is a list of paths.
The dialog can be preset to a particular directory using the optional argument start_folder:
open_dialog(f, "Pick a file to open", parent; start_folder = "/data")
Filters can be used to limit the type of files that the user can pick. Filters can be specified as a Tuple or Vector. A filter can be specified as a string, in which case it specifies a globbing pattern, for example "*.png". You can specify multiple match types for a single filter by separating the patterns with a comma, for example "*.png,*.jpg". You can alternatively specify MIME types, or if no specification is provided it defaults to types supported by GdkPixbuf. The generic specification of a filter is
GtkFileFilter(pattern = "", mimetype = "")
A human-readable name can optionally be provided using a keyword argument.
If on the other hand you want to choose a folder instead of a file, use select_folder = true in open_dialog:
dir=Ref{String}()
+open_dialog("Select Dataset Folder"; select_folder = true) do name
+ dir[] = name
+end
+
+if isdir(dir[])
+ # do something with dir
+end
We start this tutorial with a very simple example that creates an empty window of size 400x200 pixels and adds a button to it
using Gtk4
+
+win = GtkWindow("My First Gtk4.jl Program", 400, 200)
+
+b = GtkButton("Click Me")
+push!(win,b)
+
+show(win)
We will now go through this example step by step. First the package is loaded using Gtk4 statement. Then a window is created using the GtkWindow constructor. It gets as input the window title, the window width, and the window height. Then a button is created using the GtkButton constructor. In order to insert the button into the window we call
push!(win,b)
Since a GtkWindow can have only one child widget, we could have added the button to the window using
win[] = b
Finally, show(win) makes the window visible. This could also have been accomplished using the visible property (GObject properties are discussed on the Properties section of this manual).
We will now extend the example to let the button actually do something. To this end we first define a callback function that will be executed when the user clicks the button. Our callback function just prints a message.
function on_button_clicked(w)
+ println("The button has been clicked")
+end
What happens when the user clicks the button is that a "clicked" signal is emitted. In order to connect this signal to our function on_button_clicked we have to call
signal_connect(on_button_clicked, b, "clicked")
Our full extended example thus looks like:
using Gtk4
+
+win = GtkWindow("My First Gtk4.jl Program", 400, 200)
+
+b = GtkButton("Click Me")
+push!(win,b)
+
+function on_button_clicked(w)
+ println("The button has been clicked")
+end
+signal_connect(on_button_clicked, b, "clicked")
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
To capture a keyboard event, one can add a GtkEventControllerKey to a widget (for example, a window) and add a callback, as shown in the following example.
using Gtk4
+
+win = GtkWindow("Key Press Example")
+eck = GtkEventControllerKey(win)
+
+signal_connect(eck, "key-pressed") do controller, keyval, keycode, state
+ println("You pressed key ", keyval, " which is '", Char(keyval), "'.")
+end
You can then check if event.keyval has a certain value and invoke an action in that case.
The following example captures the events for both a key press and a key release and reports the time duration between the two. There is some state handling here because of the likely event that your keyboard is set to "repeat" a pressed key after some initial delay and because it is possible to press multiple keys at once. This version reports the time elapsed between the initial key press and the key release.
using Gtk4
+
+const start_times = Dict{UInt32, UInt32}()
+
+w = GtkWindow("Key Press/Release Example")
+eck = GtkEventControllerKey(w)
+
+id1 = signal_connect(eck, "key-pressed") do controller, keyval, keycode, state
+ if keyval ∉ keys(start_times)
+ start_times[keyval] = Gtk4.current_event_time(controller) # save the initial key press time
+ println("You pressed key ", keyval, " which is '", Char(keyval), "'.")
+ else
+ println("repeating key ", keyval)
+ end
+end
+
+id2 = signal_connect(eck, "key-released") do controller, keyval, keycode, state
+ start_time = pop!(start_times, keyval) # remove the key from the dictionary
+ event = Gtk4.current_event(controller)
+ duration = Gtk4.time(event) - start_time # key press duration in milliseconds
+ println("You released key ", keyval, " after time ", duration, " msec.")
+end
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
The simplest layout widget is the GtkBox. It is one-dimensional and can be either be horizontally or vertical aligned.
win = GtkWindow("New title")
+hbox = GtkBox(:h) # :h makes a horizontal layout, :v a vertical layout
+push!(win, hbox)
+cancel = GtkButton("Cancel")
+ok = GtkButton("OK")
+push!(hbox, cancel)
+push!(hbox, ok)
This layout may not be exactly what you'd like. Perhaps you'd like the OK button to fill the available space, and to insert some blank space between them:
ok.hexpand = true
+hbox.spacing = 10
The first line sets the hexpand property of the ok button within the hbox container. In GTK4, a separate vexpand property controls whether the widget expands in the vertical direction. The second line sets the spacing property of hbox to 10 pixels.
Note that these aren't evenly sized, and that doesn't change if we set the cancel button's hexpand property to true. The homogeneous property of hbox can be used to achieve this.
hbox.homogeneous = true
To add a line between widgets in a GtkBox, you can use GtkSeparator.
sep = GtkSeparator(:h)
+push!(hbox, sep)
+# add more widgets here
To create two-dimensional (tabular) layouts of widgets, you can use GtkGrid:
win = GtkWindow("A new window")
+g = GtkGrid()
+a = GtkEntry() # a widget for entering text
+a.text = "This is Gtk!"
+b = GtkCheckButton("Check me!")
+c = GtkScale(:h, 0:10) # a slider
+
+# Now let's place these graphical elements into the Grid:
+g[1,1] = a # Cartesian coordinates, g[x,y]
+g[2,1] = b
+g[1:2,2] = c # spans both columns
+g.column_homogeneous = true # grid forces columns to have the same width
+g.column_spacing = 15 # introduce a 15-pixel gap between columns
+push!(win, g)
The g[x,y] = obj assigns the location to the indicated x,y positions in the grid (note that indexing is Cartesian rather than row/column; most graphics packages address the screen using Cartesian coordinates where 1,1 is in the upper left). A range is used to indicate a span of grid cells. By default, each row/column will use only as much space as required to contain the objects, but you can force them to be of the same size by setting properties like column_homogeneous.
The GtkCenterBox widget can hold 3 widgets in a line, either horizontally or vertically oriented. It keeps the middle widget centered. Child widgets can be set and accessed like this:
cb = GtkCenterBox(:h) # :h makes a horizontal layout, :v a vertical layout
+cb[:start] = GtkButton("Left")
+cb[:center] = GtkButton("Center")
+cb[:end] = GtkButton("Right")
For vertical orientation, :start refers to the top widget and :end to the bottom widget.
The GtkPaned widget creates two slots separated by a movable divider. Like GtkBox and GtkCenterBox, it can be oriented either vertically or horizontally. To add child widgets, you can use
The GtkNotebook widget places child widgets in tabs like a browser window. Child widgets can be inserted with a label like this:
nb = GtkNotebook()
+vbox = GtkBox(:v)
+hbox = GtkBox(:h)
+push!(nb, vbox, "Vertical") # here "Vertical" is the label for the tab
+push!(nb, hbox, "Horizontal")
The GtkStack widget is a lot like GtkNotebook, but a separate widget GtkStackSwitcher controls what page is shown. An interface very similar to GtkNotebook is defined:
s = GtkStack()
+sw = GtkStackSwitcher()
+vbox = GtkBox(:v)
+push!(vbox, sw)
+push!(vbox, s)
+push!(s, GtkLabel("First label"), "id1", "Label 1") # first string is an id, second is a label
+push!(s, GtkLabel("Second label"), "id2", "Label 2") # widget can be retrieved using s[id]
The GtkTreeView is a very powerful widget for displaying table-like or hierarchical data. It is used for both lists and trees.
The power of this widget comes with a slightly more complex design that one has to understand when using the widget. The most important thing is that the widget itself does not store the displayed data. Instead there are dedicated GtkListStore and GtkTreeStore containers that will hold the data. The benefit of this approach is that it is possible to decouple the view from the data:
The widget automatically updates when adding, removing or editing data from the store
The widget can sort its data without modifications in the store
Columns can be reordered and resized
Filtering can be used to show only subsets of data
We will in the following introduce both widgets based on small and a more complex example.
Lets start with a very simple example: A table with three columns representing the name, the age and the gender of a person. Each column must have a specific type. Here, we chose to represent the gender using a boolean value where true represents female and false represents male. We thus initialize the list store using
Now we actually want to display our data. To this end we create a tree view object
tv = GtkTreeView(GtkTreeModel(ls))
Then we need specific renderers for each of the columns. Usually you will only need a text renderer, but in our example we want to display the boolean value using a checkbox.
Usually the interesting bit of a list will be the entry being selected. This is done using an additional GtkTreeSelection object that can be retrieved by
selection = Gtk4.selection(tv)
One either have single selection or multiple selections. We toggle this by calling
Gtk4.mode(selection,Gtk4.SelectionMode_MULTIPLE)
For single selection, if we want to know the index of the selected item we can use
julia> ls[selected(selection),1]
+"Pete"
For multiple selection, we can get a list of selected rows using selected_rows, which can be used to index the GtkListStore
julia> [ls[x,1] for x in selected_rows(selection)]
+3-element Vector{String}:
+ "Susanne"
+ "Pete"
+ "Paul"
Since it can happen that no item has been selected at all, it is a good idea to put this into an if statement
if hasselection(selection)
+ # do something with selected(selection)
+end
Sometimes you want to invoke an action of an item is selected. This can be done by
signal_connect(selection, "changed") do widget
+ if hasselection(selection)
+ currentIt = selected(selection)
+
+ # now you can to something with the selected item
+ println("Name: ", ls[currentIt,1], " Age: ", ls[currentIt,1])
+ end
+end
Another useful signal is "row-activated" that will be triggered by a double click of the user.
A very useful thing is to apply a filter to a list view such that only a subset of data is shown. We can do this using the GtkTreeModelFilter type. It is as the GtkListStore a GtkTreeModel and therefore we can assign it to a tree view. So the idea is to wrap a GtkListStore in a GtkTreeModelFilter and assign that to the tree view.
Next question is how to decide which row of the list store should be shown and which shouldn't. We will do this by adding an additional column to the list store that is hidden. The column will be of type Bool and a value true indicates that the entry is to be shown while false indicates the opposite. We make the filtering based on this column by a call to Gtk4.visible_column. The full example now looks like this:
You can see that we have added a little search bar such that you can see the filtering in action. It is furthermore important to note that we had to replace ls with GtkTreeModel(tmFiltered) in the selection changed callback since the selection will give an iterator that is only valid in the filtered tree model.
Like Gtk.jl, the purpose of this package is to provide functions that wrap ccall's of GTK functions in a Julian and hopefully user friendly way. While in Gtk.jl these ccall's are handwritten, in Gtk4.jl most of the wrappers call automatically generated methods that contain the ccall's. If you don't see a particular functionality wrapped, you can call these autogenerated functions yourself by using a submodule G_ defined in each of the main modules (Gtk4, Pango, GLib, and GdkPixbufLib). The names of these functions and methods are intended to be easy to predict from the corresponding C library function names, and most are the same as in the pygobject bindings for GTK.
The autogenerated methods in G_, like the corresponding C functions, use 0-based indexing, while the more user-friendly wrappers outside G_ use 1-based indexing. Some types of methods are not yet supported. For example, methods involving callbacks must be wrapped by using ccall currently.
The following table lists a few examples that should give you an idea of how these work.
C function has a return value ret in addition to output arguments _path, _column, _cell_x, and _cell_y. The Julia method returns (ret, _path, _column, _cell_x, _cell_y)
If you are confused about what one of these automatically generated methods does, you can examine the code, which is defined in the src/gendirectory. They are separated into "methods" (in an object-oriented sense, these are functions associated with a particular class) and "functions" (general C functions that aren't associated with a particular class). Constants and struct definitions are also generated using GObject introspection.
This shows you a list of properties of the object and their current values. All GTK widgets, including windows, are subtypes of GObject, which have various properties that control how the widgets are displayed. For example, notice that the title property is set to "My window". In this package, GObject properties are mapped onto Julia properties. We can change the title in the following way:
julia> win.title = "New title"
To get the title we can use:
julia> title = win.title
+"New title"
We can also use set_gtk_property! and get_gtk_property! to set or get GObject properties:
julia> set_gtk_property!(win, :title, "New title")
+julia> get_gtk_property(win, :title)
+"New title"
To get the property in a type stable way, you can specify the return type:
To access particular properties using set_gtk_property! or get_gtk_property, you can either use symbols, like :title, or strings, like "title". When using symbols, you'll need to convert any Gtk property names that use - into names with _:
Properties that are string-valued or GObject-valued can be set to nothing, which is equivalent to setting them to NULL in C (or None in Python). A list of all possible property names for a GObject instance is returned by gtk_propertynames.
Properties can be set using keyword arguments in most constructors:
Information about a property, including a description, its GLib type and default value, can be found using propertyinfo:
julia> propertyinfo(win, :title)
+Name: title
+GType name: gchararray
+Flags: Readable Writable
+Description: The title of the window
+Default value: nothing
+Current value: nothing
Some properties have corresponding getter and setter C methods. It's recommended that you use these when they exist, as they are a little faster and type stable. For example the function visible gets or sets the property "visible" of a GtkWidget:
This sequence makes the window disappear and then reappear.
The most important accessors are exported from Gtk4 but the more obscure will have to be called including the module name. For example, the property resizable for a GtkWindow, which controls whether a user is allowed to resize the window, can be set using
Properties can be bound to one another through the GObject signal system using the method bind_property. For example, if one wanted the title of a window win2 to automatically track that of another window win1, one could use
julia> b = bind_property(win1, "title", win2, "title")
Now if one calls
julia> win1.title = "New title"
the title of win2 is automatically updated to the same value. The binding can be released using unbind_property(b).
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
diff --git a/v0.4.2/manual/signals/index.html b/v0.4.2/manual/signals/index.html
new file mode 100644
index 00000000..3d9ce05a
--- /dev/null
+++ b/v0.4.2/manual/signals/index.html
@@ -0,0 +1,44 @@
+
+Signals and Callbacks · Gtk4.jl
A button is not much use if it doesn't do anything. GTK uses signals as a method for communicating that something of interest has happened. Most signals will be emitted as a consequence of user interaction: clicking on a button, closing a window, or just moving the mouse. You connect your signals to particular functions to make something happen.
Here, button_clicked_callback is a callback function, something designed to be called by GTK to implement the response to user action. You use the signal_connect function to specify when it should be called: in this case, when widget b (your button) emits the "clicked" signal.
Using Julia's do syntax, the exact same code could alternatively be written as
b = GtkButton("Press me")
+win = GtkWindow(b, "Callbacks")
+id = signal_connect(b, "clicked") do widget
+ println(widget, " was clicked!")
+end
If you try this, and click on the button, you should see something like the following:
Notice that both of the callback functions executed! GTK allows you to define multiple signal handlers for a given object; even the execution order can be specified. Callbacks for some signals require that you return an Int32, with value 0 if you want the next handler to run or 1 if you want to prevent any other handlers from running on this event.
The "clicked" signal callback should return nothing (void in C parlance), so you can't prevent other callbacks from running. However, we can disconnect the first signal handler:
signal_handler_disconnect(b, id)
Now clicking on the button just yields
julia> "Press me" was clicked!
Alternatively, you can temporarily enable or disable individual handlers with signal_handler_block and signal_handler_unblock.
The arguments of the callback depend on the signal type. Arguments and their meaning are described along with their corresponding signals. You should omit the final user_data argument described in the GTK documentation; keep in mind that you can always address other variables from inside your function block, or define the callback in terms of an anonymous function:
cb is your callback function. This will be compiled with @cfunction, and you need to follow its rules. In particular, you should use a generic function (i.e., one defined as function foo(x,y,z) ... end), and the arguments and return type should match the GTK+ documentation for the widget and signal (see examples). In contrast with the simpler interface, when writing these callbacks you must include the user_data argument. See examples below.
widget is the widget that will send the signal
signalname is a string or symbol identifying the signal, e.g., "clicked" or "button-press-event"
return_type is the type of the value returned by your callback. Usually Nothing (for void) or Cint (for gboolean)
parameter_type_tuple specifies the types of the middle arguments to the callback function, omitting the first (the widget) and last (user_data). For example, for "clicked" we have parameter_type_tuple = () (because there are no middle arguments) and for "button-press-event" we have parameter_type_tuple = (Cint, Cdouble, Cdouble).
after is a boolean, true if you want your callback to run after the default handler for your signal. When in doubt, specify false.
user_data contains any additional information your callback needs to operate. For example, you can pass other widgets, tuples of values, etc. If omitted, it defaults to widget.
The callback's arguments need to match the GTK documentation, with the exception of the user_data argument. (Rather than being a pointer, user_data will automatically be converted back to an object.)
For example, consider a GUI in which pressing a button updates a counter:
box = GtkBox(:h)
+button = GtkButton("click me")
+label = GtkLabel("0")
+push!(box, button)
+push!(box, label)
+win = GtkWindow(box, "Callbacks")
+
+const counter = [0] # Pack counter value inside array to make it a reference
+
+# "clicked" callback declaration is
+# void user_function(GtkButton *button, gpointer user_data)
+# But user_data gets converted into a Julia object automatically
+function button_cb(widgetptr::Ptr, user_data)
+ widget = convert(Gtk4.GtkButtonLeaf, widgetptr) # pointer -> object
+ lbl, cntr = user_data # unpack the user_data tuple
+ cntr[] = cntr[]+1 # increment counter[1]
+ lbl.label = string(cntr[])
+ nothing # return type is void
+end
+
+signal_connect(button_cb, button, "clicked", Nothing, (), false, (label, counter))
You should note that the value of counter[] matches the display in the GUI.
If your callback function takes an event argument, it is important to declare its type correctly. An easy way to do that is to first write a callback using the "simple" interface, e.g.,
signal_connect(win, "delete-event") do widget, event
+ @show typeof(event)
+ @show event
+ end
and then use the reported type in parameter_type_tuple.
The "simple" callback interface includes protections against corrupting Gtk state from errors, but this @cfunction-based approach does not. Consequently, you may wish to use @guarded when writing these functions. (Canvas draw functions and mouse event-handling are called through this interface, which is why you should use @guarded there.) For functions that should return a value, you can specify the value to be returned on error as the first argument. For example:
const unhandled = convert(Int32, false)
+ @guarded unhandled function my_callback(widgetptr, ...)
+ ...
+ end
Settings
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
A GtkLabel is the most basic text widget and has already been used behind the scenes in any previous example involving a GtkButton. A GtkLabel is constructed by calling
label = GtkLabel("My text")
The text of a label can be changed using the label property or Gtk4.text
Gtk4.text(label,"My other text")
+label.label = "My final text"
Furthermore, a label has limited support for adding formatted text. This is done using the Gtk4.markup function:
This document was generated with Documenter.jl on Monday 3 July 2023. Using Julia version 1.9.1.
diff --git a/v0.4.2/search_index.js b/v0.4.2/search_index.js
new file mode 100644
index 00000000..d768ac38
--- /dev/null
+++ b/v0.4.2/search_index.js
@@ -0,0 +1,3 @@
+var documenterSearchIndex = {"docs":
+[{"location":"diff3to4/#Differences-between-Gtk.jl-and-Gtk4.jl-1","page":"Gtk.jl to Gtk4.jl","title":"Differences between Gtk.jl and Gtk4.jl","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"Gtk4.jl builds on and is very similar to Gtk.jl. Here is a summary of what's different.","category":"page"},{"location":"diff3to4/#Properties-1","page":"Gtk.jl to Gtk4.jl","title":"Properties","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"GObject properties can still be set and accessed using get_gtk_property and set_gtk_property!. However, properties are now mapped onto Julia properties, so one can set a window title using win.title = \"My title\". Also, the submodule GAccessor no longer exists. In Gtk4.jl, getter and setter methods are in the main Gtk4 module, but most are not exported. Whereas in Gtk.jl one uses GAccessor.title(win, \"My title\") to set the title, in Gtk4.jl the equivalent is Gtk4.title(win, \"My title\").","category":"page"},{"location":"diff3to4/#Constants,-enums,-and-flags-1","page":"Gtk.jl to Gtk4.jl","title":"Constants, enums, and flags","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"GTK constants in Gtk4.jl are in the main module instead of a Constants submodule.","category":"page"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"In Gtk.jl, GTK's enum and flags constants are turned into integers. In Gtk4.jl, these are now mapped onto Julia enums, specifically the implementations CEnum.jl for enums and BitFlags.jl for flags. This improves understandability when a function returns an enum or flag, but the downside is the sometimes extreme length of the enum's name. To mitigate this, convert methods are defined for commonly used enums so that shorter symbols can be used instead of the full enum name. For example, :h can be used instead of Gtk4.Orientation_HORIZONTAL in GtkBox(orientation, spacing).","category":"page"},{"location":"diff3to4/#G_-contains-automatically-generated-methods-1","page":"Gtk.jl to Gtk4.jl","title":"G_ contains automatically generated methods","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"In Gtk.jl, the submodule Gtk.GAccessor contains getter and setter methods, which often correspond to object properties. In Gtk4.jl, the submodule Gtk4.G_ contains automatically generated methods, which include all methods in GAccessor and many more. These methods directly call the C functions in libgtk and thus use 0-based indexing. Where possible, they translate between Julia types and C types, for example converting nothing to C_NULL and vice versa.","category":"page"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"For consistency, the getter and setter methods in G_ keep their full names, including \"set\" and \"get\". For example, to set the title of a window in Gtk4.jl use G_.set_title(w, \"text\") rather than GAccessor.title(w, \"text\") as in Gtk.jl.","category":"page"},{"location":"diff3to4/#GObject-and-struct-names-1","page":"Gtk.jl to Gtk4.jl","title":"GObject and struct names","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"The equivalent of Gtk.ShortNames doesn't exist. All GObject types are mapped onto Julia types with the same name. Leaving out the namespace, as is done in the Python pygobject bindings, would have led to name collisions between Gtk types and Julia types or between Gtk and other GObject libraries.","category":"page"},{"location":"diff3to4/#No-showall-1","page":"Gtk.jl to Gtk4.jl","title":"No showall","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"In GTK 4, widgets are shown by default, so showall does not exist, and calling show is no longer necessary in most situations. Exceptions include GtkDialogs and GtkApplicationWindows.","category":"page"},{"location":"diff3to4/#No-GtkContainer-1","page":"Gtk.jl to Gtk4.jl","title":"No GtkContainer","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"In GTK 4, GtkContainer has been removed and most widgets derive directly from GtkWidget. Each class that can contain child widgets has its own functions for adding and/or removing them. In Gtk4.jl, collection interface methods like push! have been defined for containers that hold many widgets, such as GtkBox. For widgets that have one child, such as GtkWindow, getindex and setindex! have been defined, so that one can set a child widget using window[] = child.","category":"page"},{"location":"diff3to4/#Events-1","page":"Gtk.jl to Gtk4.jl","title":"Events","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"Events such as button presses are handled through \"event controllers\" in GTK 4.","category":"page"},{"location":"diff3to4/#Dialogs-1","page":"Gtk.jl to Gtk4.jl","title":"Dialogs","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"Dialogs no longer have a run method that takes over the GLib main loop while waiting for the user's response.","category":"page"},{"location":"diff3to4/#For-developers-1","page":"Gtk.jl to Gtk4.jl","title":"For developers","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"All uses of mutable from GLib.MutableTypes should be replaced by Julia's Ref. The type of a GValue can be set using settype! rather than setindex!.","category":"page"},{"location":"diff3to4/#More-information-1","page":"Gtk.jl to Gtk4.jl","title":"More information","text":"","category":"section"},{"location":"diff3to4/#","page":"Gtk.jl to Gtk4.jl","title":"Gtk.jl to Gtk4.jl","text":"The GTK docs have a migration guide with detailed recommendations for migrating C code from GTK version 3 to version 4. Much of that advice applies to Julia code.","category":"page"},{"location":"howto/async/#Asynchronous-UI-1","page":"Asynchronous UI","title":"Asynchronous UI","text":"","category":"section"},{"location":"howto/async/#","page":"Asynchronous UI","title":"Asynchronous UI","text":"It is possible to perform background computation without interfering with user interface responsiveness either using multithreading or using separate processes. Use of a separate process includes slightly more overhead but also ensures user interface responsiveness more robustly.","category":"page"},{"location":"howto/async/#","page":"Asynchronous UI","title":"Asynchronous UI","text":"Here is an example using threads. Notice that this example will freeze the UI during computation unless Julia is run with two or more threads (julia -t2 on the command line).","category":"page"},{"location":"howto/async/#","page":"Asynchronous UI","title":"Asynchronous UI","text":"using Gtk4\n\nbtn = GtkButton(\"Start\")\nsp = GtkSpinner()\nent = GtkEntry()\n\ngrid = GtkGrid()\ngrid[1,1] = btn\ngrid[2,1] = sp\ngrid[1:2,2] = ent\n\nsignal_connect(btn, \"clicked\") do widget\n start(sp)\n Threads.@spawn begin\n\n # Do work\n stop_time = time() + 3\n counter = 0\n while time() < stop_time\n counter += 1\n end\n\n # Interacting with GTK from a thread other than the main thread is\n # generally not allowed, so we register an idle callback instead.\n Gtk4.GLib.g_idle_add() do\n stop(sp)\n ent.text = \"I counted to $counter in a thread!\"\n Cint(false)\n end\n end\nend\n\nwin = GtkWindow(grid, \"Threads\", 200, 200)","category":"page"},{"location":"howto/async/#","page":"Asynchronous UI","title":"Asynchronous UI","text":"Here is an example using a separate process to offload the work. This toy example is fairly straightforward, but things can get more complex if the offloaded task is more complex. See the manual for details.","category":"page"},{"location":"howto/async/#","page":"Asynchronous UI","title":"Asynchronous UI","text":"using Gtk4, Distributed\n\nbtn = GtkButton(\"Start\")\nsp = GtkSpinner()\nent = GtkEntry()\n\ngrid = GtkGrid()\ngrid[1,1] = btn\ngrid[2,1] = sp\ngrid[1:2,2] = ent\n\nid = addprocs(1)[1]\n\nsignal_connect(btn, \"clicked\") do widget\n start(sp)\n @async begin\n\n # Offload work to a separate process and block until it is done.\n counter = @fetchfrom id begin\n stop_time = time() + 3\n counter = 0\n while time() < stop_time\n counter += 1\n end\n counter\n end\n\n # We are still in the main thread so it is okay to directly access widgets\n stop(sp)\n ent.text = \"I counted to $counter in a separate process!\"\n end\nend\n\nwin = GtkWindow(grid, \"Distributed\", 200, 200)","category":"page"},{"location":"manual/combobox/#Dropdown-widgets-1","page":"Dropdown widgets","title":"Dropdown widgets","text":"","category":"section"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"One often needs a widget to allow a user to select something from a few options. There are two easy ways to do this in Gtk4.jl.","category":"page"},{"location":"manual/combobox/#GtkDropDown-1","page":"Dropdown widgets","title":"GtkDropDown","text":"","category":"section"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"A simple option that was introduced in GTK version 4 is GtkDropDown. An example is shown below.","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"using Gtk4\n\nchoices = [\"one\", \"two\", \"three\", \"four\"]\ndd = GtkDropDown(choices)\n# Let's set the active element to be \"two\", keeping in mind that the \"selected\" property uses 0 based indexing\ndd.selected = 1\n\nsignal_connect(dd, \"notify::selected\") do widget, others...\n # get the active index\n idx = dd.selected\n # get the active string\n str = Gtk4.selected_string(dd)\n println(\"Active element is \\\"$str\\\" at index $idx\")\nend\n\nwin = GtkWindow(\"DropDown Example\",400,200)\npush!(win, dd)","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"A search entry can be added using Gtk4.enable_search(dd, true).","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"To change the list of options after the dropdown widget is created, you can use","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"new_options_list = Gtk4.GtkStringList([\"one\",\"two\",\"three\",\"four\",\"five\"])\nGtk4.model(dd,GListModel(new_options_list))","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"More complex uses of GtkDropDown are possible and may be supported in future versions of Gtk4.jl.","category":"page"},{"location":"manual/combobox/#GtkComboBox-1","page":"Dropdown widgets","title":"GtkComboBox","text":"","category":"section"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"The older API for dropdown menu functionality is GtkComboBox. The full, generic GtkComboBox widget is powerful but harder to use and won't be covered here. The simpler GtkComboBoxText subtype allows the user to select from text options.","category":"page"},{"location":"manual/combobox/#GtkComboBoxText-1","page":"Dropdown widgets","title":"GtkComboBoxText","text":"","category":"section"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"The following example shows how to fill a GtkComboBoxText with elements and listen on the changed event (this example is functionally equivalent to the example above for GtkDropDown):","category":"page"},{"location":"manual/combobox/#","page":"Dropdown widgets","title":"Dropdown widgets","text":"using Gtk4\n\ncb = GtkComboBoxText()\nchoices = [\"one\", \"two\", \"three\", \"four\"]\nfor choice in choices\n push!(cb,choice)\nend\n# Let's set the active element to be \"two\"\ncb.active = 1\n\nsignal_connect(cb, \"changed\") do widget, others...\n # get the active index\n idx = cb.active\n # get the active string\n str = Gtk4.active_text(cb)\n println(\"Active element is \\\"$str\\\" at index $idx\")\nend\n\nwin = GtkWindow(\"ComboBoxText Example\",400,200)\npush!(win, cb)","category":"page"},{"location":"howto/nonreplusage/#Using-Gtk4-outside-the-REPL-1","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"","category":"section"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"If you're using Gtk4 from command-line scripts, the following design prevents Julia from quitting before you have a chance to see or interact with your windows:","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"using Gtk4\nwin = GtkWindow(\"gtkwait\")\n\n# Put your GUI code here\n\nif !isinteractive()\n c = Condition()\n signal_connect(win, :close_request) do widget\n notify(c)\n end\n @async Gtk4.GLib.glib_main()\n wait(c)\nend","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"By waiting on a Condition, Julia will keep running until a signal handler calls notify(c). This pattern allows for multiple events to trigger the condition, such as a button press, or one of many windows to be closed. Program flow will resume at the wait line, after which it would terminate in this example.","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"In the common case that we simply wish to wait for a single window to be closed, this can be shortened by using waitforsignal:","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"using Gtk4\nwin = GtkWindow(\"gtkwait\")\n\n# Put your GUI code here\n\nif !isinteractive()\n @async Gtk4.GLib.glib_main()\n Gtk4.GLib.waitforsignal(win,:close_request)\nend","category":"page"},{"location":"howto/nonreplusage/#GtkApplication-1","page":"Using Gtk4 outside the REPL","title":"GtkApplication","text":"","category":"section"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"For larger projects, you may want to use GtkApplication, which enables useful functionality based around GtkApplicationWindow, GAction, GActionMap, etc. For that you can use the following pattern:","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"using Gtk4\n\nfunction activate(app)\n win = GtkApplicationWindow(app, \"my title\")\n show(win)\nend\n\napp = GtkApplication()\n\nGtk4.signal_connect(activate, app, :activate)\n\nrun(app)","category":"page"},{"location":"howto/nonreplusage/#","page":"Using Gtk4 outside the REPL","title":"Using Gtk4 outside the REPL","text":"In the activate function, you can create your windows, widgets, etc. and connect them to signals. When all GtkApplicationWindows have been closed, the script will exit.","category":"page"},{"location":"manual/dialogs/#Dialogs-1","page":"Dialogs","title":"Dialogs","text":"","category":"section"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"Dialogs are transient windows that show information or ask the user for information.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"note: Example\nSome of the code on this page can be found in \"dialogs.jl\" in the \"example\" subdirectory.","category":"page"},{"location":"manual/dialogs/#Message-dialogs-1","page":"Dialogs","title":"Message dialogs","text":"","category":"section"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"Gtk4.jl supports GtkMessageDialog and provides several convenience functions: info_dialog, ask_dialog, warn_dialog, and error_dialog. Each takes a string for a message to show and an optional parent container, and returns nothing, except for ask_dialog which returns true if the user clicks the button corresponding to yes.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"For all dialog convenience functions, there are two ways of using them. For use in the REPL or an interactive script, the following forms can be used:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"info_dialog(\"Julia rocks!\")\nask_dialog(\"Do you like chocolate ice cream?\", \"Not at all\", \"I like it\") && println(\"That's my favorite too.\")\nwarn_dialog(\"Oops!... I did it again\")","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"These take an optional argument timeout (in seconds) that can be used to make the dialog disappear after a certain time.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"In callbacks (for example when a user clicks a button in a GUI), you can use a different form, which takes a callback as the first argument that will be called when the user closes the dialog. A full example:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"b = GtkButton(\"Click me\")\nwin = GtkWindow(b,\"Info dialog example\")\nf() = println(\"message received\")\nfunction on_click(b)\n info_dialog(f, \"Julia rocks!\",win)\nend\nsignal_connect(on_click, b, \"clicked\")","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"If you are using these functions in the context of a GUI, you should set the third argument of info_dialog, parent, to be the top-level window. Otherwise, for standalone usage in scripts, do not set it.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"The callback can alternatively be constructed using Julia's do syntax:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"info_dialog(\"Julia rocks!\", win) do\n println(\"message received\")\nend","category":"page"},{"location":"manual/dialogs/#File-Dialogs-1","page":"Dialogs","title":"File Dialogs","text":"","category":"section"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"A common reason to use a dialog is to allow the user to pick a file to be opened or saved to. For this Gtk4.jl provides the functions open_dialog for choosing an existing file or directory to be opened and save_dialog for choosing a filename to be saved to. These use GtkFileChooserNative, which uses the operating system's native dialogs where possible. The syntax of these functions is similar to the message dialogs. For a callback in a GUI (for an \"Open File\" button, for example), you can use","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"function f(filename)\n # do something with the file\nend\n\nopen_dialog(f, \"Pick a file to open\", parent)","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"The function f is called with the file's path as its argument when the user selects the file and clicks \"OK\". If the user clicks \"Cancel\", f is called with \"\" as its argument. Julia's do syntax can be used to construct the function f in a convenient way:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"open_dialog(\"Pick a file to open\", parent) do filename\n # call a function here to do something with the file\nend","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"Multiple files can be opened by setting the multiple keyword argument:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"open_dialog(\"Pick files to open\", parent; multiple = true) do filenames\n # call a function here to do something with files\nend","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"In this case filenames is a list of paths.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"The dialog can be preset to a particular directory using the optional argument start_folder:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"open_dialog(f, \"Pick a file to open\", parent; start_folder = \"/data\")","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"The same syntax works for save_dialog.","category":"page"},{"location":"manual/dialogs/#Filters-1","page":"Dialogs","title":"Filters","text":"","category":"section"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"Filters can be used to limit the type of files that the user can pick. Filters can be specified as a Tuple or Vector. A filter can be specified as a string, in which case it specifies a globbing pattern, for example \"*.png\". You can specify multiple match types for a single filter by separating the patterns with a comma, for example \"*.png,*.jpg\". You can alternatively specify MIME types, or if no specification is provided it defaults to types supported by GdkPixbuf. The generic specification of a filter is","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"GtkFileFilter(pattern = \"\", mimetype = \"\")","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"A human-readable name can optionally be provided using a keyword argument.","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"If on the other hand you want to choose a folder instead of a file, use select_folder = true in open_dialog:","category":"page"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"dir=Ref{String}()\nopen_dialog(\"Select Dataset Folder\"; select_folder = true) do name\n dir[] = name\nend\n\nif isdir(dir[])\n # do something with dir\nend","category":"page"},{"location":"manual/dialogs/#Custom-dialogs-1","page":"Dialogs","title":"Custom dialogs","text":"","category":"section"},{"location":"manual/dialogs/#","page":"Dialogs","title":"Dialogs","text":"TODO","category":"page"},{"location":"manual/listtreeview/#List-and-Tree-Widgets-1","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"The GtkTreeView is a very powerful widget for displaying table-like or hierarchical data. It is used for both lists and trees.","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"The power of this widget comes with a slightly more complex design that one has to understand when using the widget. The most important thing is that the widget itself does not store the displayed data. Instead there are dedicated GtkListStore and GtkTreeStore containers that will hold the data. The benefit of this approach is that it is possible to decouple the view from the data:","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"The widget automatically updates when adding, removing or editing data from the store\nThe widget can sort its data without modifications in the store\nColumns can be reordered and resized\nFiltering can be used to show only subsets of data","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"We will in the following introduce both widgets based on small and a more complex example.","category":"page"},{"location":"manual/listtreeview/#List-Store-1","page":"List and Tree Widgets","title":"List Store","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Lets start with a very simple example: A table with three columns representing the name, the age and the gender of a person. Each column must have a specific type. Here, we chose to represent the gender using a boolean value where true represents female and false represents male. We thus initialize the list store using","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"ls = GtkListStore(String, Int, Bool)","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Now we will the store with data","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"push!(ls,(\"Peter\",20,false))\npush!(ls,(\"Paul\",30,false))\npush!(ls,(\"Mary\",25,true))","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"If we want so insert the data at a specific position we can use the insert function","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"insert!(ls, 2, (\"Susanne\", 35, true))","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"You can use ls like a matrix like container. Calling length and size will give you","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"julia> length(ls)\n4\n\njulia> size(ls)\n(4,3)","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Specific element can be be accessed using","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"julia> ls[1,1]\n\"Peter\"\njulia> ls[1,1] = \"Pete\"\n\"Pete\"","category":"page"},{"location":"manual/listtreeview/#List-View-1","page":"List and Tree Widgets","title":"List View","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Now we actually want to display our data. To this end we create a tree view object","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"tv = GtkTreeView(GtkTreeModel(ls))","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Then we need specific renderers for each of the columns. Usually you will only need a text renderer, but in our example we want to display the boolean value using a checkbox.","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"rTxt = GtkCellRendererText()\nrTog = GtkCellRendererToggle()","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Finally we create for each column a TreeViewColumn object","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"c1 = GtkTreeViewColumn(\"Name\", rTxt, Dict([(\"text\",0)]))\nc2 = GtkTreeViewColumn(\"Age\", rTxt, Dict([(\"text\",1)]))\nc3 = GtkTreeViewColumn(\"Female\", rTog, Dict([(\"active\",2)]))","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"We need to push these column description objects to the tree view","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"push!(tv, c1, c2, c3)","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Then we can display the tree view widget in a window","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"win = GtkWindow(tv, \"List View\")","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"If you prefer that the columns are resizable by the user call","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"for c in [c1, c2, c3]\n Gtk4.resizable(c, true)\nend","category":"page"},{"location":"manual/listtreeview/#Sorting-1","page":"List and Tree Widgets","title":"Sorting","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"We next want to make the tree view sortable","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"for (i,c) in enumerate([c1,c2,c3])\n Gtk4.sort_column_id(c,i-1)\nend","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"If you now click on one of the column headers, the data will be sorted with respect to the selected column. You can even make the columns reorderable","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"for (i,c) in enumerate([c1, c2, c3])\n Gtk4.reorderable(c, true)\nend","category":"page"},{"location":"manual/listtreeview/#Selection-1","page":"List and Tree Widgets","title":"Selection","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Usually the interesting bit of a list will be the entry being selected. This is done using an additional GtkTreeSelection object that can be retrieved by","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"selection = Gtk4.selection(tv)","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"One either have single selection or multiple selections. We toggle this by calling","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Gtk4.mode(selection,Gtk4.SelectionMode_MULTIPLE)","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"For single selection, if we want to know the index of the selected item we can use","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"julia> ls[selected(selection),1]\n\"Pete\"","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"For multiple selection, we can get a list of selected rows using selected_rows, which can be used to index the GtkListStore","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"julia> [ls[x,1] for x in selected_rows(selection)]\n3-element Vector{String}:\n \"Susanne\"\n \"Pete\"\n \"Paul\"","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Since it can happen that no item has been selected at all, it is a good idea to put this into an if statement","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"if hasselection(selection)\n # do something with selected(selection)\nend","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Sometimes you want to invoke an action of an item is selected. This can be done by","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"signal_connect(selection, \"changed\") do widget\n if hasselection(selection)\n currentIt = selected(selection)\n\n # now you can to something with the selected item\n println(\"Name: \", ls[currentIt,1], \" Age: \", ls[currentIt,1])\n end\nend","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Another useful signal is \"row-activated\" that will be triggered by a double click of the user.","category":"page"},{"location":"manual/listtreeview/#Filtering-1","page":"List and Tree Widgets","title":"Filtering","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"A very useful thing is to apply a filter to a list view such that only a subset of data is shown. We can do this using the GtkTreeModelFilter type. It is as the GtkListStore a GtkTreeModel and therefore we can assign it to a tree view. So the idea is to wrap a GtkListStore in a GtkTreeModelFilter and assign that to the tree view.","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Next question is how to decide which row of the list store should be shown and which shouldn't. We will do this by adding an additional column to the list store that is hidden. The column will be of type Bool and a value true indicates that the entry is to be shown while false indicates the opposite. We make the filtering based on this column by a call to Gtk4.visible_column. The full example now looks like this:","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"using Gtk4\n\nls = GtkListStore(String, Int, Bool, Bool)\npush!(ls,(\"Peter\",20,false,true))\npush!(ls,(\"Paul\",30,false,true))\npush!(ls,(\"Mary\",25,true,true))\ninsert!(ls, 2, (\"Susanne\",35,true,true))\n\nrTxt = GtkCellRendererText()\nrTog = GtkCellRendererToggle()\n\nc1 = GtkTreeViewColumn(\"Name\", rTxt, Dict([(\"text\",0)]), sort_column_id=0)\nc2 = GtkTreeViewColumn(\"Age\", rTxt, Dict([(\"text\",1)]), sort_column_id=1)\nc3 = GtkTreeViewColumn(\"Female\", rTog, Dict([(\"active\",2)]), sort_column_id=2)\n\ntmFiltered = GtkTreeModelFilter(ls)\nGtk4.visible_column(tmFiltered,3)\ntv = GtkTreeView(GtkTreeModel(tmFiltered))\npush!(tv, c1, c2, c3)\n\nselection = Gtk4.selection(tv)\n\nsignal_connect(selection, \"changed\") do widget\n if hasselection(selection)\n currentIt = selected(selection)\n\n println(\"Name: \", GtkTreeModel(tmFiltered)[currentIt,1],\n \" Age: \", GtkTreeModel(tmFiltered)[currentIt,1])\n end\nend\n\nent = GtkEntry()\n\nsignal_connect(ent, \"changed\") do widget\n searchText = get_gtk_property(ent, :text, String)\n\n for l=1:length(ls)\n showMe = true\n\n if length(searchText) > 0\n showMe = showMe && occursin(lowercase(searchText), lowercase(ls[l,1]))\n end\n\n ls[l,4] = showMe\n end\nend\n\nvbox = GtkBox(:v)\npush!(vbox,ent,tv)\n\nwin = GtkWindow(vbox, \"List View with Filter\")","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"You can see that we have added a little search bar such that you can see the filtering in action. It is furthermore important to note that we had to replace ls with GtkTreeModel(tmFiltered) in the selection changed callback since the selection will give an iterator that is only valid in the filtered tree model.","category":"page"},{"location":"manual/listtreeview/#Tree-Widget-1","page":"List and Tree Widgets","title":"Tree Widget","text":"","category":"section"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"Here is an example of the tree model in action:","category":"page"},{"location":"manual/listtreeview/#","page":"List and Tree Widgets","title":"List and Tree Widgets","text":"using Gtk4\n\nts = GtkTreeStore(String)\niter1 = push!(ts,(\"one\",))\niter2 = push!(ts,(\"two\",),iter1)\niter3 = push!(ts,(\"three\",),iter2)\ntv = GtkTreeView(GtkTreeModel(ts))\nr1 = GtkCellRendererText()\nc1 = GtkTreeViewColumn(\"A\", r1, Dict([(\"text\",0)]))\npush!(tv,c1)\nwin = GtkWindow(tv, \"Tree View\")\n\niter = Gtk4.iter_from_index(ts, [1])\nts[iter,1] = \"ONE\"","category":"page"},{"location":"manual/keyevents/#Key-Events-1","page":"Key Events","title":"Key Events","text":"","category":"section"},{"location":"manual/keyevents/#Key-press-events-1","page":"Key Events","title":"Key press events","text":"","category":"section"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"To capture a keyboard event, one can add a GtkEventControllerKey to a widget (for example, a window) and add a callback, as shown in the following example.","category":"page"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"using Gtk4\n\nwin = GtkWindow(\"Key Press Example\")\neck = GtkEventControllerKey(win)\n\nsignal_connect(eck, \"key-pressed\") do controller, keyval, keycode, state\n println(\"You pressed key \", keyval, \" which is '\", Char(keyval), \"'.\")\nend","category":"page"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"You can then check if event.keyval has a certain value and invoke an action in that case.","category":"page"},{"location":"manual/keyevents/#Modifiers-1","page":"Key Events","title":"Modifiers","text":"","category":"section"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"To detect combination keypresses like \"Control-w\", you can use the argument state, which is a GdkModifierType.","category":"page"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"using Gtk4\n\nwin = GtkWindow(\"Control-W to close\")\neck = GtkEventControllerKey(win)\n\nsignal_connect(eck, \"key-pressed\") do controller, keyval, keycode, state\n mask = Gtk4.ModifierType_CONTROL_MASK\n if ((ModifierType(state & Gtk4.MODIFIER_MASK) & mask == mask) && keyval == UInt('w'))\n close(widget(eck))\n end\nend","category":"page"},{"location":"manual/keyevents/#Key-release-events-1","page":"Key Events","title":"Key release events","text":"","category":"section"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"The following example captures the events for both a key press and a key release and reports the time duration between the two. There is some state handling here because of the likely event that your keyboard is set to \"repeat\" a pressed key after some initial delay and because it is possible to press multiple keys at once. This version reports the time elapsed between the initial key press and the key release.","category":"page"},{"location":"manual/keyevents/#","page":"Key Events","title":"Key Events","text":"using Gtk4\n\nconst start_times = Dict{UInt32, UInt32}()\n\nw = GtkWindow(\"Key Press/Release Example\")\neck = GtkEventControllerKey(w)\n\nid1 = signal_connect(eck, \"key-pressed\") do controller, keyval, keycode, state\n if keyval ∉ keys(start_times)\n start_times[keyval] = Gtk4.current_event_time(controller) # save the initial key press time\n println(\"You pressed key \", keyval, \" which is '\", Char(keyval), \"'.\")\n else\n println(\"repeating key \", keyval)\n end\nend\n\nid2 = signal_connect(eck, \"key-released\") do controller, keyval, keycode, state\n start_time = pop!(start_times, keyval) # remove the key from the dictionary\n event = Gtk4.current_event(controller)\n duration = Gtk4.time(event) - start_time # key press duration in milliseconds\n println(\"You released key \", keyval, \" after time \", duration, \" msec.\")\nend","category":"page"},{"location":"manual/canvas/#Drawing-with-Cairo-1","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"","category":"section"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"note: Example\nThe code on this page can be found in \"canvas.jl\" in the \"examples\" subdirectory.","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"Cairo based drawing can be done on Gtk4.jl's GtkCanvas widget, which is based on GTK's GtkDrawingArea. The canvas widget comes with a backing store (a Cairo image surface). You control what is drawn on this backing store by defining a draw function:","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"using Gtk4, Graphics\nc = GtkCanvas()\nwin = GtkWindow(c, \"Canvas\")\n@guarded draw(c) do widget\n ctx = getgc(c)\n h = height(c)\n w = width(c)\n # Paint red rectangle\n rectangle(ctx, 0, 0, w, h/2)\n set_source_rgb(ctx, 1, 0, 0)\n fill(ctx)\n # Paint blue rectangle\n rectangle(ctx, 0, 3h/4, w, h/4)\n set_source_rgb(ctx, 0, 0, 1)\n fill(ctx)\nend","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"This draw function will be called each time the window is resized or otherwise needs to refresh its display. If you need to force a redraw of the canvas, you can call reveal on the canvas widget.","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"(Image: canvas)","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"Errors in the draw function can corrupt Gtk4's internal state; if this happens, you have to quit julia and start a fresh session. To avoid this problem, the @guarded macro wraps your code in a try/catch block and prevents the corruption. It is especially useful when initially writing and debugging code.","category":"page"},{"location":"manual/canvas/#Mouse-events-1","page":"Drawing with Cairo","title":"Mouse events","text":"","category":"section"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"Mouse events can be handled using event controllers. The event controller for mouse clicks is GtkGestureClick. We first create this event controller, then add it to the widget using push!.","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"g=GtkGestureClick()\npush!(c,g)\n\nfunction on_pressed(controller, n_press, x, y)\n w=widget(controller)\n ctx = getgc(w)\n set_source_rgb(ctx, 0, 1, 0)\n arc(ctx, x, y, 5, 0, 2pi)\n stroke(ctx)\n reveal(w)\nend\n\nsignal_connect(on_pressed, g, \"pressed\")\n","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"This will draw a green circle on the canvas at every mouse click. Resizing the window will make them go away; they were drawn on top of the canvas one by one, but they weren't added to the draw function, which is what is called when the widget is refreshed.","category":"page"},{"location":"manual/canvas/#Controlling-the-widget's-size-1","page":"Drawing with Cairo","title":"Controlling the widget's size","text":"","category":"section"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"In the example above, the canvas was the direct child of the window, and its size is determined by the window size. If you instead make the canvas a child of one of GTK's layout widgets, like GtkBox or GtkGrid, it doesn't appear because by default, the drawing area widget does not expand to fill the space available. You can override this by setting the canvas's properties vexpand and hexpand to true. Alternatively, if you want to set the canvas to have a minimum width and height in pixels, you can set its properties content_width and content_height.","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"You can perform computations only when the widget is resized by connecting to the \"resize\" signal.","category":"page"},{"location":"manual/canvas/#Using-GtkCanvas-with-higher-level-Julia-packages-1","page":"Drawing with Cairo","title":"Using GtkCanvas with higher-level Julia packages","text":"","category":"section"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"It's pretty straightforward to use GtkCanvas to display Cairo-based plots and diagrams produced by packages like CairoMakie.jl or Luxor.jl.","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"A minimal example of displaying a CairoMakie plot is shown below:","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"using Gtk4, CairoMakie\n\nconfig = CairoMakie.ScreenConfig(1.0, 1.0, :good, true, false)\nCairoMakie.activate!()\n\ncanvas = GtkCanvas()\nw = GtkWindow(canvas,\"CairoMakie example\")\n\n@guarded draw(canvas) do widget\n global f, ax, p = lines(1:10)\n CairoMakie.autolimits!(ax) \t\n screen = CairoMakie.Screen(f.scene, config, Gtk4.cairo_surface(canvas))\n CairoMakie.resize!(f.scene, Gtk4.width(widget), Gtk4.height(widget))\n CairoMakie.cairo_draw(screen, f.scene)\nend","category":"page"},{"location":"manual/canvas/#","page":"Drawing with Cairo","title":"Drawing with Cairo","text":"A more complicated example can be found in the \"examples\" subdirectory. For interactive plots, you can try Gtk4Makie.jl, which draws GLMakie plots onto GTK's GtkGLArea widget.","category":"page"},{"location":"doc/reference/#Gtk4-Reference-1","page":"Gtk4 Reference","title":"Gtk4 Reference","text":"","category":"section"},{"location":"doc/reference/#Public-interface-1","page":"Gtk4 Reference","title":"Public interface","text":"","category":"section"},{"location":"doc/reference/#","page":"Gtk4 Reference","title":"Gtk4 Reference","text":"Modules = [Gtk4]\nOrder = [:module, :function, :macro]\nPublic = true\nPrivate = false","category":"page"},{"location":"doc/reference/#Base.parent","page":"Gtk4 Reference","title":"Base.parent","text":"parent(w::GtkWidget)\n\nReturns the parent widget of w, or nothing if the widget has not been set as the child of another widget (or is a toplevel widget, like a GtkWindow).\n\nSee also toplevel.\n\nRelated GTK function: gtk_widget_get_parent()\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Base.show-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Base.show","text":"show(w::GtkWidget)\n\nFlag w to be displayed and return w.\n\nRelated GTK function: gtk_widget_show()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Cairo.destroy-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Cairo.destroy","text":"destroy(win::GtkWindow)\n\nDrop GTK's reference to win.\n\nRelated GTK function: gtk_window_destroy()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Graphics.height","page":"Gtk4 Reference","title":"Graphics.height","text":"height(w::GtkWidget)\n\nReturns the allocated height of w in pixels.\n\nRelated GTK function: gtk_widget_get_allocated_height()\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Graphics.width","page":"Gtk4 Reference","title":"Graphics.width","text":"width(w::GtkWidget)\n\nReturns the allocated width of w in pixels.\n\nRelated GTK function: gtk_widget_get_allocated_width()\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.activate-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.activate","text":"activate(w::GtkWidget)\n\nActivates widgets like buttons, menu items, etc. that support being activated. Returns false if the widget is not activatable.\n\nRelated GTK function: gtk_widget_activate()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.ask_dialog","page":"Gtk4 Reference","title":"Gtk4.ask_dialog","text":"ask_dialog(question::AbstractString, parent = nothing; timeout = -1)\n\nCreate a dialog with a message question and two buttons \"No\" and \"Yes\". Returns true if \"Yes\" is selected and false if \"No\" is selected or the dialog (or its parent window parent) is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and false will be returned.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.buffer-Tuple{Union{_GtkTextIter, Ref{_GtkTextIter}}}","page":"Gtk4 Reference","title":"Gtk4.buffer","text":"buffer(iter::Union{Ref{_GtkTextIter}, _GtkTextIter})\n\nReturns the buffer associated with iter.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.configure!-Tuple{GtkAdjustment}","page":"Gtk4 Reference","title":"Gtk4.configure!","text":"configure!(adj::GtkAdjustment; value = nothing, lower = nothing, upper = nothing, step_increment = nothing, page_increment = nothing, page_size = nothing)\n\nSets all properties of an adjustment, while only resulting in one emission of the changed signal. If an argument is nothing, it is not changed.\n\nRelated GTK function: gtk_adjustment_configure()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.configure!-Tuple{GtkSpinButton}","page":"Gtk4 Reference","title":"Gtk4.configure!","text":"configure!(sb::GtkSpinButton; adj = nothing, climb_rate = nothing, digits = nothing)\n\nSets the adjustment adj, the climb_rate, and the number of digits of a GtkSpinButton. If an argument is nothing, it is not changed.\n\nRelated GTK function: gtk_spin_button_configure()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.create_mark-Tuple{GtkTextBuffer, Any, Union{_GtkTextIter, Ref{_GtkTextIter}}, Bool}","page":"Gtk4 Reference","title":"Gtk4.create_mark","text":"create_mark(buffer::GtkTextBuffer, mark_name, it::TI, left_gravity::Bool)\ncreate_mark(buffer::GtkTextBuffer, it::TI)\n\nImpements gtk_text_buffer_create_mark.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.cursor","page":"Gtk4 Reference","title":"Gtk4.cursor","text":"cursor(w::GtkWidget)\n\nGets the cursor c for a widget w.\n\nRelated GTK function: gtk_widget_get_cursor()\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.cursor-Tuple{GtkWidget, Union{Nothing, GdkCursor}}","page":"Gtk4 Reference","title":"Gtk4.cursor","text":"cursor(w::GtkWidget, c)\n\nSets a cursor c when the mouse pointer is over a widget w, where c can be a GdkCursor or a string to specify a name. If c is nothing, use the default cursor for w.\n\nRelated GTK functions: gtk_widget_set_cursor(), gtk_widget_set_cursor_from_name()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.fullscreen-Tuple{GtkWindow, GdkMonitor}","page":"Gtk4 Reference","title":"Gtk4.fullscreen","text":"fullscreen(win::GtkWindow, mon::GdkMonitor)\n\nSet win to fullscreen mode on a particular monitor mon. The windowing system (outside GTK's control) may not allow this, so it may not work on some platforms.\n\nSee also unfullscreen.\n\nRelated GTK function: gtk_window_fullscreen_on_monitor()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.fullscreen-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.fullscreen","text":"fullscreen(win::GtkWindow)\n\nSet win to fullscreen mode.\n\nSee also unfullscreen.\n\nRelated GTK function: gtk_window_fullscreen()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.get_error-Tuple{GtkGLArea}","page":"Gtk4 Reference","title":"Gtk4.get_error","text":"get_error(w::GtkGLArea)\n\nGets the current error set on w.\n\nRelated GTK function: gtk_gl_area_get_error()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.grab_focus-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.grab_focus","text":"grab_focus(w::GtkWidget)\n\nGives w the keyboard focus for the window it is in. Returns false if this fails.\n\nRelated GTK function: gtk_widget_grab_focus()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.hasparent-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.hasparent","text":"hasparent(w::GtkWidget) -> Bool\n\nReturns true if w has a parent widget.\n\nSee also parent.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.hide-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.hide","text":"hide(w::GtkWidget)\n\nFlag w to be hidden and return w. This is the opposite of show.\n\nRelated GTK function: gtk_widget_hide()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.info_dialog","page":"Gtk4 Reference","title":"Gtk4.info_dialog","text":"info_dialog(message::AbstractString, parent = nothing; timeout = -1)\n\nCreate a dialog with an informational message message. Returns when the dialog (or its parent window parent) is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and false will be returned.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.input_dialog","page":"Gtk4 Reference","title":"Gtk4.input_dialog","text":"input_dialog(message::AbstractString, entry_default::AbstractString, buttons = ((\"Cancel\", 0), (\"Accept\", 1)), parent = nothing; timeout = -1)\n\nCreate a dialog with a message message and a text entry. Returns the string in the entry when the \"Accept\" button is pressed, or entry_default if \"Cancel\" is pressed or the dialog or its parent window parent is closed. The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and entry_default will be returned.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.isvisible-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.isvisible","text":"isvisible(w::GtkWidget) -> Bool\n\nReturns whether w and all of its parents are marked as visible.\n\nRelated GTK function: gtk_widget_is_visible()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.make_current-Tuple{GtkGLArea}","page":"Gtk4 Reference","title":"Gtk4.make_current","text":"make_current(w::GtkGLArea)\n\nEnsures that the GdkGLContext used by area is associated with the GtkGLArea.\n\nRelated GTK function: gtk_gl_area_make_current()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.maximize-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.maximize","text":"maximize(win::GtkWindow)\n\nRequest that the window win be maximized.\n\nSee also unmaximize.\n\nRelated GTK function: gtk_window_maximize()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.open_dialog","page":"Gtk4 Reference","title":"Gtk4.open_dialog","text":"open_dialog(title::AbstractString, parent = nothing, filters::Union{AbstractVector, Tuple} = String[]; timeout = -1, multiple = false, start_folder = \"\")\n\nCreate a dialog for choosing a file or folder to be opened. Returns the path chosen by the user, or \"\" if \"Cancel\" is pressed or the dialog or its parent window parent is closed. The dialog title is set using title. The argument filters can be used to show only directory contents that match certain file extensions.\n\nKeyword arguments: timeout: The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and \"\" will be returned. multiple: if true, multiple files can be selected, and a list of file paths is returned rather than a single path. start_folder: if set, the dialog will start out browsing a particular folder. Otherwise GTK will decide.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.place_cursor-Tuple{GtkTextBuffer, _GtkTextIter}","page":"Gtk4 Reference","title":"Gtk4.place_cursor","text":"place_cursor(buffer::GtkTextBuffer, it::_GtkTextIter)\nplace_cursor(buffer::GtkTextBuffer, pos::Int)\n\nPlace the cursor at indicated position.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.present-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.present","text":"present(win::GtkWindow)\npresent(win::GtkWindow, timestamp)\n\nPresents a window to the user. Usually means move it to the front. According to the GTK docs, this function \"should not be used\" without including a timestamp for the user's request.\n\nRelated GTK function: gtk_window_present() Related GTK function: gtk_window_present_with_time()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.queue_render-Tuple{GtkGLArea}","page":"Gtk4 Reference","title":"Gtk4.queue_render","text":"queue_render(w::GtkGLArea)\n\nQueues a redraw of the widget.\n\nRelated GTK function: gtk_gl_area_queue_render()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.reveal-Tuple{GtkGLArea}","page":"Gtk4 Reference","title":"Gtk4.reveal","text":"reveal(w::GtkGLArea)\n\nTriggers a redraw of a widget by calling GTK's gtk_glarea_queue_render.\n\nRelated GTK function: gtk_gl_area_queue_render()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.reveal-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.reveal","text":"reveal(w::GtkWidget)\n\nTriggers a redraw of a widget by calling GTK's gtk_widget_queue_draw.\n\nRelated GTK function: gtk_widget_queue_draw())\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.save_dialog","page":"Gtk4 Reference","title":"Gtk4.save_dialog","text":"save_dialog(title::AbstractString, parent = nothing, filters::Union{AbstractVector, Tuple} = String[]; timeout = -1, start_folder = \"\")\n\nCreate a dialog for choosing a file to be saved to. Returns the path chosen by the user, or \"\" if \"Cancel\" is pressed or the dialog or its parent window parent is closed. The window title is set using title. The argument filters can be used to show only directory contents that match certain file extensions.\n\nKeyword arguments: timeout: The optional input timeout (disabled by default) can be used to set a time in seconds after which the dialog will close and \"\" will be returned. start_folder: if set, the dialog will start out browsing a particular folder. Otherwise GTK will decide.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.screen_size","page":"Gtk4 Reference","title":"Gtk4.screen_size","text":"screen_size(widget=nothing)\n\nReturns a tuple (width,height) that gives the primary monitor size for the display where widget is being displayed, or the default display if widget is unrealized or not given.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.scroll_to-Tuple{GtkTextView, GtkTextMark, Real, Bool, Real, Real}","page":"Gtk4 Reference","title":"Gtk4.scroll_to","text":"scroll_to(view::GtkTextView, mark::GtkTextMark, within_margin::Real,\n use_align::Bool, xalign::Real, yalign::Real)\n\nscroll_to(view::GtkTextView, iter::TI, within_margin::Real,\n use_align::Bool, xalign::Real, yalign::Real)\n\nImplements gtk_text_view_scroll_to_mark and gtk_text_view_scroll_to_iter.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.search","page":"Gtk4 Reference","title":"Gtk4.search","text":"search(buffer::GtkTextBuffer, str::AbstractString, direction = :forward,\n flag = GtkTextSearchFlags.GTK_TEXT_SEARCH_TEXT_ONLY)\n\nSearch text str in buffer in direction :forward or :backward starting from the cursor position in the buffer.\n\nReturns a tuple (found, start, stop) where found indicates whether the search was successful and start and stop are _GtkTextIters containing the location of the match.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.select_range-Tuple{GtkTextBuffer, Union{_GtkTextIter, Ref{_GtkTextIter}}, Union{_GtkTextIter, Ref{_GtkTextIter}}}","page":"Gtk4 Reference","title":"Gtk4.select_range","text":"select_range(buffer::GtkTextBuffer, ins::TI, bound::TI)\nselect_range(buffer::GtkTextBuffer, range::GtkTextRange)\n\nSelect the text in buffer accorind to _GtkTextIter ins and bound.\n\nImplements gtk_text_buffer_select_range.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.selection_bounds-Tuple{GtkTextBuffer}","page":"Gtk4 Reference","title":"Gtk4.selection_bounds","text":"selection_bounds(buffer::GtkTextBuffer)\n\nReturns a tuple (selected, start, stop) indicating if text is selected in the buffer, and if so sets the _GtkTextIter start and stop to point to the selected text.\n\nImplements gtk_text_buffer_get_selection_bounds.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.toplevel-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.toplevel","text":"toplevel(w::GtkWidget)\n\nReturns the topmost ancestor of w, which in most cases will be a GtkWindow.\n\nSee also parent.\n\nRelated GTK function: gtk_widget_get_root()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.unfullscreen-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.unfullscreen","text":"unfullscreen(win::GtkWindow)\n\nIf win is in fullscreen mode, return it to normal mode.\n\nSee also fullscreen.\n\nRelated GTK function: gtk_window_unfullscreen()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.unmaximize-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.unmaximize","text":"unmaximize(win::GtkWindow)\n\nIf win is maximized, return it to its former size.\n\nSee also maximize.\n\nRelated GTK function: gtk_window_unmaximize()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.visible-Tuple{GtkWidget, Bool}","page":"Gtk4 Reference","title":"Gtk4.visible","text":"visible(w::GtkWidget, state::Bool)\n\nControl visibility of w. Note that w will not be visible unless its parent is also visible.\n\nRelated GTK function: gtk_widget_set_visible()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.widget","page":"Gtk4 Reference","title":"Gtk4.widget","text":"widget(c::GtkEventController)\n\nReturns the widget associated with an event controller.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.@load_builder-Tuple{Any}","page":"Gtk4 Reference","title":"Gtk4.@load_builder","text":"@load_builder(b::GtkBuilder)\n\nLoads all GtkBuildable objects from a GtkBuilder object and assigns them to Julia variables in the current scope. GtkBuilder ID's are mapped onto Julia variable names.\n\n\n\n\n\n","category":"macro"},{"location":"doc/reference/#Private-methods-1","page":"Gtk4 Reference","title":"Private methods","text":"","category":"section"},{"location":"doc/reference/#","page":"Gtk4 Reference","title":"Gtk4 Reference","text":"Modules = [Gtk4]\nOrder = [:module, :type, :function, :macro]\nPublic = false\nPrivate = true","category":"page"},{"location":"doc/reference/#Gtk4.BlendMode","page":"Gtk4 Reference","title":"Gtk4.BlendMode","text":"The blend modes available for render nodes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Corner","page":"Gtk4 Reference","title":"Gtk4.Corner","text":"The corner indices used by GskRoundedRect.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GLUniformType","page":"Gtk4 Reference","title":"Gtk4.GLUniformType","text":"This defines the types of the uniforms that GskGLShaders declare.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.RenderNodeType","page":"Gtk4 Reference","title":"Gtk4.RenderNodeType","text":"The type of a node determines what the node is rendering.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScalingFilter","page":"Gtk4 Reference","title":"Gtk4.ScalingFilter","text":"The filters used when scaling texture data.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SerializationError","page":"Gtk4 Reference","title":"Gtk4.SerializationError","text":"Errors that can happen during (de)serialization.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TransformCategory","page":"Gtk4 Reference","title":"Gtk4.TransformCategory","text":"The categories of matrices relevant for GSK and GTK.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Base.close-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Base.close","text":"close(win::GtkWindow)\n\nRequest that win is closed.\n\nRelated GTK function: gtk_window_close()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Base.skip-Tuple{Ref{_GtkTextIter}, Integer, Symbol}","page":"Gtk4 Reference","title":"Base.skip","text":"skip(iter::Ref{_GtkTextIter}, count::Integer, what::Symbol)\n\nMoves iter according to the operation specified by what and count. Operations are :\n\n:chars (gtk_text_iter_forward_chars)\n:lines (gtk_text_iter_forward_lines)\n:words (gtk_text_iter_forward_word_ends)\n:word_cursor_positions (gtk_text_iter_forward_cursor_positions)\n:sentences (gtk_text_iter_forward_sentence_ends)\n:visible_words (gtk_text_iter_forward_visible_word_ends)\n:visible_cursor_positions (gtk_text_iter_forward_visible_cursor_positions)\n:visible_lines (gtk_text_iter_forward_visible_lines)\n:line_ends (gtk_text_iter_forward_visible_lines)\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Base.skip-Tuple{Ref{_GtkTextIter}, Integer}","page":"Gtk4 Reference","title":"Base.skip","text":"skip(iter::Ref{_GtkTextIter}, count::Integer)\n\nMoves iter count characters. Returns a Bool indicating if the move was successful.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Base.skip-Tuple{Ref{_GtkTextIter}, Symbol}","page":"Gtk4 Reference","title":"Base.skip","text":"skip(iter::Ref{_GtkTextIter}, what::Symbol)\n\nMoves iter according to the operation specified by what. Operations are :\n\n:forward_line (gtk_text_iter_forward_line)\n:backward_line (gtk_text_iter_backward_line)\n:forward_to_line_end (gtk_text_iter_forward_to_line_end)\n:backward_word_start (gtk_text_iter_forward_word_end)\n:forward_word_end (gtk_text_iter_backward_word_start)\n:backward_sentence_start (gtk_text_iter_backward_sentence_start)\n:forward_sentence_end (gtk_text_iter_forward_sentence_end)\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.backward_search-Tuple{Ref{_GtkTextIter}, AbstractString, Ref{_GtkTextIter}, Ref{_GtkTextIter}, Ref{_GtkTextIter}, Any}","page":"Gtk4 Reference","title":"Gtk4.backward_search","text":"backward_search(iter::Ref{_GtkTextIter},\n str::AbstractString, start::Ref{_GtkTextIter},\n stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag::Int32)\n\nImplements gtk_text_iter_backward_search.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.buffer_to_window_coords","page":"Gtk4 Reference","title":"Gtk4.buffer_to_window_coords","text":"buffer_to_window_coords(view::GtkTextView, buffer_x::Integer, buffer_y::Integer, wintype::Integer = 0)\n\nImplements gtk_text_view_buffer_to_window_coords.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.char_offset-Tuple{Union{_GtkTextIter, Ref{_GtkTextIter}}}","page":"Gtk4 Reference","title":"Gtk4.char_offset","text":"char_offset(iter::Union{Ref{_GtkTextIter}, _GtkTextIter})\n\nReturns the offset of iter (one-based index).\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.display","page":"Gtk4 Reference","title":"Gtk4.display","text":"display(w::GtkWidget)\n\nGets the GdkDisplay for w. Should only be called if w has been added to a widget hierarchy.\n\nRelated GTK function: gtk_widget_get_display()\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Gtk4.find_controller-Union{Tuple{T}, Tuple{GtkWidget, Type{T}}} where T<:GtkEventController","page":"Gtk4 Reference","title":"Gtk4.find_controller","text":"find_controller(w::GtkWidget, ::Type{T}) where T <: GtkEventController\n\nReturns an event controller of type T connected to a widget, or nothing if one doesn't exist. This function is intended for testing purposes (to simulate events) and is not recommended otherwise, as there is a performance penalty for creating a list of a widget's event controllers.\n\nRelated GTK function: gtk_widget_observe_controllers)\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.forward_search-Tuple{Ref{_GtkTextIter}, AbstractString, Ref{_GtkTextIter}, Ref{_GtkTextIter}, Ref{_GtkTextIter}, Any}","page":"Gtk4 Reference","title":"Gtk4.forward_search","text":"forward_search(iter::Ref{_GtkTextIter},\n str::AbstractString, start::Ref{_GtkTextIter},\n stop::Ref{_GtkTextIter}, limit::Ref{_GtkTextIter}, flag::Int32)\n\nImplements gtk_text_iter_forward_search.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.isfullscreen-Tuple{GtkWindow}","page":"Gtk4 Reference","title":"Gtk4.isfullscreen","text":"isfullscreen(win::GtkWindow)\n\nGet whether win is in fullscreen mode.\n\nSee also fullscreen.\n\nRelated GTK function: gtk_window_is_fullscreen()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.monitor-Tuple{GtkWidget}","page":"Gtk4 Reference","title":"Gtk4.monitor","text":"monitor(w::GtkWidget)\n\nGets the GdkMonitor where w is displayed, or nothing if the widget is not part of a widget hierarchy.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.monitors-Tuple{}","page":"Gtk4 Reference","title":"Gtk4.monitors","text":"monitors()\n\nReturns a list of GdkMonitors for the default GdkDisplay, or nothing if none are found.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.size_request-Tuple{GtkWidget, Any}","page":"Gtk4 Reference","title":"Gtk4.size_request","text":"size_request(w::GtkWidget, s)\n\nSet the minimum size w to s, which should be a tuple (width, height).\n\nRelated GTK function: gtk_widget_set_size_request()\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.text_iter_at_position-Tuple{GtkTextView, Integer, Integer}","page":"Gtk4 Reference","title":"Gtk4.text_iter_at_position","text":"text_iter_at_position(view::GtkTextView, x::Integer, y::Integer)\n\nImplements gtk_text_view_get_iter_at_position.\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Gtk4.window_to_buffer_coords","page":"Gtk4 Reference","title":"Gtk4.window_to_buffer_coords","text":"window_to_buffer_coords(view::GtkTextView, window_x::Integer, window_y::Integer, wintype::Integer = 2)\n\nImplements gtk_text_view_window_to_buffer_coords.\n\n\n\n\n\n","category":"function"},{"location":"doc/reference/#Types-1","page":"Gtk4 Reference","title":"Types","text":"","category":"section"},{"location":"doc/reference/#","page":"Gtk4 Reference","title":"Gtk4 Reference","text":"Modules = [Gtk4]\nOrder = [:type]\nPublic = true\nPrivate = false","category":"page"},{"location":"doc/reference/#Gtk4.AccessibleAutocomplete","page":"Gtk4 Reference","title":"Gtk4.AccessibleAutocomplete","text":"The possible values for the %GTKACCESSIBLEPROPERTY_AUTOCOMPLETE accessible property.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleInvalidState","page":"Gtk4 Reference","title":"Gtk4.AccessibleInvalidState","text":"The possible values for the %GTKACCESSIBLESTATE_INVALID accessible state.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleProperty","page":"Gtk4 Reference","title":"Gtk4.AccessibleProperty","text":"The possible accessible properties of a [iface@Accessible].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleRelation","page":"Gtk4 Reference","title":"Gtk4.AccessibleRelation","text":"The possible accessible relations of a [iface@Accessible].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleRole","page":"Gtk4 Reference","title":"Gtk4.AccessibleRole","text":"The accessible role for a [iface@Accessible] implementation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleSort","page":"Gtk4 Reference","title":"Gtk4.AccessibleSort","text":"The possible values for the %GTKACCESSIBLEPROPERTY_SORT accessible property.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleState","page":"Gtk4 Reference","title":"Gtk4.AccessibleState","text":"The possible accessible states of a [iface@Accessible].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AccessibleTristate","page":"Gtk4 Reference","title":"Gtk4.AccessibleTristate","text":"The possible values for the %GTKACCESSIBLESTATE_PRESSED accessible state.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Align","page":"Gtk4 Reference","title":"Gtk4.Align","text":"Controls how a widget deals with extra space in a single dimension.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AnchorHints","page":"Gtk4 Reference","title":"Gtk4.AnchorHints","text":"Positioning hints for aligning a surface relative to a rectangle.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ApplicationInhibitFlags","page":"Gtk4 Reference","title":"Gtk4.ApplicationInhibitFlags","text":"Types of user actions that may be blocked by GtkApplication.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ArrowType","page":"Gtk4 Reference","title":"Gtk4.ArrowType","text":"Used to indicate the direction in which an arrow should point.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AssistantPageType","page":"Gtk4 Reference","title":"Gtk4.AssistantPageType","text":"Determines the page role inside a GtkAssistant.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AxisFlags","page":"Gtk4 Reference","title":"Gtk4.AxisFlags","text":"Flags describing the current capabilities of a device/tool.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.AxisUse","page":"Gtk4 Reference","title":"Gtk4.AxisUse","text":"Defines how device axes are interpreted by GTK.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.BaselinePosition","page":"Gtk4 Reference","title":"Gtk4.BaselinePosition","text":"Baseline position in a row of widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.BorderStyle","page":"Gtk4 Reference","title":"Gtk4.BorderStyle","text":"Describes how the border of a UI element should be rendered.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.BuilderClosureFlags","page":"Gtk4 Reference","title":"Gtk4.BuilderClosureFlags","text":"The list of flags that can be passed to gtkbuildercreate_closure().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.BuilderError","page":"Gtk4 Reference","title":"Gtk4.BuilderError","text":"Error codes that identify various errors that can occur while using GtkBuilder.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ButtonsType","page":"Gtk4 Reference","title":"Gtk4.ButtonsType","text":"Prebuilt sets of buttons for GtkDialog.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CellRendererAccelMode","page":"Gtk4 Reference","title":"Gtk4.CellRendererAccelMode","text":"The available modes for [property@Gtk.CellRendererAccel:accel-mode].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CellRendererMode","page":"Gtk4 Reference","title":"Gtk4.CellRendererMode","text":"Identifies how the user can interact with a particular cell.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CellRendererState","page":"Gtk4 Reference","title":"Gtk4.CellRendererState","text":"Tells how a cell is to be rendered.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ConstraintAttribute","page":"Gtk4 Reference","title":"Gtk4.ConstraintAttribute","text":"The widget attributes that can be used when creating a [class@Constraint].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ConstraintRelation","page":"Gtk4 Reference","title":"Gtk4.ConstraintRelation","text":"The relation between two terms of a constraint.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ConstraintStrength","page":"Gtk4 Reference","title":"Gtk4.ConstraintStrength","text":"The strength of a constraint, expressed as a symbolic constant.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ConstraintVflParserError","page":"Gtk4 Reference","title":"Gtk4.ConstraintVflParserError","text":"Domain for VFL parsing errors.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ContentFit","page":"Gtk4 Reference","title":"Gtk4.ContentFit","text":"Controls how a content should be made to fit inside an allocation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CornerType","page":"Gtk4 Reference","title":"Gtk4.CornerType","text":"Specifies which corner a child widget should be placed in when packed into a GtkScrolledWindow.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CrossingMode","page":"Gtk4 Reference","title":"Gtk4.CrossingMode","text":"Specifies the crossing mode for enter and leave events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CssParserError","page":"Gtk4 Reference","title":"Gtk4.CssParserError","text":"Errors that can occur while parsing CSS.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.CssParserWarning","page":"Gtk4 Reference","title":"Gtk4.CssParserWarning","text":"Warnings that can occur while parsing CSS.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DebugFlags","page":"Gtk4 Reference","title":"Gtk4.DebugFlags","text":"Flags to use with gtksetdebug_flags().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DeleteType","page":"Gtk4 Reference","title":"Gtk4.DeleteType","text":"Passed to various keybinding signals for deleting text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DevicePadFeature","page":"Gtk4 Reference","title":"Gtk4.DevicePadFeature","text":"A pad feature.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DeviceToolType","page":"Gtk4 Reference","title":"Gtk4.DeviceToolType","text":"Indicates the specific type of tool being used being a tablet. Such as an airbrush, pencil, etc.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DialogFlags","page":"Gtk4 Reference","title":"Gtk4.DialogFlags","text":"Flags used to influence dialog construction.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DirectionType","page":"Gtk4 Reference","title":"Gtk4.DirectionType","text":"Focus movement types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DragAction","page":"Gtk4 Reference","title":"Gtk4.DragAction","text":"Used in GdkDrop and GdkDrag to indicate the actions that the destination can and should do with the dropped data.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.DragCancelReason","page":"Gtk4 Reference","title":"Gtk4.DragCancelReason","text":"Used in GdkDrag to the reason of a cancelled DND operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.EditableProperties","page":"Gtk4 Reference","title":"Gtk4.EditableProperties","text":"The identifiers for [iface@Gtk.Editable] properties.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.EntryIconPosition","page":"Gtk4 Reference","title":"Gtk4.EntryIconPosition","text":"Specifies the side of the entry at which an icon is placed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.EventControllerScrollFlags","page":"Gtk4 Reference","title":"Gtk4.EventControllerScrollFlags","text":"Describes the behavior of a GtkEventControllerScroll.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.EventSequenceState","page":"Gtk4 Reference","title":"Gtk4.EventSequenceState","text":"Describes the state of a [struct@Gdk.EventSequence] in a [class@Gesture].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.EventType","page":"Gtk4 Reference","title":"Gtk4.EventType","text":"Specifies the type of the event.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FileChooserAction","page":"Gtk4 Reference","title":"Gtk4.FileChooserAction","text":"Describes whether a GtkFileChooser is being used to open existing files or to save to a possibly new file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FileChooserError","page":"Gtk4 Reference","title":"Gtk4.FileChooserError","text":"These identify the various errors that can occur while calling GtkFileChooser functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FilterChange","page":"Gtk4 Reference","title":"Gtk4.FilterChange","text":"Describes changes in a filter in more detail and allows objects using the filter to optimize refiltering items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FilterMatch","page":"Gtk4 Reference","title":"Gtk4.FilterMatch","text":"Describes the known strictness of a filter.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FontChooserLevel","page":"Gtk4 Reference","title":"Gtk4.FontChooserLevel","text":"Specifies the granularity of font selection that is desired in a GtkFontChooser.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FrameClockPhase","page":"Gtk4 Reference","title":"Gtk4.FrameClockPhase","text":"Used to represent the different paint clock phases that can be requested.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.FullscreenMode","page":"Gtk4 Reference","title":"Gtk4.FullscreenMode","text":"Indicates which monitor a surface should span over when in fullscreen mode.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GLAPI","page":"Gtk4 Reference","title":"Gtk4.GLAPI","text":"The list of the different APIs that GdkGLContext can potentially support.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GLError","page":"Gtk4 Reference","title":"Gtk4.GLError","text":"Error enumeration for GdkGLContext.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkAppLaunchContext","page":"Gtk4 Reference","title":"Gtk4.GdkAppLaunchContext","text":"GdkAppLaunchContext handles launching an application in a graphical context.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkButtonEvent","page":"Gtk4 Reference","title":"Gtk4.GdkButtonEvent","text":"An event related to a button on a pointer device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkCairoContext","page":"Gtk4 Reference","title":"Gtk4.GdkCairoContext","text":"GdkCairoContext is an object representing the platform-specific draw context.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkClipboard","page":"Gtk4 Reference","title":"Gtk4.GdkClipboard","text":"The GdkClipboard object represents data shared between applications or inside an application.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkContentDeserializer","page":"Gtk4 Reference","title":"Gtk4.GdkContentDeserializer","text":"A GdkContentDeserializer is used to deserialize content received via inter-application data transfers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkContentFormats","page":"Gtk4 Reference","title":"Gtk4.GdkContentFormats","text":"The GdkContentFormats structure is used to advertise and negotiate the format of content.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkContentFormatsBuilder","page":"Gtk4 Reference","title":"Gtk4.GdkContentFormatsBuilder","text":"A GdkContentFormatsBuilder is an auxiliary struct used to create new GdkContentFormats, and should not be kept around.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkContentProvider","page":"Gtk4 Reference","title":"Gtk4.GdkContentProvider","text":"A GdkContentProvider is used to provide content for the clipboard or for drag-and-drop operations in a number of formats.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkContentSerializer","page":"Gtk4 Reference","title":"Gtk4.GdkContentSerializer","text":"A GdkContentSerializer is used to serialize content for inter-application data transfers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkCrossingEvent","page":"Gtk4 Reference","title":"Gtk4.GdkCrossingEvent","text":"An event caused by a pointing device moving between surfaces.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkCursor","page":"Gtk4 Reference","title":"Gtk4.GdkCursor","text":"GdkCursor is used to create and destroy cursors.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDNDEvent","page":"Gtk4 Reference","title":"Gtk4.GdkDNDEvent","text":"An event related to drag and drop operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDeleteEvent","page":"Gtk4 Reference","title":"Gtk4.GdkDeleteEvent","text":"An event related to closing a top-level surface.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDevice","page":"Gtk4 Reference","title":"Gtk4.GdkDevice","text":"The GdkDevice object represents an input device, such as a keyboard, a mouse, or a touchpad.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDeviceTool","page":"Gtk4 Reference","title":"Gtk4.GdkDeviceTool","text":"A physical tool associated to a GdkDevice.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDisplay","page":"Gtk4 Reference","title":"Gtk4.GdkDisplay","text":"GdkDisplay objects are the GDK representation of a workstation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDisplayManager","page":"Gtk4 Reference","title":"Gtk4.GdkDisplayManager","text":"A singleton object that offers notification when displays appear or disappear.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDrag","page":"Gtk4 Reference","title":"Gtk4.GdkDrag","text":"The GdkDrag object represents the source of an ongoing DND operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDrawContext","page":"Gtk4 Reference","title":"Gtk4.GdkDrawContext","text":"Base class for objects implementing different rendering methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkDrop","page":"Gtk4 Reference","title":"Gtk4.GdkDrop","text":"The GdkDrop object represents the target of an ongoing DND operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkEvent","page":"Gtk4 Reference","title":"Gtk4.GdkEvent","text":"GdkEvents are immutable data structures, created by GDK to represent windowing system events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkEventSequence","page":"Gtk4 Reference","title":"Gtk4.GdkEventSequence","text":"GdkEventSequence is an opaque type representing a sequence of related touch events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkFileList","page":"Gtk4 Reference","title":"Gtk4.GdkFileList","text":"An opaque type representing a list of files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkFocusEvent","page":"Gtk4 Reference","title":"Gtk4.GdkFocusEvent","text":"An event related to a keyboard focus change.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkFrameClock","page":"Gtk4 Reference","title":"Gtk4.GdkFrameClock","text":"A GdkFrameClock tells the application when to update and repaint a surface.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkFrameTimings","page":"Gtk4 Reference","title":"Gtk4.GdkFrameTimings","text":"A GdkFrameTimings object holds timing information for a single frame of the application’s displays.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkGLContext","page":"Gtk4 Reference","title":"Gtk4.GdkGLContext","text":"GdkGLContext is an object representing a platform-specific OpenGL draw context.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkGLTexture","page":"Gtk4 Reference","title":"Gtk4.GdkGLTexture","text":"A GdkTexture representing a GL texture object.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkGrabBrokenEvent","page":"Gtk4 Reference","title":"Gtk4.GdkGrabBrokenEvent","text":"An event related to a broken windowing system grab.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkKeyEvent","page":"Gtk4 Reference","title":"Gtk4.GdkKeyEvent","text":"An event related to a key-based device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkKeymapKey","page":"Gtk4 Reference","title":"Gtk4.GdkKeymapKey","text":"A GdkKeymapKey is a hardware key that can be mapped to a keyval.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkMemoryTexture","page":"Gtk4 Reference","title":"Gtk4.GdkMemoryTexture","text":"A GdkTexture representing image data in memory.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkMonitor","page":"Gtk4 Reference","title":"Gtk4.GdkMonitor","text":"GdkMonitor objects represent the individual outputs that are associated with a GdkDisplay.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkMotionEvent","page":"Gtk4 Reference","title":"Gtk4.GdkMotionEvent","text":"An event related to a pointer or touch device motion.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkPadEvent","page":"Gtk4 Reference","title":"Gtk4.GdkPadEvent","text":"An event related to a pad-based device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkPopupLayout","page":"Gtk4 Reference","title":"Gtk4.GdkPopupLayout","text":"The GdkPopupLayout struct contains information that is necessary position a [iface@Gdk.Popup] relative to its parent.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkProximityEvent","page":"Gtk4 Reference","title":"Gtk4.GdkProximityEvent","text":"An event related to the proximity of a tool to a device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkRGBA","page":"Gtk4 Reference","title":"Gtk4.GdkRGBA","text":"A GdkRGBA is used to represent a color, in a way that is compatible with cairo’s notion of color.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkRectangle","page":"Gtk4 Reference","title":"Gtk4.GdkRectangle","text":"A GdkRectangle data type for representing rectangles.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkScrollEvent","page":"Gtk4 Reference","title":"Gtk4.GdkScrollEvent","text":"An event related to a scrolling motion.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkSeat","page":"Gtk4 Reference","title":"Gtk4.GdkSeat","text":"The GdkSeat object represents a collection of input devices that belong to a user.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkSnapshot","page":"Gtk4 Reference","title":"Gtk4.GdkSnapshot","text":"Base type for snapshot operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkSurface","page":"Gtk4 Reference","title":"Gtk4.GdkSurface","text":"A GdkSurface is a rectangular region on the screen.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkTexture","page":"Gtk4 Reference","title":"Gtk4.GdkTexture","text":"GdkTexture is the basic element used to refer to pixel data.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkTimeCoord","page":"Gtk4 Reference","title":"Gtk4.GdkTimeCoord","text":"A GdkTimeCoord stores a single event in a motion history.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkToplevelLayout","page":"Gtk4 Reference","title":"Gtk4.GdkToplevelLayout","text":"The GdkToplevelLayout struct contains information that is necessary to present a sovereign window on screen.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkTouchEvent","page":"Gtk4 Reference","title":"Gtk4.GdkTouchEvent","text":"An event related to a touch-based device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkTouchpadEvent","page":"Gtk4 Reference","title":"Gtk4.GdkTouchpadEvent","text":"An event related to a gesture on a touchpad device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GdkVulkanContext","page":"Gtk4 Reference","title":"Gtk4.GdkVulkanContext","text":"GdkVulkanContext is an object representing the platform-specific Vulkan draw context.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Gravity","page":"Gtk4 Reference","title":"Gtk4.Gravity","text":"Defines the reference point of a surface and is used in GdkPopupLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskCairoRenderer","page":"Gtk4 Reference","title":"Gtk4.GskCairoRenderer","text":"A GSK renderer that is using cairo.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskColorStop","page":"Gtk4 Reference","title":"Gtk4.GskColorStop","text":"A color stop in a gradient node.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskGLShader","page":"Gtk4 Reference","title":"Gtk4.GskGLShader","text":"A GskGLShader is a snippet of GLSL that is meant to run in the fragment shader of the rendering pipeline.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskParseLocation","page":"Gtk4 Reference","title":"Gtk4.GskParseLocation","text":"A location in a parse buffer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskRenderNode","page":"Gtk4 Reference","title":"Gtk4.GskRenderNode","text":"GskRenderNode is the basic block in a scene graph to be rendered using [class@Gsk.Renderer].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskRenderer","page":"Gtk4 Reference","title":"Gtk4.GskRenderer","text":"GskRenderer is a class that renders a scene graph defined via a tree of [class@Gsk.RenderNode] instances.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskRoundedRect","page":"Gtk4 Reference","title":"Gtk4.GskRoundedRect","text":"A rectangular region with rounded corners.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskShadow","page":"Gtk4 Reference","title":"Gtk4.GskShadow","text":"The shadow parameters in a shadow node.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GskTransform","page":"Gtk4 Reference","title":"Gtk4.GskTransform","text":"GskTransform is an object to describe transform matrices.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkATContext","page":"Gtk4 Reference","title":"Gtk4.GtkATContext","text":"GtkATContext is an abstract class provided by GTK to communicate to platform-specific assistive technologies API.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAboutDialog","page":"Gtk4 Reference","title":"Gtk4.GtkAboutDialog","text":"The GtkAboutDialog offers a simple way to display information about a program.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkActionBar","page":"Gtk4 Reference","title":"Gtk4.GtkActionBar","text":"GtkActionBar is designed to present contextual actions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkActivateAction","page":"Gtk4 Reference","title":"Gtk4.GtkActivateAction","text":"A GtkShortcutAction that calls gtkwidgetactivate().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAdjustment","page":"Gtk4 Reference","title":"Gtk4.GtkAdjustment","text":"GtkAdjustment is a model for a numeric value.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAlternativeTrigger","page":"Gtk4 Reference","title":"Gtk4.GtkAlternativeTrigger","text":"A GtkShortcutTrigger that combines two triggers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAnyFilter","page":"Gtk4 Reference","title":"Gtk4.GtkAnyFilter","text":"GtkAnyFilter matches an item when at least one of its filters matches.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAppChooserButton","page":"Gtk4 Reference","title":"Gtk4.GtkAppChooserButton","text":"The GtkAppChooserButton lets the user select an application.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAppChooserDialog","page":"Gtk4 Reference","title":"Gtk4.GtkAppChooserDialog","text":"GtkAppChooserDialog shows a GtkAppChooserWidget inside a GtkDialog.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAppChooserWidget","page":"Gtk4 Reference","title":"Gtk4.GtkAppChooserWidget","text":"GtkAppChooserWidget is a widget for selecting applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkApplication","page":"Gtk4 Reference","title":"Gtk4.GtkApplication","text":"GtkApplication is a high-level API for writing applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkApplicationWindow","page":"Gtk4 Reference","title":"Gtk4.GtkApplicationWindow","text":"GtkApplicationWindow is a GtkWindow subclass that integrates with GtkApplication.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAspectFrame","page":"Gtk4 Reference","title":"Gtk4.GtkAspectFrame","text":"GtkAspectFrame preserves the aspect ratio of its child.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAssistant","page":"Gtk4 Reference","title":"Gtk4.GtkAssistant","text":"GtkAssistant is used to represent a complex as a series of steps.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkAssistantPage","page":"Gtk4 Reference","title":"Gtk4.GtkAssistantPage","text":"GtkAssistantPage is an auxiliary object used by `GtkAssistant.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBinLayout","page":"Gtk4 Reference","title":"Gtk4.GtkBinLayout","text":"GtkBinLayout is a GtkLayoutManager subclass useful for create \"bins\" of widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBitset","page":"Gtk4 Reference","title":"Gtk4.GtkBitset","text":"A GtkBitset represents a set of unsigned integers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBitsetIter","page":"Gtk4 Reference","title":"Gtk4.GtkBitsetIter","text":"An opaque, stack-allocated struct for iterating over the elements of a GtkBitset.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBookmarkList","page":"Gtk4 Reference","title":"Gtk4.GtkBookmarkList","text":"GtkBookmarkList is a list model that wraps GBookmarkFile.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBoolFilter","page":"Gtk4 Reference","title":"Gtk4.GtkBoolFilter","text":"GtkBoolFilter evaluates a boolean GtkExpression to determine whether to include items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBorder","page":"Gtk4 Reference","title":"Gtk4.GtkBorder","text":"A struct that specifies a border around a rectangular area.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBox","page":"Gtk4 Reference","title":"Gtk4.GtkBox","text":"The GtkBox widget arranges child widgets into a single row or column.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBoxLayout","page":"Gtk4 Reference","title":"Gtk4.GtkBoxLayout","text":"GtkBoxLayout is a layout manager that arranges children in a single row or column.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBuildableParseContext","page":"Gtk4 Reference","title":"Gtk4.GtkBuildableParseContext","text":"An opaque context struct for GtkBuildableParser.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBuildableParser","page":"Gtk4 Reference","title":"Gtk4.GtkBuildableParser","text":"A sub-parser for GtkBuildable implementations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBuilder","page":"Gtk4 Reference","title":"Gtk4.GtkBuilder","text":"A GtkBuilder reads XML descriptions of a user interface and instantiates the described objects.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBuilderCScope","page":"Gtk4 Reference","title":"Gtk4.GtkBuilderCScope","text":"A GtkBuilderScope implementation for the C language.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkBuilderListItemFactory","page":"Gtk4 Reference","title":"Gtk4.GtkBuilderListItemFactory","text":"GtkBuilderListItemFactory is a GtkListItemFactory that creates widgets by instantiating GtkBuilder UI templates.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkButton","page":"Gtk4 Reference","title":"Gtk4.GtkButton","text":"The GtkButton widget is generally used to trigger a callback function that is called when the button is pressed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCalendar","page":"Gtk4 Reference","title":"Gtk4.GtkCalendar","text":"GtkCalendar is a widget that displays a Gregorian calendar, one month at a time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCallbackAction","page":"Gtk4 Reference","title":"Gtk4.GtkCallbackAction","text":"A GtkShortcutAction that invokes a callback.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellArea","page":"Gtk4 Reference","title":"Gtk4.GtkCellArea","text":"An abstract class for laying out GtkCellRenderers\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellAreaBox","page":"Gtk4 Reference","title":"Gtk4.GtkCellAreaBox","text":"A cell area that renders GtkCellRenderers into a row or a column\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellAreaContext","page":"Gtk4 Reference","title":"Gtk4.GtkCellAreaContext","text":"Stores geometrical information for a series of rows in a GtkCellArea\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRenderer","page":"Gtk4 Reference","title":"Gtk4.GtkCellRenderer","text":"An object for rendering a single cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererAccel","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererAccel","text":"Renders a keyboard accelerator in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererCombo","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererCombo","text":"Renders a combobox in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererPixbuf","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererPixbuf","text":"Renders a pixbuf in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererProgress","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererProgress","text":"Renders numbers as progress bars\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererSpin","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererSpin","text":"Renders a spin button in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererSpinner","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererSpinner","text":"Renders a spinning animation in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererText","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererText","text":"Renders text in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellRendererToggle","page":"Gtk4 Reference","title":"Gtk4.GtkCellRendererToggle","text":"Renders a toggle button in a cell\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCellView","page":"Gtk4 Reference","title":"Gtk4.GtkCellView","text":"A widget displaying a single row of a GtkTreeModel\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCenterBox","page":"Gtk4 Reference","title":"Gtk4.GtkCenterBox","text":"GtkCenterBox arranges three children in a row, keeping the middle child centered as well as possible.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCenterLayout","page":"Gtk4 Reference","title":"Gtk4.GtkCenterLayout","text":"GtkCenterLayout is a layout manager that manages up to three children.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCheckButton","page":"Gtk4 Reference","title":"Gtk4.GtkCheckButton","text":"A GtkCheckButton places a label next to an indicator.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkColorButton","page":"Gtk4 Reference","title":"Gtk4.GtkColorButton","text":"The GtkColorButton allows to open a color chooser dialog to change the color.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkColorChooserDialog","page":"Gtk4 Reference","title":"Gtk4.GtkColorChooserDialog","text":"A dialog for choosing a color.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkColorChooserWidget","page":"Gtk4 Reference","title":"Gtk4.GtkColorChooserWidget","text":"The GtkColorChooserWidget widget lets the user select a color.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkColumnView","page":"Gtk4 Reference","title":"Gtk4.GtkColumnView","text":"GtkColumnView presents a large dynamic list of items using multiple columns with headers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkColumnViewColumn","page":"Gtk4 Reference","title":"Gtk4.GtkColumnViewColumn","text":"GtkColumnViewColumn represents the columns being added to GtkColumnView.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkComboBox","page":"Gtk4 Reference","title":"Gtk4.GtkComboBox","text":"A GtkComboBox is a widget that allows the user to choose from a list of valid choices.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkComboBoxText","page":"Gtk4 Reference","title":"Gtk4.GtkComboBoxText","text":"A GtkComboBoxText is a simple variant of GtkComboBox for text-only use cases.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkConstraint","page":"Gtk4 Reference","title":"Gtk4.GtkConstraint","text":"GtkConstraint describes a constraint between attributes of two widgets, expressed as a linear equation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkConstraintGuide","page":"Gtk4 Reference","title":"Gtk4.GtkConstraintGuide","text":"A GtkConstraintGuide is an invisible layout element in a GtkConstraintLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkConstraintLayout","page":"Gtk4 Reference","title":"Gtk4.GtkConstraintLayout","text":"A layout manager using constraints to describe relations between widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkConstraintLayoutChild","page":"Gtk4 Reference","title":"Gtk4.GtkConstraintLayoutChild","text":"GtkLayoutChild subclass for children in a GtkConstraintLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCssLocation","page":"Gtk4 Reference","title":"Gtk4.GtkCssLocation","text":"Represents a location in a file or other source of data parsed by the CSS engine.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCssProvider","page":"Gtk4 Reference","title":"Gtk4.GtkCssProvider","text":"GtkCssProvider is an object implementing the GtkStyleProvider interface for CSS.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCssSection","page":"Gtk4 Reference","title":"Gtk4.GtkCssSection","text":"Defines a part of a CSS document.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCustomFilter","page":"Gtk4 Reference","title":"Gtk4.GtkCustomFilter","text":"GtkCustomFilter determines whether to include items with a callback.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCustomLayout","page":"Gtk4 Reference","title":"Gtk4.GtkCustomLayout","text":"GtkCustomLayout uses closures for size negotiation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkCustomSorter","page":"Gtk4 Reference","title":"Gtk4.GtkCustomSorter","text":"GtkCustomSorter is a GtkSorter implementation that sorts via a callback function.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDialog","page":"Gtk4 Reference","title":"Gtk4.GtkDialog","text":"Dialogs are a convenient way to prompt the user for a small amount of input.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDirectoryList","page":"Gtk4 Reference","title":"Gtk4.GtkDirectoryList","text":"GtkDirectoryList is a list model that wraps gfileenumeratechildrenasync().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDragIcon","page":"Gtk4 Reference","title":"Gtk4.GtkDragIcon","text":"GtkDragIcon is a GtkRoot implementation for drag icons.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDragSource","page":"Gtk4 Reference","title":"Gtk4.GtkDragSource","text":"GtkDragSource is an event controller to initiate Drag-And-Drop operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDrawingArea","page":"Gtk4 Reference","title":"Gtk4.GtkDrawingArea","text":"GtkDrawingArea is a widget that allows drawing with cairo.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDropControllerMotion","page":"Gtk4 Reference","title":"Gtk4.GtkDropControllerMotion","text":"GtkDropControllerMotion is an event controller tracking the pointer during Drag-and-Drop operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDropDown","page":"Gtk4 Reference","title":"Gtk4.GtkDropDown","text":"GtkDropDown is a widget that allows the user to choose an item from a list of options.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDropTarget","page":"Gtk4 Reference","title":"Gtk4.GtkDropTarget","text":"GtkDropTarget is an event controller to receive Drag-and-Drop operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkDropTargetAsync","page":"Gtk4 Reference","title":"Gtk4.GtkDropTargetAsync","text":"GtkDropTargetAsync is an event controller to receive Drag-and-Drop operations, asynchronously.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEditableLabel","page":"Gtk4 Reference","title":"Gtk4.GtkEditableLabel","text":"A GtkEditableLabel is a label that allows users to edit the text by switching to an “edit mode”.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEmojiChooser","page":"Gtk4 Reference","title":"Gtk4.GtkEmojiChooser","text":"The GtkEmojiChooser is used by text widgets such as GtkEntry or GtkTextView to let users insert Emoji characters.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEntry","page":"Gtk4 Reference","title":"Gtk4.GtkEntry","text":"GtkEntry is a single line text entry widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEntryBuffer","page":"Gtk4 Reference","title":"Gtk4.GtkEntryBuffer","text":"A GtkEntryBuffer hold the text displayed in a GtkText widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEntryCompletion","page":"Gtk4 Reference","title":"Gtk4.GtkEntryCompletion","text":"GtkEntryCompletion is an auxiliary object to provide completion functionality for GtkEntry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventController","page":"Gtk4 Reference","title":"Gtk4.GtkEventController","text":"GtkEventController is the base class for event controllers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventControllerFocus","page":"Gtk4 Reference","title":"Gtk4.GtkEventControllerFocus","text":"GtkEventControllerFocus is an event controller to keep track of keyboard focus.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventControllerKey","page":"Gtk4 Reference","title":"Gtk4.GtkEventControllerKey","text":"GtkEventControllerKey is an event controller that provides access to key events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventControllerLegacy","page":"Gtk4 Reference","title":"Gtk4.GtkEventControllerLegacy","text":"GtkEventControllerLegacy is an event controller that provides raw access to the event stream.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventControllerMotion","page":"Gtk4 Reference","title":"Gtk4.GtkEventControllerMotion","text":"GtkEventControllerMotion is an event controller tracking the pointer position.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEventControllerScroll","page":"Gtk4 Reference","title":"Gtk4.GtkEventControllerScroll","text":"GtkEventControllerScroll is an event controller that handles scroll events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkEveryFilter","page":"Gtk4 Reference","title":"Gtk4.GtkEveryFilter","text":"GtkEveryFilter matches an item when each of its filters matches.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkExpander","page":"Gtk4 Reference","title":"Gtk4.GtkExpander","text":"GtkExpander allows the user to reveal its child by clicking on an expander triangle.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkExpression","page":"Gtk4 Reference","title":"Gtk4.GtkExpression","text":"GtkExpression provides a way to describe references to values.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkExpressionWatch","page":"Gtk4 Reference","title":"Gtk4.GtkExpressionWatch","text":"An opaque structure representing a watched GtkExpression.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFileChooserDialog","page":"Gtk4 Reference","title":"Gtk4.GtkFileChooserDialog","text":"GtkFileChooserDialog is a dialog suitable for use with “File Open” or “File Save” commands.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFileChooserNative","page":"Gtk4 Reference","title":"Gtk4.GtkFileChooserNative","text":"GtkFileChooserNative is an abstraction of a dialog suitable for use with “File Open” or “File Save as” commands.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFileChooserWidget","page":"Gtk4 Reference","title":"Gtk4.GtkFileChooserWidget","text":"GtkFileChooserWidget is a widget for choosing files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFileFilter","page":"Gtk4 Reference","title":"Gtk4.GtkFileFilter","text":"GtkFileFilter filters files by name or mime type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFilter","page":"Gtk4 Reference","title":"Gtk4.GtkFilter","text":"A GtkFilter object describes the filtering to be performed by a [class@Gtk.FilterListModel].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFilterListModel","page":"Gtk4 Reference","title":"Gtk4.GtkFilterListModel","text":"GtkFilterListModel is a list model that filters the elements of the underlying model according to a GtkFilter.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFixed","page":"Gtk4 Reference","title":"Gtk4.GtkFixed","text":"GtkFixed places its child widgets at fixed positions and with fixed sizes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFixedLayout","page":"Gtk4 Reference","title":"Gtk4.GtkFixedLayout","text":"GtkFixedLayout is a layout manager which can place child widgets at fixed positions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFixedLayoutChild","page":"Gtk4 Reference","title":"Gtk4.GtkFixedLayoutChild","text":"GtkLayoutChild subclass for children in a GtkFixedLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFlattenListModel","page":"Gtk4 Reference","title":"Gtk4.GtkFlattenListModel","text":"GtkFlattenListModel is a list model that concatenates other list models.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFlowBox","page":"Gtk4 Reference","title":"Gtk4.GtkFlowBox","text":"A GtkFlowBox puts child widgets in reflowing grid.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFlowBoxChild","page":"Gtk4 Reference","title":"Gtk4.GtkFlowBoxChild","text":"GtkFlowBoxChild is the kind of widget that can be added to a GtkFlowBox.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFontButton","page":"Gtk4 Reference","title":"Gtk4.GtkFontButton","text":"The GtkFontButton allows to open a font chooser dialog to change the font.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFontChooserDialog","page":"Gtk4 Reference","title":"Gtk4.GtkFontChooserDialog","text":"The GtkFontChooserDialog widget is a dialog for selecting a font.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFontChooserWidget","page":"Gtk4 Reference","title":"Gtk4.GtkFontChooserWidget","text":"The GtkFontChooserWidget widget lets the user select a font.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkFrame","page":"Gtk4 Reference","title":"Gtk4.GtkFrame","text":"GtkFrame is a widget that surrounds its child with a decorative frame and an optional label.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGLArea","page":"Gtk4 Reference","title":"Gtk4.GtkGLArea","text":"GtkGLArea is a widget that allows drawing with OpenGL.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGesture","page":"Gtk4 Reference","title":"Gtk4.GtkGesture","text":"GtkGesture is the base class for gesture recognition.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureClick","page":"Gtk4 Reference","title":"Gtk4.GtkGestureClick","text":"GtkGestureClick is a GtkGesture implementation for clicks.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureDrag","page":"Gtk4 Reference","title":"Gtk4.GtkGestureDrag","text":"GtkGestureDrag is a GtkGesture implementation for drags.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureLongPress","page":"Gtk4 Reference","title":"Gtk4.GtkGestureLongPress","text":"GtkGestureLongPress is a GtkGesture for long presses.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGesturePan","page":"Gtk4 Reference","title":"Gtk4.GtkGesturePan","text":"GtkGesturePan is a GtkGesture for pan gestures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureRotate","page":"Gtk4 Reference","title":"Gtk4.GtkGestureRotate","text":"GtkGestureRotate is a GtkGesture for 2-finger rotations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureSingle","page":"Gtk4 Reference","title":"Gtk4.GtkGestureSingle","text":"GtkGestureSingle is a GtkGestures subclass optimized for singe-touch and mouse gestures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureStylus","page":"Gtk4 Reference","title":"Gtk4.GtkGestureStylus","text":"GtkGestureStylus is a GtkGesture specific to stylus input.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureSwipe","page":"Gtk4 Reference","title":"Gtk4.GtkGestureSwipe","text":"GtkGestureSwipe is a GtkGesture for swipe gestures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGestureZoom","page":"Gtk4 Reference","title":"Gtk4.GtkGestureZoom","text":"GtkGestureZoom is a GtkGesture for 2-finger pinch/zoom gestures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGrid","page":"Gtk4 Reference","title":"Gtk4.GtkGrid","text":"GtkGrid is a container which arranges its child widgets in rows and columns.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGridLayout","page":"Gtk4 Reference","title":"Gtk4.GtkGridLayout","text":"GtkGridLayout is a layout manager which arranges child widgets in rows and columns.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGridLayoutChild","page":"Gtk4 Reference","title":"Gtk4.GtkGridLayoutChild","text":"GtkLayoutChild subclass for children in a GtkGridLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkGridView","page":"Gtk4 Reference","title":"Gtk4.GtkGridView","text":"GtkGridView presents a large dynamic grid of items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkHeaderBar","page":"Gtk4 Reference","title":"Gtk4.GtkHeaderBar","text":"GtkHeaderBar is a widget for creating custom title bars for windows.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIMContext","page":"Gtk4 Reference","title":"Gtk4.GtkIMContext","text":"GtkIMContext defines the interface for GTK input methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIMContextSimple","page":"Gtk4 Reference","title":"Gtk4.GtkIMContextSimple","text":"GtkIMContextSimple is an input method supporting table-based input methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIMMulticontext","page":"Gtk4 Reference","title":"Gtk4.GtkIMMulticontext","text":"GtkIMMulticontext is an input method context supporting multiple, switchable input methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIconPaintable","page":"Gtk4 Reference","title":"Gtk4.GtkIconPaintable","text":"Contains information found when looking up an icon in GtkIconTheme.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIconTheme","page":"Gtk4 Reference","title":"Gtk4.GtkIconTheme","text":"GtkIconTheme provides a facility for loading themed icons.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkIconView","page":"Gtk4 Reference","title":"Gtk4.GtkIconView","text":"GtkIconView is a widget which displays data in a grid of icons.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkImage","page":"Gtk4 Reference","title":"Gtk4.GtkImage","text":"The GtkImage widget displays an image.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkInfoBar","page":"Gtk4 Reference","title":"Gtk4.GtkInfoBar","text":"GtkInfoBar can be show messages to the user without a dialog.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkInscription","page":"Gtk4 Reference","title":"Gtk4.GtkInscription","text":"GtkInscription is a widget to show text in a predefined area.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkKeyvalTrigger","page":"Gtk4 Reference","title":"Gtk4.GtkKeyvalTrigger","text":"A GtkShortcutTrigger that triggers when a specific keyval and modifiers are pressed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLabel","page":"Gtk4 Reference","title":"Gtk4.GtkLabel","text":"The GtkLabel widget displays a small amount of text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLayoutChild","page":"Gtk4 Reference","title":"Gtk4.GtkLayoutChild","text":"GtkLayoutChild is the base class for objects that are meant to hold layout properties.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLayoutManager","page":"Gtk4 Reference","title":"Gtk4.GtkLayoutManager","text":"Layout managers are delegate classes that handle the preferred size and the allocation of a widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLevelBar","page":"Gtk4 Reference","title":"Gtk4.GtkLevelBar","text":"GtkLevelBar is a widget that can be used as a level indicator.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLinkButton","page":"Gtk4 Reference","title":"Gtk4.GtkLinkButton","text":"A GtkLinkButton is a button with a hyperlink.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListBase","page":"Gtk4 Reference","title":"Gtk4.GtkListBase","text":"GtkListBase is the abstract base class for GTK's list widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListBox","page":"Gtk4 Reference","title":"Gtk4.GtkListBox","text":"GtkListBox is a vertical list.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListBoxRow","page":"Gtk4 Reference","title":"Gtk4.GtkListBoxRow","text":"GtkListBoxRow is the kind of widget that can be added to a GtkListBox.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListItem","page":"Gtk4 Reference","title":"Gtk4.GtkListItem","text":"GtkListItem is used by list widgets to represent items in a GListModel.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListItemFactory","page":"Gtk4 Reference","title":"Gtk4.GtkListItemFactory","text":"A GtkListItemFactory creates widgets for the items taken from a GListModel.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListStore","page":"Gtk4 Reference","title":"Gtk4.GtkListStore","text":"A list-like data structure that can be used with the [class@Gtk.TreeView].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkListView","page":"Gtk4 Reference","title":"Gtk4.GtkListView","text":"GtkListView presents a large dynamic list of items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkLockButton","page":"Gtk4 Reference","title":"Gtk4.GtkLockButton","text":"GtkLockButton is a widget to obtain and revoke authorizations needed to operate the controls.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMapListModel","page":"Gtk4 Reference","title":"Gtk4.GtkMapListModel","text":"A GtkMapListModel maps the items in a list model to different items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMediaControls","page":"Gtk4 Reference","title":"Gtk4.GtkMediaControls","text":"GtkMediaControls is a widget to show controls for a video.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMediaFile","page":"Gtk4 Reference","title":"Gtk4.GtkMediaFile","text":"GtkMediaFile implements GtkMediaStream for files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMediaStream","page":"Gtk4 Reference","title":"Gtk4.GtkMediaStream","text":"GtkMediaStream is the integration point for media playback inside GTK.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMenuButton","page":"Gtk4 Reference","title":"Gtk4.GtkMenuButton","text":"The GtkMenuButton widget is used to display a popup when clicked.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMessageDialog","page":"Gtk4 Reference","title":"Gtk4.GtkMessageDialog","text":"GtkMessageDialog presents a dialog with some message text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMnemonicAction","page":"Gtk4 Reference","title":"Gtk4.GtkMnemonicAction","text":"A GtkShortcutAction that calls gtkwidgetmnemonic_activate().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMnemonicTrigger","page":"Gtk4 Reference","title":"Gtk4.GtkMnemonicTrigger","text":"A GtkShortcutTrigger that triggers when a specific mnemonic is pressed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMountOperation","page":"Gtk4 Reference","title":"Gtk4.GtkMountOperation","text":"GtkMountOperation is an implementation of GMountOperation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMultiFilter","page":"Gtk4 Reference","title":"Gtk4.GtkMultiFilter","text":"GtkMultiFilter is the base class for filters that combine multiple filters.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMultiSelection","page":"Gtk4 Reference","title":"Gtk4.GtkMultiSelection","text":"GtkMultiSelection is a GtkSelectionModel that allows selecting multiple elements.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkMultiSorter","page":"Gtk4 Reference","title":"Gtk4.GtkMultiSorter","text":"GtkMultiSorter combines multiple sorters by trying them in turn.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNamedAction","page":"Gtk4 Reference","title":"Gtk4.GtkNamedAction","text":"A GtkShortcutAction that activates an action by name.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNativeDialog","page":"Gtk4 Reference","title":"Gtk4.GtkNativeDialog","text":"Native dialogs are platform dialogs that don't use GtkDialog.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNeverTrigger","page":"Gtk4 Reference","title":"Gtk4.GtkNeverTrigger","text":"A GtkShortcutTrigger that never triggers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNoSelection","page":"Gtk4 Reference","title":"Gtk4.GtkNoSelection","text":"GtkNoSelection is a GtkSelectionModel that does not allow selecting anything.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNotebook","page":"Gtk4 Reference","title":"Gtk4.GtkNotebook","text":"GtkNotebook is a container whose children are pages switched between using tabs.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNotebookPage","page":"Gtk4 Reference","title":"Gtk4.GtkNotebookPage","text":"GtkNotebookPage is an auxiliary object used by GtkNotebook.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNothingAction","page":"Gtk4 Reference","title":"Gtk4.GtkNothingAction","text":"A GtkShortcutAction that does nothing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkNumericSorter","page":"Gtk4 Reference","title":"Gtk4.GtkNumericSorter","text":"GtkNumericSorter is a GtkSorter that compares numbers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkOverlay","page":"Gtk4 Reference","title":"Gtk4.GtkOverlay","text":"GtkOverlay is a container which contains a single main child, on top of which it can place “overlay” widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkOverlayLayout","page":"Gtk4 Reference","title":"Gtk4.GtkOverlayLayout","text":"GtkOverlayLayout is the layout manager used by GtkOverlay.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkOverlayLayoutChild","page":"Gtk4 Reference","title":"Gtk4.GtkOverlayLayoutChild","text":"GtkLayoutChild subclass for children in a GtkOverlayLayout.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPadActionEntry","page":"Gtk4 Reference","title":"Gtk4.GtkPadActionEntry","text":"Struct defining a pad action entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPadController","page":"Gtk4 Reference","title":"Gtk4.GtkPadController","text":"GtkPadController is an event controller for the pads found in drawing tablets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPageSetup","page":"Gtk4 Reference","title":"Gtk4.GtkPageSetup","text":"A GtkPageSetup object stores the page size, orientation and margins.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPaned","page":"Gtk4 Reference","title":"Gtk4.GtkPaned","text":"A widget with two panes, arranged either horizontally or vertically.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPaperSize","page":"Gtk4 Reference","title":"Gtk4.GtkPaperSize","text":"GtkPaperSize handles paper sizes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPasswordEntry","page":"Gtk4 Reference","title":"Gtk4.GtkPasswordEntry","text":"GtkPasswordEntry is an entry that has been tailored for entering secrets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPasswordEntryBuffer","page":"Gtk4 Reference","title":"Gtk4.GtkPasswordEntryBuffer","text":"A GtkEntryBuffer that locks the underlying memory to prevent it from being swapped to disk.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPicture","page":"Gtk4 Reference","title":"Gtk4.GtkPicture","text":"The GtkPicture widget displays a GdkPaintable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPopover","page":"Gtk4 Reference","title":"Gtk4.GtkPopover","text":"GtkPopover is a bubble-like context popup.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPopoverMenu","page":"Gtk4 Reference","title":"Gtk4.GtkPopoverMenu","text":"GtkPopoverMenu is a subclass of GtkPopover that implements menu behavior.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPopoverMenuBar","page":"Gtk4 Reference","title":"Gtk4.GtkPopoverMenuBar","text":"GtkPopoverMenuBar presents a horizontal bar of items that pop up popover menus when clicked.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPrintContext","page":"Gtk4 Reference","title":"Gtk4.GtkPrintContext","text":"A GtkPrintContext encapsulates context information that is required when drawing pages for printing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPrintJob","page":"Gtk4 Reference","title":"Gtk4.GtkPrintJob","text":"A GtkPrintJob object represents a job that is sent to a printer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPrintOperation","page":"Gtk4 Reference","title":"Gtk4.GtkPrintOperation","text":"GtkPrintOperation is the high-level, portable printing API.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPrintSettings","page":"Gtk4 Reference","title":"Gtk4.GtkPrintSettings","text":"A GtkPrintSettings object represents the settings of a print dialog in a system-independent way.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkPrinter","page":"Gtk4 Reference","title":"Gtk4.GtkPrinter","text":"A GtkPrinter object represents a printer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkProgressBar","page":"Gtk4 Reference","title":"Gtk4.GtkProgressBar","text":"GtkProgressBar is typically used to display the progress of a long running operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRange","page":"Gtk4 Reference","title":"Gtk4.GtkRange","text":"GtkRange is the common base class for widgets which visualize an adjustment.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRecentData","page":"Gtk4 Reference","title":"Gtk4.GtkRecentData","text":"Meta-data to be passed to gtkrecentmanageraddfull() when registering a recently used resource.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRecentInfo","page":"Gtk4 Reference","title":"Gtk4.GtkRecentInfo","text":"GtkRecentInfo contains the metadata associated with an item in the recently used files list.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRecentManager","page":"Gtk4 Reference","title":"Gtk4.GtkRecentManager","text":"GtkRecentManager manages and looks up recently used files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRequestedSize","page":"Gtk4 Reference","title":"Gtk4.GtkRequestedSize","text":"Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a natural size for children calling. See [func@distributenaturalallocation].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRequisition","page":"Gtk4 Reference","title":"Gtk4.GtkRequisition","text":"A GtkRequisition represents the desired size of a widget. See GtkWidget’s geometry management section for more information.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkRevealer","page":"Gtk4 Reference","title":"Gtk4.GtkRevealer","text":"A GtkRevealer animates the transition of its child from invisible to visible.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkScale","page":"Gtk4 Reference","title":"Gtk4.GtkScale","text":"A GtkScale is a slider control used to select a numeric value.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkScaleButton","page":"Gtk4 Reference","title":"Gtk4.GtkScaleButton","text":"GtkScaleButton provides a button which pops up a scale widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkScrollbar","page":"Gtk4 Reference","title":"Gtk4.GtkScrollbar","text":"The GtkScrollbar widget is a horizontal or vertical scrollbar.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkScrolledWindow","page":"Gtk4 Reference","title":"Gtk4.GtkScrolledWindow","text":"GtkScrolledWindow is a container that makes its child scrollable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSearchBar","page":"Gtk4 Reference","title":"Gtk4.GtkSearchBar","text":"GtkSearchBar is a container made to have a search entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSearchEntry","page":"Gtk4 Reference","title":"Gtk4.GtkSearchEntry","text":"GtkSearchEntry is an entry widget that has been tailored for use as a search entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSelectionFilterModel","page":"Gtk4 Reference","title":"Gtk4.GtkSelectionFilterModel","text":"GtkSelectionFilterModel is a list model that presents the selection from a GtkSelectionModel.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSeparator","page":"Gtk4 Reference","title":"Gtk4.GtkSeparator","text":"GtkSeparator is a horizontal or vertical separator widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSettings","page":"Gtk4 Reference","title":"Gtk4.GtkSettings","text":"GtkSettings provides a mechanism to share global settings between applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcut","page":"Gtk4 Reference","title":"Gtk4.GtkShortcut","text":"A GtkShortcut describes a keyboard shortcut.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutAction","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutAction","text":"GtkShortcutAction encodes an action that can be triggered by a keyboard shortcut.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutController","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutController","text":"GtkShortcutController is an event controller that manages shortcuts.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutLabel","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutLabel","text":"GtkShortcutLabel displays a single keyboard shortcut or gesture.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutTrigger","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutTrigger","text":"GtkShortcutTrigger tracks how a GtkShortcut should be activated.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutsGroup","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutsGroup","text":"A GtkShortcutsGroup represents a group of related keyboard shortcuts or gestures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutsSection","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutsSection","text":"A GtkShortcutsSection collects all the keyboard shortcuts and gestures for a major application mode.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutsShortcut","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutsShortcut","text":"A GtkShortcutsShortcut represents a single keyboard shortcut or gesture with a short text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkShortcutsWindow","page":"Gtk4 Reference","title":"Gtk4.GtkShortcutsWindow","text":"A GtkShortcutsWindow shows information about the keyboard shortcuts and gestures of an application.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSignalAction","page":"Gtk4 Reference","title":"Gtk4.GtkSignalAction","text":"A GtkShortcutAction that emits a signal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSignalListItemFactory","page":"Gtk4 Reference","title":"Gtk4.GtkSignalListItemFactory","text":"GtkSignalListItemFactory is a GtkListItemFactory that emits signals to to manage listitems.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSingleSelection","page":"Gtk4 Reference","title":"Gtk4.GtkSingleSelection","text":"GtkSingleSelection is a GtkSelectionModel that allows selecting a single item.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSizeGroup","page":"Gtk4 Reference","title":"Gtk4.GtkSizeGroup","text":"GtkSizeGroup groups widgets together so they all request the same size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSliceListModel","page":"Gtk4 Reference","title":"Gtk4.GtkSliceListModel","text":"GtkSliceListModel is a list model that presents a slice of another model.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSnapshot","page":"Gtk4 Reference","title":"Gtk4.GtkSnapshot","text":"GtkSnapshot assists in creating [class@Gsk.RenderNode]s for widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSortListModel","page":"Gtk4 Reference","title":"Gtk4.GtkSortListModel","text":"A GListModel that sorts the elements of an underlying model according to a GtkSorter.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSorter","page":"Gtk4 Reference","title":"Gtk4.GtkSorter","text":"GtkSorter is an object to describe sorting criteria.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSpinButton","page":"Gtk4 Reference","title":"Gtk4.GtkSpinButton","text":"A GtkSpinButton is an ideal way to allow the user to set the value of some attribute.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSpinner","page":"Gtk4 Reference","title":"Gtk4.GtkSpinner","text":"A GtkSpinner widget displays an icon-size spinning animation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStack","page":"Gtk4 Reference","title":"Gtk4.GtkStack","text":"GtkStack is a container which only shows one of its children at a time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStackPage","page":"Gtk4 Reference","title":"Gtk4.GtkStackPage","text":"GtkStackPage is an auxiliary class used by GtkStack.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStackSidebar","page":"Gtk4 Reference","title":"Gtk4.GtkStackSidebar","text":"A GtkStackSidebar uses a sidebar to switch between GtkStack pages.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStackSwitcher","page":"Gtk4 Reference","title":"Gtk4.GtkStackSwitcher","text":"The GtkStackSwitcher shows a row of buttons to switch between GtkStack pages.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStatusbar","page":"Gtk4 Reference","title":"Gtk4.GtkStatusbar","text":"A GtkStatusbar widget is usually placed along the bottom of an application's main [class@Gtk.Window].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStringFilter","page":"Gtk4 Reference","title":"Gtk4.GtkStringFilter","text":"GtkStringFilter determines whether to include items by comparing strings to a fixed search term.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStringList","page":"Gtk4 Reference","title":"Gtk4.GtkStringList","text":"GtkStringList is a list model that wraps an array of strings.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStringObject","page":"Gtk4 Reference","title":"Gtk4.GtkStringObject","text":"GtkStringObject is the type of items in a GtkStringList.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStringSorter","page":"Gtk4 Reference","title":"Gtk4.GtkStringSorter","text":"GtkStringSorter is a GtkSorter that compares strings.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkStyleContext","page":"Gtk4 Reference","title":"Gtk4.GtkStyleContext","text":"GtkStyleContext stores styling information affecting a widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkSwitch","page":"Gtk4 Reference","title":"Gtk4.GtkSwitch","text":"GtkSwitch is a \"light switch\" that has two states: on or off.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkText","page":"Gtk4 Reference","title":"Gtk4.GtkText","text":"The GtkText widget is a single-line text entry widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextBuffer","page":"Gtk4 Reference","title":"Gtk4.GtkTextBuffer","text":"Stores text and attributes for display in a GtkTextView.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextChildAnchor","page":"Gtk4 Reference","title":"Gtk4.GtkTextChildAnchor","text":"A GtkTextChildAnchor is a spot in a GtkTextBuffer where child widgets can be “anchored”.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextIter","page":"Gtk4 Reference","title":"Gtk4.GtkTextIter","text":"An iterator for the contents of a GtkTextBuffer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextMark","page":"Gtk4 Reference","title":"Gtk4.GtkTextMark","text":"A GtkTextMark is a position in a GtkTextbuffer that is preserved across modifications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextTag","page":"Gtk4 Reference","title":"Gtk4.GtkTextTag","text":"A tag that can be applied to text contained in a GtkTextBuffer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextTagTable","page":"Gtk4 Reference","title":"Gtk4.GtkTextTagTable","text":"The collection of tags in a GtkTextBuffer\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTextView","page":"Gtk4 Reference","title":"Gtk4.GtkTextView","text":"A widget that displays the contents of a [class@Gtk.TextBuffer].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkToggleButton","page":"Gtk4 Reference","title":"Gtk4.GtkToggleButton","text":"A GtkToggleButton is a button which remains “pressed-in” when clicked.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTooltip","page":"Gtk4 Reference","title":"Gtk4.GtkTooltip","text":"GtkTooltip is an object representing a widget tooltip.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeExpander","page":"Gtk4 Reference","title":"Gtk4.GtkTreeExpander","text":"GtkTreeExpander is a widget that provides an expander for a list.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeIter","page":"Gtk4 Reference","title":"Gtk4.GtkTreeIter","text":"The GtkTreeIter is the primary structure for accessing a GtkTreeModel. Models are expected to put a unique integer in the @stamp member, and put model-specific data in the three @user_data members.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeListModel","page":"Gtk4 Reference","title":"Gtk4.GtkTreeListModel","text":"GtkTreeListModel is a list model that can create child models on demand.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeListRow","page":"Gtk4 Reference","title":"Gtk4.GtkTreeListRow","text":"GtkTreeListRow is used by GtkTreeListModel to represent items.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeListRowSorter","page":"Gtk4 Reference","title":"Gtk4.GtkTreeListRowSorter","text":"GtkTreeListRowSorter is a special-purpose sorter that will apply a given sorter to the levels in a tree.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeModelFilter","page":"Gtk4 Reference","title":"Gtk4.GtkTreeModelFilter","text":"A GtkTreeModel which hides parts of an underlying tree model\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeModelSort","page":"Gtk4 Reference","title":"Gtk4.GtkTreeModelSort","text":"A GtkTreeModel which makes an underlying tree model sortable\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreePath","page":"Gtk4 Reference","title":"Gtk4.GtkTreePath","text":"An opaque structure representing a path to a row in a model.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeSelection","page":"Gtk4 Reference","title":"Gtk4.GtkTreeSelection","text":"The selection object for GtkTreeView\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeStore","page":"Gtk4 Reference","title":"Gtk4.GtkTreeStore","text":"A tree-like data structure that can be used with the GtkTreeView\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeView","page":"Gtk4 Reference","title":"Gtk4.GtkTreeView","text":"A widget for displaying both trees and lists\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkTreeViewColumn","page":"Gtk4 Reference","title":"Gtk4.GtkTreeViewColumn","text":"A visible column in a [class@Gtk.TreeView] widget\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkVideo","page":"Gtk4 Reference","title":"Gtk4.GtkVideo","text":"GtkVideo is a widget to show a GtkMediaStream with media controls.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkViewport","page":"Gtk4 Reference","title":"Gtk4.GtkViewport","text":"GtkViewport implements scrollability for widgets that lack their own scrolling capabilities.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkVolumeButton","page":"Gtk4 Reference","title":"Gtk4.GtkVolumeButton","text":"GtkVolumeButton is a GtkScaleButton subclass tailored for volume control.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWidget","page":"Gtk4 Reference","title":"Gtk4.GtkWidget","text":"The base class for all widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWidgetPaintable","page":"Gtk4 Reference","title":"Gtk4.GtkWidgetPaintable","text":"GtkWidgetPaintable is a GdkPaintable that displays the contents of a widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWindow","page":"Gtk4 Reference","title":"Gtk4.GtkWindow","text":"A GtkWindow is a toplevel window which can contain other widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWindowControls","page":"Gtk4 Reference","title":"Gtk4.GtkWindowControls","text":"GtkWindowControls shows window frame controls.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWindowGroup","page":"Gtk4 Reference","title":"Gtk4.GtkWindowGroup","text":"GtkWindowGroup makes group of windows behave like separate applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.GtkWindowHandle","page":"Gtk4 Reference","title":"Gtk4.GtkWindowHandle","text":"GtkWindowHandle is a titlebar area widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.IconLookupFlags","page":"Gtk4 Reference","title":"Gtk4.IconLookupFlags","text":"Used to specify options for gtkiconthemelookupicon().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.IconSize","page":"Gtk4 Reference","title":"Gtk4.IconSize","text":"Built-in icon sizes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.IconThemeError","page":"Gtk4 Reference","title":"Gtk4.IconThemeError","text":"Error codes for GtkIconTheme operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.IconViewDropPosition","page":"Gtk4 Reference","title":"Gtk4.IconViewDropPosition","text":"An enum for determining where a dropped item goes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ImageType","page":"Gtk4 Reference","title":"Gtk4.ImageType","text":"Describes the image data representation used by a [class@Gtk.Image].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.InputHints","page":"Gtk4 Reference","title":"Gtk4.InputHints","text":"Describes hints that might be taken into account by input methods or applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.InputPurpose","page":"Gtk4 Reference","title":"Gtk4.InputPurpose","text":"Describes primary purpose of the input widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.InputSource","page":"Gtk4 Reference","title":"Gtk4.InputSource","text":"An enumeration describing the type of an input device in general terms.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.InscriptionOverflow","page":"Gtk4 Reference","title":"Gtk4.InscriptionOverflow","text":"The different methods to handle text in #GtkInscription when it doesn't fit the available space.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Justification","page":"Gtk4 Reference","title":"Gtk4.Justification","text":"Used for justifying the text inside a [class@Label] widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.KeyMatch","page":"Gtk4 Reference","title":"Gtk4.KeyMatch","text":"Describes how well an event matches a given keyval and modifiers.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.LevelBarMode","page":"Gtk4 Reference","title":"Gtk4.LevelBarMode","text":"Describes how [class@LevelBar] contents should be rendered.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.License","page":"Gtk4 Reference","title":"Gtk4.License","text":"The type of license for an application.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.MemoryFormat","page":"Gtk4 Reference","title":"Gtk4.MemoryFormat","text":"GdkMemoryFormat describes formats that image data can have in memory.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.MessageType","page":"Gtk4 Reference","title":"Gtk4.MessageType","text":"The type of message being displayed in a [class@MessageDialog].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ModifierType","page":"Gtk4 Reference","title":"Gtk4.ModifierType","text":"Flags to indicate the state of modifier keys and mouse buttons in events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.MovementStep","page":"Gtk4 Reference","title":"Gtk4.MovementStep","text":"Passed as argument to various keybinding signals for moving the cursor position.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.NaturalWrapMode","page":"Gtk4 Reference","title":"Gtk4.NaturalWrapMode","text":"Options for selecting a different wrap mode for natural size requests.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.NotebookTab","page":"Gtk4 Reference","title":"Gtk4.NotebookTab","text":"The parameter used in the action signals of GtkNotebook.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.NotifyType","page":"Gtk4 Reference","title":"Gtk4.NotifyType","text":"Specifies the kind of crossing for enter and leave events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.NumberUpLayout","page":"Gtk4 Reference","title":"Gtk4.NumberUpLayout","text":"Used to determine the layout of pages on a sheet when printing multiple pages per sheet.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Ordering","page":"Gtk4 Reference","title":"Gtk4.Ordering","text":"Describes the way two values can be compared.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Orientation","page":"Gtk4 Reference","title":"Gtk4.Orientation","text":"Represents the orientation of widgets and other objects.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Overflow","page":"Gtk4 Reference","title":"Gtk4.Overflow","text":"Defines how content overflowing a given area should be handled.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PackType","page":"Gtk4 Reference","title":"Gtk4.PackType","text":"Represents the packing location of a children in its parent.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PadActionType","page":"Gtk4 Reference","title":"Gtk4.PadActionType","text":"The type of a pad action.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PageOrientation","page":"Gtk4 Reference","title":"Gtk4.PageOrientation","text":"See also gtkprintsettingssetorientation().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PageSet","page":"Gtk4 Reference","title":"Gtk4.PageSet","text":"See also gtkprintjobsetpage_set().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PaintableFlags","page":"Gtk4 Reference","title":"Gtk4.PaintableFlags","text":"Flags about a paintable object.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PanDirection","page":"Gtk4 Reference","title":"Gtk4.PanDirection","text":"Describes the panning direction of a [class@GesturePan].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PickFlags","page":"Gtk4 Reference","title":"Gtk4.PickFlags","text":"Flags that influence the behavior of [method@Widget.pick].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PolicyType","page":"Gtk4 Reference","title":"Gtk4.PolicyType","text":"Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PopoverMenuFlags","page":"Gtk4 Reference","title":"Gtk4.PopoverMenuFlags","text":"Flags that affect how popover menus are created from a menu model.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PositionType","page":"Gtk4 Reference","title":"Gtk4.PositionType","text":"Describes which edge of a widget a certain feature is positioned at.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintCapabilities","page":"Gtk4 Reference","title":"Gtk4.PrintCapabilities","text":"Specifies which features the print dialog should offer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintDuplex","page":"Gtk4 Reference","title":"Gtk4.PrintDuplex","text":"See also gtkprintsettingssetduplex().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintError","page":"Gtk4 Reference","title":"Gtk4.PrintError","text":"Error codes that identify various errors that can occur while using the GTK printing support.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintOperationAction","page":"Gtk4 Reference","title":"Gtk4.PrintOperationAction","text":"Determines what action the print operation should perform.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintOperationResult","page":"Gtk4 Reference","title":"Gtk4.PrintOperationResult","text":"The result of a print operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintPages","page":"Gtk4 Reference","title":"Gtk4.PrintPages","text":"See also gtkprintjobsetpages()\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintQuality","page":"Gtk4 Reference","title":"Gtk4.PrintQuality","text":"See also gtkprintsettingssetquality().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PrintStatus","page":"Gtk4 Reference","title":"Gtk4.PrintStatus","text":"The status gives a rough indication of the completion of a running print operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PropagationLimit","page":"Gtk4 Reference","title":"Gtk4.PropagationLimit","text":"Describes limits of a [class@EventController] for handling events targeting other widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.PropagationPhase","page":"Gtk4 Reference","title":"Gtk4.PropagationPhase","text":"Describes the stage at which events are fed into a [class@EventController].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.RecentManagerError","page":"Gtk4 Reference","title":"Gtk4.RecentManagerError","text":"Error codes for GtkRecentManager operations\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ResponseType","page":"Gtk4 Reference","title":"Gtk4.ResponseType","text":"Predefined values for use as response ids in gtkdialogadd_button().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.RevealerTransitionType","page":"Gtk4 Reference","title":"Gtk4.RevealerTransitionType","text":"These enumeration values describe the possible transitions when the child of a GtkRevealer widget is shown or hidden.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScrollDirection","page":"Gtk4 Reference","title":"Gtk4.ScrollDirection","text":"Specifies the direction for scroll events.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScrollStep","page":"Gtk4 Reference","title":"Gtk4.ScrollStep","text":"Passed as argument to various keybinding signals.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScrollType","page":"Gtk4 Reference","title":"Gtk4.ScrollType","text":"Scrolling types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScrollUnit","page":"Gtk4 Reference","title":"Gtk4.ScrollUnit","text":"Specifies the unit of scroll deltas.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ScrollablePolicy","page":"Gtk4 Reference","title":"Gtk4.ScrollablePolicy","text":"Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SeatCapabilities","page":"Gtk4 Reference","title":"Gtk4.SeatCapabilities","text":"Flags describing the seat capabilities.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SelectionMode","page":"Gtk4 Reference","title":"Gtk4.SelectionMode","text":"Used to control what selections users are allowed to make.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SensitivityType","page":"Gtk4 Reference","title":"Gtk4.SensitivityType","text":"Determines how GTK handles the sensitivity of various controls, such as combo box buttons.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ShortcutActionFlags","page":"Gtk4 Reference","title":"Gtk4.ShortcutActionFlags","text":"List of flags that can be passed to action activation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ShortcutScope","page":"Gtk4 Reference","title":"Gtk4.ShortcutScope","text":"Describes where [class@Shortcut]s added to a [class@ShortcutController] get handled.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ShortcutType","page":"Gtk4 Reference","title":"Gtk4.ShortcutType","text":"GtkShortcutType specifies the kind of shortcut that is being described.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SizeGroupMode","page":"Gtk4 Reference","title":"Gtk4.SizeGroupMode","text":"The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SizeRequestMode","page":"Gtk4 Reference","title":"Gtk4.SizeRequestMode","text":"Specifies a preference for height-for-width or width-for-height geometry management.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SortType","page":"Gtk4 Reference","title":"Gtk4.SortType","text":"Determines the direction of a sort.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SorterChange","page":"Gtk4 Reference","title":"Gtk4.SorterChange","text":"Describes changes in a sorter in more detail and allows users to optimize resorting.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SorterOrder","page":"Gtk4 Reference","title":"Gtk4.SorterOrder","text":"Describes the type of order that a GtkSorter may produce.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SpinButtonUpdatePolicy","page":"Gtk4 Reference","title":"Gtk4.SpinButtonUpdatePolicy","text":"Determines whether the spin button displays values outside the adjustment bounds.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SpinType","page":"Gtk4 Reference","title":"Gtk4.SpinType","text":"The values of the GtkSpinType enumeration are used to specify the change to make in gtkspinbutton_spin().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.StackTransitionType","page":"Gtk4 Reference","title":"Gtk4.StackTransitionType","text":"Possible transitions between pages in a GtkStack widget.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.StateFlags","page":"Gtk4 Reference","title":"Gtk4.StateFlags","text":"Describes a widget state.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.StringFilterMatchMode","page":"Gtk4 Reference","title":"Gtk4.StringFilterMatchMode","text":"Specifies how search strings are matched inside text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.StyleContextPrintFlags","page":"Gtk4 Reference","title":"Gtk4.StyleContextPrintFlags","text":"Flags that modify the behavior of gtkstylecontexttostring().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SubpixelLayout","page":"Gtk4 Reference","title":"Gtk4.SubpixelLayout","text":"This enumeration describes how the red, green and blue components of physical pixels on an output device are laid out.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SurfaceEdge","page":"Gtk4 Reference","title":"Gtk4.SurfaceEdge","text":"Determines a surface edge or corner.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SymbolicColor","page":"Gtk4 Reference","title":"Gtk4.SymbolicColor","text":"The indexes of colors passed to symbolic color rendering, such as [vfunc@Gtk.SymbolicPaintable.snapshot_symbolic].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.SystemSetting","page":"Gtk4 Reference","title":"Gtk4.SystemSetting","text":"Values that can be passed to the [vfunc@Gtk.Widget.systemsettingchanged] vfunc.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextDirection","page":"Gtk4 Reference","title":"Gtk4.TextDirection","text":"Reading directions for text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextExtendSelection","page":"Gtk4 Reference","title":"Gtk4.TextExtendSelection","text":"Granularity types that extend the text selection. Use the GtkTextView::extend-selection signal to customize the selection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextSearchFlags","page":"Gtk4 Reference","title":"Gtk4.TextSearchFlags","text":"Flags affecting how a search is done.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextViewLayer","page":"Gtk4 Reference","title":"Gtk4.TextViewLayer","text":"Used to reference the layers of GtkTextView for the purpose of customized drawing with the ::snapshot_layer vfunc.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextWindowType","page":"Gtk4 Reference","title":"Gtk4.TextWindowType","text":"Used to reference the parts of GtkTextView.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TextureError","page":"Gtk4 Reference","title":"Gtk4.TextureError","text":"Possible errors that can be returned by GdkTexture constructors.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.ToplevelState","page":"Gtk4 Reference","title":"Gtk4.ToplevelState","text":"Specifies the state of a toplevel surface.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TouchpadGesturePhase","page":"Gtk4 Reference","title":"Gtk4.TouchpadGesturePhase","text":"Specifies the current state of a touchpad gesture.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TreeModelFlags","page":"Gtk4 Reference","title":"Gtk4.TreeModelFlags","text":"These flags indicate various properties of a GtkTreeModel.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TreeViewColumnSizing","page":"Gtk4 Reference","title":"Gtk4.TreeViewColumnSizing","text":"The sizing method the column uses to determine its width. Please note that %GTKTREEVIEWCOLUMNAUTOSIZE are inefficient for large views, and can make columns appear choppy.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TreeViewDropPosition","page":"Gtk4 Reference","title":"Gtk4.TreeViewDropPosition","text":"An enum for determining where a dropped row goes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.TreeViewGridLines","page":"Gtk4 Reference","title":"Gtk4.TreeViewGridLines","text":"Used to indicate which grid lines to draw in a tree view.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.Unit","page":"Gtk4 Reference","title":"Gtk4.Unit","text":"See also gtkprintsettingssetpaper_width().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.VulkanError","page":"Gtk4 Reference","title":"Gtk4.VulkanError","text":"Error enumeration for GdkVulkanContext.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4.WrapMode","page":"Gtk4 Reference","title":"Gtk4.WrapMode","text":"Describes a type of line wrapping.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/reference/#Gtk4._GtkTextIter-Tuple{GtkTextBuffer, Integer}","page":"Gtk4 Reference","title":"Gtk4._GtkTextIter","text":"_GtkTextIter(text::GtkTextBuffer, char_offset::Integer)\n\nCreates a _GtkTextIter with offset char_offset (one-based index).\n\n\n\n\n\n","category":"method"},{"location":"doc/reference/#Constants-1","page":"Gtk4 Reference","title":"Constants","text":"","category":"section"},{"location":"doc/reference/#","page":"Gtk4 Reference","title":"Gtk4 Reference","text":"Modules = [Gtk4]\nOrder = [:constant]","category":"page"},{"location":"doc/reference/#Gtk4.ACCESSIBLE_VALUE_UNDEFINED","page":"Gtk4 Reference","title":"Gtk4.ACCESSIBLE_VALUE_UNDEFINED","text":"An undefined value. The accessible attribute is either unset, or its value is undefined.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.ACTION_ALL","page":"Gtk4 Reference","title":"Gtk4.ACTION_ALL","text":"Defines all possible DND actions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.BINARY_AGE","page":"Gtk4 Reference","title":"Gtk4.BINARY_AGE","text":"Like [func@getbinaryage], but from the headers used at application compile time, rather than from the library linked against at application run time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.BUTTON_MIDDLE","page":"Gtk4 Reference","title":"Gtk4.BUTTON_MIDDLE","text":"The middle button.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.BUTTON_PRIMARY","page":"Gtk4 Reference","title":"Gtk4.BUTTON_PRIMARY","text":"The primary button. This is typically the left mouse button, or the right button in a left-handed setup.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.BUTTON_SECONDARY","page":"Gtk4 Reference","title":"Gtk4.BUTTON_SECONDARY","text":"The secondary button. This is typically the right mouse button, or the left button in a left-handed setup.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.CURRENT_TIME","page":"Gtk4 Reference","title":"Gtk4.CURRENT_TIME","text":"Represents the current time, and can be used anywhere a time is expected.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.EVENT_PROPAGATE","page":"Gtk4 Reference","title":"Gtk4.EVENT_PROPAGATE","text":"Use this macro as the return value for continuing the propagation of an event handler.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.EVENT_STOP","page":"Gtk4 Reference","title":"Gtk4.EVENT_STOP","text":"Use this macro as the return value for stopping the propagation of an event handler.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.INPUT_ERROR","page":"Gtk4 Reference","title":"Gtk4.INPUT_ERROR","text":"Constant to return from a signal handler for the ::input signal in case of conversion failure.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.INTERFACE_AGE","page":"Gtk4 Reference","title":"Gtk4.INTERFACE_AGE","text":"Like [func@getinterfaceage], but from the headers used at application compile time, rather than from the library linked against at application run time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.INVALID_LIST_POSITION","page":"Gtk4 Reference","title":"Gtk4.INVALID_LIST_POSITION","text":"The value used to refer to a guaranteed invalid position in a GListModel.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.LEVEL_BAR_OFFSET_FULL","page":"Gtk4 Reference","title":"Gtk4.LEVEL_BAR_OFFSET_FULL","text":"The name used for the stock full offset included by GtkLevelBar.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.LEVEL_BAR_OFFSET_HIGH","page":"Gtk4 Reference","title":"Gtk4.LEVEL_BAR_OFFSET_HIGH","text":"The name used for the stock high offset included by GtkLevelBar.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.LEVEL_BAR_OFFSET_LOW","page":"Gtk4 Reference","title":"Gtk4.LEVEL_BAR_OFFSET_LOW","text":"The name used for the stock low offset included by GtkLevelBar.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.MAJOR_VERSION","page":"Gtk4 Reference","title":"Gtk4.MAJOR_VERSION","text":"Like [func@getmajorversion], but from the headers used at application compile time, rather than from the library linked against at application run time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.MICRO_VERSION","page":"Gtk4 Reference","title":"Gtk4.MICRO_VERSION","text":"Like [func@getmicroversion], but from the headers used at application compile time, rather than from the library linked against at application run time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.MINOR_VERSION","page":"Gtk4 Reference","title":"Gtk4.MINOR_VERSION","text":"Like [func@getminorversion], but from the headers used at application compile time, rather than from the library linked against at application run time.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.MODIFIER_MASK","page":"Gtk4 Reference","title":"Gtk4.MODIFIER_MASK","text":"A mask covering all entries in GdkModifierType.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_A3","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_A3","text":"Name for the A3 paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_A4","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_A4","text":"Name for the A4 paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_A5","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_A5","text":"Name for the A5 paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_B5","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_B5","text":"Name for the B5 paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_EXECUTIVE","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_EXECUTIVE","text":"Name for the Executive paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_LEGAL","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_LEGAL","text":"Name for the Legal paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PAPER_NAME_LETTER","page":"Gtk4 Reference","title":"Gtk4.PAPER_NAME_LETTER","text":"Name for the Letter paper size.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRINT_SETTINGS_OUTPUT_BASENAME","page":"Gtk4 Reference","title":"Gtk4.PRINT_SETTINGS_OUTPUT_BASENAME","text":"The key used by the “Print to file” printer to store the file name of the output without the path to the directory and the file extension.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRINT_SETTINGS_OUTPUT_DIR","page":"Gtk4 Reference","title":"Gtk4.PRINT_SETTINGS_OUTPUT_DIR","text":"The key used by the “Print to file” printer to store the directory to which the output should be written.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRINT_SETTINGS_OUTPUT_FILE_FORMAT","page":"Gtk4 Reference","title":"Gtk4.PRINT_SETTINGS_OUTPUT_FILE_FORMAT","text":"The key used by the “Print to file” printer to store the format of the output. The supported values are “PS” and “PDF”.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRINT_SETTINGS_OUTPUT_URI","page":"Gtk4 Reference","title":"Gtk4.PRINT_SETTINGS_OUTPUT_URI","text":"The key used by the “Print to file” printer to store the URI to which the output should be written. GTK itself supports only “file://” URIs.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRIORITY_REDRAW","page":"Gtk4 Reference","title":"Gtk4.PRIORITY_REDRAW","text":"This is the priority that the idle handler processing surface updates is given in the main loop.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.PRIORITY_RESIZE","page":"Gtk4 Reference","title":"Gtk4.PRIORITY_RESIZE","text":"Use this priority for functionality related to size allocation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.STYLE_PROVIDER_PRIORITY_APPLICATION","page":"Gtk4 Reference","title":"Gtk4.STYLE_PROVIDER_PRIORITY_APPLICATION","text":"A priority that can be used when adding a GtkStyleProvider for application-specific style information.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.STYLE_PROVIDER_PRIORITY_FALLBACK","page":"Gtk4 Reference","title":"Gtk4.STYLE_PROVIDER_PRIORITY_FALLBACK","text":"The priority used for default style information that is used in the absence of themes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.STYLE_PROVIDER_PRIORITY_SETTINGS","page":"Gtk4 Reference","title":"Gtk4.STYLE_PROVIDER_PRIORITY_SETTINGS","text":"The priority used for style information provided via GtkSettings.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.STYLE_PROVIDER_PRIORITY_THEME","page":"Gtk4 Reference","title":"Gtk4.STYLE_PROVIDER_PRIORITY_THEME","text":"The priority used for style information provided by themes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.STYLE_PROVIDER_PRIORITY_USER","page":"Gtk4 Reference","title":"Gtk4.STYLE_PROVIDER_PRIORITY_USER","text":"The priority used for the style information from $XDG_CONFIG_HOME/gtk-4.0/gtk.css.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.TEXT_VIEW_PRIORITY_VALIDATE","page":"Gtk4 Reference","title":"Gtk4.TEXT_VIEW_PRIORITY_VALIDATE","text":"The priority at which the text view validates onscreen lines in an idle job in the background.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID","page":"Gtk4 Reference","title":"Gtk4.TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID","text":"Uses the default sort function in a [iface@Gtk.TreeSortable].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/reference/#Gtk4.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID","page":"Gtk4 Reference","title":"Gtk4.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID","text":"Disables sorting in a [iface@Gtk.TreeSortable].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"manual/gettingStarted/#Getting-Started-1","page":"Getting Started","title":"Getting Started","text":"","category":"section"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"We start this tutorial with a very simple example that creates an empty window of size 400x200 pixels and adds a button to it","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"using Gtk4\n\nwin = GtkWindow(\"My First Gtk4.jl Program\", 400, 200)\n\nb = GtkButton(\"Click Me\")\npush!(win,b)\n\nshow(win)","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"We will now go through this example step by step. First the package is loaded using Gtk4 statement. Then a window is created using the GtkWindow constructor. It gets as input the window title, the window width, and the window height. Then a button is created using the GtkButton constructor. In order to insert the button into the window we call","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"push!(win,b)","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"Since a GtkWindow can have only one child widget, we could have added the button to the window using","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"win[] = b","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"Finally, show(win) makes the window visible. This could also have been accomplished using the visible property (GObject properties are discussed on the Properties section of this manual).","category":"page"},{"location":"manual/gettingStarted/#Extended-Example-1","page":"Getting Started","title":"Extended Example","text":"","category":"section"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"We will now extend the example to let the button actually do something. To this end we first define a callback function that will be executed when the user clicks the button. Our callback function just prints a message.","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"function on_button_clicked(w)\n println(\"The button has been clicked\")\nend","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"What happens when the user clicks the button is that a \"clicked\" signal is emitted. In order to connect this signal to our function on_button_clicked we have to call","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"signal_connect(on_button_clicked, b, \"clicked\")","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"Our full extended example thus looks like:","category":"page"},{"location":"manual/gettingStarted/#","page":"Getting Started","title":"Getting Started","text":"using Gtk4\n\nwin = GtkWindow(\"My First Gtk4.jl Program\", 400, 200)\n\nb = GtkButton(\"Click Me\")\npush!(win,b)\n\nfunction on_button_clicked(w)\n println(\"The button has been clicked\")\nend\nsignal_connect(on_button_clicked, b, \"clicked\")","category":"page"},{"location":"manual/methods/#Automatically-generated-methods-1","page":"Automatically generated methods","title":"Automatically generated methods","text":"","category":"section"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"Like Gtk.jl, the purpose of this package is to provide functions that wrap ccall's of GTK functions in a Julian and hopefully user friendly way. While in Gtk.jl these ccall's are handwritten, in Gtk4.jl most of the wrappers call automatically generated methods that contain the ccall's. If you don't see a particular functionality wrapped, you can call these autogenerated functions yourself by using a submodule G_ defined in each of the main modules (Gtk4, Pango, GLib, and GdkPixbufLib). The names of these functions and methods are intended to be easy to predict from the corresponding C library function names, and most are the same as in the pygobject bindings for GTK.","category":"page"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"The autogenerated methods in G_, like the corresponding C functions, use 0-based indexing, while the more user-friendly wrappers outside G_ use 1-based indexing. Some types of methods are not yet supported. For example, methods involving callbacks must be wrapped by using ccall currently.","category":"page"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"The following table lists a few examples that should give you an idea of how these work.","category":"page"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"C function Gtk4.G_ Julia method Comments\nvoid gtk_window_add_child (GtkWindow* window, GtkWidget* child) add_child (window::GtkWindow, child::GtkWidget) C arguments mapped directly onto Julia arguments\nGtkStackPage* gtk_stack_add_child (GtkStack* stack, GtkWidget* child) add_child (stack::GtkStack, child::GtkWidget) many widgets have add_child methods, but we dispatch using the type of the first argument\nvoid gtk_builder_add_from_file (GtkBuilder* builder, const gchar* filename, GError** error) add_from_file (builder::GtkBuilder, filename::AbstractString) if ccall fills GError argument, a Julia exception is thrown\nguint gtk_get_major_version () get_major_version () Julia method returns a UInt32\nvoid gtk_rgb_to_hsv (float r, float g, float b, float* h, float* s, float* v) rgb_to_hsv (r::Real, g::Real, b::Real) The arguments h, s, and v are outputs. Julia method returns (h, s, v)\ngboolean gtk_tree_view_get_path_at_pos (GtkTreeView* tree_view, int x, int y, GtkTreePath** path, GtkTreeViewColumn** column, int* cell_x, int* cell_y) get_path_at_pos (instance::GtkTreeView, _x::Integer, _y::Integer) C function has a return value ret in addition to output arguments _path, _column, _cell_x, and _cell_y. The Julia method returns (ret, _path, _column, _cell_x, _cell_y)","category":"page"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"If you are confused about what one of these automatically generated methods does, you can examine the code, which is defined in the src/gen directory. They are separated into \"methods\" (in an object-oriented sense, these are functions associated with a particular class) and \"functions\" (general C functions that aren't associated with a particular class). Constants and struct definitions are also generated using GObject introspection.","category":"page"},{"location":"manual/methods/#Constructors-1","page":"Automatically generated methods","title":"Constructors","text":"","category":"section"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"Constructor methods in G_ are treated a little differently. They are named according to GObjectconstructorname, as in the following table:","category":"page"},{"location":"manual/methods/#","page":"Automatically generated methods","title":"Automatically generated methods","text":"C function Gtk4.G_ Julia method Comments\nGtkWidget* gtk_window_new() Window_new() Returns a newly constructed GtkWindow\nGtkWidget* gtk_scale_new_with_range(GtkOrientation orientation, double min, double max, double step) Scale_new_with_range(orientation, min, max, step) Example with arguments","category":"page"},{"location":"manual/signals/#Signals-and-Callbacks-1","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"","category":"section"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"A button is not much use if it doesn't do anything. GTK uses signals as a method for communicating that something of interest has happened. Most signals will be emitted as a consequence of user interaction: clicking on a button, closing a window, or just moving the mouse. You connect your signals to particular functions to make something happen.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Let's try a simple example:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"b = GtkButton(\"Press me\")\nwin = GtkWindow(b, \"Callbacks\")\n\nfunction button_clicked_callback(widget)\n println(widget, \" was clicked!\")\nend\n\nid = signal_connect(button_clicked_callback, b, \"clicked\")","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Here, button_clicked_callback is a callback function, something designed to be called by GTK to implement the response to user action. You use the signal_connect function to specify when it should be called: in this case, when widget b (your button) emits the \"clicked\" signal.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Using Julia's do syntax, the exact same code could alternatively be written as","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"b = GtkButton(\"Press me\")\nwin = GtkWindow(b, \"Callbacks\")\nid = signal_connect(b, \"clicked\") do widget\n println(widget, \" was clicked!\")\nend","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"If you try this, and click on the button, you should see something like the following:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"julia> GtkButton(action-name=NULL, action-target, related-action, use-action-appearance=TRUE, name=\"\", parent, width-request=-1, height-request=-1, visible=TRUE, sensitive=TRUE, app-paintable=FALSE, can-focus=TRUE, has-focus=TRUE, is-focus=TRUE, can-default=FALSE, has-default=FALSE, receives-default=TRUE, composite-child=FALSE, style, events=0, no-show-all=FALSE, has-tooltip=FALSE, tooltip-markup=NULL, tooltip-text=NULL, window, double-buffered=TRUE, halign=GTK_ALIGN_FILL, valign=GTK_ALIGN_FILL, margin-left=0, margin-right=0, margin-top=0, margin-bottom=0, margin=0, hexpand=FALSE, vexpand=FALSE, hexpand-set=FALSE, vexpand-set=FALSE, expand=FALSE, border-width=0, resize-mode=GTK_RESIZE_PARENT, child, label=\"Press me\", image, relief=GTK_RELIEF_NORMAL, use-underline=TRUE, use-stock=FALSE, focus-on-click=TRUE, xalign=0.500000, yalign=0.500000, image-position=GTK_POS_LEFT, ) was clicked!","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"That's quite a lot of output; let's just print the label of the button:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"id2 = signal_connect(b, \"clicked\") do widget\n println(\"\\\"\", get_gtk_property(widget,:label,String), \"\\\" was clicked!\")\nend","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Now you get something like this:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"julia> GtkButton(action-name=NULL, action-target, related-action, use-action-appearance=TRUE, name=\"\", parent, width-request=-1, height-request=-1, visible=TRUE, sensitive=TRUE, app-paintable=FALSE, can-focus=TRUE, has-focus=TRUE, is-focus=TRUE, can-default=FALSE, has-default=FALSE, receives-default=TRUE, composite-child=FALSE, style, events=0, no-show-all=FALSE, has-tooltip=FALSE, tooltip-markup=NULL, tooltip-text=NULL, window, double-buffered=TRUE, halign=GTK_ALIGN_FILL, valign=GTK_ALIGN_FILL, margin-left=0, margin-right=0, margin-top=0, margin-bottom=0, margin=0, hexpand=FALSE, vexpand=FALSE, hexpand-set=FALSE, vexpand-set=FALSE, expand=FALSE, border-width=0, resize-mode=GTK_RESIZE_PARENT, child, label=\"Press me\", image, relief=GTK_RELIEF_NORMAL, use-underline=TRUE, use-stock=FALSE, focus-on-click=TRUE, xalign=0.500000, yalign=0.500000, image-position=GTK_POS_LEFT, ) was clicked!\n\"Press me\" was clicked!","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Notice that both of the callback functions executed! GTK allows you to define multiple signal handlers for a given object; even the execution order can be specified. Callbacks for some signals require that you return an Int32, with value 0 if you want the next handler to run or 1 if you want to prevent any other handlers from running on this event.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"The \"clicked\" signal callback should return nothing (void in C parlance), so you can't prevent other callbacks from running. However, we can disconnect the first signal handler:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"signal_handler_disconnect(b, id)","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Now clicking on the button just yields","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"julia> \"Press me\" was clicked!","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Alternatively, you can temporarily enable or disable individual handlers with signal_handler_block and signal_handler_unblock.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"The arguments of the callback depend on the signal type. Arguments and their meaning are described along with their corresponding signals. You should omit the final user_data argument described in the GTK documentation; keep in mind that you can always address other variables from inside your function block, or define the callback in terms of an anonymous function:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"id = signal_connect((widget, event) -> cb_buttonpressed(widget, event, guistate, drawfunction, ...), b, \"button-press-event\")","category":"page"},{"location":"manual/signals/#Property-notifications-1","page":"Signals and Callbacks","title":"Property notifications","text":"","category":"section"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"Any time a GObject property is changed, a \"notify\" signal is emitted.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"To set a callback to be called when a window's title is changed, use:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"signal_connect(win, \"notify::title\") do obj, pspec # here `obj` is the GObject\n println(obj.title)\nend","category":"page"},{"location":"manual/signals/#Alternative-approach-to-signals-and-signal-handlers-1","page":"Signals and Callbacks","title":"Alternative approach to signals and signal-handlers","text":"","category":"section"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"In addition to the \"simple\" interface, signal_connect supports an approach that allows your callback function to be directly compiled to machine code.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"This alternative syntax is as follows:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"signal_connect(cb, widget, signalname, return_type, parameter_type_tuple, after, user_data=widget)","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"where:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"cb is your callback function. This will be compiled with @cfunction, and you need to follow its rules. In particular, you should use a generic function (i.e., one defined as function foo(x,y,z) ... end), and the arguments and return type should match the GTK+ documentation for the widget and signal (see examples). In contrast with the simpler interface, when writing these callbacks you must include the user_data argument. See examples below.\nwidget is the widget that will send the signal\nsignalname is a string or symbol identifying the signal, e.g., \"clicked\" or \"button-press-event\"\nreturn_type is the type of the value returned by your callback. Usually Nothing (for void) or Cint (for gboolean)\nparameter_type_tuple specifies the types of the middle arguments to the callback function, omitting the first (the widget) and last (user_data). For example, for \"clicked\" we have parameter_type_tuple = () (because there are no middle arguments) and for \"button-press-event\" we have parameter_type_tuple = (Cint, Cdouble, Cdouble).\nafter is a boolean, true if you want your callback to run after the default handler for your signal. When in doubt, specify false.\nuser_data contains any additional information your callback needs to operate. For example, you can pass other widgets, tuples of values, etc. If omitted, it defaults to widget.","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"The callback's arguments need to match the GTK documentation, with the exception of the user_data argument. (Rather than being a pointer, user_data will automatically be converted back to an object.)","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"For example, consider a GUI in which pressing a button updates a counter:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"box = GtkBox(:h)\nbutton = GtkButton(\"click me\")\nlabel = GtkLabel(\"0\")\npush!(box, button)\npush!(box, label)\nwin = GtkWindow(box, \"Callbacks\")\n\nconst counter = [0] # Pack counter value inside array to make it a reference\n\n# \"clicked\" callback declaration is\n# void user_function(GtkButton *button, gpointer user_data)\n# But user_data gets converted into a Julia object automatically\nfunction button_cb(widgetptr::Ptr, user_data)\n widget = convert(Gtk4.GtkButtonLeaf, widgetptr) # pointer -> object\n lbl, cntr = user_data # unpack the user_data tuple\n cntr[] = cntr[]+1 # increment counter[1]\n lbl.label = string(cntr[])\n nothing # return type is void\nend\n\nsignal_connect(button_cb, button, \"clicked\", Nothing, (), false, (label, counter))","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"You should note that the value of counter[] matches the display in the GUI.","category":"page"},{"location":"manual/signals/#Specifying-the-event-type-1","page":"Signals and Callbacks","title":"Specifying the event type","text":"","category":"section"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"If your callback function takes an event argument, it is important to declare its type correctly. An easy way to do that is to first write a callback using the \"simple\" interface, e.g.,","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":" signal_connect(win, \"delete-event\") do widget, event\n @show typeof(event)\n @show event\n end","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"and then use the reported type in parameter_type_tuple.","category":"page"},{"location":"manual/signals/#@guarded-1","page":"Signals and Callbacks","title":"@guarded","text":"","category":"section"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":"The \"simple\" callback interface includes protections against corrupting Gtk state from errors, but this @cfunction-based approach does not. Consequently, you may wish to use @guarded when writing these functions. (Canvas draw functions and mouse event-handling are called through this interface, which is why you should use @guarded there.) For functions that should return a value, you can specify the value to be returned on error as the first argument. For example:","category":"page"},{"location":"manual/signals/#","page":"Signals and Callbacks","title":"Signals and Callbacks","text":" const unhandled = convert(Int32, false)\n @guarded unhandled function my_callback(widgetptr, ...)\n ...\n end","category":"page"},{"location":"manual/layout/#Layout-1","page":"Layout","title":"Layout","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"Gtk4 provides many layout widgets for arranging widgets in a window.","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"note: Note\nFor larger projects it might be a good idea to create the layout using Cambalache in combination with GtkBuilder. See Builder.","category":"page"},{"location":"manual/layout/#GtkBox-1","page":"Layout","title":"GtkBox","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The simplest layout widget is the GtkBox. It is one-dimensional and can be either be horizontally or vertical aligned.","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"win = GtkWindow(\"New title\")\nhbox = GtkBox(:h) # :h makes a horizontal layout, :v a vertical layout\npush!(win, hbox)\ncancel = GtkButton(\"Cancel\")\nok = GtkButton(\"OK\")\npush!(hbox, cancel)\npush!(hbox, ok)","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"This layout may not be exactly what you'd like. Perhaps you'd like the OK button to fill the available space, and to insert some blank space between them:","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"ok.hexpand = true\nhbox.spacing = 10","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The first line sets the hexpand property of the ok button within the hbox container. In GTK4, a separate vexpand property controls whether the widget expands in the vertical direction. The second line sets the spacing property of hbox to 10 pixels.","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"Note that these aren't evenly sized, and that doesn't change if we set the cancel button's hexpand property to true. The homogeneous property of hbox can be used to achieve this.","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"hbox.homogeneous = true","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"To add a line between widgets in a GtkBox, you can use GtkSeparator.","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"sep = GtkSeparator(:h)\npush!(hbox, sep)\n# add more widgets here","category":"page"},{"location":"manual/layout/#GtkGrid-1","page":"Layout","title":"GtkGrid","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"To create two-dimensional (tabular) layouts of widgets, you can use GtkGrid:","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"win = GtkWindow(\"A new window\")\ng = GtkGrid()\na = GtkEntry() # a widget for entering text\na.text = \"This is Gtk!\"\nb = GtkCheckButton(\"Check me!\")\nc = GtkScale(:h, 0:10) # a slider\n\n# Now let's place these graphical elements into the Grid:\ng[1,1] = a # Cartesian coordinates, g[x,y]\ng[2,1] = b\ng[1:2,2] = c # spans both columns\ng.column_homogeneous = true # grid forces columns to have the same width\ng.column_spacing = 15 # introduce a 15-pixel gap between columns\npush!(win, g)","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The g[x,y] = obj assigns the location to the indicated x,y positions in the grid (note that indexing is Cartesian rather than row/column; most graphics packages address the screen using Cartesian coordinates where 1,1 is in the upper left). A range is used to indicate a span of grid cells. By default, each row/column will use only as much space as required to contain the objects, but you can force them to be of the same size by setting properties like column_homogeneous.","category":"page"},{"location":"manual/layout/#GtkCenterBox-1","page":"Layout","title":"GtkCenterBox","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The GtkCenterBox widget can hold 3 widgets in a line, either horizontally or vertically oriented. It keeps the middle widget centered. Child widgets can be set and accessed like this:","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"cb = GtkCenterBox(:h) # :h makes a horizontal layout, :v a vertical layout\ncb[:start] = GtkButton(\"Left\")\ncb[:center] = GtkButton(\"Center\")\ncb[:end] = GtkButton(\"Right\")","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"For vertical orientation, :start refers to the top widget and :end to the bottom widget.","category":"page"},{"location":"manual/layout/#GtkPaned-1","page":"Layout","title":"GtkPaned","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The GtkPaned widget creates two slots separated by a movable divider. Like GtkBox and GtkCenterBox, it can be oriented either vertically or horizontally. To add child widgets, you can use","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"paned = GtkPaned()\npaned[1] = top_or_left_widget\npaned[2] = bottom_or_right_widget","category":"page"},{"location":"manual/layout/#GtkNotebook-1","page":"Layout","title":"GtkNotebook","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The GtkNotebook widget places child widgets in tabs like a browser window. Child widgets can be inserted with a label like this:","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"nb = GtkNotebook()\nvbox = GtkBox(:v)\nhbox = GtkBox(:h)\npush!(nb, vbox, \"Vertical\") # here \"Vertical\" is the label for the tab\npush!(nb, hbox, \"Horizontal\")","category":"page"},{"location":"manual/layout/#GtkStack-1","page":"Layout","title":"GtkStack","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"The GtkStack widget is a lot like GtkNotebook, but a separate widget GtkStackSwitcher controls what page is shown. An interface very similar to GtkNotebook is defined:","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"s = GtkStack()\nsw = GtkStackSwitcher()\nvbox = GtkBox(:v)\npush!(vbox, sw)\npush!(vbox, s)\npush!(s, GtkLabel(\"First label\"), \"id1\", \"Label 1\") # first string is an id, second is a label\npush!(s, GtkLabel(\"Second label\"), \"id2\", \"Label 2\") # widget can be retrieved using s[id]","category":"page"},{"location":"manual/layout/#Iterating-over-child-widgets-1","page":"Layout","title":"Iterating over child widgets","text":"","category":"section"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"For any of the widgets described above (or any GtkWidget that has children), you can iterate over all child widgets using","category":"page"},{"location":"manual/layout/#","page":"Layout","title":"Layout","text":"for w in widget\n myfunc(w)\nend","category":"page"},{"location":"doc/GLib_reference/#GLib-Reference-1","page":"GLib Reference","title":"GLib Reference","text":"","category":"section"},{"location":"doc/GLib_reference/#Public-interface-1","page":"GLib Reference","title":"Public interface","text":"","category":"section"},{"location":"doc/GLib_reference/#","page":"GLib Reference","title":"GLib Reference","text":"Modules = [Gtk4.GLib]\nOrder = [:module, :function, :macro]\nPublic = true\nPrivate = false","category":"page"},{"location":"doc/GLib_reference/#Gtk4.GLib.bind_property","page":"GLib Reference","title":"Gtk4.GLib.bind_property","text":"bind_property(source::GObject, source_property, target::GObject, target_property, flags = BindingFlags_DEFAULT)\n\nCreates a binding between source_property on source and target_property on target. When source_property is changed, target_property will be updated to the same value. Returns a GBinding object that can be used to release the binding using unbind_property.\n\nSee also unbind_property.\n\nRelated GTK function: g_object_bind_property\n\n\n\n\n\n","category":"function"},{"location":"doc/GLib_reference/#Gtk4.GLib.g_idle_add","page":"GLib Reference","title":"Gtk4.GLib.g_idle_add","text":"g_idle_add(f, priority=PRIORITY_DEFAULT_IDLE)\n\nAdd a Julia function f that will be called when there are no higher priority GTK events to be processed. This function can be used from any thread. The optional priority argument, which is an integer, sets the priority of the event source (smaller is higher priority). The GLib main loop uses this priority value to decide what sources to handle next.\n\nSee also @idle_add.\n\nRelated GTK function: g_idle_add_full()\n\n\n\n\n\n","category":"function"},{"location":"doc/GLib_reference/#Gtk4.GLib.g_source_remove-Tuple{Any}","page":"GLib Reference","title":"Gtk4.GLib.g_source_remove","text":"g_source_remove(id::Integer)\n\nRemove the event source identified by id from the GLib main loop. The id is returned by g_idle_add and g_timeout_add. The main loop reuses id's so care should be taken that the source intended to be removed is still active.\n\nRelated GTK function: g_source_remove()\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.g_timeout_add","page":"GLib Reference","title":"Gtk4.GLib.g_timeout_add","text":"g_timeout_add(f, interval, priority=PRIORITY_DEFAULT)\n\nAdd a function f that will be called every interval milliseconds by the GTK main loop. The function is expected to return a Cint. If it returns a nonzero value, the function will be called again after another interval milliseconds. Otherwise it will not be called again. The optional priority argument, which is an integer, sets the priority of the event source (smaller is higher priority). The GLib main loop uses this priority value to decide what sources to handle next.\n\nThis function returns an event source ID that can be used with g_source_remove to stop the timeout.\n\nRelated GTK function: g_timeout_add()\n\n\n\n\n\n","category":"function"},{"location":"doc/GLib_reference/#Gtk4.GLib.gtk_propertynames-Tuple{Gtk4.GLib.GObject}","page":"GLib Reference","title":"Gtk4.GLib.gtk_propertynames","text":"gtk_propertynames(w::GObject)\n\nPrints a list of property names for the GObject w.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.signal_handler_disconnect-Tuple{Gtk4.GLib.GObject, UInt64}","page":"GLib Reference","title":"Gtk4.GLib.signal_handler_disconnect","text":"signal_handler_disconnect(w::GObject, id)\n\nDisconnect a signal handler from a widget w by its id.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.unbind_property-Tuple{Gtk4.GLib.GBinding}","page":"GLib Reference","title":"Gtk4.GLib.unbind_property","text":"unbind_property(b::GBinding)\n\nReleases a binding created by bind_property.\n\nSee also bind_property.\n\nRelated GTK function: g_binding_unbind\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.@idle_add-Tuple{Any}","page":"GLib Reference","title":"Gtk4.GLib.@idle_add","text":"@idle_add(ex)\n\nCreate a function from an expression ex that will be called when there are no higher priority GTK events to be processed. This function can be used from any thread.\n\nSee also g_idle_add.\n\nRelated GTK function: g_idle_add()\n\n\n\n\n\n","category":"macro"},{"location":"doc/GLib_reference/#Private-methods-1","page":"GLib Reference","title":"Private methods","text":"","category":"section"},{"location":"doc/GLib_reference/#","page":"GLib Reference","title":"GLib Reference","text":"Modules = [Gtk4.GLib]\nOrder = [:module, :function, :macro]\nPublic = false\nPrivate = true","category":"page"},{"location":"doc/GLib_reference/#Gtk4.GLib.g_type-Tuple{UInt64}","page":"GLib Reference","title":"Gtk4.GLib.g_type","text":"g_type(x)\n\nGet the GType corresponding to a Julia type or object. See GLib documentation for more information.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.get_uv_loop_integration-Tuple{}","page":"GLib Reference","title":"Gtk4.GLib.get_uv_loop_integration","text":"get_uv_loop_integration()\n\nGet Gtk4.jl's libuv loop integration setting: \"auto\", \"enabled\", or \"disabled\".\n\nSee also set_uv_loop_integration.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.is_uv_loop_integration_enabled-Tuple{}","page":"GLib Reference","title":"Gtk4.GLib.is_uv_loop_integration_enabled","text":"is_uv_loop_integration_enabled()\n\nGet whether Gtk4.jl's libuv loop integration is enabled.\n\nSee also set_uv_loop_integration.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.propertyinfo-Tuple{Gtk4.GLib.GObject, AbstractString}","page":"GLib Reference","title":"Gtk4.GLib.propertyinfo","text":"propertyinfo(w::GObject, name)\n\nPrints information about a property of the GObject w, including a brief description, its type, its default value, and its current value.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.set_uv_loop_integration","page":"GLib Reference","title":"Gtk4.GLib.set_uv_loop_integration","text":"set_uv_loop_integration(s = \"auto\")\n\nChange Gtk4.jl's libuv loop integration setting. The argument s should be \"auto\" to use Gtk4.jl's default setting or \"enabled\" or \"disabled\" to override this. This setting will take effect after restarting Julia.\n\nEnabling libuv loop integration may improve REPL response on some platforms (Mac) but negatively impacts multithreaded performance. This function has no effect when running on Windows.\n\n\n\n\n\n","category":"function"},{"location":"doc/GLib_reference/#Gtk4.GLib.signal_handler_is_connected-Tuple{Gtk4.GLib.GObject, UInt64}","page":"GLib Reference","title":"Gtk4.GLib.signal_handler_is_connected","text":"signal_handler_is_connected(widget, id) -> Bool\n\nReturn true/false depending on whether widget has a connected signal handler with the given id.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.start_main_loop-Tuple{}","page":"GLib Reference","title":"Gtk4.GLib.start_main_loop","text":"start_main_loop()\n\nIf the default GLib main event loop is not already running, start a Julia task that runs it.\n\nSee also stop_main_loop.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.stop_main_loop-Tuple{}","page":"GLib Reference","title":"Gtk4.GLib.stop_main_loop","text":"stop_main_loop()\n\nStops the default GLib main loop after the next iteration. Does not affect loop operation if GApplication's run() method is being used instead of GLib.start_main_loop().\n\nSee also start_main_loop.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Gtk4.GLib.waitforsignal-Tuple{Gtk4.GLib.GObject, Any}","page":"GLib Reference","title":"Gtk4.GLib.waitforsignal","text":"waitforsignal(obj::GObject, signal)\n\nReturns when a GObject's signal is emitted. Can be used to wait for a window to be closed.\n\n\n\n\n\n","category":"method"},{"location":"doc/GLib_reference/#Types-1","page":"GLib Reference","title":"Types","text":"","category":"section"},{"location":"doc/GLib_reference/#","page":"GLib Reference","title":"GLib Reference","text":"Modules = [Gtk4.GLib]\nOrder = [:type]\nPublic = true\nPrivate = false","category":"page"},{"location":"doc/GLib_reference/#Gtk4.GLib.AppInfoCreateFlags","page":"GLib Reference","title":"Gtk4.GLib.AppInfoCreateFlags","text":"Flags used when creating a #GAppInfo.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ApplicationFlags","page":"GLib Reference","title":"Gtk4.GLib.ApplicationFlags","text":"Flags used to define the behaviour of a #GApplication.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.AskPasswordFlags","page":"GLib Reference","title":"Gtk4.GLib.AskPasswordFlags","text":"#GAskPasswordFlags are used to request specific information from the user, or to notify the user of their choices in an authentication situation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.BindingFlags","page":"GLib Reference","title":"Gtk4.GLib.BindingFlags","text":"Flags to be passed to gobjectbindproperty() or gobjectbindproperty_full().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.BookmarkFileError","page":"GLib Reference","title":"Gtk4.GLib.BookmarkFileError","text":"Error codes returned by bookmark file parsing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.BusNameOwnerFlags","page":"GLib Reference","title":"Gtk4.GLib.BusNameOwnerFlags","text":"Flags used in gbusown_name().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.BusNameWatcherFlags","page":"GLib Reference","title":"Gtk4.GLib.BusNameWatcherFlags","text":"Flags used in gbuswatch_name().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.BusType","page":"GLib Reference","title":"Gtk4.GLib.BusType","text":"An enumeration for well-known message buses.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ChecksumType","page":"GLib Reference","title":"Gtk4.GLib.ChecksumType","text":"The hashing algorithm to be used by #GChecksum when performing the digest of some data.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ConnectFlags","page":"GLib Reference","title":"Gtk4.GLib.ConnectFlags","text":"The connection flags are used to specify the behaviour of a signal's connection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ConvertError","page":"GLib Reference","title":"Gtk4.GLib.ConvertError","text":"Error codes returned by character set conversion routines.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ConverterFlags","page":"GLib Reference","title":"Gtk4.GLib.ConverterFlags","text":"Flags used when calling a gconverterconvert().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ConverterResult","page":"GLib Reference","title":"Gtk4.GLib.ConverterResult","text":"Results returned from gconverterconvert().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.CredentialsType","page":"GLib Reference","title":"Gtk4.GLib.CredentialsType","text":"Enumeration describing different kinds of native credential types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusCallFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusCallFlags","text":"Flags used in gdbusconnection_call() and similar APIs.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusCapabilityFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusCapabilityFlags","text":"Capabilities negotiated with the remote peer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusConnectionFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusConnectionFlags","text":"Flags used when creating a new #GDBusConnection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusError","page":"GLib Reference","title":"Gtk4.GLib.DBusError","text":"Error codes for the %GDBUSERROR error domain.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusInterfaceSkeletonFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusInterfaceSkeletonFlags","text":"Flags describing the behavior of a #GDBusInterfaceSkeleton instance.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusMessageByteOrder","page":"GLib Reference","title":"Gtk4.GLib.DBusMessageByteOrder","text":"Enumeration used to describe the byte order of a D-Bus message.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusMessageFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusMessageFlags","text":"Message flags used in #GDBusMessage.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusMessageHeaderField","page":"GLib Reference","title":"Gtk4.GLib.DBusMessageHeaderField","text":"Header fields used in #GDBusMessage.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusMessageType","page":"GLib Reference","title":"Gtk4.GLib.DBusMessageType","text":"Message types used in #GDBusMessage.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusObjectManagerClientFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusObjectManagerClientFlags","text":"Flags used when constructing a #GDBusObjectManagerClient.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusPropertyInfoFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusPropertyInfoFlags","text":"Flags describing the access control of a D-Bus property.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusProxyFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusProxyFlags","text":"Flags used when constructing an instance of a #GDBusProxy derived class.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusSendMessageFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusSendMessageFlags","text":"Flags used when sending #GDBusMessages on a #GDBusConnection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusServerFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusServerFlags","text":"Flags used when creating a #GDBusServer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusSignalFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusSignalFlags","text":"Flags used when subscribing to signals via gdbusconnectionsignalsubscribe().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBusSubtreeFlags","page":"GLib Reference","title":"Gtk4.GLib.DBusSubtreeFlags","text":"Flags passed to gdbusconnectionregistersubtree().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DataStreamByteOrder","page":"GLib Reference","title":"Gtk4.GLib.DataStreamByteOrder","text":"#GDataStreamByteOrder is used to ensure proper endianness of streaming data sources across various machine architectures.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DataStreamNewlineType","page":"GLib Reference","title":"Gtk4.GLib.DataStreamNewlineType","text":"#GDataStreamNewlineType is used when checking for or setting the line endings for a given file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DateDMY","page":"GLib Reference","title":"Gtk4.GLib.DateDMY","text":"This enumeration isn't used in the API, but may be useful if you need to mark a number as a day, month, or year.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DateMonth","page":"GLib Reference","title":"Gtk4.GLib.DateMonth","text":"Enumeration representing a month; values are %GDATEJANUARY, %GDATEFEBRUARY, etc. %GDATEBAD_MONTH is the invalid value.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DateWeekday","page":"GLib Reference","title":"Gtk4.GLib.DateWeekday","text":"Enumeration representing a day of the week; %GDATEMONDAY, %GDATETUESDAY, etc. %GDATEBAD_WEEKDAY is an invalid weekday.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DriveStartFlags","page":"GLib Reference","title":"Gtk4.GLib.DriveStartFlags","text":"Flags used when starting a drive.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.DriveStartStopType","page":"GLib Reference","title":"Gtk4.GLib.DriveStartStopType","text":"Enumeration describing how a drive can be started/stopped.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.EmblemOrigin","page":"GLib Reference","title":"Gtk4.GLib.EmblemOrigin","text":"GEmblemOrigin is used to add information about the origin of the emblem to #GEmblem.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ErrorType","page":"GLib Reference","title":"Gtk4.GLib.ErrorType","text":"The possible errors, used in the @verror field of #GTokenValue, when the token is a %GTOKEN_ERROR.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileAttributeInfoFlags","page":"GLib Reference","title":"Gtk4.GLib.FileAttributeInfoFlags","text":"Flags specifying the behaviour of an attribute.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileAttributeStatus","page":"GLib Reference","title":"Gtk4.GLib.FileAttributeStatus","text":"Used by gfilesetattributesfrom_info() when setting file attributes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileAttributeType","page":"GLib Reference","title":"Gtk4.GLib.FileAttributeType","text":"The data types for file attributes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileCopyFlags","page":"GLib Reference","title":"Gtk4.GLib.FileCopyFlags","text":"Flags used when copying or moving files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileCreateFlags","page":"GLib Reference","title":"Gtk4.GLib.FileCreateFlags","text":"Flags used when an operation may create a file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileError","page":"GLib Reference","title":"Gtk4.GLib.FileError","text":"Values corresponding to @errno codes returned from file operations on UNIX. Unlike @errno codes, GFileError values are available on all systems, even Windows. The exact meaning of each code depends on what sort of file operation you were performing; the UNIX documentation gives more details. The following error code descriptions come from the GNU C Library manual, and are under the copyright of that manual.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileMeasureFlags","page":"GLib Reference","title":"Gtk4.GLib.FileMeasureFlags","text":"Flags that can be used with gfilemeasurediskusage().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileMonitorEvent","page":"GLib Reference","title":"Gtk4.GLib.FileMonitorEvent","text":"Specifies what type of event a monitor event is.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileMonitorFlags","page":"GLib Reference","title":"Gtk4.GLib.FileMonitorFlags","text":"Flags used to set what a #GFileMonitor will watch for.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileQueryInfoFlags","page":"GLib Reference","title":"Gtk4.GLib.FileQueryInfoFlags","text":"Flags used when querying a #GFileInfo.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileSetContentsFlags","page":"GLib Reference","title":"Gtk4.GLib.FileSetContentsFlags","text":"Flags to pass to gfilesetcontentsfull() to affect its safety and performance.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileTest","page":"GLib Reference","title":"Gtk4.GLib.FileTest","text":"A test to perform on a file using gfiletest().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FileType","page":"GLib Reference","title":"Gtk4.GLib.FileType","text":"Indicates the file's on-disk type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FilesystemPreviewType","page":"GLib Reference","title":"Gtk4.GLib.FilesystemPreviewType","text":"Indicates a hint from the file system whether files should be previewed in a file manager. Returned as the value of the key %GFILEATTRIBUTEFILESYSTEMUSE_PREVIEW.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.FormatSizeFlags","page":"GLib Reference","title":"Gtk4.GLib.FormatSizeFlags","text":"Flags to modify the format of the string returned by gformatsize_full().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GAppInfoMonitor","page":"GLib Reference","title":"Gtk4.GLib.GAppInfoMonitor","text":"#GAppInfoMonitor is a very simple object used for monitoring the app info database for changes (ie: newly installed or removed applications).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GAppLaunchContext","page":"GLib Reference","title":"Gtk4.GLib.GAppLaunchContext","text":"Integrating the launch with the launching application. This is used to handle for instance startup notification and launching the new application on the same screen as the launching window.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GApplication","page":"GLib Reference","title":"Gtk4.GLib.GApplication","text":"A #GApplication is the foundation of an application. It wraps some low-level platform-specific services and is intended to act as the foundation for higher-level application classes such as #GtkApplication or #MxApplication. In general, you should not use this class outside of a higher level framework.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GApplicationCommandLine","page":"GLib Reference","title":"Gtk4.GLib.GApplicationCommandLine","text":"#GApplicationCommandLine represents a command-line invocation of an application. It is created by #GApplication and emitted in the #GApplication::command-line signal and virtual function.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBinding","page":"GLib Reference","title":"Gtk4.GLib.GBinding","text":"#GBinding is the representation of a binding between a property on a #GObject instance (or source) and another property on another #GObject instance (or target).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBindingGroup","page":"GLib Reference","title":"Gtk4.GLib.GBindingGroup","text":"The #GBindingGroup can be used to bind multiple properties from an object collectively.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBufferedInputStream","page":"GLib Reference","title":"Gtk4.GLib.GBufferedInputStream","text":"Buffered input stream implements #GFilterInputStream and provides for buffered reads.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBufferedOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GBufferedOutputStream","text":"Buffered output stream implements #GFilterOutputStream and provides for buffered writes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBytes","page":"GLib Reference","title":"Gtk4.GLib.GBytes","text":"A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GBytesIcon","page":"GLib Reference","title":"Gtk4.GLib.GBytesIcon","text":"#GBytesIcon specifies an image held in memory in a common format (usually png) to be used as icon.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GCancellable","page":"GLib Reference","title":"Gtk4.GLib.GCancellable","text":"GCancellable is a thread-safe operation cancellation stack used throughout GIO to allow for cancellation of synchronous and asynchronous operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GCharsetConverter","page":"GLib Reference","title":"Gtk4.GLib.GCharsetConverter","text":"#GCharsetConverter is an implementation of #GConverter based on GIConv.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GChecksum","page":"GLib Reference","title":"Gtk4.GLib.GChecksum","text":"An opaque structure representing a checksumming operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GConverterInputStream","page":"GLib Reference","title":"Gtk4.GLib.GConverterInputStream","text":"Converter input stream implements #GInputStream and allows conversion of data of various types during reading.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GConverterOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GConverterOutputStream","text":"Converter output stream implements #GOutputStream and allows conversion of data of various types during reading.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GCredentials","page":"GLib Reference","title":"Gtk4.GLib.GCredentials","text":"The #GCredentials type is a reference-counted wrapper for native credentials. This information is typically used for identifying, authenticating and authorizing other processes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusActionGroup","page":"GLib Reference","title":"Gtk4.GLib.GDBusActionGroup","text":"#GDBusActionGroup is an implementation of the #GActionGroup interface that can be used as a proxy for an action group that is exported over D-Bus with gdbusconnectionexportaction_group().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusAuthObserver","page":"GLib Reference","title":"Gtk4.GLib.GDBusAuthObserver","text":"The #GDBusAuthObserver type provides a mechanism for participating in how a #GDBusServer (or a #GDBusConnection) authenticates remote peers. Simply instantiate a #GDBusAuthObserver and connect to the signals you are interested in. Note that new signals may be added in the future\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusConnection","page":"GLib Reference","title":"Gtk4.GLib.GDBusConnection","text":"The #GDBusConnection type is used for D-Bus connections to remote peers such as a message buses. It is a low-level API that offers a lot of flexibility. For instance, it lets you establish a connection over any transport that can by represented as a #GIOStream.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusErrorEntry","page":"GLib Reference","title":"Gtk4.GLib.GDBusErrorEntry","text":"Struct used in gdbuserrorregistererror_domain().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusInterfaceSkeleton","page":"GLib Reference","title":"Gtk4.GLib.GDBusInterfaceSkeleton","text":"Abstract base class for D-Bus interfaces on the service side.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusMenuModel","page":"GLib Reference","title":"Gtk4.GLib.GDBusMenuModel","text":"#GDBusMenuModel is an implementation of #GMenuModel that can be used as a proxy for a menu model that is exported over D-Bus with gdbusconnectionexportmenu_model().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusMessage","page":"GLib Reference","title":"Gtk4.GLib.GDBusMessage","text":"A type for representing D-Bus messages that can be sent or received on a #GDBusConnection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusMethodInvocation","page":"GLib Reference","title":"Gtk4.GLib.GDBusMethodInvocation","text":"Instances of the #GDBusMethodInvocation class are used when handling D-Bus method calls. It provides a way to asynchronously return results and errors.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusObjectManagerClient","page":"GLib Reference","title":"Gtk4.GLib.GDBusObjectManagerClient","text":"#GDBusObjectManagerClient is used to create, monitor and delete object proxies for remote objects exported by a #GDBusObjectManagerServer (or any code implementing the org.freedesktop.DBus.ObjectManager interface).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusObjectManagerServer","page":"GLib Reference","title":"Gtk4.GLib.GDBusObjectManagerServer","text":"#GDBusObjectManagerServer is used to export #GDBusObject instances using the standardized org.freedesktop.DBus.ObjectManager interface. For example, remote D-Bus clients can get all objects and properties in a single call. Additionally, any change in the object hierarchy is broadcast using signals. This means that D-Bus clients can keep caches up to date by only listening to D-Bus signals.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusObjectProxy","page":"GLib Reference","title":"Gtk4.GLib.GDBusObjectProxy","text":"A #GDBusObjectProxy is an object used to represent a remote object with one or more D-Bus interfaces. Normally, you don't instantiate a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient is used to obtain it.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusObjectSkeleton","page":"GLib Reference","title":"Gtk4.GLib.GDBusObjectSkeleton","text":"A #GDBusObjectSkeleton instance is essentially a group of D-Bus interfaces. The set of exported interfaces on the object may be dynamic and change at runtime.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusProxy","page":"GLib Reference","title":"Gtk4.GLib.GDBusProxy","text":"#GDBusProxy is a base class used for proxies to access a D-Bus interface on a remote object. A #GDBusProxy can be constructed for both well-known and unique names.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDBusServer","page":"GLib Reference","title":"Gtk4.GLib.GDBusServer","text":"#GDBusServer is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the org.freedesktop.DBus interface.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDataInputStream","page":"GLib Reference","title":"Gtk4.GLib.GDataInputStream","text":"Data input stream implements #GInputStream and includes functions for reading structured data directly from a binary input stream.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDataOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GDataOutputStream","text":"Data output stream implements #GOutputStream and includes functions for writing data directly to an output stream.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDate","page":"GLib Reference","title":"Gtk4.GLib.GDate","text":"Represents a day between January 1, Year 1 and a few thousand years in the future. None of its members should be accessed directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDateTime","page":"GLib Reference","title":"Gtk4.GLib.GDateTime","text":"An opaque structure that represents a date and time, including a time zone.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDebugKey","page":"GLib Reference","title":"Gtk4.GLib.GDebugKey","text":"Associates a string with a bit flag. Used in gparsedebug_string().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GDesktopAppInfo","page":"GLib Reference","title":"Gtk4.GLib.GDesktopAppInfo","text":"#GDesktopAppInfo is an implementation of #GAppInfo based on desktop files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GEmblem","page":"GLib Reference","title":"Gtk4.GLib.GEmblem","text":"#GEmblem is an implementation of #GIcon that supports having an emblem, which is an icon with additional properties. It can than be added to a #GEmblemedIcon.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GEmblemedIcon","page":"GLib Reference","title":"Gtk4.GLib.GEmblemedIcon","text":"#GEmblemedIcon is an implementation of #GIcon that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured via gemblemediconaddemblem().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GEnumClass","page":"GLib Reference","title":"Gtk4.GLib.GEnumClass","text":"The class of an enumeration type holds information about its possible values.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileAttributeInfo","page":"GLib Reference","title":"Gtk4.GLib.GFileAttributeInfo","text":"Information about a specific attribute.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileAttributeInfoList","page":"GLib Reference","title":"Gtk4.GLib.GFileAttributeInfoList","text":"Acts as a lightweight registry for possible valid file attributes. The registry stores Key-Value pair formats as #GFileAttributeInfos.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileAttributeMatcher","page":"GLib Reference","title":"Gtk4.GLib.GFileAttributeMatcher","text":"Determines if a string matches a file attribute.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileEnumerator","page":"GLib Reference","title":"Gtk4.GLib.GFileEnumerator","text":"#GFileEnumerator allows you to operate on a set of #GFiles, returning a #GFileInfo structure for each file enumerated (e.g. gfileenumerate_children() will return a #GFileEnumerator for each of the children within a directory).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileIOStream","page":"GLib Reference","title":"Gtk4.GLib.GFileIOStream","text":"GFileIOStream provides io streams that both read and write to the same file handle.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileIcon","page":"GLib Reference","title":"Gtk4.GLib.GFileIcon","text":"#GFileIcon specifies an icon by pointing to an image file to be used as icon.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileInfo","page":"GLib Reference","title":"Gtk4.GLib.GFileInfo","text":"Functionality for manipulating basic metadata for files. #GFileInfo implements methods for getting information that all files should contain, and allows for manipulation of extended attributes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileInputStream","page":"GLib Reference","title":"Gtk4.GLib.GFileInputStream","text":"GFileInputStream provides input streams that take their content from a file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileMonitor","page":"GLib Reference","title":"Gtk4.GLib.GFileMonitor","text":"Monitors a file or directory for changes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFileOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GFileOutputStream","text":"GFileOutputStream provides output streams that write their content to a file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFilenameCompleter","page":"GLib Reference","title":"Gtk4.GLib.GFilenameCompleter","text":"Completes partial file and directory names given a partial string by looking in the file system for clues. Can return a list of possible completion strings for widget implementations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFilterInputStream","page":"GLib Reference","title":"Gtk4.GLib.GFilterInputStream","text":"Base class for input stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFilterOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GFilterOutputStream","text":"Base class for output stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GFlagsClass","page":"GLib Reference","title":"Gtk4.GLib.GFlagsClass","text":"The class of a flags type holds information about its possible values.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GIOModule","page":"GLib Reference","title":"Gtk4.GLib.GIOModule","text":"Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GIOStream","page":"GLib Reference","title":"Gtk4.GLib.GIOStream","text":"GIOStream represents an object that has both read and write streams. Generally the two streams act as separate input and output streams, but they share some common resources and state. For instance, for seekable streams, both streams may use the same position.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInetAddress","page":"GLib Reference","title":"Gtk4.GLib.GInetAddress","text":"#GInetAddress represents an IPv4 or IPv6 internet address. Use gresolverlookupbyname() or gresolverlookupbynameasync() to look up the #GInetAddress for a hostname. Use gresolverlookupbyaddress() or gresolverlookupbyaddressasync() to look up the hostname for a #GInetAddress.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInetAddressMask","page":"GLib Reference","title":"Gtk4.GLib.GInetAddressMask","text":"#GInetAddressMask represents a range of IPv4 or IPv6 addresses described by a base address and a length indicating how many bits of the base address are relevant for matching purposes. These are often given in string form. Eg, \"10.0.0.0/8\", or \"fe80::/10\".\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInetSocketAddress","page":"GLib Reference","title":"Gtk4.GLib.GInetSocketAddress","text":"An IPv4 or IPv6 socket address; that is, the combination of a #GInetAddress and a port number.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInitiallyUnowned","page":"GLib Reference","title":"Gtk4.GLib.GInitiallyUnowned","text":"A type for objects that have an initially floating reference.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInputStream","page":"GLib Reference","title":"Gtk4.GLib.GInputStream","text":"#GInputStream has functions to read from a stream (ginputstreamread()), to close a stream (ginputstreamclose()) and to skip some content (ginputstream_skip()).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GInputVector","page":"GLib Reference","title":"Gtk4.GLib.GInputVector","text":"Structure used for scatter/gather data input. You generally pass in an array of #GInputVectors and the operation will store the read data starting in the first buffer, switching to the next as needed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GKeyFile","page":"GLib Reference","title":"Gtk4.GLib.GKeyFile","text":"The GKeyFile struct contains only private data and should not be accessed directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GListStore","page":"GLib Reference","title":"Gtk4.GLib.GListStore","text":"#GListStore is a simple implementation of #GListModel that stores all items in memory.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GLogField","page":"GLib Reference","title":"Gtk4.GLib.GLogField","text":"Structure representing a single field in a structured log entry. See glogstructured() for details.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMainContext","page":"GLib Reference","title":"Gtk4.GLib.GMainContext","text":"The GMainContext struct is an opaque data type representing a set of sources to be handled in a main loop.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMainLoop","page":"GLib Reference","title":"Gtk4.GLib.GMainLoop","text":"The GMainLoop struct is an opaque data type representing the main event loop of a GLib or GTK+ application.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMappedFile","page":"GLib Reference","title":"Gtk4.GLib.GMappedFile","text":"The #GMappedFile represents a file mapping created with gmappedfile_new(). It has only private members and should not be accessed directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMarkupParseContext","page":"GLib Reference","title":"Gtk4.GLib.GMarkupParseContext","text":"A parse context is used to parse a stream of bytes that you expect to contain marked-up text.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMatchInfo","page":"GLib Reference","title":"Gtk4.GLib.GMatchInfo","text":"A GMatchInfo is an opaque struct used to return information about matches.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMemoryInputStream","page":"GLib Reference","title":"Gtk4.GLib.GMemoryInputStream","text":"#GMemoryInputStream is a class for using arbitrary memory chunks as input for GIO streaming input operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMemoryOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GMemoryOutputStream","text":"#GMemoryOutputStream is a class for using arbitrary memory chunks as output for GIO streaming output operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMenu","page":"GLib Reference","title":"Gtk4.GLib.GMenu","text":"#GMenu is a simple implementation of #GMenuModel. You populate a #GMenu by adding #GMenuItem instances to it.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMenuAttributeIter","page":"GLib Reference","title":"Gtk4.GLib.GMenuAttributeIter","text":"#GMenuAttributeIter is an opaque structure type. You must access it using the functions below.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMenuItem","page":"GLib Reference","title":"Gtk4.GLib.GMenuItem","text":"#GMenuItem is an opaque structure type. You must access it using the functions below.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMenuLinkIter","page":"GLib Reference","title":"Gtk4.GLib.GMenuLinkIter","text":"#GMenuLinkIter is an opaque structure type. You must access it using the functions below.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMenuModel","page":"GLib Reference","title":"Gtk4.GLib.GMenuModel","text":"#GMenuModel represents the contents of a menu – an ordered list of menu items. The items are associated with actions, which can be activated through them. Items can be grouped in sections, and may have submenus associated with them. Both items and sections usually have some representation data, such as labels or icons. The type of the associated action (ie whether it is stateful, and what kind of state it has) can influence the representation of the item.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GMountOperation","page":"GLib Reference","title":"Gtk4.GLib.GMountOperation","text":"#GMountOperation provides a mechanism for interacting with the user. It can be used for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations. It can also be used to ask the user questions or show a list of applications preventing unmount or eject operations from completing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GNativeSocketAddress","page":"GLib Reference","title":"Gtk4.GLib.GNativeSocketAddress","text":"A socket address of some unknown native type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GNetworkAddress","page":"GLib Reference","title":"Gtk4.GLib.GNetworkAddress","text":"#GNetworkAddress provides an easy way to resolve a hostname and then attempt to connect to that host, handling the possibility of multiple IP addresses and multiple address families.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GNetworkService","page":"GLib Reference","title":"Gtk4.GLib.GNetworkService","text":"Like #GNetworkAddress does with hostnames, #GNetworkService provides an easy way to resolve a SRV record, and then attempt to connect to one of the hosts that implements that service, handling service priority/weighting, multiple IP addresses, and multiple address families.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GNotification","page":"GLib Reference","title":"Gtk4.GLib.GNotification","text":"#GNotification is a mechanism for creating a notification to be shown to the user – typically as a pop-up notification presented by the desktop environment shell.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GOptionEntry","page":"GLib Reference","title":"Gtk4.GLib.GOptionEntry","text":"A GOptionEntry struct defines a single option. To have an effect, they must be added to a #GOptionGroup with goptioncontextaddmainentries() or goptiongroupadd_entries().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GOutputStream","page":"GLib Reference","title":"Gtk4.GLib.GOutputStream","text":"#GOutputStream has functions to write to a stream (goutputstreamwrite()), to close a stream (goutputstreamclose()) and to flush pending writes (goutputstream_flush()).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GOutputVector","page":"GLib Reference","title":"Gtk4.GLib.GOutputVector","text":"Structure used for scatter/gather data output. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GPatternSpec","page":"GLib Reference","title":"Gtk4.GLib.GPatternSpec","text":"A GPatternSpec struct is the 'compiled' form of a pattern. This structure is opaque and its fields cannot be accessed directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GPermission","page":"GLib Reference","title":"Gtk4.GLib.GPermission","text":"A #GPermission represents the status of the caller's permission to perform a certain action.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GPropertyAction","page":"GLib Reference","title":"Gtk4.GLib.GPropertyAction","text":"A #GPropertyAction is a way to get a #GAction with a state value reflecting and controlling the value of a #GObject property.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GProxyAddress","page":"GLib Reference","title":"Gtk4.GLib.GProxyAddress","text":"Support for proxied #GInetSocketAddress.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GProxyAddressEnumerator","page":"GLib Reference","title":"Gtk4.GLib.GProxyAddressEnumerator","text":"#GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator and wraps them in #GProxyAddress instances, using the given #GProxyAddressEnumerator:proxy-resolver.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GRegex","page":"GLib Reference","title":"Gtk4.GLib.GRegex","text":"The gregex*() functions implement regular expression pattern matching using syntax and semantics similar to Perl regular expression.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GResolver","page":"GLib Reference","title":"Gtk4.GLib.GResolver","text":"#GResolver provides cancellable synchronous and asynchronous DNS resolution, for hostnames (gresolverlookupbyaddress(), gresolverlookupbyname() and their async variants) and SRV (service) records (gresolverlookup_service()).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GResource","page":"GLib Reference","title":"Gtk4.GLib.GResource","text":"Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance #GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files, icons, etc. These are often shipped as files in $datadir/appname, or manually included as literal strings in the code.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GScannerConfig","page":"GLib Reference","title":"Gtk4.GLib.GScannerConfig","text":"Specifies the #GScanner parser configuration. Most settings can be changed during the parsing phase and will affect the lexical parsing of the next unpeeked token.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSettings","page":"GLib Reference","title":"Gtk4.GLib.GSettings","text":"The #GSettings class provides a convenient API for storing and retrieving application settings.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSettingsBackend","page":"GLib Reference","title":"Gtk4.GLib.GSettingsBackend","text":"The #GSettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for #GSettings, you need to implement the #GSettingsBackend interface and then make it implement the extension point %GSETTINGSBACKENDEXTENSIONPOINT_NAME.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSettingsSchema","page":"GLib Reference","title":"Gtk4.GLib.GSettingsSchema","text":"The #GSettingsSchemaSource and #GSettingsSchema APIs provide a mechanism for advanced control over the loading of schemas and a mechanism for introspecting their content.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSettingsSchemaKey","page":"GLib Reference","title":"Gtk4.GLib.GSettingsSchemaKey","text":"#GSettingsSchemaKey is an opaque data structure and can only be accessed using the following functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSettingsSchemaSource","page":"GLib Reference","title":"Gtk4.GLib.GSettingsSchemaSource","text":"This is an opaque structure type. You may not access it directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSignalInvocationHint","page":"GLib Reference","title":"Gtk4.GLib.GSignalInvocationHint","text":"The #GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSignalQuery","page":"GLib Reference","title":"Gtk4.GLib.GSignalQuery","text":"A structure holding in-depth information for a specific signal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimpleAction","page":"GLib Reference","title":"Gtk4.GLib.GSimpleAction","text":"A #GSimpleAction is the obvious simple implementation of the #GAction interface. This is the easiest way to create an action for purposes of adding it to a #GSimpleActionGroup.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimpleActionGroup","page":"GLib Reference","title":"Gtk4.GLib.GSimpleActionGroup","text":"#GSimpleActionGroup is a hash table filled with #GAction objects, implementing the #GActionGroup and #GActionMap interfaces.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimpleAsyncResult","page":"GLib Reference","title":"Gtk4.GLib.GSimpleAsyncResult","text":"As of GLib 2.46, #GSimpleAsyncResult is deprecated in favor of #GTask, which provides a simpler API.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimpleIOStream","page":"GLib Reference","title":"Gtk4.GLib.GSimpleIOStream","text":"GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and #GOutputStream. This allows any pair of input and output streams to be used with #GIOStream methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimplePermission","page":"GLib Reference","title":"Gtk4.GLib.GSimplePermission","text":"#GSimplePermission is a trivial implementation of #GPermission that represents a permission that is either always or never allowed. The value is given at construction and doesn't change.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSimpleProxyResolver","page":"GLib Reference","title":"Gtk4.GLib.GSimpleProxyResolver","text":"#GSimpleProxyResolver is a simple #GProxyResolver implementation that handles a single default proxy, multiple URI-scheme-specific proxies, and a list of hosts that proxies should not be used for.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocket","page":"GLib Reference","title":"Gtk4.GLib.GSocket","text":"A #GSocket is a low-level networking primitive. It is a more or less direct mapping of the BSD socket API in a portable GObject based API. It supports both the UNIX socket implementations and winsock2 on Windows.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketAddress","page":"GLib Reference","title":"Gtk4.GLib.GSocketAddress","text":"#GSocketAddress is the equivalent of struct sockaddr in the BSD sockets API. This is an abstract class; use #GInetSocketAddress for internet sockets, or #GUnixSocketAddress for UNIX domain sockets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketAddressEnumerator","page":"GLib Reference","title":"Gtk4.GLib.GSocketAddressEnumerator","text":"#GSocketAddressEnumerator is an enumerator type for #GSocketAddress instances. It is returned by enumeration functions such as gsocketconnectable_enumerate(), which returns a #GSocketAddressEnumerator to list each #GSocketAddress which could be used to connect to that #GSocketConnectable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketClient","page":"GLib Reference","title":"Gtk4.GLib.GSocketClient","text":"#GSocketClient is a lightweight high-level utility class for connecting to a network host using a connection oriented socket type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketConnection","page":"GLib Reference","title":"Gtk4.GLib.GSocketConnection","text":"#GSocketConnection is a #GIOStream for a connected socket. They can be created either by #GSocketClient when connecting to a host, or by #GSocketListener when accepting a new client.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketControlMessage","page":"GLib Reference","title":"Gtk4.GLib.GSocketControlMessage","text":"A #GSocketControlMessage is a special-purpose utility message that can be sent to or received from a #GSocket. These types of messages are often called \"ancillary data\".\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketListener","page":"GLib Reference","title":"Gtk4.GLib.GSocketListener","text":"A #GSocketListener is an object that keeps track of a set of server sockets and helps you accept sockets from any of the socket, either sync or async.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSocketService","page":"GLib Reference","title":"Gtk4.GLib.GSocketService","text":"A #GSocketService is an object that represents a service that is provided to the network or over local sockets. When a new connection is made to the service the #GSocketService::incoming signal is emitted.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSource","page":"GLib Reference","title":"Gtk4.GLib.GSource","text":"The GSource struct is an opaque data type representing an event source.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSourceCallbackFuncs","page":"GLib Reference","title":"Gtk4.GLib.GSourceCallbackFuncs","text":"The GSourceCallbackFuncs struct contains functions for managing callback objects.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSrvTarget","page":"GLib Reference","title":"Gtk4.GLib.GSrvTarget","text":"SRV (service) records are used by some network protocols to provide service-specific aliasing and load-balancing. For example, XMPP (Jabber) uses SRV records to locate the XMPP server for a domain; rather than connecting directly to \"example.com\" or assuming a specific server hostname like \"xmpp.example.com\", an XMPP client would look up the \"xmpp-client\" SRV record for \"example.com\", and then connect to whatever host was pointed to by that record.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GString","page":"GLib Reference","title":"Gtk4.GLib.GString","text":"The GString struct contains the public fields of a GString.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSubprocess","page":"GLib Reference","title":"Gtk4.GLib.GSubprocess","text":"#GSubprocess allows the creation of and interaction with child processes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSubprocessLauncher","page":"GLib Reference","title":"Gtk4.GLib.GSubprocessLauncher","text":"This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTask","page":"GLib Reference","title":"Gtk4.GLib.GTask","text":"A #GTask represents and manages a cancellable \"task\".\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTcpConnection","page":"GLib Reference","title":"Gtk4.GLib.GTcpConnection","text":"This is the subclass of #GSocketConnection that is created for TCP/IP sockets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTcpWrapperConnection","page":"GLib Reference","title":"Gtk4.GLib.GTcpWrapperConnection","text":"A #GTcpWrapperConnection can be used to wrap a #GIOStream that is based on a #GSocket, but which is not actually a #GSocketConnection. This is used by #GSocketClient so that it can always return a #GSocketConnection, even when the connection it has actually created is not directly a #GSocketConnection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTestDBus","page":"GLib Reference","title":"Gtk4.GLib.GTestDBus","text":"A helper class for testing code which uses D-Bus without touching the user's session bus.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GThemedIcon","page":"GLib Reference","title":"Gtk4.GLib.GThemedIcon","text":"#GThemedIcon is an implementation of #GIcon that supports icon themes. #GThemedIcon contains a list of all of the icons present in an icon theme, so that icons can be looked up quickly. #GThemedIcon does not provide actual pixmaps for icons, just the icon names. Ideally something like gtkiconthemechooseicon() should be used to resolve the list of names so that fallback icons work nicely with themes that inherit other themes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GThreadedSocketService","page":"GLib Reference","title":"Gtk4.GLib.GThreadedSocketService","text":"A #GThreadedSocketService is a simple subclass of #GSocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the #GThreadedSocketService::run signal in the new thread.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTimeZone","page":"GLib Reference","title":"Gtk4.GLib.GTimeZone","text":"#GTimeZone is an opaque structure whose members cannot be accessed directly.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTlsCertificate","page":"GLib Reference","title":"Gtk4.GLib.GTlsCertificate","text":"A certificate used for TLS authentication and encryption. This can represent either a certificate only (eg, the certificate received by a client from a server), or the combination of a certificate and a private key (which is needed when acting as a #GTlsServerConnection).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTlsConnection","page":"GLib Reference","title":"Gtk4.GLib.GTlsConnection","text":"#GTlsConnection is the base TLS connection class type, which wraps a #GIOStream and provides TLS encryption on top of it. Its subclasses, #GTlsClientConnection and #GTlsServerConnection, implement client-side and server-side TLS, respectively.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTlsDatabase","page":"GLib Reference","title":"Gtk4.GLib.GTlsDatabase","text":"#GTlsDatabase is used to look up certificates and other information from a certificate or key store. It is an abstract base class which TLS library specific subtypes override.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTlsInteraction","page":"GLib Reference","title":"Gtk4.GLib.GTlsInteraction","text":"#GTlsInteraction provides a mechanism for the TLS connection and database code to interact with the user. It can be used to ask the user for passwords.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTlsPassword","page":"GLib Reference","title":"Gtk4.GLib.GTlsPassword","text":"Holds a password used in TLS.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTypeFundamentalInfo","page":"GLib Reference","title":"Gtk4.GLib.GTypeFundamentalInfo","text":"A structure that provides information to the type system which is used specifically for managing fundamental types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTypeModule","page":"GLib Reference","title":"Gtk4.GLib.GTypeModule","text":"#GTypeModule provides a simple implementation of the #GTypePlugin interface.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTypePluginClass","page":"GLib Reference","title":"Gtk4.GLib.GTypePluginClass","text":"The #GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GTypeQuery","page":"GLib Reference","title":"Gtk4.GLib.GTypeQuery","text":"A structure holding information for a specific type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUnixConnection","page":"GLib Reference","title":"Gtk4.GLib.GUnixConnection","text":"This is the subclass of #GSocketConnection that is created for UNIX domain sockets.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUnixCredentialsMessage","page":"GLib Reference","title":"Gtk4.GLib.GUnixCredentialsMessage","text":"This #GSocketControlMessage contains a #GCredentials instance. It may be sent using gsocketsendmessage() and received using gsocketreceivemessage() over UNIX sockets (ie: sockets in the %GSOCKETFAMILY_UNIX family).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUri","page":"GLib Reference","title":"Gtk4.GLib.GUri","text":"The #GUri type and related functions can be used to parse URIs into their components, and build valid URIs from individual components.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GValueArray","page":"GLib Reference","title":"Gtk4.GLib.GValueArray","text":"A #GValueArray contains an array of #GValue elements.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GVariantBuilder","page":"GLib Reference","title":"Gtk4.GLib.GVariantBuilder","text":"A utility type for constructing container-type #GVariant instances.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GVariantDict","page":"GLib Reference","title":"Gtk4.GLib.GVariantDict","text":"#GVariantDict is a mutable interface to #GVariant dictionaries.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GVariantType","page":"GLib Reference","title":"Gtk4.GLib.GVariantType","text":"This section introduces the GVariant type system. It is based, in large part, on the D-Bus type system, with two major changes and some minor lifting of restrictions. The D-Bus specification, therefore, provides a significant amount of information that is useful when working with GVariant.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GVfs","page":"GLib Reference","title":"Gtk4.GLib.GVfs","text":"Entry point for using GIO functionality.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GVolumeMonitor","page":"GLib Reference","title":"Gtk4.GLib.GVolumeMonitor","text":"#GVolumeMonitor is for listing the user interesting devices and volumes on the computer. In other words, what a file selector or file manager would show in a sidebar.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GZlibCompressor","page":"GLib Reference","title":"Gtk4.GLib.GZlibCompressor","text":"#GZlibCompressor is an implementation of #GConverter that compresses data using zlib.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.GZlibDecompressor","page":"GLib Reference","title":"Gtk4.GLib.GZlibDecompressor","text":"#GZlibDecompressor is an implementation of #GConverter that decompresses data compressed with zlib.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.HookFlagMask","page":"GLib Reference","title":"Gtk4.GLib.HookFlagMask","text":"Flags used internally in the #GHook implementation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOChannelError","page":"GLib Reference","title":"Gtk4.GLib.IOChannelError","text":"Error codes returned by #GIOChannel operations.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOCondition","page":"GLib Reference","title":"Gtk4.GLib.IOCondition","text":"A bitwise combination representing a condition to watch for on an event source.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOError","page":"GLib Reference","title":"Gtk4.GLib.IOError","text":"#GIOError is only used by the deprecated functions giochannelread(), giochannelwrite(), and giochannel_seek().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOErrorEnum","page":"GLib Reference","title":"Gtk4.GLib.IOErrorEnum","text":"Error codes returned by GIO functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOFlags","page":"GLib Reference","title":"Gtk4.GLib.IOFlags","text":"Specifies properties of a #GIOChannel. Some of the flags can only be read with giochannelgetflags(), but not changed with giochannelsetflags().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOModuleScopeFlags","page":"GLib Reference","title":"Gtk4.GLib.IOModuleScopeFlags","text":"Flags for use with giomodulescopenew().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOStatus","page":"GLib Reference","title":"Gtk4.GLib.IOStatus","text":"Statuses returned by most of the #GIOFuncs functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.IOStreamSpliceFlags","page":"GLib Reference","title":"Gtk4.GLib.IOStreamSpliceFlags","text":"GIOStreamSpliceFlags determine how streams should be spliced.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.KeyFileError","page":"GLib Reference","title":"Gtk4.GLib.KeyFileError","text":"Error codes returned by key file parsing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.KeyFileFlags","page":"GLib Reference","title":"Gtk4.GLib.KeyFileFlags","text":"Flags which influence the parsing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.LogLevelFlags","page":"GLib Reference","title":"Gtk4.GLib.LogLevelFlags","text":"Flags specifying the level of log messages.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.LogWriterOutput","page":"GLib Reference","title":"Gtk4.GLib.LogWriterOutput","text":"Return values from #GLogWriterFuncs to indicate whether the given log entry was successfully handled by the writer, or whether there was an error in handling it (and hence a fallback writer should be used).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MainContextFlags","page":"GLib Reference","title":"Gtk4.GLib.MainContextFlags","text":"Flags to pass to gmaincontextnewwith_flags() which affect the behaviour of a #GMainContext.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MarkupCollectType","page":"GLib Reference","title":"Gtk4.GLib.MarkupCollectType","text":"A mixed enumerated type and flags field. You must specify one type (string, strdup, boolean, tristate). Additionally, you may optionally bitwise OR the type with the flag %GMARKUPCOLLECT_OPTIONAL.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MarkupError","page":"GLib Reference","title":"Gtk4.GLib.MarkupError","text":"Error codes returned by markup parsing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MarkupParseFlags","page":"GLib Reference","title":"Gtk4.GLib.MarkupParseFlags","text":"Flags that affect the behaviour of the parser.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MemoryMonitorWarningLevel","page":"GLib Reference","title":"Gtk4.GLib.MemoryMonitorWarningLevel","text":"Memory availability warning levels.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MountMountFlags","page":"GLib Reference","title":"Gtk4.GLib.MountMountFlags","text":"Flags used when mounting a mount.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MountOperationResult","page":"GLib Reference","title":"Gtk4.GLib.MountOperationResult","text":"#GMountOperationResult is returned as a result when a request for information is send by the mounting operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.MountUnmountFlags","page":"GLib Reference","title":"Gtk4.GLib.MountUnmountFlags","text":"Flags used when an unmounting a mount.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.NetworkConnectivity","page":"GLib Reference","title":"Gtk4.GLib.NetworkConnectivity","text":"The host's network connectivity state, as reported by #GNetworkMonitor.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.NormalizeMode","page":"GLib Reference","title":"Gtk4.GLib.NormalizeMode","text":"Defines how a Unicode string is transformed in a canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character. Unicode strings should generally be normalized before comparing them.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.NotificationPriority","page":"GLib Reference","title":"Gtk4.GLib.NotificationPriority","text":"Priority levels for #GNotifications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.NumberParserError","page":"GLib Reference","title":"Gtk4.GLib.NumberParserError","text":"Error codes returned by functions converting a string to a number.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.OnceStatus","page":"GLib Reference","title":"Gtk4.GLib.OnceStatus","text":"The possible statuses of a one-time initialization function controlled by a #GOnce struct.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.OptionArg","page":"GLib Reference","title":"Gtk4.GLib.OptionArg","text":"The #GOptionArg enum values determine which type of extra argument the options expect to find. If an option expects an extra argument, it can be specified in several ways; with a short option: -x arg, with a long option: --name arg or combined in a single argument: --name=arg.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.OptionError","page":"GLib Reference","title":"Gtk4.GLib.OptionError","text":"Error codes returned by option parsing.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.OptionFlags","page":"GLib Reference","title":"Gtk4.GLib.OptionFlags","text":"Flags which modify individual options.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.OutputStreamSpliceFlags","page":"GLib Reference","title":"Gtk4.GLib.OutputStreamSpliceFlags","text":"GOutputStreamSpliceFlags determine how streams should be spliced.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ParamFlags","page":"GLib Reference","title":"Gtk4.GLib.ParamFlags","text":"Through the #GParamFlags flag values, certain aspects of parameters can be configured.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.PasswordSave","page":"GLib Reference","title":"Gtk4.GLib.PasswordSave","text":"#GPasswordSave is used to indicate the lifespan of a saved password.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.PollableReturn","page":"GLib Reference","title":"Gtk4.GLib.PollableReturn","text":"Return value for various IO operations that signal errors via the return value and not necessarily via a #GError.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.RegexCompileFlags","page":"GLib Reference","title":"Gtk4.GLib.RegexCompileFlags","text":"Flags specifying compile-time options.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.RegexError","page":"GLib Reference","title":"Gtk4.GLib.RegexError","text":"Error codes returned by regular expressions functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.RegexMatchFlags","page":"GLib Reference","title":"Gtk4.GLib.RegexMatchFlags","text":"Flags specifying match-time options.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResolverError","page":"GLib Reference","title":"Gtk4.GLib.ResolverError","text":"An error code used with %GRESOLVERERROR in a #GError returned from a #GResolver routine.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResolverNameLookupFlags","page":"GLib Reference","title":"Gtk4.GLib.ResolverNameLookupFlags","text":"Flags to modify lookup behavior.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResolverRecordType","page":"GLib Reference","title":"Gtk4.GLib.ResolverRecordType","text":"The type of record that gresolverlookuprecords() or gresolverlookuprecords_async() should retrieve. The records are returned as lists of #GVariant tuples. Each record type has different values in the variant tuples returned.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResourceError","page":"GLib Reference","title":"Gtk4.GLib.ResourceError","text":"An error code used with %GRESOURCEERROR in a #GError returned from a #GResource routine.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResourceFlags","page":"GLib Reference","title":"Gtk4.GLib.ResourceFlags","text":"GResourceFlags give information about a particular file inside a resource bundle.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ResourceLookupFlags","page":"GLib Reference","title":"Gtk4.GLib.ResourceLookupFlags","text":"GResourceLookupFlags determine how resource path lookups are handled.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SeekType","page":"GLib Reference","title":"Gtk4.GLib.SeekType","text":"An enumeration specifying the base position for a giochannelseekposition() operation.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SettingsBindFlags","page":"GLib Reference","title":"Gtk4.GLib.SettingsBindFlags","text":"Flags used when creating a binding. These flags determine in which direction the binding works. The default is to synchronize in both directions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ShellError","page":"GLib Reference","title":"Gtk4.GLib.ShellError","text":"Error codes returned by shell functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SignalFlags","page":"GLib Reference","title":"Gtk4.GLib.SignalFlags","text":"The signal flags are used to specify a signal's behaviour.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SignalMatchType","page":"GLib Reference","title":"Gtk4.GLib.SignalMatchType","text":"The match types specify what gsignalhandlersblockmatched(), gsignalhandlersunblockmatched() and gsignalhandlersdisconnectmatched() match signals by.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketClientEvent","page":"GLib Reference","title":"Gtk4.GLib.SocketClientEvent","text":"Describes an event occurring on a #GSocketClient. See the #GSocketClient::event signal for more details.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketFamily","page":"GLib Reference","title":"Gtk4.GLib.SocketFamily","text":"The protocol family of a #GSocketAddress. (These values are identical to the system defines %AFINET, %AFINET6 and %AF_UNIX, if available.)\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketListenerEvent","page":"GLib Reference","title":"Gtk4.GLib.SocketListenerEvent","text":"Describes an event occurring on a #GSocketListener. See the #GSocketListener::event signal for more details.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketMsgFlags","page":"GLib Reference","title":"Gtk4.GLib.SocketMsgFlags","text":"Flags used in gsocketreceivemessage() and gsocketsendmessage(). The flags listed in the enum are some commonly available flags, but the values used for them are the same as on the platform, and any other flags are passed in/out as is. So to use a platform specific flag, just include the right system header and pass in the flag.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketProtocol","page":"GLib Reference","title":"Gtk4.GLib.SocketProtocol","text":"A protocol identifier is specified when creating a #GSocket, which is a family/type specific identifier, where 0 means the default protocol for the particular family/type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SocketType","page":"GLib Reference","title":"Gtk4.GLib.SocketType","text":"Flags used when creating a #GSocket. Some protocols may not implement all the socket types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SpawnError","page":"GLib Reference","title":"Gtk4.GLib.SpawnError","text":"Error codes returned by spawning processes.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SpawnFlags","page":"GLib Reference","title":"Gtk4.GLib.SpawnFlags","text":"Flags passed to gspawnsync(), gspawnasync() and gspawnasyncwithpipes().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.SubprocessFlags","page":"GLib Reference","title":"Gtk4.GLib.SubprocessFlags","text":"Flags to define the behaviour of a #GSubprocess.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TestDBusFlags","page":"GLib Reference","title":"Gtk4.GLib.TestDBusFlags","text":"Flags to define future #GTestDBus behaviour.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TestFileType","page":"GLib Reference","title":"Gtk4.GLib.TestFileType","text":"The type of file to return the filename for, when used with gtestbuild_filename().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TestSubprocessFlags","page":"GLib Reference","title":"Gtk4.GLib.TestSubprocessFlags","text":"Flags to pass to gtesttrap_subprocess() to control input and output.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ThreadError","page":"GLib Reference","title":"Gtk4.GLib.ThreadError","text":"Possible errors of thread related functions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TimeType","page":"GLib Reference","title":"Gtk4.GLib.TimeType","text":"Disambiguates a given time in two ways.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsAuthenticationMode","page":"GLib Reference","title":"Gtk4.GLib.TlsAuthenticationMode","text":"The client authentication mode for a #GTlsServerConnection.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsCertificateFlags","page":"GLib Reference","title":"Gtk4.GLib.TlsCertificateFlags","text":"A set of flags describing TLS certification validation. This can be used to describe why a particular certificate was rejected (for example, in #GTlsConnection::accept-certificate).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsCertificateRequestFlags","page":"GLib Reference","title":"Gtk4.GLib.TlsCertificateRequestFlags","text":"Flags for gtlsinteractionrequestcertificate(), gtlsinteractionrequestcertificateasync(), and gtlsinteractioninvokerequestcertificate().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsChannelBindingError","page":"GLib Reference","title":"Gtk4.GLib.TlsChannelBindingError","text":"An error code used with %GTLSCHANNELBINDINGERROR in a #GError to indicate a TLS channel binding retrieval error.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsChannelBindingType","page":"GLib Reference","title":"Gtk4.GLib.TlsChannelBindingType","text":"The type of TLS channel binding data to retrieve from #GTlsConnection or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The tls-unique-for-telnet binding type is not currently implemented.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsDatabaseLookupFlags","page":"GLib Reference","title":"Gtk4.GLib.TlsDatabaseLookupFlags","text":"Flags for gtlsdatabaselookupcertificateforhandle(), gtlsdatabaselookupcertificateissuer(), and gtlsdatabaselookupcertificatesissued_by().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsDatabaseVerifyFlags","page":"GLib Reference","title":"Gtk4.GLib.TlsDatabaseVerifyFlags","text":"Flags for gtlsdatabaseverifychain().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsError","page":"GLib Reference","title":"Gtk4.GLib.TlsError","text":"An error code used with %GTLSERROR in a #GError returned from a TLS-related routine.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsInteractionResult","page":"GLib Reference","title":"Gtk4.GLib.TlsInteractionResult","text":"#GTlsInteractionResult is returned by various functions in #GTlsInteraction when finishing an interaction request.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsPasswordFlags","page":"GLib Reference","title":"Gtk4.GLib.TlsPasswordFlags","text":"Various flags for the password.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TlsProtocolVersion","page":"GLib Reference","title":"Gtk4.GLib.TlsProtocolVersion","text":"The TLS or DTLS protocol version used by a #GTlsConnection or #GDtlsConnection. The integer values of these versions are sequential to ensure newer known protocol versions compare greater than older known versions. Any known DTLS protocol version will compare greater than any SSL or TLS protocol version. The protocol version may be %GTLSPROTOCOLVERSIONUNKNOWN if the TLS backend supports a newer protocol version that GLib does not yet know about. This means that it's possible for an unknown DTLS protocol version to compare less than the TLS protocol versions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TokenType","page":"GLib Reference","title":"Gtk4.GLib.TokenType","text":"The possible types of token returned from each gscannergetnexttoken() call.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TraverseFlags","page":"GLib Reference","title":"Gtk4.GLib.TraverseFlags","text":"Specifies which nodes are visited during several of the tree functions, including gnodetraverse() and gnodefind().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TraverseType","page":"GLib Reference","title":"Gtk4.GLib.TraverseType","text":"Specifies the type of traversal performed by gtreetraverse(), gnodetraverse() and gnodefind(). The different orders are illustrated here:\n\nIn order: A, B, C, D, E, F, G, H, I (Image: )\nPre order: F, B, A, D, C, E, G, I, H (Image: )\nPost order: A, C, E, D, B, H, I, G, F (Image: )\nLevel order: F, B, G, A, D, I, C, E, H (Image: )\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TypeFlags","page":"GLib Reference","title":"Gtk4.GLib.TypeFlags","text":"Bit masks used to check or determine characteristics of a type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.TypeFundamentalFlags","page":"GLib Reference","title":"Gtk4.GLib.TypeFundamentalFlags","text":"Bit masks used to check or determine specific characteristics of a fundamental type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UnicodeBreakType","page":"GLib Reference","title":"Gtk4.GLib.UnicodeBreakType","text":"These are the possible line break classifications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UnicodeScript","page":"GLib Reference","title":"Gtk4.GLib.UnicodeScript","text":"The #GUnicodeScript enumeration identifies different writing systems. The values correspond to the names as defined in the Unicode standard. The enumeration has been added in GLib 2.14, and is interchangeable with #PangoScript.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UnicodeType","page":"GLib Reference","title":"Gtk4.GLib.UnicodeType","text":"These are the possible character classifications from the Unicode specification. See Unicode Character Database.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UnixSocketAddressType","page":"GLib Reference","title":"Gtk4.GLib.UnixSocketAddressType","text":"The type of name used by a #GUnixSocketAddress. %GUNIXSOCKETADDRESSPATH indicates a traditional unix domain socket bound to a filesystem path. %GUNIXSOCKETADDRESSANONYMOUS indicates a socket not bound to any name (eg, a client-side socket, or a socket created with socketpair()).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UriError","page":"GLib Reference","title":"Gtk4.GLib.UriError","text":"Error codes returned by #GUri methods.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UriFlags","page":"GLib Reference","title":"Gtk4.GLib.UriFlags","text":"Flags that describe a URI.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UriHideFlags","page":"GLib Reference","title":"Gtk4.GLib.UriHideFlags","text":"Flags describing what parts of the URI to hide in guritostringpartial(). Note that %GURIHIDEPASSWORD and %GURIHIDEAUTH_PARAMS will only work if the #GUri was parsed with the corresponding flags.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UriParamsFlags","page":"GLib Reference","title":"Gtk4.GLib.UriParamsFlags","text":"Flags modifying the way parameters are handled by guriparse_params() and #GUriParamsIter.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.UserDirectory","page":"GLib Reference","title":"Gtk4.GLib.UserDirectory","text":"These are logical ids for special directories which are defined depending on the platform used. You should use ggetuserspecialdir() to retrieve the full path associated to the logical id.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.VariantClass","page":"GLib Reference","title":"Gtk4.GLib.VariantClass","text":"The range of possible top-level types of #GVariant instances.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.VariantParseError","page":"GLib Reference","title":"Gtk4.GLib.VariantParseError","text":"Error codes returned by parsing text-format GVariants.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Gtk4.GLib.ZlibCompressorFormat","page":"GLib Reference","title":"Gtk4.GLib.ZlibCompressorFormat","text":"Used to select the type of data format to use for #GZlibDecompressor and #GZlibCompressor.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"type"},{"location":"doc/GLib_reference/#Constants-1","page":"GLib Reference","title":"Constants","text":"","category":"section"},{"location":"doc/GLib_reference/#","page":"GLib Reference","title":"GLib Reference","text":"Modules = [Gtk4.GLib]\nOrder = [:constant]","category":"page"},{"location":"doc/GLib_reference/#Gtk4.GLib.ASCII_DTOSTR_BUF_SIZE","page":"GLib Reference","title":"Gtk4.GLib.ASCII_DTOSTR_BUF_SIZE","text":"A good size for a buffer to be passed into gasciidtostr(). It is guaranteed to be enough for all output of that function on systems with 64bit IEEE-compatible doubles.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.BIG_ENDIAN","page":"GLib Reference","title":"Gtk4.GLib.BIG_ENDIAN","text":"Specifies one of the possible types of byte order. See %GBYTEORDER.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.CSET_A_2_Z","page":"GLib Reference","title":"Gtk4.GLib.CSET_A_2_Z","text":"The set of uppercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.CSET_DIGITS","page":"GLib Reference","title":"Gtk4.GLib.CSET_DIGITS","text":"The set of ASCII digits. Used for specifying valid identifier characters in #GScannerConfig.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.CSET_a_2_z","page":"GLib Reference","title":"Gtk4.GLib.CSET_a_2_z","text":"The set of lowercase ASCII alphabet characters. Used for specifying valid identifier characters in #GScannerConfig.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DATALIST_FLAGS_MASK","page":"GLib Reference","title":"Gtk4.GLib.DATALIST_FLAGS_MASK","text":"A bitmask that restricts the possible flags passed to gdatalistsetflags(). Passing a flags value where flags & ~GDATALISTFLAGSMASK != 0 is an error.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DATE_BAD_DAY","page":"GLib Reference","title":"Gtk4.GLib.DATE_BAD_DAY","text":"Represents an invalid #GDateDay.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DATE_BAD_JULIAN","page":"GLib Reference","title":"Gtk4.GLib.DATE_BAD_JULIAN","text":"Represents an invalid Julian day number.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DATE_BAD_YEAR","page":"GLib Reference","title":"Gtk4.GLib.DATE_BAD_YEAR","text":"Represents an invalid year.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBUS_METHOD_INVOCATION_HANDLED","page":"GLib Reference","title":"Gtk4.GLib.DBUS_METHOD_INVOCATION_HANDLED","text":"The value returned by handlers of the signals generated by the gdbus-codegen tool to indicate that a method call has been handled by an implementation. It is equal to %TRUE, but using this macro is sometimes more readable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DBUS_METHOD_INVOCATION_UNHANDLED","page":"GLib Reference","title":"Gtk4.GLib.DBUS_METHOD_INVOCATION_UNHANDLED","text":"The value returned by handlers of the signals generated by the gdbus-codegen tool to indicate that a method call has not been handled by an implementation. It is equal to %FALSE, but using this macro is sometimes more readable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DEBUG_CONTROLLER_EXTENSION_POINT_NAME","page":"GLib Reference","title":"Gtk4.GLib.DEBUG_CONTROLLER_EXTENSION_POINT_NAME","text":"Extension point for debug control functionality. See [Extending GIO][extending-gio].\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DIR_SEPARATOR","page":"GLib Reference","title":"Gtk4.GLib.DIR_SEPARATOR","text":"The directory separator character. This is '/' on UNIX machines and '\\' under Windows.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DIR_SEPARATOR_S","page":"GLib Reference","title":"Gtk4.GLib.DIR_SEPARATOR_S","text":"The directory separator as a string. This is \"/\" on UNIX machines and \"\\\" under Windows.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.DRIVE_IDENTIFIER_KIND_UNIX_DEVICE","page":"GLib Reference","title":"Gtk4.GLib.DRIVE_IDENTIFIER_KIND_UNIX_DEVICE","text":"The string used to obtain a Unix device path with gdriveget_identifier().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_DELETE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_DELETE","text":"A key in the \"access\" namespace for checking deletion privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE","text":"A key in the \"access\" namespace for getting execution privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_READ","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_READ","text":"A key in the \"access\" namespace for getting read privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_RENAME","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_RENAME","text":"A key in the \"access\" namespace for checking renaming privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_TRASH","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_TRASH","text":"A key in the \"access\" namespace for checking trashing privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_WRITE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ACCESS_CAN_WRITE","text":"A key in the \"access\" namespace for getting write privileges.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_ARCHIVE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_ARCHIVE","text":"A key in the \"dos\" namespace for checking if the file's archive flag is set.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT","text":"A key in the \"dos\" namespace for checking if the file is a NTFS mount point (a volume mount or a junction point).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_SYSTEM","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_DOS_IS_SYSTEM","text":"A key in the \"dos\" namespace for checking if the file's backup flag is set.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG","text":"A key in the \"dos\" namespace for getting the file NTFS reparse tag.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ETAG_VALUE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ETAG_VALUE","text":"A key in the \"etag\" namespace for getting the value of the file's entity tag.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_FREE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_FREE","text":"A key in the \"filesystem\" namespace for getting the number of bytes of free space left on the file system.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_READONLY","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_READONLY","text":"A key in the \"filesystem\" namespace for checking if the file system is read only.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_REMOTE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_REMOTE","text":"A key in the \"filesystem\" namespace for checking if the file system is remote.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_SIZE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_SIZE","text":"A key in the \"filesystem\" namespace for getting the total size (in bytes) of the file system, used in gfilequeryfilesysteminfo().\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_TYPE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_TYPE","text":"A key in the \"filesystem\" namespace for getting the file system's type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_USED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_USED","text":"A key in the \"filesystem\" namespace for getting the number of bytes used by data on the file system.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW","text":"A key in the \"filesystem\" namespace for hinting a file manager application whether it should preview (e.g. thumbnail) files on the file system.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_GVFS_BACKEND","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_GVFS_BACKEND","text":"A key in the \"gvfs\" namespace that gets the name of the current GVFS backend in use.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ID_FILE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ID_FILE","text":"A key in the \"id\" namespace for getting a file identifier.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_ID_FILESYSTEM","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_ID_FILESYSTEM","text":"A key in the \"id\" namespace for getting the file system identifier.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) can be ejected.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) is mountable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) can be polled.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_START","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_START","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) can be started.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) can be started degraded.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) can be stopped.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) is unmountable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI","text":"A key in the \"mountable\" namespace for getting the HAL UDI for the mountable file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC","text":"A key in the \"mountable\" namespace for checking if a file (of type GFILETYPE_MOUNTABLE) is automatically polled for media.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE","text":"A key in the \"mountable\" namespace for getting the #GDriveStartStopType.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE","text":"A key in the \"mountable\" namespace for getting the unix device.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE","text":"A key in the \"mountable\" namespace for getting the unix device file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_OWNER_GROUP","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_OWNER_GROUP","text":"A key in the \"owner\" namespace for getting the file owner's group.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_OWNER_USER","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_OWNER_USER","text":"A key in the \"owner\" namespace for getting the user name of the file's owner.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_OWNER_USER_REAL","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_OWNER_USER_REAL","text":"A key in the \"owner\" namespace for getting the real name of the user that owns the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_PREVIEW_ICON","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_PREVIEW_ICON","text":"A key in the \"preview\" namespace for getting a #GIcon that can be used to get preview of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_RECENT_MODIFIED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_RECENT_MODIFIED","text":"A key in the \"recent\" namespace for getting time, when the metadata for the file in recent:/// was last changed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_SELINUX_CONTEXT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_SELINUX_CONTEXT","text":"A key in the \"selinux\" namespace for getting the file's SELinux context.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE","text":"A key in the \"standard\" namespace for getting the amount of disk space that is consumed by the file (in bytes).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","text":"A key in the \"standard\" namespace for getting the content type of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_COPY_NAME","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_COPY_NAME","text":"A key in the \"standard\" namespace for getting the copy name of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_DESCRIPTION","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_DESCRIPTION","text":"A key in the \"standard\" namespace for getting the description of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME","text":"A key in the \"standard\" namespace for getting the display name of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_EDIT_NAME","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_EDIT_NAME","text":"A key in the \"standard\" namespace for edit name of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE","text":"A key in the \"standard\" namespace for getting the fast content type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_ICON","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_ICON","text":"A key in the \"standard\" namespace for getting the icon for the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_BACKUP","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_BACKUP","text":"A key in the \"standard\" namespace for checking if a file is a backup file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_HIDDEN","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_HIDDEN","text":"A key in the \"standard\" namespace for checking if a file is hidden.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_SYMLINK","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_SYMLINK","text":"A key in the \"standard\" namespace for checking if the file is a symlink. Typically the actual type is something else, if we followed the symlink to get the type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL","text":"A key in the \"standard\" namespace for checking if a file is virtual.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_VOLATILE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_IS_VOLATILE","text":"A key in the \"standard\" namespace for checking if a file is volatile. This is meant for opaque, non-POSIX-like backends to indicate that the URI is not persistent. Applications should look at %GFILEATTRIBUTESTANDARDSYMLINK_TARGET for the persistent URI.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_NAME","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_NAME","text":"A key in the \"standard\" namespace for getting the name of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SIZE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SIZE","text":"A key in the \"standard\" namespace for getting the file's size (in bytes).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SORT_ORDER","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SORT_ORDER","text":"A key in the \"standard\" namespace for setting the sort order of a file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON","text":"A key in the \"standard\" namespace for getting the symbolic icon for the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET","text":"A key in the \"standard\" namespace for getting the symlink target, if the file is a symlink.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_TARGET_URI","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_TARGET_URI","text":"A key in the \"standard\" namespace for getting the target URI for the file, in the case of %GFILETYPESHORTCUT or %GFILETYPEMOUNTABLE files.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_TYPE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_STANDARD_TYPE","text":"A key in the \"standard\" namespace for storing file types.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAILING_FAILED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAILING_FAILED","text":"A key in the \"thumbnail\" namespace for checking if thumbnailing failed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAIL_IS_VALID","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAIL_IS_VALID","text":"A key in the \"thumbnail\" namespace for checking whether the thumbnail is outdated.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAIL_PATH","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_THUMBNAIL_PATH","text":"A key in the \"thumbnail\" namespace for getting the path to the thumbnail image.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS","text":"A key in the \"time\" namespace for getting the time the file was last accessed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS_NSEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS_NSEC","text":"A key in the \"time\" namespace for getting the nanoseconds of the time the file was last accessed. This should be used in conjunction with #GFILEATTRIBUTETIMEACCESS. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS_USEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_ACCESS_USEC","text":"A key in the \"time\" namespace for getting the microseconds of the time the file was last accessed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED","text":"A key in the \"time\" namespace for getting the time the file was last changed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED_NSEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED_NSEC","text":"A key in the \"time\" namespace for getting the nanoseconds of the time the file was last changed. This should be used in conjunction with #GFILEATTRIBUTETIMECHANGED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED_USEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CHANGED_USEC","text":"A key in the \"time\" namespace for getting the microseconds of the time the file was last changed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED","text":"A key in the \"time\" namespace for getting the time the file was created.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED_NSEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED_NSEC","text":"A key in the \"time\" namespace for getting the nanoseconds of the time the file was created. This should be used in conjunction with #GFILEATTRIBUTETIMECREATED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED_USEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_CREATED_USEC","text":"A key in the \"time\" namespace for getting the microseconds of the time the file was created.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED","text":"A key in the \"time\" namespace for getting the time the file was last modified.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED_NSEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED_NSEC","text":"A key in the \"time\" namespace for getting the nanoseconds of the time the file was last modified. This should be used in conjunction with #GFILEATTRIBUTETIMEMODIFIED. Corresponding #GFileAttributeType is %GFILEATTRIBUTETYPEUINT32.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED_USEC","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TIME_MODIFIED_USEC","text":"A key in the \"time\" namespace for getting the microseconds of the time the file was last modified.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TRASH_DELETION_DATE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TRASH_DELETION_DATE","text":"A key in the \"trash\" namespace for getting the deletion date and time of a file inside the trash:/// folder.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TRASH_ITEM_COUNT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TRASH_ITEM_COUNT","text":"A key in the \"trash\" namespace for getting the number of (toplevel) items that are present in the trash:/// folder.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_TRASH_ORIG_PATH","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_TRASH_ORIG_PATH","text":"A key in the \"trash\" namespace for getting the original path of a file inside the trash:/// folder before it was trashed.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_BLOCKS","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_BLOCKS","text":"A key in the \"unix\" namespace for getting the number of blocks allocated for the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_BLOCK_SIZE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_BLOCK_SIZE","text":"A key in the \"unix\" namespace for getting the block size for the file system.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_DEVICE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_DEVICE","text":"A key in the \"unix\" namespace for getting the device id of the device the file is located on (see stat() documentation).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_GID","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_GID","text":"A key in the \"unix\" namespace for getting the group ID for the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_INODE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_INODE","text":"A key in the \"unix\" namespace for getting the inode of the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT","text":"A key in the \"unix\" namespace for checking if the file represents a UNIX mount point.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_MODE","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_MODE","text":"A key in the \"unix\" namespace for getting the mode of the file (e.g. whether the file is a regular file, symlink, etc).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_NLINK","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_NLINK","text":"A key in the \"unix\" namespace for getting the number of hard links for a file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_RDEV","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_RDEV","text":"A key in the \"unix\" namespace for getting the device ID for the file (if it is a special file).\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.FILE_ATTRIBUTE_UNIX_UID","page":"GLib Reference","title":"Gtk4.GLib.FILE_ATTRIBUTE_UNIX_UID","text":"A key in the \"unix\" namespace for getting the user ID for the file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT16_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GINT16_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT16_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GINT16_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint16 or #guint16. It is a string literal, but doesn't include the percent-sign, such that you can add precision and length modifiers between percent-sign and conversion specifier and append a conversion specifier.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT32_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GINT32_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gint32. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT32_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GINT32_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint32 or #guint32. It is a string literal. See also %GGINT16MODIFIER.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT64_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GINT64_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gint64. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINT64_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GINT64_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gint64 or #guint64. It is a string literal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINTPTR_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GINTPTR_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gintptr.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GINTPTR_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GINTPTR_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gintptr or #guintptr. It is a string literal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSIZE_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GSIZE_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gsize. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSIZE_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GSIZE_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gsize. It is a string literal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSSIZE_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GSSIZE_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #gssize. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GSSIZE_MODIFIER","page":"GLib Reference","title":"Gtk4.GLib.GSSIZE_MODIFIER","text":"The platform dependent length modifier for conversion specifiers for scanning and printing values of type #gssize. It is a string literal.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUINT16_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GUINT16_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #guint16. See also %GGINT16FORMAT\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUINT32_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GUINT32_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #guint32. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUINT64_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GUINT64_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #guint64. See also %GGINT16FORMAT.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.GUINTPTR_FORMAT","page":"GLib Reference","title":"Gtk4.GLib.GUINTPTR_FORMAT","text":"This is the platform dependent conversion specifier for scanning and printing values of type #guintptr.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.HAVE_GNUC_VISIBILITY","page":"GLib Reference","title":"Gtk4.GLib.HAVE_GNUC_VISIBILITY","text":"Defined to 1 if gcc-style visibility handling is supported.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.HOOK_FLAG_USER_SHIFT","page":"GLib Reference","title":"Gtk4.GLib.HOOK_FLAG_USER_SHIFT","text":"The position of the first bit which is not reserved for internal use be the #GHook implementation, i.e. 1 << G_HOOK_FLAG_USER_SHIFT is the first bit which can be used for application-defined flags.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.IEEE754_DOUBLE_BIAS","page":"GLib Reference","title":"Gtk4.GLib.IEEE754_DOUBLE_BIAS","text":"The bias by which exponents in double-precision floats are offset.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.IEEE754_FLOAT_BIAS","page":"GLib Reference","title":"Gtk4.GLib.IEEE754_FLOAT_BIAS","text":"The bias by which exponents in single-precision floats are offset.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_GROUP","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_GROUP","text":"The name of the main group of a desktop entry file, as defined in the Desktop Entry Specification. Consult the specification for more details about the meanings of the keys below.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ACTIONS","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ACTIONS","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string list giving the available application actions.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_CATEGORIES","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_CATEGORIES","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a list of strings giving the categories in which the desktop entry should be shown in a menu.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_COMMENT","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_COMMENT","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a localized string giving the tooltip for the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a boolean set to true if the application is D-Bus activatable.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_EXEC","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_EXEC","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the command line to execute. It is only valid for desktop entries with the Application type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_GENERIC_NAME","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_GENERIC_NAME","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a localized string giving the generic name of the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_HIDDEN","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_HIDDEN","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a boolean stating whether the desktop entry has been deleted by the user.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ICON","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ICON","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a localized string giving the name of the icon to be displayed for the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_MIME_TYPE","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_MIME_TYPE","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a list of strings giving the MIME types supported by this desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NAME","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NAME","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a localized string giving the specific name of the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a list of strings identifying the environments that should not display the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NO_DISPLAY","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_NO_DISPLAY","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a boolean stating whether the desktop entry should be shown in menus.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a list of strings identifying the environments that should display the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_PATH","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_PATH","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string containing the working directory to run the program in. It is only valid for desktop entries with the Application type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a boolean stating whether the application supports the Startup Notification Protocol Specification.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is string identifying the WM class or name hint of a window that the application will create, which can be used to emulate Startup Notification with older applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TERMINAL","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TERMINAL","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a boolean stating whether the program should be run in a terminal window.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TRY_EXEC","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TRY_EXEC","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the file name of a binary on disk used to determine if the program is actually installed. It is only valid for desktop entries with the Application type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TYPE","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_TYPE","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the type of the desktop entry.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_URL","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_URL","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the URL to access. It is only valid for desktop entries with the Link type.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_KEY_VERSION","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_KEY_VERSION","text":"A key under %GKEYFILEDESKTOPGROUP, whose value is a string giving the version of the Desktop Entry Specification used for the desktop entry file.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_APPLICATION","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_APPLICATION","text":"The value of the %GKEYFILEDESKTOPKEY_TYPE, key for desktop entries representing applications.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_DIRECTORY","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_DIRECTORY","text":"The value of the %GKEYFILEDESKTOPKEY_TYPE, key for desktop entries representing directories.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_LINK","page":"GLib Reference","title":"Gtk4.GLib.KEY_FILE_DESKTOP_TYPE_LINK","text":"The value of the %GKEYFILEDESKTOPKEY_TYPE, key for desktop entries representing links to documents.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.LITTLE_ENDIAN","page":"GLib Reference","title":"Gtk4.GLib.LITTLE_ENDIAN","text":"Specifies one of the possible types of byte order. See %GBYTEORDER.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.LOG_DOMAIN","page":"GLib Reference","title":"Gtk4.GLib.LOG_DOMAIN","text":"Defines the log domain. See Log Domains.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.LOG_FATAL_MASK","page":"GLib Reference","title":"Gtk4.GLib.LOG_FATAL_MASK","text":"GLib log levels that are considered fatal by default.\n\nDetails can be found in the GTK docs.\n\n\n\n\n\n","category":"constant"},{"location":"doc/GLib_reference/#Gtk4.GLib.LOG_LEVEL_USER_SHIFT","page":"GLib Reference","title":"Gtk4.GLib.LOG_LEVEL_USER_SHIFT","text":"Log levels below 1<\n\n \n \n","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"In order to access the widgets from Julia we first create a GtkBuilder object that will serve as a connector between the XML definition and our Julia code.","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"b = GtkBuilder(\"path/to/myapp.ui\")","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"Alternatively, if we store the above XML definition in a Julia string myapp we can initialize the builder by","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"b = GtkBuilder(myapp, -1)","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"Now we want to access a widget from the XML file in order to actually display it on the screen. To do so we can call","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"win = b[\"window1\"]","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"for each widget we want to access in our Julia code. Widgets that we don't need to access from Julia, for example layout widgets like GtkBox that are being used only to arrange more interesting widgets for input or display, do not need to be loaded. You can thus see your builder as a kind of a widget store that you use when you need access to your widgets.","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"note: Note\nIf you are developing the code in a package you can get the package directory using the @__DIR__ macro. For instance, if your UI file is located at MyPackage/src/builder/myuifile.ui, you can get the full path using uifile = joinpath(@__DIR__, \"builder\", \"myuifile.ui\").","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"In Gtk4.jl a macro @load_builder is defined that iterates over the GtkWidgets in a GtkBuilder object and automatically assigns them to Julia variables with the same id. For example, if a GtkEntry with an id entry1 and two GtkButtons with id's button1 and button2 are present in myapp.ui, calling","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"@load_builder(GtkBuilder(filename=\"myapp.ui\"))","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"is equivalent to","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"entry1 = b[\"entry1\"]\nbutton1 = b[\"button1\"]\nbutton2 = b[\"button2\"]","category":"page"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"Note that this only works for GtkWidgets that implement the interface GtkBuildable, which excludes some objects often defined in UI files, for example GtkAdjustment. Those objects will have to be fetched using calls to get_object.","category":"page"},{"location":"manual/builder/#Callbacks-1","page":"Builder","title":"Callbacks","text":"","category":"section"},{"location":"manual/builder/#","page":"Builder","title":"Builder","text":"The XML file lets us only describe the visual structure of our widgets and not their behavior when the using is interacting with it. For this reason, we will have to add callbacks to the widgets which we do in Julia code as it was described in Signals and Callbacks.","category":"page"},{"location":"manual/properties/#Properties-1","page":"Properties","title":"Properties","text":"","category":"section"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"If you're following along, you probably noticed that creating win caused quite a lot of output:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Gtk4.GtkWindowLeaf(accessible-role=GTK_ACCESSIBLE_ROLE_WINDOW, name=\"\", parent, root, width-request=-1, height-request=-1, visible=true, sensitive=true, can-focus=true, has-focus=false, can-target=true, focus-on-click=true, focusable=false, has-default=false, receives-default=false, cursor, has-tooltip=false, tooltip-markup=nothing, tooltip-text=nothing, opacity=1.000000, overflow=GTK_OVERFLOW_HIDDEN, halign=GTK_ALIGN_FILL, valign=GTK_ALIGN_FILL, margin-start=0, margin-end=0, margin-top=0, margin-bottom=0, hexpand=false, vexpand=false, hexpand-set=false, vexpand-set=false, scale-factor=1, css-name=\"window\", css-classes, layout-manager, title=nothing, resizable=true, modal=false, default-width=200, default-height=200, destroy-with-parent=false, hide-on-close=false, icon-name=nothing, display, decorated=true, deletable=true, transient-for, application, default-widget, focus-widget, child, titlebar, handle-menubar-accel=true, is-active=false, startup-id, mnemonics-visible=false, focus-visible=false, maximized=false, fullscreened=false)","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"This shows you a list of properties of the object and their current values. All GTK widgets, including windows, are subtypes of GObject, which have various properties that control how the widgets are displayed. For example, notice that the title property is set to \"My window\". In this package, GObject properties are mapped onto Julia properties. We can change the title in the following way:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> win.title = \"New title\"","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"To get the title we can use:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> title = win.title\n\"New title\"","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"We can also use set_gtk_property! and get_gtk_property! to set or get GObject properties:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> set_gtk_property!(win, :title, \"New title\")\njulia> get_gtk_property(win, :title)\n\"New title\"","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"To get the property in a type stable way, you can specify the return type:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> get_gtk_property(win, :title, String)\n\"New title\"","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"To access particular properties using set_gtk_property! or get_gtk_property, you can either use symbols, like :title, or strings, like \"title\". When using symbols, you'll need to convert any Gtk property names that use - into names with _:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> get_gtk_property(win, :default_width)\ntrue","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Properties that are string-valued or GObject-valued can be set to nothing, which is equivalent to setting them to NULL in C (or None in Python). A list of all possible property names for a GObject instance is returned by gtk_propertynames.","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Properties can be set using keyword arguments in most constructors:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> win = GtkWindow(; title=\"My title\", visible=true)","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Information about a property, including a description, its GLib type and default value, can be found using propertyinfo:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> propertyinfo(win, :title)\nName: title\nGType name: gchararray\nFlags: Readable Writable\nDescription: The title of the window\nDefault value: nothing\nCurrent value: nothing","category":"page"},{"location":"manual/properties/#Getter-and-setter-methods-1","page":"Properties","title":"Getter and setter methods","text":"","category":"section"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Some properties have corresponding getter and setter C methods. It's recommended that you use these when they exist, as they are a little faster and type stable. For example the function visible gets or sets the property \"visible\" of a GtkWidget:","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> visible(win)\ntrue\n\njulia> visible(win, false)\n\njulia> visible(win)\nfalse\n\njulia> visible(win, true)","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"This sequence makes the window disappear and then reappear.","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"The most important accessors are exported from Gtk4 but the more obscure will have to be called including the module name. For example, the property resizable for a GtkWindow, which controls whether a user is allowed to resize the window, can be set using","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> Gtk4.resizable(win, false)","category":"page"},{"location":"manual/properties/#Binding-properties-1","page":"Properties","title":"Binding properties","text":"","category":"section"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Properties can be bound to one another through the GObject signal system using the method bind_property. For example, if one wanted the title of a window win2 to automatically track that of another window win1, one could use","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> b = bind_property(win1, \"title\", win2, \"title\")","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"Now if one calls","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"julia> win1.title = \"New title\"","category":"page"},{"location":"manual/properties/#","page":"Properties","title":"Properties","text":"the title of win2 is automatically updated to the same value. The binding can be released using unbind_property(b).","category":"page"},{"location":"doc/GI_reference/#API-Reference-1","page":"-","title":"API Reference","text":"","category":"section"},{"location":"doc/GI_reference/#Public-interface-1","page":"-","title":"Public interface","text":"","category":"section"},{"location":"doc/GI_reference/#","page":"-","title":"-","text":"Modules = [GI]\nOrder = [:module, :constant, :type, :function, :macro]\nPublic = true\nPrivate = false","category":"page"},{"location":"doc/GI_reference/#Private-methods-1","page":"-","title":"Private methods","text":"","category":"section"},{"location":"doc/GI_reference/#","page":"-","title":"-","text":"Modules = [GI]\nOrder = [:module, :constant, :type, :function, :macro]\nPublic = false\nPrivate = true","category":"page"},{"location":"manual/textwidgets/#Text-Widgets-1","page":"Text Widgets","title":"Text Widgets","text":"","category":"section"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"There are two basic widgets available for rendering simple text: GtkLabel is for displaying non-editable text and GtkEntry is for editable text.","category":"page"},{"location":"manual/textwidgets/#GtkLabel-1","page":"Text Widgets","title":"GtkLabel","text":"","category":"section"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"A GtkLabel is the most basic text widget and has already been used behind the scenes in any previous example involving a GtkButton. A GtkLabel is constructed by calling","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"label = GtkLabel(\"My text\")","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"The text of a label can be changed using the label property or Gtk4.text","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Gtk4.text(label,\"My other text\")\nlabel.label = \"My final text\"","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Furthermore, a label has limited support for adding formatted text. This is done using the Gtk4.markup function:","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Gtk4.markup(label,\"\"\"My bold text\\n\n GTK+ website\"\"\")","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"The syntax for this markup text is borrowed from HTML and explained here.","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"A label can be made selectable (so that it can be copied and pasted elsewhere) using","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Gtk4.selectable(label,true)","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"The justification of a label can be changed in the following way:","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Gtk4.justify(label,Gtk4.Justification_RIGHT)","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Possible values of the enum Justification are LEFT,RIGHT,CENTER, and FILL.","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Automatic line wrapping can be enabled using","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Gtk4.text(label,repeat(\"Very long text! \",20))\nGtk4.wrap(label,true)","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Note that wrapping will only occur if the size of the widget is limited by layout constraints.","category":"page"},{"location":"manual/textwidgets/#GtkEntry-1","page":"Text Widgets","title":"GtkEntry","text":"","category":"section"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"The entry widget allows the user to enter text. The entered text can be read and written using","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"ent = GtkEntry()\nent.text = \"My String\"\nstr = ent.text","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"A maximum number of characters can be set using ent.max_length = 10.","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"Sometimes you might want to make the widget non-editable. This can be done using the call","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"# using the accessor method\nGtk4.editable(GtkEditable(ent),false)\n# using the property system\nent.editable = false","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"If you want to use the entry to retrieve passwords you can hide the visibility of the entered text. This can be achieved by calling","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"ent.visibility = false","category":"page"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"To get notified by changes to the entry one can listen to the \"changed\" event.","category":"page"},{"location":"manual/textwidgets/#Search-Entry-1","page":"Text Widgets","title":"Search Entry","text":"","category":"section"},{"location":"manual/textwidgets/#","page":"Text Widgets","title":"Text Widgets","text":"A special variant of the entry that can be used as a search box is GtkSearchEntry. It is equipped with a button to clear the entry.","category":"page"},{"location":"#Gtk4.jl-1","page":"Home","title":"Gtk4.jl","text":"","category":"section"},{"location":"#","page":"Home","title":"Home","text":"Julia Bindings for Gtk version 4.x.","category":"page"},{"location":"#Introduction-1","page":"Home","title":"Introduction","text":"","category":"section"},{"location":"#","page":"Home","title":"Home","text":"Gtk4.jl is a Julia package providing bindings for the Gtk library: https://www.gtk.org/","category":"page"},{"location":"#","page":"Home","title":"Home","text":"Complete Gtk documentation is available at https://www.gtk.org/docs/","category":"page"},{"location":"#Usage-1","page":"Home","title":"Usage","text":"","category":"section"},{"location":"#","page":"Home","title":"Home","text":"See Getting Started for an introduction to using the package, adapted from the Gtk.jl manual.\nSee Gtk4 Reference for an API reference automatically generated from docstrings.\nSee Differences between Gtk.jl and Gtk4.jl for a summary of the differences between this package and Gtk.jl.","category":"page"},{"location":"#History-1","page":"Home","title":"History","text":"","category":"section"},{"location":"#","page":"Home","title":"Home","text":"This package was adapted from Gtk.jl, which was written by Jameson Nash and others and supported GTK versions 2 and 3. With version 4 there were so many changes to the GTK API that it would have been messy to try to support it and previous versions in the same package. Note that much of the GLib/GObject functionality that underlies GTK is largely the same code as in Gtk.jl. Some changes were made to try to take better advantage of GObject introspection or to remove old code that was no longer necessary in recent versions of Julia.","category":"page"}]
+}
diff --git a/v0.4.2/siteinfo.js b/v0.4.2/siteinfo.js
new file mode 100644
index 00000000..c928059b
--- /dev/null
+++ b/v0.4.2/siteinfo.js
@@ -0,0 +1 @@
+var DOCUMENTER_CURRENT_VERSION = "v0.4.2";
