code.delx.au - pulseaudio/blob - polyp/module-x11-bell.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <assert.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include <X11/Xlib.h>
  32 #include <X11/XKBlib.h>
  33
  34 #include "module.h"
  35 #include "sink.h"
  36 #include "scache.h"
  37 #include "modargs.h"
  38 #include "xmalloc.h"
  39 #include "namereg.h"
  40
  41 struct x11_source {
  42     struct pa_io_event *io_event;
  43     struct x11_source *next;
  44 };
  45
  46 struct userdata {
  47     struct pa_core *core;
  48     Display *display;
  49     struct x11_source *x11_sources;
  50     int xkb_event_base;
  51
  52     char *sink_name;
  53     char *scache_item;
  54 };
  55
  56 static const char* const valid_modargs[] = {
  57     "sink",
  58     "sample",
  59     "display",
  60     NULL
  61 };
  62
  63 static int ring_bell(struct userdata *u, int percent) {
  64     struct pa_sink *s;
  65     assert(u);
  66
  67     if (!(s = pa_namereg_get(u->core, u->sink_name, PA_NAMEREG_SINK, 1))) {
  68         fprintf(stderr, __FILE__": Invalid sink\n");
  69         return -1;
  70     }
  71
  72     pa_scache_play_item(u->core, u->scache_item, s, percent*2);
  73     return 0;
  74 }
  75
  76 static void io_callback(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
  77     struct userdata *u = userdata;
  78     assert(u);
  79
  80     while (XPending(u->display)) {
  81         XEvent e;
  82         XkbBellNotifyEvent *bne;
  83         XNextEvent(u->display, &e);
  84
  85         if (((XkbEvent*) &e)->any.xkb_type != XkbBellNotify)
  86             continue;
  87
  88         bne = ((XkbBellNotifyEvent*) &e);
  89
  90         if (ring_bell(u, bne->percent) < 0) {
  91             fprintf(stderr, __FILE__": Ringing bell failed, reverting to X11 device bell.\n");
  92             XkbForceDeviceBell(u->display, bne->device, bne->bell_class, bne->bell_id, bne->percent);
  93         }
  94     }
  95 }
  96
  97 static void new_io_source(struct userdata *u, int fd) {
  98     struct x11_source *s;
  99
 100     s = pa_xmalloc(sizeof(struct x11_source));
 101     s->io_event = u->core->mainloop->io_new(u->core->mainloop, fd, PA_IO_EVENT_INPUT, io_callback, u);
 102     assert(s->io_event);
 103     s->next = u->x11_sources;
 104     u->x11_sources = s;
 105 }
 106
 107 int pa_module_init(struct pa_core *c, struct pa_module*m) {
 108     struct userdata *u = NULL;
 109     struct pa_modargs *ma = NULL;
 110     int major, minor;
 111     unsigned int auto_ctrls, auto_values;
 112     assert(c && m);
 113
 114     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 115         fprintf(stderr, __FILE__": failed to parse module arguments\n");
 116         goto fail;
 117     }
 118
 119     m->userdata = u = pa_xmalloc(sizeof(struct userdata));
 120     u->core = c;
 121     u->display = NULL;
 122     u->x11_sources = NULL;
 123     u->scache_item = pa_xstrdup(pa_modargs_get_value(ma, "sample", "x11-bell"));
 124     u->sink_name = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));
 125
 126     if (!(u->display = XOpenDisplay(pa_modargs_get_value(ma, "display", NULL)))) {
 127         fprintf(stderr, __FILE__": XOpenDisplay() failed\n");
 128         goto fail;
 129     }
 130
 131     new_io_source(u, ConnectionNumber(u->display));
 132
 133     major = XkbMajorVersion;
 134     minor = XkbMinorVersion;
 135
 136     if (!XkbLibraryVersion(&major, &minor)) {
 137         fprintf(stderr, __FILE__": XkbLibraryVersion() failed\n");
 138         goto fail;
 139     }
 140
 141     major = XkbMajorVersion;
 142     minor = XkbMinorVersion;
 143
 144     if (!XkbQueryExtension(u->display, NULL, &u->xkb_event_base, NULL, &major, &minor)) {
 145         fprintf(stderr, __FILE__": XkbQueryExtension() failed\n");
 146         goto fail;
 147     }
 148
 149     XkbSelectEvents(u->display, XkbUseCoreKbd, XkbBellNotifyMask, XkbBellNotifyMask);
 150     auto_ctrls = auto_values = XkbAudibleBellMask;
 151     XkbSetAutoResetControls(u->display, XkbAudibleBellMask, &auto_ctrls, &auto_values);
 152     XkbChangeEnabledControls(u->display, XkbUseCoreKbd, XkbAudibleBellMask, 0);
 153
 154     pa_modargs_free(ma);
 155
 156     return 0;
 157
 158 fail:
 159     if (ma)
 160         pa_modargs_free(ma);
 161     if (m->userdata)
 162         pa_module_done(c, m);
 163     return -1;
 164 }
 165
 166 void pa_module_done(struct pa_core *c, struct pa_module*m) {
 167     struct userdata *u = m->userdata;
 168     assert(c && m && u);
 169
 170     while (u->x11_sources) {
 171         struct x11_source *s = u->x11_sources;
 172         u->x11_sources = u->x11_sources->next;
 173         c->mainloop->io_free(s->io_event);
 174         pa_xfree(s);
 175     }
 176
 177     pa_xfree(u->scache_item);
 178     pa_xfree(u->sink_name);
 179
 180     if (u->display)
 181         XCloseDisplay(u->display);
 182     pa_xfree(u);
 183 }