awesome/lib/naughty.lua.in at v3.5.2 · hishamhm/awesome

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

----------------------------------------------------------------------------

-- @author koniu <gkusnierz@gmail.com>

-- @release @AWESOME_VERSION@

----------------------------------------------------------------------------

-- Package environment

local pairs = pairs

local table = table

local type = type

local string = string

local tostring = tostring

local pcall = pcall

local capi = { screen = screen,

awesome = awesome,

dbus = dbus,

timer = timer,

awesome = awesome }

local button = require("awful.button")

local util = require("awful.util")

local bt = require("beautiful")

local wibox = require("wibox")

local surface = require("gears.surface")

local cairo = require("lgi").cairo

local schar = string.char

local sbyte = string.byte

local tcat = table.concat

local tins = table.insert

--- Notification library

local naughty = {}

--- Naughty configuration - a table containing common popup settings.

naughty.config = {}

--- Space between popups and edge of the workarea. Default: 4

naughty.config.padding = 4

--- Spacing between popups. Default: 1

naughty.config.spacing = 1

--- List of directories that will be checked by getIcon()

-- Default: { "/usr/share/pixmaps/", }

naughty.config.icon_dirs = { "/usr/share/pixmaps/", }

--- List of formats that will be checked by getIcon()

-- Default: { "png", "gif" }

naughty.config.icon_formats = { "png", "gif" }

--- Callback used to modify or reject notifications.

-- Default: nil

-- Example:

-- naughty.config.notify_callback = function(args)

-- args.text = 'prefix: ' .. args.text

-- return args

-- end

naughty.config.notify_callback = nil

--- Notification Presets - a table containing presets for different purposes

-- Preset is a table of any parameters available to notify(), overriding default

-- values (@see defaults)

-- You have to pass a reference of a preset in your notify() call to use the preset

-- The presets "low", "normal" and "critical" are used for notifications over DBUS

-- @field low The preset for notifications with low urgency level

-- @field normal The default preset for every notification without a preset that will also be used for normal urgency level

-- @field critical The preset for notifications with a critical urgency level

-- @class table

naughty.config.presets = {

normal = {},

low = {

timeout = 5

critical = {

bg = "#ff0000",

fg = "#ffffff",

timeout = 0,

}

--- Default values for the params to notify().

-- These can optionally be overridden by specifying a preset

-- @see naughty.config.presets

-- @see naughty.notify

naughty.config.defaults = {

timeout = 5,

text = "",

screen = 1,

ontop = true,

margin = "5",

border_width = "1",

position = "top_right"

}

-- DBUS Notification constants

local urgency = {

low = "\0",

normal = "\1",

critical = "\2"

}

--- DBUS notification to preset mapping

-- The first element is an object containing the filter

-- If the rules in the filter matches the associated preset will be applied

-- The rules object can contain: urgency, category, appname

-- The second element is the preset

naughty.config.mapping = {

{{urgency = urgency.low}, naughty.config.presets.low},

{{urgency = urgency.normal}, naughty.config.presets.normal},

{{urgency = urgency.critical}, naughty.config.presets.critical}

}

-- Counter for the notifications

-- Required for later access via DBUS

local counter = 1

-- True if notifying is suspended

local suspended = false

--- Index of notifications per screen and position. See config table for valid

-- 'position' values. Each element is a table consisting of:

-- @field box Wibox object containing the popup

-- @field height Popup height

-- @field width Popup width

-- @field die Function to be executed on timeout

-- @field id Unique notification id based on a counter

naughty.notifications = { suspended = { } }

for s = 1, capi.screen.count() do

naughty.notifications[s] = {

top_left = {},

top_right = {},

bottom_left = {},

bottom_right = {},

}

end

--- Suspend notifications

function naughty.suspend()

suspended = true

end

--- Resume notifications

function naughty.resume()

suspended = false

for i, v in pairs(naughty.notifications.suspended) do

v.box.visible = true

if v.timer then v.timer:start() end

end

naughty.notifications.suspended = { }

end

--- Toggle notification state

function naughty.toggle()

if suspended then

naughty.resume()

else

naughty.suspend()

end

-- Evaluate desired position of the notification by index - internal

-- @param idx Index of the notification

-- @param position top_right | top_left | bottom_right | bottom_left

-- @param height Popup height

-- @param width Popup width (optional)

-- @return Absolute position and index in { x = X, y = Y, idx = I } table

local function get_offset(screen, position, idx, width, height)

local ws = capi.screen[screen].workarea

local v = {}

local idx = idx or #naughty.notifications[screen][position] + 1

local width = width or naughty.notifications[screen][position][idx].width

-- calculate x

if position:match("left") then

v.x = ws.x + naughty.config.padding

else

v.x = ws.x + ws.width - (width + naughty.config.padding)

end

-- calculate existing popups' height

local existing = 0

for i = 1, idx-1, 1 do

existing = existing + naughty.notifications[screen][position][i].height + naughty.config.spacing

end

-- calculate y

if position:match("top") then

v.y = ws.y + naughty.config.padding + existing

else

v.y = ws.y + ws.height - (naughty.config.padding + height + existing)

end

-- if positioned outside workarea, destroy oldest popup and recalculate

if v.y + height > ws.y + ws.height or v.y < ws.y then

idx = idx - 1

naughty.destroy(naughty.notifications[screen][position][1])

v = get_offset(screen, position, idx, width, height)

end

if not v.idx then v.idx = idx end

return v

end

-- Re-arrange notifications according to their position and index - internal

-- @return None

local function arrange(screen)

for p,pos in pairs(naughty.notifications[screen]) do

for i,notification in pairs(naughty.notifications[screen][p]) do

local offset = get_offset(screen, p, i, notification.width, notification.height)

notification.box:geometry({ x = offset.x, y = offset.y })

notification.idx = offset.idx

end

--- Destroy notification by notification object

-- @param notification Notification object to be destroyed

-- @return True if the popup was successfully destroyed, nil otherwise

function naughty.destroy(notification)

if notification and notification.box.visible then

if suspended then

for k, v in pairs(naughty.notifications.suspended) do

if v.box == notification.box then

table.remove(naughty.notifications.suspended, k)

break

end

local scr = notification.screen

table.remove(naughty.notifications[scr][notification.position], notification.idx)

if notification.timer then

notification.timer:stop()

end

notification.box.visible = false

arrange(scr)

return true

end

-- Get notification by ID

-- @param id ID of the notification

-- @return notification object if it was found, nil otherwise

local function getById(id)

-- iterate the notifications to get the notfications with the correct ID

for s = 1, capi.screen.count() do

for p,pos in pairs(naughty.notifications[s]) do

for i,notification in pairs(naughty.notifications[s][p]) do

if notification.id == id then

return notification

end

--- Create notification. args is a dictionary of (optional) arguments.

-- @param text Text of the notification. Default: ''

-- @param title Title of the notification. Default: nil

-- @param timeout Time in seconds after which popup expires.

-- Set 0 for no timeout. Default: 5

-- @param hover_timeout Delay in seconds after which hovered popup disappears.

-- Default: nil

-- @param screen Target screen for the notification. Default: 1

-- @param position Corner of the workarea displaying the popups.

-- Values: "top_right" (default), "top_left", "bottom_left", "bottom_right".

-- @param ontop Boolean forcing popups to display on top. Default: true

-- @param height Popup height. Default: nil (auto)

-- @param width Popup width. Default: nil (auto)

-- @param font Notification font. Default: beautiful.font or awesome.font

-- @param icon Path to icon. Default: nil

-- @param icon_size Desired icon size in px. Default: nil

-- @param fg Foreground color. Default: beautiful.fg_focus or '#ffffff'

-- @param bg Background color. Default: beautiful.bg_focus or '#535d6c'

-- @param border_width Border width. Default: 1

-- @param border_color Border color.

-- Default: beautiful.border_focus or '#535d6c'

-- @param run Function to run on left click. Default: nil

-- @param preset Table with any of the above parameters. Note: Any parameters

-- specified directly in args will override ones defined in the preset.

-- @param replaces_id Replace the notification with the given ID

-- @param callback function that will be called with all arguments

-- the notification will only be displayed if the function returns true

-- note: this function is only relevant to notifications sent via dbus

-- @usage naughty.notify({ title = "Achtung!", text = "You're idling", timeout = 0 })

-- @return The notification object

function naughty.notify(args)

if naughty.config.notify_callback then

args = naughty.config.notify_callback(args)

if not args then return end

end

-- gather variables together

local preset = util.table.join(naughty.config.defaults or {},

args.preset or naughty.config.presets.normal or {})

local timeout = args.timeout or preset.timeout

local icon = args.icon or preset.icon

local icon_size = args.icon_size or preset.icon_size

local text = args.text or preset.text

local title = args.title or preset.title

local screen = args.screen or preset.screen

local ontop = args.ontop or preset.ontop

local width = args.width or preset.width

local height = args.height or preset.height

local hover_timeout = args.hover_timeout or preset.hover_timeout

local opacity = args.opacity or preset.opacity

local margin = args.margin or preset.margin

local border_width = args.border_width or preset.border_width

local position = args.position or preset.position

local escape_pattern = "[<>&]"

local escape_subs = { ['<'] = "<", ['>'] = ">", ['&'] = "&" }

-- beautiful

local beautiful = bt.get()

local font = args.font or preset.font or beautiful.font or capi.awesome.font

local fg = args.fg or preset.fg or beautiful.fg_normal or '#ffffff'

local bg = args.bg or preset.bg or beautiful.bg_normal or '#535d6c'

local border_color = args.border_color or preset.border_color or beautiful.bg_focus or '#535d6c'

local notification = { screen = screen }

-- replace notification if needed

if args.replaces_id then

local obj = getById(args.replaces_id)

if obj then

-- destroy this and ...

naughty.destroy(obj)

end

-- ... may use its ID

if args.replaces_id <= counter then

notification.id = args.replaces_id

else

counter = counter + 1

notification.id = counter

end

else

-- get a brand new ID

counter = counter + 1

notification.id = counter

end

notification.position = position

if title then title = title .. "\n" else title = "" end

-- hook destroy

local die = function () naughty.destroy(notification) end

if timeout > 0 then

local timer_die = capi.timer { timeout = timeout }

timer_die:connect_signal("timeout", die)

if not suspended then

timer_die:start()

end

notification.timer = timer_die

end

notification.die = die

local run = function ()

if args.run then

args.run(notification)

else

die()

end

local hover_destroy = function ()

if hover_timeout == 0 then

die()

else

if notification.timer then notification.timer:stop() end

notification.timer = capi.timer { timeout = hover_timeout }

notification.timer:connect_signal("timeout", die)

notification.timer:start()

end

-- create textbox

local textbox = wibox.widget.textbox()

local marginbox = wibox.layout.margin()

marginbox:set_margins(margin)

marginbox:set_widget(textbox)

textbox:set_valign("middle")

textbox:set_font(font)

local function setMarkup(pattern, replacements)

textbox:set_markup(string.format('%s%s', title, text:gsub(pattern, replacements)))

end

local function setText()

textbox:set_text(string.format('%s %s', title, text))

end

-- Since the title cannot contain markup, it must be escaped first so that

-- it is not interpreted by Pango later.

title = title:gsub(escape_pattern, escape_subs)

-- Try to set the text while only interpreting .

-- (Setting a textbox' .text to an invalid pattern throws a lua error)

if not pcall(setMarkup, "<br.->", "\n") then

-- That failed, escape everything which might cause an error from pango

if not pcall(setMarkup, escape_pattern, escape_subs) then

-- Ok, just ignore all pango markup. If this fails, we got some invalid utf8

if not pcall(setText) then

textbox:set_markup("<Invalid markup or UTF8, cannot display message>")

end

-- create iconbox

local iconbox = nil

local iconmargin = nil

local icon_w, icon_h = 0, 0

if icon then

-- try to guess icon if the provided one is non-existent/readable

if type(icon) == "string" and not util.file_readable(icon) then

icon = util.geticonpath(icon, naughty.config.icon_formats, naughty.config.icon_dirs, icon_size) or icon

end

-- is the icon file readable?

local success, res = pcall(function() return surface.load(icon) end)

if success then

icon = res

else

io.stderr:write(string.format("naughty: Couldn't load image '%s': %s\n", tostring(icon), res))

icon = nil

end

-- if we have an icon, use it

if icon then

iconbox = wibox.widget.imagebox()

iconmargin = wibox.layout.margin(iconbox, margin, margin, margin, margin)

if icon_size then

local scaled = cairo.ImageSurface(cairo.Format.ARGB32, icon_size, icon_size)

local cr = cairo.Context(scaled)

cr:scale(icon_size / icon:get_height(), icon_size / icon:get_width())

cr:set_source_surface(icon, 0, 0)

cr:paint()

icon = scaled

end

iconbox:set_resize(false)

iconbox:set_image(icon)

icon_w = icon:get_width()

icon_h = icon:get_height()

end

-- create container wibox

notification.box = wibox({ fg = fg,

bg = bg,

border_color = border_color,

border_width = border_width,

type = "notification" })

if hover_timeout then notification.box:connect_signal("mouse::enter", hover_destroy) end

-- calculate the height

if not height then

local w, h = textbox:fit(-1, -1)

if iconbox and icon_h + 2 * margin > h + 2 * margin then

height = icon_h + 2 * margin

else

height = h + 2 * margin

end

-- calculate the width

if not width then

local w, h = textbox:fit(-1, -1)

width = w + (iconbox and icon_w + 2 * margin or 0) + 2 * margin

end

-- crop to workarea size if too big

local workarea = capi.screen[screen].workarea

if width > workarea.width - 2 * (border_width or 0) - 2 * (naughty.config.padding or 0) then

width = workarea.width - 2 * (border_width or 0) - 2 * (naughty.config.padding or 0)

end

if height > workarea.height - 2 * (border_width or 0) - 2 * (naughty.config.padding or 0) then

height = workarea.height - 2 * (border_width or 0) - 2 * (naughty.config.padding or 0)

end

-- set size in notification object

notification.height = height + 2 * (border_width or 0)

notification.width = width + 2 * (border_width or 0)

-- position the wibox

local offset = get_offset(screen, notification.position, nil, notification.width, notification.height)

notification.box.ontop = ontop

notification.box:geometry({ width = width,

height = height,

x = offset.x,

y = offset.y })

notification.box.opacity = opacity

notification.box.visible = true

notification.idx = offset.idx

-- populate widgets

local layout = wibox.layout.fixed.horizontal()

if iconmargin then

layout:add(iconmargin)

end

layout:add(marginbox)

notification.box:set_widget(layout)

-- Setup the mouse events

layout:buttons(util.table.join(button({ }, 1, run), button({ }, 3, die)))

-- insert the notification to the table

table.insert(naughty.notifications[screen][notification.position], notification)

if suspended then

notification.box.visible = false

table.insert(naughty.notifications.suspended, notification)

end

-- return the notification

return notification

end

-- DBUS/Notification support

-- Notify

if capi.dbus then

capi.dbus.connect_signal("org.freedesktop.Notifications", function (data, appname, replaces_id, icon, title, text, actions, hints, expire)

local args = { }

if data.member == "Notify" then

if text ~= "" then

args.text = text

if title ~= "" then

args.title = title

end

else

if title ~= "" then

args.text = title

else

return

end

if appname ~= "" then

args.appname = appname

end

for i, obj in pairs(naughty.config.mapping) do

local filter, preset, s = obj[1], obj[2], 0

if (not filter.urgency or filter.urgency == hints.urgency) and

(not filter.category or filter.category == hints.category) and

(not filter.appname or filter.appname == appname) then

args.preset = util.table.join(args.preset, preset)

end

local preset = args.preset or naughty.config.defaults

if not preset.callback or (type(preset.callback) == "function" and

preset.callback(data, appname, replaces_id, icon, title, text, actions, hints, expire)) then

if icon ~= "" then

args.icon = icon

elseif hints.icon_data or hints.image_data then

if hints.icon_data == nil then hints.icon_data = hints.image_data end

-- icon_data is an array:

-- 1 -> width

-- 2 -> height

-- 3 -> rowstride

-- 4 -> has alpha

-- 5 -> bits per sample

-- 6 -> channels

-- 7 -> data

local w, h, rowstride, _, _, channels, data = unpack(hints.icon_data)

-- Do the arguments look sane? (e.g. we have enough data)

local expected_length = rowstride * (h - 1) + w * channels

if w < 0 or h < 0 or rowstride < 0 or (channels ~= 3 and channels ~= 4) or

string.len(data) < expected_length then

w = 0

h = 0

end

local format = cairo.Format[channels == 4 and 'ARGB32' or 'RGB24']

-- Figure out some stride magic (cairo dictates rowstride)

local stride = cairo.Format.stride_for_width(format, w)

local append = schar(0):rep(stride - 4 * w)

local offset = 0

-- Now convert each row on its own

local rows = {}

for y = 1, h do

local this_row = {}

for i = 1 + offset, w * channels + offset, channels do

local R, G, B, A = sbyte(data, i, i + channels - 1)

tins(this_row, schar(B, G, R, A or 255))

end

-- Handle rowstride, offset is stride for the input, append for output

tins(this_row, append)

tins(rows, tcat(this_row))

offset = offset + rowstride

end

args.icon = cairo.ImageSurface.create_for_data(tcat(rows), format,

w, h, stride)

end

if replaces_id and replaces_id ~= "" and replaces_id ~= 0 then

args.replaces_id = replaces_id

end

if expire and expire > -1 then

args.timeout = expire / 1000

end

local id = naughty.notify(args).id

return "u", id

end

return "u", "0"

elseif data.member == "CloseNotification" then

local obj = getById(appname)

if obj then

naughty.destroy(obj)

end

elseif data.member == "GetServerInfo" or data.member == "GetServerInformation" then

-- name of notification app, name of vender, version

return "s", "naughty", "s", "awesome", "s", capi.awesome.version:match("%d.%d"), "s", "1.0"

elseif data.member == "GetCapabilities" then

-- We actually do display the body of the message, we support ,

-- and in the body and we handle static (non-animated) icons.

return "as", { "s", "body", "s", "body-markup", "s", "icon-static" }

end

end)

capi.dbus.connect_signal("org.freedesktop.DBus.Introspectable",

function (data, text)

if data.member == "Introspect" then

local xml = [=[<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object

Introspection 1.0//EN"

"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">

<node>

</method>

</interface>

</method>

</method>

</method>

</method>

</method>

</interface>

</node>]=]

return "s", xml

end

end)

-- listen for dbus notification requests

capi.dbus.request_name("session", "org.freedesktop.Notifications")

end

return naughty

-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80

FilesExpand file tree

naughty.lua.in

Latest commit

History

naughty.lua.in

File metadata and controls