Hoogle Search

Within LTS Haskell 24.52 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. type SettingsWritableChangedCallback = Text -> IO ()

    gi-gio GI.Gio.Objects.Settings

    The "writable-changed" signal is emitted when the writability of a key has potentially changed. You should call settingsIsWritable in order to determine the new status. This signal supports detailed connections. You can connect to the detailed signal "writable-changedx" in order to only receive callbacks when the writability of "x" changes.

  2. type SimpleActionActivateCallback = Maybe GVariant -> IO ()

    gi-gio GI.Gio.Objects.SimpleAction

    Indicates that the action was just activated. parameter will always be of the expected type, i.e. the parameter type specified when the action was created. If an incorrect type is given when activating the action, this signal is not emitted. Since GLib 2.40, if no handler is connected to this signal then the default behaviour for boolean-stated actions with a Nothing parameter type is to toggle them via the SimpleAction::changeState signal. For stateful actions where the state type is equal to the parameter type, the default is to forward them directly to SimpleAction::changeState. This should allow almost all users of SimpleAction to connect only one handler or the other. Since: 2.28

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

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

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

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

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

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

  9. 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");

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

Page 461 of many | Previous | Next