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.

  1. 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.30

  2. type 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:

    Each event except SocketClientEventComplete may be emitted multiple times (or not at all) for a given connectable (in particular, if client ends up attempting to connect to more than one address). However, if client emits the SocketClient::event signal at all for a given connectable, then it will always emit it with SocketClientEventComplete when it is done. Note that there may be additional SocketClientEvent values in the future; unrecognized event values should be ignored. Since: 2.32

  3. 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

  4. type SocketServiceIncomingCallback = SocketConnection -> Maybe Object -> IO Bool

    gi-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

  5. constructThemedIconUseDefaultFallbacks :: (IsThemedIcon o, MonadIO m) => Bool -> m (GValueConstruct o)

    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.

  6. getThemedIconUseDefaultFallbacks :: (MonadIO m, IsThemedIcon o) => o -> m Bool

    gi-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
    

  7. themedIconNewWithDefaultFallbacks :: (HasCallStack, MonadIO m) => Text -> m ThemedIcon

    gi-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");
    

  8. type ThreadedSocketServiceRunCallback = SocketConnection -> Maybe Object -> IO Bool

    gi-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.

  9. type TlsConnectionAcceptCertificateCallback = TlsCertificate -> [TlsCertificateFlags] -> IO Bool

    gi-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

  10. type UnixMountMonitorMountpointsChangedCallback = IO ()

    gi-gio GI.Gio.Objects.UnixMountMonitor

    Emitted when the unix mount points have changed.

Page 461 of many | Previous | Next