lib/naughty.lua.in

   1 ----------------------------------------------------------------------------
   2 -- @author koniu &lt;gkusnierz@gmail.com&gt;
   3 -- @copyright 2008 koniu
   4 -- @release @AWESOME_VERSION@
   5 ----------------------------------------------------------------------------
   6
   7 -- Package environment
   8 local pairs = pairs
   9 local table = table
  10 local type = type
  11 local string = string
  12 local capi = { screen = screen,
  13                awesome = awesome,
  14                dbus = dbus,
  15                widget = widget,
  16                wibox = wibox,
  17                image = image,
  18                timer = timer }
  19 local button = require("awful.button")
  20 local util = require("awful.util")
  21 local bt = require("beautiful")
  22 local layout = require("awful.widget.layout")
  23
  24 --- Notification library
  25 module("naughty")
  26
  27 --- Naughty configuration - a table containing common popup settings.
  28 -- @name config
  29 -- @field padding Space between popups and edge of the workarea. Default: 4
  30 -- @field spacing Spacing between popups. Default: 1
  31 -- @field icon_dirs List of directories that will be checked by getIcon()
  32 --   Default: { "/usr/share/pixmaps/", }
  33 -- @field icon_formats List of formats that will be checked by getIcon()
  34 --   Default: { "png", "gif" }
  35 -- @field default_preset Preset to be used by default.
  36 --   Default: config.presets.normal
  37 -- @class table
  38
  39 config = {}
  40 config.padding = 4
  41 config.spacing = 1
  42 config.icon_dirs = { "/usr/share/pixmaps/", }
  43 config.icon_formats = { "png", "gif" }
  44
  45
  46 --- Notification Presets - a table containing presets for different purposes
  47 -- Preset is a table of any parameters available to notify()
  48 -- You have to pass a reference of a preset in your notify() call to use the preset
  49 -- At least the default preset named "normal" has to be defined
  50 -- The presets "low", "normal" and "critical" are used for notifications over DBUS
  51 -- @name config.presets
  52 -- @field low The preset for notifications with low urgency level
  53 -- @field normal The default preset for every notification without a preset that will also be used for normal urgency level
  54 -- @field critical The preset for notifications with a critical urgency level
  55 -- @class table
  56
  57 config.presets = {
  58     normal = {},
  59     low = {
  60         timeout = 5
  61     },
  62     critical = {
  63         bg = "#ff0000",
  64         fg = "#ffffff",
  65         timeout = 0,
  66     }
  67 }
  68
  69 config.default_preset = config.presets.normal
  70
  71 -- DBUS Notification constants
  72 urgency = {
  73     low = "\0",
  74     normal = "\1",
  75     critical = "\2"
  76 }
  77
  78 --- DBUS notification to preset mapping
  79 -- @name config.mapping
  80 -- The first element is an object containing the filter
  81 -- If the rules in the filter matches the associated preset will be applied
  82 -- The rules object can contain: urgency, category, appname
  83 -- The second element is the preset
  84
  85 config.mapping = {
  86     {{urgency = urgency.low}, config.presets.low},
  87     {{urgency = urgency.normal}, config.presets.normal},
  88     {{urgency = urgency.critical}, config.presets.critical}
  89 }
  90
  91 -- Counter for the notifications
  92 -- Required for later access via DBUS
  93 local counter = 1
  94
  95 -- True if notifying is suspended
  96 local suspended = false
  97
  98 --- Index of notifications. See config table for valid 'position' values.
  99 -- Each element is a table consisting of:
 100 -- @field box Wibox object containing the popup
 101 -- @field height Popup height
 102 -- @field width Popup width
 103 -- @field die Function to be executed on timeout
 104 -- @field id Unique notification id based on a counter
 105 -- @name notifications[screen][position]
 106 -- @class table
 107
 108 notifications = { suspended = { } }
 109 for s = 1, capi.screen.count() do
 110     notifications[s] = {
 111         top_left = {},
 112         top_right = {},
 113         bottom_left = {},
 114         bottom_right = {},
 115     }
 116 end
 117
 118 --- Suspend notifications
 119 function suspend()
 120     suspended = true
 121 end
 122
 123 --- Resume notifications
 124 function resume()
 125     suspended = false
 126     for i, v in pairs(notifications.suspended) do
 127         v.box.visible = true
 128         if v.timer then v.timer:start() end
 129     end
 130     notifications.suspended = { }
 131 end
 132
 133 -- Evaluate desired position of the notification by index - internal
 134 -- @param idx Index of the notification
 135 -- @param position top_right | top_left | bottom_right | bottom_left
 136 -- @param height Popup height
 137 -- @param width Popup width (optional)
 138 -- @return Absolute position and index in { x = X, y = Y, idx = I } table
 139 local function get_offset(screen, position, idx, width, height)
 140     local ws = capi.screen[screen].workarea
 141     local v = {}
 142     local idx = idx or #notifications[screen][position] + 1
 143     local width = width or notifications[screen][position][idx].width
 144
 145     -- calculate x
 146     if position:match("left") then
 147         v.x = ws.x + config.padding
 148     else
 149         v.x = ws.x + ws.width - (width + config.padding)
 150     end
 151
 152     -- calculate existing popups' height
 153     local existing = 0
 154     for i = 1, idx-1, 1 do
 155         existing = existing + notifications[screen][position][i].height + config.spacing
 156     end
 157
 158     -- calculate y
 159     if position:match("top") then
 160         v.y = ws.y + config.padding + existing
 161     else
 162         v.y = ws.y + ws.height - (config.padding + height + existing)
 163     end
 164
 165     -- if positioned outside workarea, destroy oldest popup and recalculate
 166     if v.y + height > ws.y + ws.height or v.y < ws.y then
 167         idx = idx - 1
 168         destroy(notifications[screen][position][1])
 169         v = get_offset(screen, position, idx, width, height)
 170     end
 171     if not v.idx then v.idx = idx end
 172
 173     return v
 174 end
 175
 176 -- Re-arrange notifications according to their position and index - internal
 177 -- @return None
 178 local function arrange(screen)
 179     for p,pos in pairs(notifications[screen]) do
 180         for i,notification in pairs(notifications[screen][p]) do
 181             local offset = get_offset(screen, p, i, notification.width, notification.height)
 182             notification.box:geometry({ x = offset.x, y = offset.y })
 183             notification.idx = offset.idx
 184         end
 185     end
 186 end
 187
 188 --- Destroy notification by notification object
 189 -- @param notification Notification object to be destroyed
 190 -- @return True if the popup was successfully destroyed, nil otherwise
 191 function destroy(notification)
 192     if notification and notification.box.screen then
 193         if suspended then
 194             for k, v in pairs(notifications.suspended) do
 195                 if v.box == notification.box then
 196                     table.remove(notifications.suspended, k)
 197                     break
 198                 end
 199             end
 200         end
 201         local scr = notification.box.screen
 202         table.remove(notifications[notification.box.screen][notification.position], notification.idx)
 203         if notification.timer then
 204             notification.timer:stop()
 205         end
 206         notification.box.screen = nil
 207         arrange(scr)
 208         return true
 209     end
 210 end
 211
 212 -- Get notification by ID
 213 -- @param id ID of the notification
 214 -- @return notification object if it was found, nil otherwise
 215 local function getById(id)
 216     -- iterate the notifications to get the notfications with the correct ID
 217     for s = 1, capi.screen.count() do
 218         for p,pos in pairs(notifications[s]) do
 219             for i,notification in pairs(notifications[s][p]) do
 220                 if notification.id == id then
 221                     return notification
 222                  end
 223             end
 224         end
 225     end
 226 end
 227
 228 -- Search for an icon in specified directories with a specified format
 229 -- @param icon Name of the icon
 230 -- @return full path of the icon, or nil of no icon was found
 231 local function getIcon(name)
 232     for d, dir in pairs(config.icon_dirs) do
 233         for f, format in pairs(config.icon_formats) do
 234             local icon = dir .. name .. "." .. format
 235             if util.file_readable(icon) then
 236                 return icon
 237             end
 238         end
 239     end
 240 end
 241
 242 --- Create notification. args is a dictionary of (optional) arguments.
 243 -- @param text Text of the notification. Default: ''
 244 -- @param title Title of the notification. Default: nil
 245 -- @param timeout Time in seconds after which popup expires.
 246 --   Set 0 for no timeout. Default: 5
 247 -- @param hover_timeout Delay in seconds after which hovered popup disappears.
 248 --   Default: nil
 249 -- @param screen Target screen for the notification. Default: 1
 250 -- @param position Corner of the workarea displaying the popups.
 251 --   Values: "top_right" (default), "top_left", "bottom_left", "bottom_right".
 252 -- @param ontop Boolean forcing popups to display on top. Default: true
 253 -- @param height Popup height. Default: nil (auto)
 254 -- @param width Popup width. Default: nil (auto)
 255 -- @param font Notification font. Default: beautiful.font or awesome.font
 256 -- @param icon Path to icon. Default: nil
 257 -- @param icon_size Desired icon size in px. Default: nil
 258 -- @param fg Foreground color. Default: beautiful.fg_focus or '#ffffff'
 259 -- @param bg Background color. Default: beautiful.bg_focus or '#535d6c'
 260 -- @param border_width Border width. Default: 1
 261 -- @param border_color Border color.
 262 --   Default: beautiful.border_focus or '#535d6c'
 263 -- @param run Function to run on left click. Default: nil
 264 -- @param preset Table with any of the above parameters. Note: Any parameters
 265 --   specified directly in args will override ones defined in the preset.
 266 -- @param replaces_id Replace the notification with the given ID
 267 -- @param callback function that will be called with all arguments
 268 --  the notification will only be displayed if the function returns true
 269 --  note: this function is only relevant to notifications sent via dbus
 270 -- @usage naughty.notify({ title = "Achtung!", text = "You're idling", timeout = 0 })
 271 -- @return The notification object
 272 function notify(args)
 273     -- gather variables together
 274     local preset = args.preset or config.default_preset or {}
 275     local timeout = args.timeout or preset.timeout or 5
 276     local icon = args.icon or preset.icon
 277     local icon_size = args.icon_size or preset.icon_size
 278     local text = args.text or preset.text or ""
 279     local title = args.title or preset.title
 280     local screen = args.screen or preset.screen or 1
 281     local ontop = args.ontop or preset.ontop or true
 282     local width = args.width or preset.width
 283     local height = args.height or preset.height
 284     local hover_timeout = args.hover_timeout or preset.hover_timeout
 285     local opacity = args.opacity or preset.opacity
 286     local margin = args.margin or preset.margin or "5"
 287     local border_width = args.border_width or preset.border_width or "1"
 288     local position = args.position or preset.position or "top_right"
 289
 290     -- beautiful
 291     local beautiful = bt.get()
 292     local font = args.font or preset.font or beautiful.font or capi.awesome.font
 293     local fg = args.fg or preset.fg or beautiful.fg_normal or '#ffffff'
 294     local bg = args.bg or preset.bg or beautiful.bg_normal or '#535d6c'
 295     local border_color = args.border_color or preset.border_color or beautiful.bg_focus or '#535d6c'
 296     local notification = {}
 297
 298     -- replace notification if needed
 299     if args.replaces_id then
 300         obj = getById(args.replaces_id)
 301         if obj then
 302             -- destroy this and ...
 303             destroy(obj)
 304         end
 305         -- ... may use its ID
 306         if args.replaces_id < counter then
 307             notification.id = args.replaces_id
 308         else
 309             counter = counter + 1
 310             notification.id = counter
 311         end
 312     else
 313         -- get a brand new ID
 314         counter = counter + 1
 315         notification.id = counter
 316     end
 317
 318     notification.position = position
 319
 320     if title then title = title .. "\n" else title = "" end
 321
 322     -- hook destroy
 323     local die = function () destroy(notification) end
 324     if timeout > 0 then
 325         local timer_die = capi.timer { timeout = timeout }
 326         timer_die:add_signal("timeout", die)
 327         if not suspended then
 328             timer_die:start()
 329         end
 330         notification.timer = timer_die
 331     end
 332     notification.die = die
 333
 334     local run = function ()
 335         if args.run then
 336             args.run(notification)
 337         else
 338             die()
 339         end
 340     end
 341
 342     local hover_destroy = function ()
 343         if hover_timeout == 0 then
 344             die()
 345         else
 346             if notification.timer then notification.timer:stop() end
 347             notification.timer = capi.timer { timeout = hover_timeout }
 348             notification.timer:add_signal("timeout", die)
 349             notification.timer:start()
 350         end
 351     end
 352
 353     -- create textbox
 354     local textbox = capi.widget({ type = "textbox", align = "flex" })
 355     textbox:buttons(util.table.join(button({ }, 1, run), button({ }, 3, die)))
 356     layout.margins[textbox] = { right = margin, left = margin, bottom = margin, top = margin }
 357     textbox.text = string.format('<span font_desc="%s"><b>%s</b>%s</span>', font, title, text:gsub("<br.->", "\n"))
 358     textbox.valign = "middle"
 359
 360     -- create iconbox
 361     local iconbox = nil
 362     if icon then
 363         -- try to guess icon if the provided one is non-existent/readable
 364         if type(icon) == "string" and not util.file_readable(icon) then
 365             icon = getIcon(icon)
 366         end
 367
 368         -- if we have an icon, use it
 369         if icon then
 370             iconbox = capi.widget({ type = "imagebox", align = "left" })
 371             layout.margins[iconbox] = { right = margin, left = margin, bottom = margin, top = margin }
 372             iconbox:buttons(util.table.join(button({ }, 1, run), button({ }, 3, die)))
 373             local img
 374             if type(icon) == "string" then
 375                 img = capi.image(icon)
 376             else
 377                 img = icon
 378             end
 379             if icon_size then
 380                 img = img:crop_and_scale(0,0,img.height,img.width,icon_size,icon_size)
 381             end
 382             iconbox.resize = false
 383             iconbox.image = img
 384         end
 385     end
 386
 387     -- create container wibox
 388     notification.box = capi.wibox({ fg = fg,
 389                                     bg = bg,
 390                                     border_color = border_color,
 391                                     border_width = border_width })
 392
 393     if hover_timeout then notification.box:add_signal("mouse::enter", hover_destroy) end
 394
 395     -- calculate the height
 396     if not height then
 397         if iconbox and iconbox:extents().height + 2 * margin > textbox:extents().height + 2 * margin then
 398             height = iconbox:extents().height + 2 * margin
 399         else
 400             height = textbox:extents().height + 2 * margin
 401         end
 402     end
 403
 404     -- calculate the width
 405     if not width then
 406         width = textbox:extents().width + (iconbox and iconbox:extents().width + 2 * margin or 0) + 2 * margin
 407     end
 408
 409     -- crop to workarea size if too big
 410     local workarea = capi.screen[screen].workarea
 411     if width > workarea.width - 2 * (border_width or 0) - 2 * (config.padding or 0) then
 412         width = workarea.width - 2 * (border_width or 0) - 2 * (config.padding or 0)
 413     end
 414     if height > workarea.height - 2 * (border_width or 0) - 2 * (config.padding or 0) then
 415         height = workarea.height - 2 * (border_width or 0) - 2 * (config.padding or 0)
 416     end
 417
 418     -- set size in notification object
 419     notification.height = height + 2 * (border_width or 0)
 420     notification.width = width + 2 * (border_width or 0)
 421
 422     -- position the wibox
 423     local offset = get_offset(screen, notification.position, nil, notification.width, notification.height)
 424     notification.box.ontop = ontop
 425     notification.box:geometry({ width = width,
 426                                 height = height,
 427                                 x = offset.x,
 428                                 y = offset.y })
 429     notification.box.opacity = opacity
 430     notification.box.screen = screen
 431     notification.idx = offset.idx
 432
 433     -- populate widgets
 434     notification.box.widgets = { iconbox, textbox, ["layout"] = layout.horizontal.leftright }
 435
 436     -- insert the notification to the table
 437     table.insert(notifications[screen][notification.position], notification)
 438
 439     if suspended then
 440         notification.box.visible = false
 441         table.insert(notifications.suspended, notification)
 442     end
 443
 444     -- return the notification
 445     return notification
 446 end
 447
 448 -- DBUS/Notification support
 449 -- Notify
 450 if capi.dbus then
 451     capi.dbus.add_signal("org.freedesktop.Notifications", function (data, appname, replaces_id, icon, title, text, actions, hints, expire)
 452     args = { preset = { } }
 453     if data.member == "Notify" then
 454         if text ~= "" then
 455             args.text = text
 456             if title ~= "" then
 457                 args.title = title
 458             end
 459         else
 460             if title ~= "" then
 461                 args.text = title
 462             else
 463                 return
 464             end
 465         end
 466         local score = 0
 467         for i, obj in pairs(config.mapping) do
 468             local filter, preset, s = obj[1], obj[2], 0
 469             if (not filter.urgency or filter.urgency == hints.urgency) and
 470                (not filter.category or filter.category == hints.category) and
 471                (not filter.appname or filter.appname == appname) then
 472                 for j, el in pairs(filter) do s = s + 1 end
 473                 if s > score then
 474                     score = s
 475                     args.preset = preset
 476                 end
 477             end
 478         end
 479         if not args.preset.callback or (type(args.preset.callback) == "function" and
 480             args.preset.callback(data, appname, replaces_id, icon, title, text, actions, hints, expire)) then
 481             if icon ~= "" then
 482                 args.icon = icon
 483             elseif hints.icon_data then
 484                 -- icon_data is an array:
 485                 -- 1 -> width, 2 -> height, 3 -> rowstride, 4 -> has alpha
 486                 -- 5 -> bits per sample, 6 -> channels, 7 -> data
 487
 488                 local imgdata
 489                 -- If has alpha (ARGB32)
 490                 if hints.icon_data[6] == 4 then
 491                     imgdata = hints.icon_data[7]
 492                 -- If has not alpha (RGB24)
 493                 elseif hints.icon_data[6] == 3 then
 494                     imgdata = ""
 495                     for i = 1, #hints.icon_data[7], 3 do
 496                         imgdata = imgdata .. hints.icon_data[7]:sub(i , i + 2):reverse()
 497                         imgdata = imgdata .. string.format("%c", 255) -- alpha is 255
 498                     end
 499                 end
 500                 if imgdata then
 501                     args.icon = capi.image.argb32(hints.icon_data[1], hints.icon_data[2], imgdata)
 502                 end
 503             end
 504             if replaces_id and replaces_id ~= "" and replaces_id ~= 0 then
 505                 args.replaces_id = replaces_id
 506             end
 507             if expire and expire > -1 then
 508                 args.timeout = expire / 1000
 509             end
 510             local id = notify(args).id
 511             return "u", id
 512         end
 513         return "u", "0"
 514     elseif data.member == "CloseNotification" then
 515         local obj = getById(appname)
 516         if obj then
 517            destroy(obj)
 518         end
 519     elseif data.member == "GetServerInfo" or data.member == "GetServerInformation" then
 520         -- name of notification app, name of vender, version
 521         return "s", "naughty", "s", "awesome", "s", capi.awesome.version:match("%d.%d"), "s", "1.0"
 522     elseif data.member == "GetCapabilities" then
 523         -- We actually do display the body of the message, we support <b>, <i>
 524         -- and <u> in the body and we handle static (non-animated) icons.
 525         return "as", { "s", "body", "s", "body-markup", "s", "icon-static" }
 526     end
 527     end)
 528
 529     capi.dbus.add_signal("org.freedesktop.DBus.Introspectable",
 530     function (data, text)
 531     if data.member == "Introspect" then
 532         local xml = [=[<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object
 533     Introspection 1.0//EN"
 534     "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 535     <node>
 536       <interface name="org.freedesktop.DBus.Introspectable">
 537         <method name="Introspect">
 538           <arg name="data" direction="out" type="s"/>
 539         </method>
 540       </interface>
 541       <interface name="org.freedesktop.Notifications">
 542         <method name="GetCapabilities">
 543           <arg name="caps" type="as" direction="out"/>
 544         </method>
 545         <method name="CloseNotification">
 546           <arg name="id" type="u" direction="in"/>
 547         </method>
 548         <method name="Notify">
 549           <arg name="app_name" type="s" direction="in"/>
 550           <arg name="id" type="u" direction="in"/>
 551           <arg name="icon" type="s" direction="in"/>
 552           <arg name="summary" type="s" direction="in"/>
 553           <arg name="body" type="s" direction="in"/>
 554           <arg name="actions" type="as" direction="in"/>
 555           <arg name="hints" type="a{sv}" direction="in"/>
 556           <arg name="timeout" type="i" direction="in"/>
 557           <arg name="return_id" type="u" direction="out"/>
 558         </method>
 559         <method name="GetServerInformation">
 560           <arg name="return_name" type="s" direction="out"/>
 561           <arg name="return_vendor" type="s" direction="out"/>
 562           <arg name="return_version" type="s" direction="out"/>
 563           <arg name="return_spec_version" type="s" direction="out"/>
 564         </method>
 565         <method name="GetServerInfo">
 566           <arg name="return_name" type="s" direction="out"/>
 567           <arg name="return_vendor" type="s" direction="out"/>
 568           <arg name="return_version" type="s" direction="out"/>
 569        </method>
 570       </interface>
 571     </node>]=]
 572         return "s", xml
 573     end
 574     end)
 575
 576     -- listen for dbus notification requests
 577     capi.dbus.request_name("session", "org.freedesktop.Notifications")
 578 end
 579
 580 -- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80