← Back to branch summary

~ubuntu-branches/debian/squeeze/nas/squeeze

« back to all changes in this revision

Viewing changes to clients/audio/aupanel/aupanel.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve McIntyre
  • Date: 2008-10-08 01:18:19 UTC
  • mfrom: (4.1.7 intrepid)
  • Revision ID: james.westby@ubuntu.com-20081008011819-wmr4h2w0298k8t7z
Tags: 1.9.1-5
http://bugs.debian.org/491766
http://bugs.debian.org/500437
http://bugs.debian.org/500533
http://bugs.debian.org/500973
* Fix pending l10n issues. Debconf translations:
* Swedish. Closes: #491766 (thanks to brother@bsnet.se)
* Arabic. Closes: #500437 (thanks to Ossama Khayat)
* Basque. Closes: #500533 (thanks to Piarres Beobide)
* Brazilian Portuguese. Closes: #500973 (thanks to Felipe
  Augusto van de Wiel)
* Many thanks again to Christian Perrier for his i18n efforts,
  co-ordinating the above.

Show diffs side-by-side

added added

removed removed

Lines of Context:
clients/audio/aupanel/aupanel.c
55
55
 
56
56
#define APP_CLASS               "Aupanel"
57
57
 
 
58
#define DEFAULT_QUERY_INTERVAL  10000UL
 
59
 
58
60
#define USAGE "\
59
 
usage: aupanel [-a audioserver]\
 
61
usage: aupanel [-a audioserver] [-dev id] [-in seconds]\
60
62
"
61
63
 
62
64
#define MakeCommandButton(w, parent, label, callback)                          \
100
102
                    deviceNum,
101
103
                   *restoreValues;
102
104
    AuDeviceAttributes *da;
 
105
    unsigned long   queryInterval;
 
106
    XtIntervalId    queryTimerID;
103
107
}               GlobalDataRec, *GlobalDataPtr;
104
108
 
105
109
static String   defaultResources[] =
149
153
};
150
154
 
151
155
static void
152
 
fatalError(message, arg)
153
 
char           *message,
154
 
               *arg;
 
156
fatalError(const char *message, const char *arg)
155
157
{
156
158
    fprintf(stderr, message, arg);
157
159
    fprintf(stderr, "\n");
159
161
}
160
162
 
161
163
static void
162
 
quitCB(w, gp, call_data)
163
 
Widget          w;
164
 
XtPointer       gp;
165
 
XtPointer       call_data;
 
164
quitCB(Widget w, XtPointer gp, XtPointer call_data)
166
165
{
167
166
    exit(0);
168
167
}
169
168
 
170
169
static void
171
 
showDevice(g)
172
 
GlobalDataPtr   g;
 
170
showDevice(GlobalDataPtr g)
173
171
{
174
172
    Boolean         inputModeEnable, outputModeEnable,
175
173
                    gainEnable;
243
241
 
244
242
}
245
243
 
 
244
static void timedQueryCB(XtPointer, XtIntervalId *);
 
245
 
246
246
static void
247
 
queryCB(w, gp, call_data)
248
 
Widget          w;
249
 
XtPointer       gp;
250
 
XtPointer       call_data;
 
247
queryCB(Widget w, XtPointer gp, XtPointer call_data)
251
248
{
252
249
    GlobalDataPtr   g = (GlobalDataPtr) gp;
253
250
 
 
251
    if(g->queryInterval)
 
252
        XtRemoveTimeOut(g->queryTimerID);
 
253
 
254
254
    AuFreeDeviceAttributes(g->aud, g->numDevices, g->da);
255
255
    g->da = AuListDevices(g->aud, 0, NULL, &g->numDevices, NULL);
256
256
    showDevice(g);
257
 
}
258
 
 
259
 
static void
260
 
inputModeCB(w, gp, call_data)
261
 
Widget          w;
262
 
XtPointer       gp;
263
 
XtPointer       call_data;
 
257
 
 
258
    if(g->queryInterval)
 
259
        g->queryTimerID = XtAppAddTimeOut(XtWidgetToApplicationContext(g->top),
 
260
                                          g->queryInterval, timedQueryCB, gp);
 
261
}
 
262
 
 
263
static void
 
264
timedQueryCB(XtPointer gp, XtIntervalId *queryIntervalID)
 
265
{
 
266
    GlobalDataPtr   g = (GlobalDataPtr) gp;
 
267
 
 
268
    queryCB(g->top, gp, NULL);
 
269
}
 
270
 
 
271
static void
 
272
inputModeCB(Widget w, XtPointer gp, XtPointer call_data)
264
273
{
265
274
    GlobalDataPtr   g = (GlobalDataPtr) gp;
266
275
    AuDeviceAttributes *da = &g->da[g->deviceNum];
279
288
}
280
289
 
281
290
static void
282
 
outputModeCB(w, gp, call_data)
283
 
Widget          w;
284
 
XtPointer       gp;
285
 
XtPointer       call_data;
 
291
outputModeCB(Widget w, XtPointer gp, XtPointer call_data)
286
292
{
287
293
    GlobalDataPtr   g = (GlobalDataPtr) gp;
288
294
    AuDeviceAttributes *da = &g->da[g->deviceNum];
305
311
    queryCB(w, g, call_data);
306
312
}
307
313
 
 
314
static void set_device_by_name(GlobalDataPtr g, const char *name);
 
315
 
308
316
static void
309
 
menuCB(w, gp, call_data)
310
 
Widget          w;
311
 
XtPointer       gp;
312
 
XtPointer       call_data;
 
317
menuCB(Widget w, XtPointer gp, XtPointer call_data)
313
318
{
314
319
    GlobalDataPtr   g = (GlobalDataPtr) gp;
315
 
    int             i;
316
320
    String          string;
317
321
 
318
322
    XtVaGetValues(w, XtNlabel, &string, NULL);
319
323
    XtVaSetValues(g->device, XtNlabel, string, NULL);
320
 
 
321
 
    for (i = 0; i < g->numDevices; i++)
322
 
        if (!strcmp(string, AuDeviceDescription(&g->da[i])->data))
323
 
            break;
324
 
 
325
 
    g->deviceNum = i;
 
324
    set_device_by_name(g, string);
326
325
    queryCB(w, g, call_data);
327
326
    showDevice(g);
328
327
}
329
328
 
330
329
static void
331
 
setGain(w, gp, valuep)
332
 
Widget          w;
333
 
XtPointer       gp;
334
 
XtPointer       valuep;
 
330
setGain(Widget w, XtPointer gp, XtPointer valuep)
335
331
{
336
332
    GlobalDataPtr   g = (GlobalDataPtr) gp;
337
333
    AuDeviceAttributes *da = &g->da[g->deviceNum];
349
345
}
350
346
 
351
347
static void
352
 
muteCB(w, gp, call_data)
353
 
Widget          w;
354
 
XtPointer       gp;
355
 
XtPointer       call_data;
 
348
muteCB(Widget w, XtPointer gp, XtPointer call_data)
356
349
{
357
350
    GlobalDataPtr g = (GlobalDataPtr) gp;
358
351
    AuDeviceAttributes *da;
373
366
}
374
367
 
375
368
static void
376
 
createWidgets(g)
377
 
GlobalDataPtr   g;
 
369
createWidgets(GlobalDataPtr g)
378
370
{
379
371
    int             i;
380
372
    Widget          w;
389
381
    g->da = AuListDevices(g->aud, 0, NULL, &g->numDevices, NULL);
390
382
 
391
383
    if (!g->numDevices)
392
 
        fatalError("no devices");
 
384
        fatalError("no devices", NULL);
393
385
 
394
386
    for (i = 0; i < g->numDevices; i++)
395
387
    {
429
421
}
430
422
 
431
423
static void
432
 
alignWidgets(g)
433
 
GlobalDataPtr   g;
 
424
alignWidgets(GlobalDataPtr g)
434
425
{
435
426
    Dimension       w,
436
427
                    w1;
452
443
    XtVaSetValues(g->device, XtNresizable, False, NULL);
453
444
}
454
445
 
 
446
static AuInt32 parse_hex(const char *s)
 
447
{
 
448
    AuInt32 val = 0;
 
449
 
 
450
    sscanf (s, "%lx", &val);
 
451
    return val;
 
452
}
 
453
 
 
454
static AuBool is_decimal_number(const char *s)
 
455
{
 
456
    int i;
 
457
 
 
458
    if (!s)
 
459
        return AuFalse;
 
460
 
 
461
    for (i=0; s[i]; i++)
 
462
        if ((s[i] < '0') || (s[i] > '9'))
 
463
            return AuFalse;
 
464
 
 
465
    return AuTrue;
 
466
}
 
467
 
 
468
static AuDeviceID parse_device_id(const char *s)
 
469
{
 
470
    if ((s[0] == '0') && ((s[1] == 'x') || (s[1] == 'X')))
 
471
        return parse_hex(s);
 
472
    return AuNone;
 
473
}
 
474
 
 
475
static void set_device_by_id(GlobalDataPtr g, AuDeviceID id)
 
476
{
 
477
    int i;
 
478
    AuDeviceAttributes *d;
 
479
 
 
480
    for (i=0; i<g->numDevices; i++) {
 
481
        d = AuServerDevice(g->aud, i);
 
482
        if ((AuDeviceValueMask(d) & AuCompCommonIDMask) &&
 
483
            id == d->common.id) {
 
484
            g->deviceNum = i;
 
485
            break;
 
486
        }
 
487
    }
 
488
}
 
489
 
 
490
static void set_device_by_name(GlobalDataPtr g, const char *name)
 
491
{
 
492
    int i;
 
493
 
 
494
    for (i = 0; i < g->numDevices; i++)
 
495
        if (!strcmp(name, AuDeviceDescription(&g->da[i])->data)) {
 
496
            g->deviceNum = i;
 
497
            break;
 
498
        }
 
499
}
 
500
 
455
501
int
456
 
main(argc, argv)
457
 
int             argc;
458
 
char          **argv;
 
502
main(int argc, char **argv)
459
503
{
460
504
    GlobalDataRec   globals;
461
505
    GlobalDataPtr   g = &globals;
462
506
    XtAppContext    appContext;
463
507
    char           *audioServer = NULL;
 
508
    int             i;
 
509
    AuDeviceID      initialDevice = AuNone;
 
510
    char           *initialDeviceName = NULL;
464
511
 
465
512
    g->top = XtVaAppInitialize(&appContext, APP_CLASS, NULL, ZERO,
466
513
                               &argc, argv, defaultResources, NULL, 0);
467
514
 
468
 
    if (argc == 3)
469
 
        if (!strncmp(argv[1], "-a", 2))
470
 
            audioServer = argv[2];
471
 
        else
472
 
            fatalError(USAGE);
473
 
    else if (argc != 1)
474
 
        fatalError(USAGE);
 
515
    g->queryInterval = DEFAULT_QUERY_INTERVAL;
 
516
 
 
517
    for (i = 1; i < argc; i++) {
 
518
        if (!strncmp(argv[i], "-a", 2)) {
 
519
            audioServer = argv[++i];
 
520
        } else if (!strncmp(argv[i], "-dev", 4)) {
 
521
            initialDeviceName = argv[++i];
 
522
            initialDevice = parse_device_id(initialDeviceName);
 
523
        } else if (!strncmp(argv[i], "-in", 3)) {
 
524
            int tmp = atoi(argv[++i]);
 
525
            if (tmp >= 0) {
 
526
                g->queryInterval = tmp * 1000;
 
527
            }
 
528
        } else {
 
529
            fatalError(USAGE, NULL);
 
530
        }
 
531
    }
475
532
 
476
533
    if (!(g->aud = AuOpenServer(audioServer, 0, NULL, 0, NULL, NULL)))
477
 
        fatalError("Can't connect to audio server");
 
534
        fatalError("Can't connect to audio server", NULL);
478
535
 
479
536
    if(!(g->restoreValues = calloc(AuServerNumDevices(g->aud), sizeof(int))))
480
 
        fatalError("Out of memory");
 
537
        fatalError("Out of memory", NULL);
481
538
 
482
539
    createWidgets(g);
483
540
    XtRealizeWidget(g->top);
486
543
    AuXtAppAddAudioHandler(appContext, g->aud);
487
544
 
488
545
    g->deviceNum = 0;
 
546
 
 
547
    if (initialDevice != AuNone) {
 
548
        set_device_by_id(g, initialDevice);
 
549
    } else if (initialDeviceName) {
 
550
        if (is_decimal_number(initialDeviceName)) {
 
551
            g->deviceNum = atoi(initialDeviceName);
 
552
            if (g->deviceNum >= g->numDevices) {
 
553
                fprintf(stderr, "cannot activate device %d, there are only %d"
 
554
                                " devices (0 to %d)\n",
 
555
                                g->deviceNum, g->numDevices, g->numDevices - 1);
 
556
                g->deviceNum = 0;
 
557
            }
 
558
        } else {
 
559
            set_device_by_name(g, initialDeviceName);
 
560
        }
 
561
    }
 
562
 
489
563
    showDevice(g);
490
564
 
 
565
    g->queryTimerID = XtAppAddTimeOut(appContext, g->queryInterval,
 
566
                                      timedQueryCB , g);
 
567
 
491
568
    XtAppMainLoop(appContext);
492
569
 
493
570
    free(g->restoreValues);