Safe Haskell	None

Libnotify

Contents

Notification API
Modifiers
Concenience re-exports

Description

High level interface to libnotify API

Synopsis

Notification API

data Notification Source

Notification object

Instances

Eq Notification
Show Notification

display :: Mod Notification -> IO Notification Source

Display notification

>>> token <- display (summary "Greeting" <> body "Hello world!" <> icon "face-smile-big")

You can reuse notification tokens:

>>> display_ (reuse token <> body "Hey!")

display_ :: Mod Notification -> IO ()Source

Display and discard notification token

>>> display_ (summary "Greeting" <> body "Hello world!" <> icon "face-smile-big")

close :: Notification -> IO ()Source

Close notification

Modifiers

data Mod a Source

A notification modifier

Instances

Monoid (Mod a)

summary :: String -> Mod Notification Source

Set notification summary

>>> display_ (summary "Hello!")

body :: String -> Mod Notification Source

Set notification body

>>> display_ (body "Hello world!")

icon :: String -> Mod Notification Source

Set notification icon

>>> display_ (icon "face-smile")

The argument is either icon name or file name

timeout :: Timeout -> Mod Notification Source

Set notification timeout

data Timeout Source

Timeout after which notification is closed

Constructors

Default	Default server timeout
Custom Int	User defined timeout (in milliseconds)
Infinite	Notification will never expire

Instances

Eq Timeout
Data Timeout
Show Timeout
Typeable Timeout
Generic Timeout

category :: String -> Mod Notification Source

Set notification category

urgency :: Urgency -> Mod Notification Source

Set notification urgency

data Urgency Source

The urgency level of the notification

Constructors

Low	Low urgency. Used for unimportant notifications
Normal	Normal urgency. Used for most standard notifications
Critical	Critical urgency. Used for very important notifications

Instances

Eq Urgency
Data Urgency
Ord Urgency
Show Urgency
Typeable Urgency
Generic Urgency

image :: Pixbuf -> Mod Notification Source

Set notification image

class Hint v whereSource

Add a hint to notification

It's perfectly OK to add multiple hints to a single notification

Methods

hint :: String -> v -> Mod Notification Source

Instances

Hint Double
Hint Int32
Hint Word8
Hint String
Hint ByteString

nohints :: Mod Notification Source

Remove all hints from the notification

action Source

Arguments

:: String	Name
-> String	Button label
-> (Notification -> String -> IO a)	Callback
-> Mod Notification

Add an action to notification

It's perfectly OK to add multiple actions to a single notification

>>> display_ (action "hello" "Hello world!" (\_ _ -> return ()))

noactions :: Mod Notification Source

Remove all actions from the notification

>>> let callback _ _ = return ()
>>> display_ (summary "No hello for you!" <> action "hello" "Hello world!" callback <> noactions)

reuse :: Notification -> Mod Notification Source

Reuse existing notification token, instead of creating a new one

If you try to reuse multiple tokens, the last one wins, e.g.

>>> foo <- display (body "foo")
>>> bar <- display (body "bar")
>>> display_ (base foo <> base bar)

will show only "bar"

Concenience re-exports

class Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

```
mappend mempty x = x
```
```
mappend x mempty = x
```

mappend x (mappend y z) = mappend (mappend x y) z

```
mconcat = foldr mappend mempty
```

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Minimal complete definition: mempty and mappend.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering
Monoid ()
Monoid All
Monoid Any
Monoid ByteString
Monoid [a]
Monoid a => Monoid (Dual a)
Monoid (Endo a)
Num a => Monoid (Sum a)
Num a => Monoid (Product a)
Monoid (First a)
Monoid (Last a)
Monoid a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Monoid (Mod a)
Monoid b => Monoid (a -> b)
(Monoid a, Monoid b) => Monoid (a, b)
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

(<>) :: Monoid m => m -> m -> m

An infix synonym for mappend.