nagbalae/dunst
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor/cleanup

Browse Source 
* run code through `indent --no-tabs -linux`
 * use generic list implemenation for queues

This sould have been multiple commits but some git foobar on my part
made me loose the history :-/
This commit is contained in:
Sascha Kruse 2012-06-21 17:40:44 +02:00
parent 305a791e21
commit b0bf0b0b07
7 changed files with 1544 additions and 1498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@ -3,7 +3,7 @@
include config.mk
SRC = draw.c dunst.c ini.c
SRC = draw.c dunst.c list.c dunst_dbus.c ini.c
OBJ = ${SRC:.c=.o}
all: doc options dunst
@ -20,9 +20,9 @@ options:
${OBJ}: config.mk
dunst: draw.o dunst.o ini.o
dunst: draw.o dunst.o list.o dunst_dbus.o ini.o
@echo CC -o $@
@${CC} ${CFLAGS} -o $@ dunst.o draw.o ini.o ${LDFLAGS}
@${CC} ${CFLAGS} -o $@ dunst.o draw.o list.o dunst_dbus.o ini.o ${LDFLAGS}
clean:
@echo cleaning

361
draw.c
View File

@ -42,207 +42,234 @@ DEALINGS IN THE SOFTWARE.
#define MIN(a, b) ((a) < (b) ? (a) : (b))
void
drawrect(DC *dc, int x, int y, unsigned int w, unsigned int h, Bool fill, unsigned long color) {
XSetForeground(dc->dpy, dc->gc, color);
if(fill)
XFillRectangle(dc->dpy, dc->canvas, dc->gc, dc->x + x, dc->y + y, w, h);
else
XDrawRectangle(dc->dpy, dc->canvas, dc->gc, dc->x + x, dc->y + y, w-1, h-1);
drawrect(DC * dc, int x, int y, unsigned int w, unsigned int h, Bool fill,
unsigned long color)
{
XSetForeground(dc->dpy, dc->gc, color);
if (fill)
XFillRectangle(dc->dpy, dc->canvas, dc->gc, dc->x + x,
dc->y + y, w, h);
else
XDrawRectangle(dc->dpy, dc->canvas, dc->gc, dc->x + x,
dc->y + y, w - 1, h - 1);
}
void
drawtext(DC *dc, const char *text, ColorSet *col) {
char buf[BUFSIZ];
size_t mn, n = strlen(text);
void drawtext(DC * dc, const char *text, ColorSet * col)
{
char buf[BUFSIZ];
size_t mn, n = strlen(text);
/* shorten text if necessary */
for(mn = MIN(n, sizeof buf); textnw(dc, text, mn) + dc->font.height/2 > dc->w; mn--)
if(mn == 0)
return;
memcpy(buf, text, mn);
if(mn < n)
for(n = MAX(mn-3, 0); n < mn; buf[n++] = '.');
/* shorten text if necessary */
for (mn = MIN(n, sizeof buf);
textnw(dc, text, mn) + dc->font.height / 2 > dc->w; mn--)
if (mn == 0)
return;
memcpy(buf, text, mn);
if (mn < n)
for (n = MAX(mn - 3, 0); n < mn; buf[n++] = '.') ;
drawrect(dc, 0, 0, dc->w, dc->h, True, col->BG);
drawtextn(dc, buf, mn, col);
drawrect(dc, 0, 0, dc->w, dc->h, True, col->BG);
drawtextn(dc, buf, mn, col);
}
void
drawtextn(DC *dc, const char *text, size_t n, ColorSet *col) {
int x = dc->x + dc->font.height/2;
int y = dc->y + dc->font.ascent+1;
void drawtextn(DC * dc, const char *text, size_t n, ColorSet * col)
{
int x = dc->x + dc->font.height / 2;
int y = dc->y + dc->font.ascent + 1;
XSetForeground(dc->dpy, dc->gc, col->FG);
if(dc->font.xft_font) {
if (!dc->xftdraw)
eprintf("error, xft drawable does not exist");
XftDrawStringUtf8(dc->xftdraw, &col->FG_xft,
dc->font.xft_font, x, y, (unsigned char*)text, n);
} else if(dc->font.set) {
printf("XmbDrawString\n");
XmbDrawString(dc->dpy, dc->canvas, dc->font.set, dc->gc, x, y, text, n);
} else {
XSetFont(dc->dpy, dc->gc, dc->font.xfont->fid);
XDrawString(dc->dpy, dc->canvas, dc->gc, x, y, text, n);
}
XSetForeground(dc->dpy, dc->gc, col->FG);
if (dc->font.xft_font) {
if (!dc->xftdraw)
eprintf("error, xft drawable does not exist");
XftDrawStringUtf8(dc->xftdraw, &col->FG_xft,
dc->font.xft_font, x, y,
(unsigned char *)text, n);
} else if (dc->font.set) {
printf("XmbDrawString\n");
XmbDrawString(dc->dpy, dc->canvas, dc->font.set, dc->gc, x, y,
text, n);
} else {
XSetFont(dc->dpy, dc->gc, dc->font.xfont->fid);
XDrawString(dc->dpy, dc->canvas, dc->gc, x, y, text, n);
}
}
void
eprintf(const char *fmt, ...) {
va_list ap;
void eprintf(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
if(fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':') {
fputc(' ', stderr);
perror(NULL);
}
exit(EXIT_FAILURE);
if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':') {
fputc(' ', stderr);
perror(NULL);
}
exit(EXIT_FAILURE);
}
void
freecol(DC *dc, ColorSet *col) {
if(col) {
if(&col->FG_xft)
XftColorFree(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)), &col->FG_xft);
free(col);
}
void freecol(DC * dc, ColorSet * col)
{
if (col) {
if (&col->FG_xft)
XftColorFree(dc->dpy,
DefaultVisual(dc->dpy,
DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy,
DefaultScreen(dc->dpy)),
&col->FG_xft);
free(col);
}
}
void
freedc(DC *dc) {
if(dc->font.xft_font) {
XftFontClose(dc->dpy, dc->font.xft_font);
XftDrawDestroy(dc->xftdraw);
}
if(dc->font.set)
XFreeFontSet(dc->dpy, dc->font.set);
if(dc->font.xfont)
XFreeFont(dc->dpy, dc->font.xfont);
if(dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
if(dc->gc)
XFreeGC(dc->dpy, dc->gc);
if(dc->dpy)
XCloseDisplay(dc->dpy);
if(dc)
free(dc);
void freedc(DC * dc)
{
if (dc->font.xft_font) {
XftFontClose(dc->dpy, dc->font.xft_font);
XftDrawDestroy(dc->xftdraw);
}
if (dc->font.set)
XFreeFontSet(dc->dpy, dc->font.set);
if (dc->font.xfont)
XFreeFont(dc->dpy, dc->font.xfont);
if (dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
if (dc->gc)
XFreeGC(dc->dpy, dc->gc);
if (dc->dpy)
XCloseDisplay(dc->dpy);
if (dc)
free(dc);
}
unsigned long
getcolor(DC *dc, const char *colstr) {
Colormap cmap = DefaultColormap(dc->dpy, DefaultScreen(dc->dpy));
XColor color;
unsigned long getcolor(DC * dc, const char *colstr)
{
Colormap cmap = DefaultColormap(dc->dpy, DefaultScreen(dc->dpy));
XColor color;
if(!XAllocNamedColor(dc->dpy, cmap, colstr, &color, &color))
eprintf("cannot allocate color '%s'\n", colstr);
return color.pixel;
if (!XAllocNamedColor(dc->dpy, cmap, colstr, &color, &color))
eprintf("cannot allocate color '%s'\n", colstr);
return color.pixel;
}
ColorSet *
initcolor(DC *dc, const char * foreground, const char * background) {
ColorSet * col = (ColorSet *)malloc(sizeof(ColorSet));
if(!col)
eprintf("error, cannot allocate memory for color set");
col->BG = getcolor(dc, background);
col->FG = getcolor(dc, foreground);
if(dc->font.xft_font)
if(!XftColorAllocName(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)), foreground, &col->FG_xft))
eprintf("error, cannot allocate xft font color '%s'\n", foreground);
return col;
ColorSet *initcolor(DC * dc, const char *foreground, const char *background)
{
ColorSet *col = (ColorSet *) malloc(sizeof(ColorSet));
if (!col)
eprintf("error, cannot allocate memory for color set");
col->BG = getcolor(dc, background);
col->FG = getcolor(dc, foreground);
if (dc->font.xft_font)
if (!XftColorAllocName
(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)),
foreground, &col->FG_xft))
eprintf("error, cannot allocate xft font color '%s'\n",
foreground);
return col;
}
DC *
initdc(void) {
DC *dc;
DC *initdc(void)
{
DC *dc;
if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
fputs("no locale support\n", stderr);
if(!(dc = calloc(1, sizeof *dc)))
eprintf("cannot malloc %u bytes:", sizeof *dc);
if(!(dc->dpy = XOpenDisplay(NULL)))
eprintf("cannot open display\n");
if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
fputs("no locale support\n", stderr);
if (!(dc = calloc(1, sizeof *dc)))
eprintf("cannot malloc %u bytes:", sizeof *dc);
if (!(dc->dpy = XOpenDisplay(NULL)))
eprintf("cannot open display\n");
dc->gc = XCreateGC(dc->dpy, DefaultRootWindow(dc->dpy), 0, NULL);
XSetLineAttributes(dc->dpy, dc->gc, 1, LineSolid, CapButt, JoinMiter);
return dc;
dc->gc = XCreateGC(dc->dpy, DefaultRootWindow(dc->dpy), 0, NULL);
XSetLineAttributes(dc->dpy, dc->gc, 1, LineSolid, CapButt, JoinMiter);
return dc;
}
void
initfont(DC *dc, const char *fontstr) {
char *def, **missing, **names;
int i, n;
XFontStruct **xfonts;
void initfont(DC * dc, const char *fontstr)
{
char *def, **missing, **names;
int i, n;
XFontStruct **xfonts;
missing = NULL;
if((dc->font.xfont = XLoadQueryFont(dc->dpy, fontstr))) {
dc->font.ascent = dc->font.xfont->ascent;
dc->font.descent = dc->font.xfont->descent;
dc->font.width = dc->font.xfont->max_bounds.width;
} else if((dc->font.set = XCreateFontSet(dc->dpy, fontstr, &missing, &n, &def))) {
n = XFontsOfFontSet(dc->font.set, &xfonts, &names);
for(i = 0; i < n; i++) {
dc->font.ascent = MAX(dc->font.ascent, xfonts[i]->ascent);
dc->font.descent = MAX(dc->font.descent, xfonts[i]->descent);
dc->font.width = MAX(dc->font.width, xfonts[i]->max_bounds.width);
}
} else if((dc->font.xft_font = XftFontOpenName(dc->dpy, DefaultScreen(dc->dpy), fontstr))) {
dc->font.ascent = dc->font.xft_font->ascent;
dc->font.descent = dc->font.xft_font->descent;
dc->font.width = dc->font.xft_font->max_advance_width;
} else {
eprintf("cannot load font '%s'\n", fontstr);
}
if(missing)
XFreeStringList(missing);
dc->font.height = dc->font.ascent + dc->font.descent;
return;
missing = NULL;
if ((dc->font.xfont = XLoadQueryFont(dc->dpy, fontstr))) {
dc->font.ascent = dc->font.xfont->ascent;
dc->font.descent = dc->font.xfont->descent;
dc->font.width = dc->font.xfont->max_bounds.width;
} else
if ((dc->font.set =
XCreateFontSet(dc->dpy, fontstr, &missing, &n, &def))) {
n = XFontsOfFontSet(dc->font.set, &xfonts, &names);
for (i = 0; i < n; i++) {
dc->font.ascent =
MAX(dc->font.ascent, xfonts[i]->ascent);
dc->font.descent =
MAX(dc->font.descent, xfonts[i]->descent);
dc->font.width =
MAX(dc->font.width, xfonts[i]->max_bounds.width);
}
} else
if ((dc->font.xft_font =
XftFontOpenName(dc->dpy, DefaultScreen(dc->dpy), fontstr))) {
dc->font.ascent = dc->font.xft_font->ascent;
dc->font.descent = dc->font.xft_font->descent;
dc->font.width = dc->font.xft_font->max_advance_width;
} else {
eprintf("cannot load font '%s'\n", fontstr);
}
if (missing)
XFreeStringList(missing);
dc->font.height = dc->font.ascent + dc->font.descent;
return;
}
void
mapdc(DC *dc, Window win, unsigned int w, unsigned int h) {
XCopyArea(dc->dpy, dc->canvas, win, dc->gc, 0, 0, w, h, 0, 0);
void mapdc(DC * dc, Window win, unsigned int w, unsigned int h)
{
XCopyArea(dc->dpy, dc->canvas, win, dc->gc, 0, 0, w, h, 0, 0);
}
void
resizedc(DC *dc, unsigned int w, unsigned int h) {
int screen = DefaultScreen(dc->dpy);
if(dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
void resizedc(DC * dc, unsigned int w, unsigned int h)
{
int screen = DefaultScreen(dc->dpy);
if (dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
dc->w = w;
dc->h = h;
dc->canvas = XCreatePixmap(dc->dpy, DefaultRootWindow(dc->dpy), w, h,
DefaultDepth(dc->dpy, screen));
if(dc->xftdraw) {
XftDrawDestroy(dc->xftdraw);
}
if(dc->font.xft_font) {
dc->xftdraw = XftDrawCreate(dc->dpy, dc->canvas, DefaultVisual(dc->dpy,screen), DefaultColormap(dc->dpy,screen));
if(!(dc->xftdraw))
eprintf("error, cannot create xft drawable\n");
}
dc->w = w;
dc->h = h;
dc->canvas = XCreatePixmap(dc->dpy, DefaultRootWindow(dc->dpy), w, h,
DefaultDepth(dc->dpy, screen));
if (dc->xftdraw) {
XftDrawDestroy(dc->xftdraw);
}
if (dc->font.xft_font) {
dc->xftdraw =
XftDrawCreate(dc->dpy, dc->canvas,
DefaultVisual(dc->dpy, screen),
DefaultColormap(dc->dpy, screen));
if (!(dc->xftdraw))
eprintf("error, cannot create xft drawable\n");
}
}
int
textnw(DC *dc, const char *text, size_t len) {
if(dc->font.xft_font) {
XGlyphInfo gi;
XftTextExtentsUtf8(dc->dpy, dc->font.xft_font, (const FcChar8*)text, len, &gi);
return gi.width;
} else if(dc->font.set) {
XRectangle r;
XmbTextExtents(dc->font.set, text, len, NULL, &r);
return r.width;
}
return XTextWidth(dc->font.xfont, text, len);
int textnw(DC * dc, const char *text, size_t len)
{
if (dc->font.xft_font) {
XGlyphInfo gi;
XftTextExtentsUtf8(dc->dpy, dc->font.xft_font,
(const FcChar8 *)text, len, &gi);
return gi.width;
} else if (dc->font.set) {
XRectangle r;
XmbTextExtents(dc->font.set, text, len, NULL, &r);
return r.width;
}
return XTextWidth(dc->font.xfont, text, len);
}
int
textw(DC *dc, const char *text) {
return textnw(dc, text, strlen(text)) + dc->font.height;
int textw(DC * dc, const char *text)
{
return textnw(dc, text, strlen(text)) + dc->font.height;
}
/* vim: set ts=8 sw=8 tw=0: */

64
draw.h
View File

@ -36,42 +36,44 @@ DEALINGS IN THE SOFTWARE.
#include <X11/Xft/Xft.h>
typedef struct {
int x, y, w, h;
Bool invert;
Display *dpy;
GC gc;
Pixmap canvas;
XftDraw *xftdraw;
struct {
int ascent;
int descent;
int height;
int width;
XFontSet set;
XFontStruct *xfont;
XftFont *xft_font;
} font;
} DC; /* draw context */
int x, y, w, h;
Bool invert;
Display *dpy;
GC gc;
Pixmap canvas;
XftDraw *xftdraw;
struct {
int ascent;
int descent;
int height;
int width;
XFontSet set;
XFontStruct *xfont;
XftFont *xft_font;
} font;
} DC; /* draw context */
typedef struct {
unsigned long FG;
XftColor FG_xft;
unsigned long BG;
unsigned long FG;
XftColor FG_xft;
unsigned long BG;
} ColorSet;
void drawrect(DC *dc, int x, int y, unsigned int w, unsigned int h, Bool fill, unsigned long color);
void drawtext(DC *dc, const char *text, ColorSet *col);
void drawtextn(DC *dc, const char *text, size_t n, ColorSet *col);
void freecol(DC *dc, ColorSet *col);
void drawrect(DC * dc, int x, int y, unsigned int w, unsigned int h, Bool fill,
unsigned long color);
void drawtext(DC * dc, const char *text, ColorSet * col);
void drawtextn(DC * dc, const char *text, size_t n, ColorSet * col);
void freecol(DC * dc, ColorSet * col);
void eprintf(const char *fmt, ...);
void freedc(DC *dc);
unsigned long getcolor(DC *dc, const char *colstr);
ColorSet *initcolor(DC *dc, const char *foreground, const char *background);
void freedc(DC * dc);
unsigned long getcolor(DC * dc, const char *colstr);
ColorSet *initcolor(DC * dc, const char *foreground, const char *background);
DC *initdc(void);
void initfont(DC *dc, const char *fontstr);
void mapdc(DC *dc, Window win, unsigned int w, unsigned int h);
void resizedc(DC *dc, unsigned int w, unsigned int h);
int textnw(DC *dc, const char *text, size_t len);
int textw(DC *dc, const char *text);
void initfont(DC * dc, const char *fontstr);
void mapdc(DC * dc, Window win, unsigned int w, unsigned int h);
void resizedc(DC * dc, unsigned int w, unsigned int h);
int textnw(DC * dc, const char *text, size_t len);
int textw(DC * dc, const char *text);
#endif
/* vim: set ts=8 sw=8 tw=0: */

1987
dunst.c
View File

File diff suppressed because it is too large Load Diff

69
dunst.h
View File

@ -14,43 +14,48 @@
#define ColBG 0
typedef struct _rule_t {
char *name;
/* filters */
char *appname;
char *summary;
char *body;
char *icon;
char *name;
/* filters */
char *appname;
char *summary;
char *body;
char *icon;
/* actions */
int timeout;
int urgency;
char *fg;
char *bg;
const char *format;
/* actions */
int timeout;
int urgency;
char *fg;
char *bg;
const char *format;
struct _rule_t *next;
struct _rule_t *next;
} rule_t;
typedef struct _msg_queue_t {
char *appname;
char *summary;
char *body;
char *icon;
char *msg;
const char *format;
struct _msg_queue_t *next;
time_t start;
int timeout;
int urgency;
ColorSet *colors;
char *color_strings[2];
} msg_queue_t;
typedef struct _notification {
char *appname;
char *summary;
char *body;
char *icon;
char *msg;
const char *format;
time_t start;
time_t timestamp;
int timeout;
int urgency;
int redisplayed; /* has been displayed before? */
ColorSet *colors;
char *color_strings[2];
} notification;
typedef struct _dimension_t {
int x;
int y;
unsigned int h;
unsigned int w;
int mask;
int x;
int y;
unsigned int h;
unsigned int w;
int mask;
} dimension_t;
#endif
/* vim: set ts=8 sw=8 tw=0: */
void init_notification(notification * n);
void map_win(void);

538
dunst_dbus.c
View File

@ -3,59 +3,57 @@
#include <dbus/dbus.h>
#include "dunst.h"
#include "list.h"
#define DBUS_POLL_TIMEOUT 200
#include "dunst_dbus.h"
DBusError dbus_err;
DBusConnection *dbus_conn;
dbus_uint32_t dbus_serial = 0;
static const char *introspect = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<node name=\"/org/freedesktop/Notifications\">"
" <interface name=\"org.freedesktop.Notifications\">"
" "
" <method name=\"GetCapabilities\">"
" <arg direction=\"out\" name=\"capabilities\" type=\"as\"/>"
" </method>"
" <method name=\"Notify\">"
" <arg direction=\"in\" name=\"app_name\" type=\"s\"/>"
" <arg direction=\"in\" name=\"replaces_id\" type=\"u\"/>"
" <arg direction=\"in\" name=\"app_icon\" type=\"s\"/>"
" <arg direction=\"in\" name=\"summary\" type=\"s\"/>"
" <arg direction=\"in\" name=\"body\" type=\"s\"/>"
" <arg direction=\"in\" name=\"actions\" type=\"as\"/>"
" <arg direction=\"in\" name=\"hints\" type=\"a{sv}\"/>"
" <arg direction=\"in\" name=\"expire_timeout\" type=\"i\"/>"
" <arg direction=\"out\" name=\"id\" type=\"u\"/>"
" </method>"
" "
" <method name=\"CloseNotification\">"
" <arg direction=\"in\" name=\"id\" type=\"u\"/>"
" </method>"
" <method name=\"GetServerInformation\">"
" <arg direction=\"out\" name=\"name\" type=\"s\"/>"
" <arg direction=\"out\" name=\"vendor\" type=\"s\"/>"
" <arg direction=\"out\" name=\"version\" type=\"s\"/>"
" <arg direction=\"out\" name=\"spec_version\" type=\"s\"/>"
" </method>"
" <signal name=\"NotificationClosed\">"
" <arg name=\"id\" type=\"u\"/>"
" <arg name=\"reason\" type=\"u\"/>"
" </signal>"
" <signal name=\"ActionInvoked\">"
" <arg name=\"id\" type=\"u\"/>"
" <arg name=\"action_key\" type=\"s\"/>"
" </signal>"
" </interface>"
" "
" <interface name=\"org.xfce.Notifyd\">"
" <method name=\"Quit\"/>" " </interface>" "</node>";
"<node name=\"/org/freedesktop/Notifications\">"
" <interface name=\"org.freedesktop.Notifications\">"
" "
" <method name=\"GetCapabilities\">"
" <arg direction=\"out\" name=\"capabilities\" type=\"as\"/>"
" </method>"
" <method name=\"Notify\">"
" <arg direction=\"in\" name=\"app_name\" type=\"s\"/>"
" <arg direction=\"in\" name=\"replaces_id\" type=\"u\"/>"
" <arg direction=\"in\" name=\"app_icon\" type=\"s\"/>"
" <arg direction=\"in\" name=\"summary\" type=\"s\"/>"
" <arg direction=\"in\" name=\"body\" type=\"s\"/>"
" <arg direction=\"in\" name=\"actions\" type=\"as\"/>"
" <arg direction=\"in\" name=\"hints\" type=\"a{sv}\"/>"
" <arg direction=\"in\" name=\"expire_timeout\" type=\"i\"/>"
" <arg direction=\"out\" name=\"id\" type=\"u\"/>"
" </method>"
" "
" <method name=\"CloseNotification\">"
" <arg direction=\"in\" name=\"id\" type=\"u\"/>"
" </method>"
" <method name=\"GetServerInformation\">"
" <arg direction=\"out\" name=\"name\" type=\"s\"/>"
" <arg direction=\"out\" name=\"vendor\" type=\"s\"/>"
" <arg direction=\"out\" name=\"version\" type=\"s\"/>"
" <arg direction=\"out\" name=\"spec_version\" type=\"s\"/>"
" </method>"
" <signal name=\"NotificationClosed\">"
" <arg name=\"id\" type=\"u\"/>"
" <arg name=\"reason\" type=\"u\"/>"
" </signal>"
" <signal name=\"ActionInvoked\">"
" <arg name=\"id\" type=\"u\"/>"
" <arg name=\"action_key\" type=\"s\"/>"
" </signal>"
" </interface>"
" "
" <interface name=\"org.xfce.Notifyd\">"
" <method name=\"Quit\"/>"
" </interface>"
"</node>";
void dbus_introspect(DBusMessage * dmsg) {
void dbus_introspect(DBusMessage * dmsg)
{
DBusMessage *reply;
DBusMessageIter args;
@ -69,287 +67,273 @@ void dbus_introspect(DBusMessage * dmsg) {
}
void
initdbus(void) {
int ret;
dbus_error_init(&dbus_err);
dbus_conn = dbus_bus_get(DBUS_BUS_SESSION, &dbus_err);
if(dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Connection Error (%s)\n", dbus_err.message);
dbus_error_free(&dbus_err);
}
if(dbus_conn == NULL) {
fprintf(stderr, "dbus_con == NULL\n");
exit(EXIT_FAILURE);
}
void initdbus(void)
{
int ret;
dbus_error_init(&dbus_err);
dbus_conn = dbus_bus_get(DBUS_BUS_SESSION, &dbus_err);
if (dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Connection Error (%s)\n", dbus_err.message);
dbus_error_free(&dbus_err);
}
if (dbus_conn == NULL) {
fprintf(stderr, "dbus_con == NULL\n");
exit(EXIT_FAILURE);
}
ret = dbus_bus_request_name(dbus_conn, "org.freedesktop.Notifications",
DBUS_NAME_FLAG_REPLACE_EXISTING, &dbus_err);
if(dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Name Error (%s)\n", dbus_err.message);
}
if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
fprintf(stderr, "There's already another notification-daemon running\n");
exit(EXIT_FAILURE);
}
ret = dbus_bus_request_name(dbus_conn, "org.freedesktop.Notifications",
DBUS_NAME_FLAG_REPLACE_EXISTING, &dbus_err);
if (dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Name Error (%s)\n", dbus_err.message);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
fprintf(stderr,
"There's already another notification-daemon running\n");
exit(EXIT_FAILURE);
}
dbus_bus_add_match(dbus_conn,
"type='signal',interface='org.freedesktop.Notifications'",
&dbus_err);
if(dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Match error (%s)\n", dbus_err.message);
exit(EXIT_FAILURE);
}
dbus_bus_add_match(dbus_conn,
"type='signal',interface='org.freedesktop.Notifications'",
&dbus_err);
if (dbus_error_is_set(&dbus_err)) {
fprintf(stderr, "Match error (%s)\n", dbus_err.message);
exit(EXIT_FAILURE);
}
}
void
dbus_poll(void) {
DBusMessage *dbus_msg;
void dbus_poll(int timeout)
{
DBusMessage *dbus_msg;
/* make timeout smaller if we are displaying a message
* to improve responsivness for mouse clicks
*/
if(msgqueue == NULL) {
dbus_connection_read_write(dbus_conn, DBUS_POLL_TIMEOUT);
} else {
dbus_connection_read_write(dbus_conn, 100);
}
dbus_connection_read_write(dbus_conn, timeout);
dbus_msg = dbus_connection_pop_message(dbus_conn);
/* we don't have a new message */
if(dbus_msg == NULL) {
return;
}
dbus_msg = dbus_connection_pop_message(dbus_conn);
/* we don't have a new message */
if (dbus_msg == NULL) {
return;
}
if (dbus_message_is_method_call(dbus_msg,"org.freedesktop.DBus.Introspectable", "Introspect")) {
dbus_introspect(dbus_msg);
}
if (dbus_message_is_method_call
(dbus_msg, "org.freedesktop.DBus.Introspectable", "Introspect")) {
dbus_introspect(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications","Notify")) {
notify(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "GetCapabilities")) {
getCapabilities(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "GetServerInformation")) {
getServerInformation(dbus_msg);
}
if(dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications", "CloseNotification")) {
closeNotification(dbus_msg);
}
dbus_message_unref(dbus_msg);
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"Notify")) {
notify(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"GetCapabilities")) {
getCapabilities(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"GetServerInformation")) {
getServerInformation(dbus_msg);
}
if (dbus_message_is_method_call(dbus_msg,
"org.freedesktop.Notifications",
"CloseNotification")) {
closeNotification(dbus_msg);
}
dbus_message_unref(dbus_msg);
}
void
getCapabilities(DBusMessage *dmsg) {
DBusMessage* reply;
DBusMessageIter args;
DBusMessageIter subargs;
void getCapabilities(DBusMessage * dmsg)
{
DBusMessage *reply;
DBusMessageIter args;
DBusMessageIter subargs;
const char *caps[1] = {"body"};
dbus_serial++;
const char *caps[1] = { "body" };
dbus_serial++;
reply = dbus_message_new_method_return(dmsg);
if(!reply) {
return;
}
reply = dbus_message_new_method_return(dmsg);
if (!reply) {
return;
}
dbus_message_iter_init_append(reply, &args);
dbus_message_iter_init_append(reply, &args);
if(!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subargs )
|| !dbus_message_iter_append_basic(&subargs, DBUS_TYPE_STRING, caps)
|| !dbus_message_iter_close_container(&args, &subargs)
|| !dbus_connection_send(dbus_conn, reply, &dbus_serial)) {
fprintf(stderr, "Unable to reply");
return;
}
if (!dbus_message_iter_open_container
(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subargs)
|| !dbus_message_iter_append_basic(&subargs, DBUS_TYPE_STRING, caps)
|| !dbus_message_iter_close_container(&args, &subargs)
|| !dbus_connection_send(dbus_conn, reply, &dbus_serial)) {
fprintf(stderr, "Unable to reply");
return;
}
dbus_connection_flush(dbus_conn);
dbus_message_unref(reply);
dbus_connection_flush(dbus_conn);
dbus_message_unref(reply);
}
void
closeNotification(DBusMessage *dmsg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(dmsg);
if(!reply) {
return;
}
dbus_connection_send(dbus_conn, reply, &dbus_serial);
dbus_connection_flush(dbus_conn);
void closeNotification(DBusMessage * dmsg)
{
DBusMessage *reply;
reply = dbus_message_new_method_return(dmsg);
if (!reply) {
return;
}
dbus_connection_send(dbus_conn, reply, &dbus_serial);
dbus_connection_flush(dbus_conn);
}
void
getServerInformation(DBusMessage *dmsg) {
DBusMessage *reply;
DBusMessageIter args;
char *param = "";
const char *info[4] = {"dunst", "dunst", "2011", "2011"};
void getServerInformation(DBusMessage * dmsg)
{
DBusMessage *reply;
DBusMessageIter args;
char *param = "";
const char *info[4] = { "dunst", "dunst", "2011", "2011" };
if (!dbus_message_iter_init(dmsg, &args)) {
} else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) {
} else {
dbus_message_iter_get_basic(&args, &param);
}
if (!dbus_message_iter_init(dmsg, &args)) {
}
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) {
}
else {
dbus_message_iter_get_basic(&args, &param);
}
reply = dbus_message_new_method_return(dmsg);
dbus_message_iter_init_append(reply, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &info[0])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
&info[1])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
&info[2])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
&info[3])) {
fprintf(stderr, "Unable to fill arguments");
return;
}
dbus_serial++;
if (!dbus_connection_send(dbus_conn, reply, &dbus_serial)) {
fprintf(stderr, "Out Of Memory!\n");
exit(EXIT_FAILURE);
}
dbus_connection_flush(dbus_conn);
reply = dbus_message_new_method_return(dmsg);
dbus_message_iter_init_append(reply, &args);
if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &info[0])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &info[1])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &info[2])
|| !dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &info[3])) {
fprintf(stderr, "Unable to fill arguments");
return;
}
dbus_serial++;
if (!dbus_connection_send(dbus_conn, reply, &dbus_serial)) {
fprintf(stderr, "Out Of Memory!\n");
exit(EXIT_FAILURE);
}
dbus_connection_flush(dbus_conn);
dbus_message_unref(reply);
dbus_message_unref(reply);
}
static void
_extract_basic(int type, DBusMessageIter *iter, void *target) {
int iter_type = dbus_message_iter_get_arg_type(iter);
if (iter_type != type) {
dunst_printf(DEBUG, "Invalid dbus notification: expected type %d but got %d.\n",
type, iter_type);
} else {
dbus_message_iter_get_basic(iter, target);
}
static void _extract_basic(int type, DBusMessageIter * iter, void *target)
{
int iter_type = dbus_message_iter_get_arg_type(iter);
if (iter_type == type) {
dbus_message_iter_get_basic(iter, target);
}
}
static void
_extract_hint(const char *name, const char *hint_name,
DBusMessageIter *hint, void *target) {
DBusMessageIter * hint, void *target)
{
DBusMessageIter hint_value;
DBusMessageIter hint_value;
if(!strcmp(hint_name, name)) {
dunst_printf(DEBUG, "%s found\n", name);
dbus_message_iter_next(hint);
dbus_message_iter_recurse(hint, &hint_value);
do {
dbus_message_iter_get_basic(&hint_value, target);
} while(dbus_message_iter_next(hint));
}
if (!strcmp(hint_name, name)) {
dbus_message_iter_next(hint);
dbus_message_iter_recurse(hint, &hint_value);
do {
dbus_message_iter_get_basic(&hint_value, target);
} while (dbus_message_iter_next(hint));
}
}
void
notify(DBusMessage *dmsg) {
DBusMessage *reply;
DBusMessageIter args;
DBusMessageIter hints;
DBusMessageIter hint;
char *hint_name;
void notify(DBusMessage * dmsg)
{
DBusMessage *reply;
DBusMessageIter args;
DBusMessageIter hints;
DBusMessageIter hint;
char *hint_name;
int i;
int id = 23;
const char *appname = NULL;
const char *summary = NULL;
const char *body = NULL;
const char *icon = NULL;
const char *fgcolor = NULL;
const char *bgcolor = NULL;
int urgency = 1;
msg_queue_t *msg = malloc(sizeof(msg_queue_t));
dbus_uint32_t nid=0;
dbus_int32_t expires=-1;
int i;
int id = 23;
const char *appname = NULL;
const char *summary = NULL;
const char *body = NULL;
const char *icon = NULL;
const char *fgcolor = NULL;
const char *bgcolor = NULL;
int urgency = 1;
notification *n = malloc(sizeof(notification));
dbus_uint32_t nid = 0;
dbus_int32_t expires = -1;
dbus_serial++;
dunst_printf(DEBUG, "new dbus message\n");
dbus_message_iter_init(dmsg, &args);
dbus_serial++;
dbus_message_iter_init(dmsg, &args);
dunst_printf(DEBUG, "extracting appname\n");
_extract_basic(DBUS_TYPE_STRING, &args, &appname);
_extract_basic(DBUS_TYPE_STRING, &args, &appname);
dbus_message_iter_next( &args );
dunst_printf(DEBUG, "extracting nid\n");
_extract_basic(DBUS_TYPE_UINT32, &args, &nid);
dbus_message_iter_next(&args);
_extract_basic(DBUS_TYPE_UINT32, &args, &nid);
dbus_message_iter_next( &args );
dunst_printf(DEBUG, "extracting icon\n");
_extract_basic(DBUS_TYPE_STRING, &args, &icon);
dbus_message_iter_next(&args);
_extract_basic(DBUS_TYPE_STRING, &args, &icon);
dbus_message_iter_next( &args );
dunst_printf(DEBUG, "extracting summary\n");
_extract_basic(DBUS_TYPE_STRING, &args, &summary);
dbus_message_iter_next(&args);
_extract_basic(DBUS_TYPE_STRING, &args, &summary);
dbus_message_iter_next( &args );
dunst_printf(DEBUG, "extracting body\n");
_extract_basic(DBUS_TYPE_STRING, &args, &body);
dbus_message_iter_next(&args);
_extract_basic(DBUS_TYPE_STRING, &args, &body);
dbus_message_iter_next( &args );
dbus_message_iter_next( &args );
dbus_message_iter_next(&args);
dbus_message_iter_next(&args);
dunst_printf(DEBUG, "extracting hints\n");
dbus_message_iter_recurse(&args, &hints);
dbus_message_iter_next( &args );
dbus_message_iter_recurse(&args, &hints);
dbus_message_iter_next(&args);
dunst_printf(DEBUG, "extracting expires\n");
_extract_basic(DBUS_TYPE_INT32, &args, &expires);
_extract_basic(DBUS_TYPE_INT32, &args, &expires);
dunst_printf(DEBUG, "extracting hints\n");
while (dbus_message_iter_get_arg_type(&hints) != DBUS_TYPE_INVALID) {
dbus_message_iter_recurse(&hints, &hint);
while (dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_INVALID) {
if(dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_STRING) {
dbus_message_iter_next(&hint);
continue;
}
dbus_message_iter_get_basic(&hint, &hint_name);
_extract_hint("urgency", hint_name, &hint, &urgency);
_extract_hint("fgcolor", hint_name, &hint, &fgcolor);
_extract_hint("bgcolor", hint_name, &hint, &bgcolor);
dbus_message_iter_next(&hint);
while (dbus_message_iter_get_arg_type(&hints) != DBUS_TYPE_INVALID) {
dbus_message_iter_recurse(&hints, &hint);
while (dbus_message_iter_get_arg_type(&hint) !=
DBUS_TYPE_INVALID) {
if (dbus_message_iter_get_arg_type(&hint) !=
DBUS_TYPE_STRING) {
dbus_message_iter_next(&hint);
continue;
}
dbus_message_iter_get_basic(&hint, &hint_name);
_extract_hint("urgency", hint_name, &hint, &urgency);
_extract_hint("fgcolor", hint_name, &hint, &fgcolor);
_extract_hint("bgcolor", hint_name, &hint, &bgcolor);
dbus_message_iter_next(&hint);
}
dbus_message_iter_next(&hints);
}
dbus_message_iter_next(&hints);
}
if(expires > 0) {
/* do some rounding */
expires = (expires+500)/1000;
if(expires < 1) {
expires = 1;
if (expires > 0) {
/* do some rounding */
expires = (expires + 500) / 1000;
if (expires < 1) {
expires = 1;
}
}
}
msg->appname = strdup(appname);
msg->summary = strdup(summary);
msg->body = strdup(body);
msg->icon = strdup(icon);
msg->timeout = expires;
msg->urgency = urgency;
for(i = 0; i < ColLast; i++) {
msg->color_strings[i] = NULL;
}
msg->color_strings[ColFG] = fgcolor == NULL ? NULL : strdup(fgcolor);
msg->color_strings[ColBG] = bgcolor == NULL ? NULL : strdup(bgcolor);
initmsg(msg);
msgqueue = add(msgqueue, msg);
drawmsg();
n->appname = strdup(appname);
n->summary = strdup(summary);
n->body = strdup(body);
n->icon = strdup(icon);
n->timeout = expires;
n->urgency = urgency;
for (i = 0; i < ColLast; i++) {
n->color_strings[i] = NULL;
}
n->color_strings[ColFG] = fgcolor == NULL ? NULL : strdup(fgcolor);
n->color_strings[ColBG] = bgcolor == NULL ? NULL : strdup(bgcolor);
init_notification(n);
map_win();
reply = dbus_message_new_method_return(dmsg);
reply = dbus_message_new_method_return(dmsg);
dbus_message_iter_init_append(reply, &args);
dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &id);
dbus_connection_send(dbus_conn, reply, &dbus_serial);
dbus_message_iter_init_append(reply, &args);
dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &id);
dbus_connection_send(dbus_conn, reply, &dbus_serial);
dbus_message_unref(reply);
dbus_message_unref(reply);
}
/* vim: set ts=8 sw=8 tw=0: */

17
dunst_dbus.h
View File

@ -1,12 +1,17 @@
/* copyright 2012 Sascha Kruse and contributors (see LICENSE for licensing information) */
#ifndef _DUNST_DBUS_H
#define _DUNST_DBUS_H
#include <dbus/dbus.h>
void initdbus(void);
void dbus_poll(void);
void notify(DBusMessage *msg);
void getCapabilities(DBusMessage *dmsg);
void closeNotification(DBusMessage *dmsg);
void getServerInformation(DBusMessage *dmsg);
void dbus_poll(int timeout);
void notify(DBusMessage * msg);
void getCapabilities(DBusMessage * dmsg);
void closeNotification(DBusMessage * dmsg);
void getServerInformation(DBusMessage * dmsg);
#include "dunst_dbus.c"
#endif
/* vim: set ts=8 sw=8 tw=0: */