Hoogle Search
Within LTS Haskell 24.67 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
type
SimpleActionChangeStateCallback = Maybe GVariant -> IO ()gi-gio GI.Gio.Objects.SimpleAction Indicates that the action just received a request to change its state. value will always be of the correct state type, i.e. the type of the initial state passed to simpleActionNewStateful. If an incorrect type is given when requesting to change the state, this signal is not emitted. If no handler is connected to this signal then the default behaviour is to call simpleActionSetState to set the state to the requested value. If you connect a signal handler then no default action is taken. If the state should change then you must call simpleActionSetState from the handler. An example of a 'change-state' handler:
C code
static void change_volume_state (GSimpleAction *action, GVariant *value, gpointer user_data) { gint requested; requested = g_variant_get_int32 (value); // Volume only goes from 0 to 10 if (0 <= requested && requested <= 10) g_simple_action_set_state (action, value); }The handler need not set the state to the requested value. It could set it to any value at all, or take some other action. Since: 2.30type
SocketClientEventCallback = SocketClientEvent -> SocketConnectable -> Maybe IOStream -> IO ()gi-gio GI.Gio.Objects.SocketClient Emitted when client's activity on connectable changes state. Among other things, this can be used to provide progress information about a network connection in the UI. The meanings of the different event values are as follows:
- SocketClientEventResolving: client is about to look up connectable in DNS. connection will be Nothing.
- SocketClientEventResolved: client has successfully resolved connectable in DNS. connection will be Nothing.
- SocketClientEventConnecting: client is about to make a connection to a remote host; either a proxy server or the destination server itself. connection is the SocketConnection, which is not yet connected. Since GLib 2.40, you can access the remote address via socketConnectionGetRemoteAddress.
- SocketClientEventConnected: client has successfully connected to a remote host. connection is the connected SocketConnection.
- SocketClientEventProxyNegotiating: client is about to negotiate with a proxy to get it to connect to connectable. connection is the SocketConnection to the proxy server.
- SocketClientEventProxyNegotiated: client has negotiated a connection to connectable through a proxy server. connection is the stream returned from proxyConnect, which may or may not be a SocketConnection.
- SocketClientEventTlsHandshaking: client is about to begin a TLS handshake. connection is a TlsClientConnection.
- SocketClientEventTlsHandshaked: client has successfully completed the TLS handshake. connection is a TlsClientConnection.
- SocketClientEventComplete: client has either successfully connected to connectable (in which case connection is the SocketConnection that it will be returning to the caller) or has failed (in which case connection is Nothing and the client is about to return an error).
type
SocketListenerEventCallback = SocketListenerEvent -> Socket -> IO ()gi-gio GI.Gio.Objects.SocketListener Emitted when listener's activity on socket changes state. Note that when listener is used to listen on both IPv4 and IPv6, a separate set of signals will be emitted for each, and the order they happen in is undefined. Since: 2.46
type
SocketServiceIncomingCallback = SocketConnection -> Maybe Object -> IO Boolgi-gio GI.Gio.Objects.SocketService The incoming signal is emitted when a new incoming connection to service needs to be handled. The handler must initiate the handling of connection, but may not block; in essence, asynchronous operations must be used. connection will be unreffed once the signal handler returns, so you need to ref it yourself if you are planning to use it. Since: 2.22
-
gi-gio GI.Gio.Objects.ThemedIcon Construct a GValueConstruct with valid value for the “use-default-fallbacks” property. This is rarely needed directly, but it is used by new.
getThemedIconUseDefaultFallbacks :: (MonadIO m, IsThemedIcon o) => o -> m Boolgi-gio GI.Gio.Objects.ThemedIcon Get the value of the “use-default-fallbacks” property. When overloading is enabled, this is equivalent to
get themedIcon #useDefaultFallbacks
themedIconNewWithDefaultFallbacks :: (HasCallStack, MonadIO m) => Text -> m ThemedIcongi-gio GI.Gio.Objects.ThemedIcon Creates a new themed icon for iconname, and all the names that can be created by shortening iconname at '-' characters. In the following example, icon1 and icon2 are equivalent:
C code
const char *names[] = { "gnome-dev-cdrom-audio", "gnome-dev-cdrom", "gnome-dev", "gnome" }; icon1 = g_themed_icon_new_from_names (names, 4); icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio");type
ThreadedSocketServiceRunCallback = SocketConnection -> Maybe Object -> IO Boolgi-gio GI.Gio.Objects.ThreadedSocketService The run signal is emitted in a worker thread in response to an incoming connection. This thread is dedicated to handling connection and may perform blocking IO. The signal handler need not return until the connection is closed.
type
TlsConnectionAcceptCertificateCallback = TlsCertificate -> [TlsCertificateFlags] -> IO Boolgi-gio GI.Gio.Objects.TlsConnection Emitted during the TLS handshake after the peer certificate has been received. You can examine peerCert's certification path by calling tlsCertificateGetIssuer on it. For a client-side connection, peerCert is the server's certificate, and the signal will only be emitted if the certificate was not acceptable according to conn's TlsClientConnection:validation_flags. If you would like the certificate to be accepted despite errors, return True from the signal handler. Otherwise, if no handler accepts the certificate, the handshake will fail with TlsErrorBadCertificate. GLib guarantees that if certificate verification fails, this signal will be emitted with at least one error will be set in errors, but it does not guarantee that all possible errors will be set. Accordingly, you may not safely decide to ignore any particular type of error. For example, it would be incorrect to ignore TlsCertificateFlagsExpired if you want to allow expired certificates, because this could potentially be the only error flag set even if other problems exist with the certificate. For a server-side connection, peerCert is the certificate presented by the client, if this was requested via the server's TlsServerConnection:authentication_mode. On the server side, the signal is always emitted when the client presents a certificate, and the certificate will only be accepted if a handler returns True. Note that if this signal is emitted as part of asynchronous I/O in the main thread, then you should not attempt to interact with the user before returning from the signal handler. If you want to let the user decide whether or not to accept the certificate, you would have to return False from the signal handler on the first attempt, and then after the connection attempt returns a TlsErrorBadCertificate, you can interact with the user, and if the user decides to accept the certificate, remember that fact, create a new connection, and return True from the signal handler the next time. If you are doing I/O in another thread, you do not need to worry about this, and can simply block in the signal handler until the UI thread returns an answer. Since: 2.28
type
UnixMountMonitorMountpointsChangedCallback = IO ()gi-gio GI.Gio.Objects.UnixMountMonitor Emitted when the unix mount points have changed.