update features5.pdf, fix intl titlebars, add sams icons
[goodguy/history.git] / cinelerra-5.1 / cinelerra / adeviceprefs.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "adeviceprefs.h"
23 #include "audioalsa.h"
24 #include "audiodevice.inc"
25 #include "bitspopup.h"
26 #include "edl.h"
27 #include "language.h"
28 #include "playbackconfig.h"
29 #include "preferences.h"
30 #include "preferencesthread.h"
31 #include "recordconfig.h"
32 #include <string.h>
33
34 #define DEVICE_H 50
35
36 ADevicePrefs::ADevicePrefs(int x, int y, PreferencesWindow *pwindow, PreferencesDialog *dialog,
37         AudioOutConfig *out_config, AudioInConfig *in_config, int mode)
38 {
39         reset();
40         this->pwindow = pwindow;
41         this->dialog = dialog;
42         this->driver = -1;
43         this->mode = mode;
44         this->out_config = out_config;
45         this->in_config = in_config;
46         this->x = x;
47         this->y = y;
48 }
49
50 ADevicePrefs::~ADevicePrefs()
51 {
52         delete_objects();
53         if(menu) delete menu;
54 }
55
56 void ADevicePrefs::reset()
57 {
58         menu = 0;
59         follow_audio_config = 0;
60         firewire_path = 0;
61         firewire_syt = 0;
62         syt_title = 0;
63         path_title = 0;
64
65         alsa_drivers = 0;
66         path_title = 0;
67         bits_title = 0;
68         alsa_device = 0;
69         alsa_workaround = 0;
70
71         alsa_bits = 0;
72         oss_bits = 0;
73         dvb_bits = 0;
74         v4l2_bits = 0;
75
76         for(int i = 0; i < MAXDEVICES; i++)
77                 oss_path[i] = 0;
78
79         dvb_adapter_title = 0;
80         dvb_adapter_path = 0;
81         dvb_device_title = 0;
82         dvb_adapter_device = 0;
83
84         cine_bits = 0;
85         cine_path = 0;
86 }
87
88 int ADevicePrefs::initialize(int creation)
89 {
90         int *driver = 0;
91         delete_objects();
92
93         switch(mode) {
94         case MODEPLAY:
95                 driver = &out_config->driver;
96                 break;
97         case MODERECORD:
98                 driver = &in_config->driver;
99                 break;
100         case MODEDUPLEX:
101                 driver = &out_config->driver;
102                 break;
103         }
104         this->driver = *driver;
105
106         if(!menu) {
107                 dialog->add_subwindow(menu = new ADriverMenu(x,
108                         y + 10,
109                         this,
110                         (mode == MODERECORD),
111                         driver));
112                 menu->create_objects();
113         }
114
115         switch(*driver) {
116         case AUDIO_OSS:
117         case AUDIO_OSS_ENVY24:
118                 create_oss_objs();
119                 break;
120         case AUDIO_ALSA:
121                 create_alsa_objs();
122                 break;
123         case AUDIO_ESOUND:
124                 create_esound_objs();
125                 break;
126         case AUDIO_1394:
127         case AUDIO_DV1394:
128         case AUDIO_IEC61883:
129                 create_firewire_objs();
130                 break;
131         case AUDIO_DVB:
132                 create_dvb_objs();
133                 break;
134         case AUDIO_V4L2MPEG:
135                 create_v4l2mpeg_objs();
136                 break;
137         }
138
139         return 0;
140 }
141
142 int ADevicePrefs::get_h(int recording)
143 {
144         return !recording ? DEVICE_H + 30 : DEVICE_H;
145 }
146
147 int ADevicePrefs::delete_objects()
148 {
149         switch(driver) {
150         case AUDIO_OSS:
151         case AUDIO_OSS_ENVY24:
152                 delete_oss_objs();
153                 break;
154         case AUDIO_ALSA:
155                 delete_alsa_objs();
156                 break;
157         case AUDIO_ESOUND:
158                         delete_esound_objs();
159                 break;
160         case AUDIO_1394:
161         case AUDIO_DV1394:
162         case AUDIO_IEC61883:
163                 delete_firewire_objs();
164                 break;
165         case AUDIO_DVB:
166                 delete_dvb_objs();
167                 break;
168         case AUDIO_V4L2MPEG:
169                 delete_v4l2mpeg_objs();
170                 break;
171         }
172
173         delete cine_bits;
174         delete cine_path;
175
176         reset();
177         driver = -1;
178         return 0;
179 }
180
181 int ADevicePrefs::delete_oss_objs()
182 {
183         delete path_title;
184         delete bits_title;
185         delete oss_bits;
186
187         if(oss_path)
188         {
189                 for(int i = 0; i < MAXDEVICES; i++)
190                 {
191                         delete oss_path[i];
192                         break;
193                 }
194         }
195         return 0;
196 }
197
198 int ADevicePrefs::delete_esound_objs()
199 {
200         delete server_title;
201         delete port_title;
202         delete esound_server;
203         delete esound_port;
204         return 0;
205 }
206
207 int ADevicePrefs::delete_firewire_objs()
208 {
209         delete port_title;
210         delete channel_title;
211         delete firewire_port;
212         delete firewire_channel;
213         if(firewire_path)
214         {
215                 delete path_title;
216                 delete firewire_path;
217         }
218         firewire_path = 0;
219         if(firewire_syt)
220         {
221                 delete firewire_syt;
222                 delete syt_title;
223         }
224         firewire_syt = 0;
225         return 0;
226 }
227
228 int ADevicePrefs::delete_alsa_objs()
229 {
230 #ifdef HAVE_ALSA
231         if(alsa_drivers) alsa_drivers->remove_all_objects();
232         delete alsa_drivers;
233         delete path_title;
234         delete bits_title;
235         delete alsa_device;
236         delete alsa_bits;
237         delete alsa_workaround;
238 #endif
239         return 0;
240 }
241
242 int ADevicePrefs::delete_dvb_objs()
243 {
244         delete dvb_adapter_title;
245         delete dvb_adapter_path;
246         delete dvb_device_title;
247         delete dvb_adapter_device;
248         delete dvb_bits;
249         delete follow_audio_config;
250         return 0;
251 }
252
253 int ADevicePrefs::delete_v4l2mpeg_objs()
254 {
255         delete follow_audio_config;
256         delete v4l2_bits;
257         return 0;
258 }
259
260 int ADevicePrefs::create_oss_objs()
261 {
262         char *output_char = 0;
263         int *output_int = 0;
264         int y1 = y;
265         BC_Resources *resources = BC_WindowBase::get_resources();
266
267         for(int i = 0; i < MAXDEVICES; i++) {
268                 int x1 = x + menu->get_w() + 5;
269 #if 0
270                 switch(mode) {
271                 case MODEPLAY:
272                         output_int = &out_config->oss_enable[i];
273                         break;
274                 case MODERECORD:
275                         output_int = &in_config->oss_enable[i];
276                         break;
277                 case MODEDUPLEX:
278                         output_int = &out_config->oss_enable[i];
279                         break;
280                 }
281                 dialog->add_subwindow(oss_enable[i] = new OSSEnable(x1, y1 + 20, output_int));
282                 x1 += oss_enable[i]->get_w() + 5;
283 #endif
284                 switch(mode) {
285                 case MODEPLAY:
286                         output_char = out_config->oss_out_device[i];
287                         break;
288                 case MODERECORD:
289                         output_char = in_config->oss_in_device[i];
290                         break;
291                 case MODEDUPLEX:
292                         output_char = out_config->oss_out_device[i];
293                         break;
294                 }
295
296                 if(i == 0) {
297                         path_title = new BC_Title(x1, y, _("Device path:"),
298                                 MEDIUMFONT, resources->text_default);
299                         dialog->add_subwindow(path_title);
300                 }
301
302                 oss_path[i] = new ADeviceTextBox(x1, y1 + 20, output_char);
303                 dialog->add_subwindow(oss_path[i]);
304
305                 x1 += oss_path[i]->get_w() + 5;
306                 if(i == 0) {
307                         switch(mode) {
308                         case MODEPLAY:
309                                 output_int = &out_config->oss_out_bits;
310                                 break;
311                         case MODERECORD:
312                                 output_int = &in_config->oss_in_bits;
313                                 break;
314                         case MODEDUPLEX:
315                                 output_int = &out_config->oss_out_bits;
316                                 break;
317                         }
318                         bits_title = new BC_Title(x1, y, _("Bits:"),
319                                         MEDIUMFONT, resources->text_default);
320                         dialog->add_subwindow(bits_title);
321                         oss_bits = new BitsPopup(dialog, x1, y1 + 20, output_int,
322                                 0, 0, 0, 0, 1);
323                         oss_bits->create_objects();
324                 }
325
326                 x1 += oss_bits->get_w() + 5;
327                 y1 += DEVICE_H;
328 break;  // apparently, 'i' must be zero
329         }
330
331         return 0;
332 }
333
334 int ADevicePrefs::create_alsa_objs()
335 {
336 #ifdef HAVE_ALSA
337         char *output_char = 0;
338         int *output_int = 0;
339         int y1 = y;
340         BC_Resources *resources = BC_WindowBase::get_resources();
341
342         int x1 = x + menu->get_w() + 5;
343
344         ArrayList<char*> *alsa_titles = new ArrayList<char*>;
345         alsa_titles->set_array_delete();
346         AudioALSA::list_devices(alsa_titles, 0, mode);
347
348
349         alsa_drivers = new ArrayList<BC_ListBoxItem*>;
350         for(int i = 0; i < alsa_titles->total; i++)
351                 alsa_drivers->append(new BC_ListBoxItem(alsa_titles->values[i]));
352         alsa_titles->remove_all_objects();
353         delete alsa_titles;
354
355         switch(mode) {
356         case MODEPLAY:
357                 output_char = out_config->alsa_out_device;
358                 break;
359         case MODERECORD:
360                 output_char = in_config->alsa_in_device;
361                 break;
362         case MODEDUPLEX:
363                 output_char = out_config->alsa_out_device;
364                 break;
365         }
366         path_title = new BC_Title(x1, y, _("Device:"),
367                         MEDIUMFONT, resources->text_default);
368         dialog->add_subwindow(path_title);
369         alsa_device = new ALSADevice(dialog, x1, y1 + 20, output_char, alsa_drivers);
370         alsa_device->create_objects();
371         int x2 = x1;
372
373         x1 += alsa_device->get_w() + 5;
374         switch(mode) {
375         case MODEPLAY:
376                 output_int = &out_config->alsa_out_bits;
377                 break;
378         case MODERECORD:
379                 output_int = &in_config->alsa_in_bits;
380                 break;
381         case MODEDUPLEX:
382                 output_int = &out_config->alsa_out_bits;
383                 break;
384         }
385         bits_title = new BC_Title(x1, y, _("Bits:"),
386                         MEDIUMFONT, resources->text_default);
387         dialog->add_subwindow(bits_title);
388         alsa_bits = new BitsPopup(dialog, x1, y1 + 20, output_int, 0, 0, 0, 0, 1);
389         alsa_bits->create_objects();
390
391         y1 += alsa_bits->get_h() + 20 + 5;
392         x1 = x2;
393
394         if(mode == MODEPLAY) {
395                 alsa_workaround = new BC_CheckBox(x1, y1,
396                                 &out_config->interrupt_workaround,
397                                 _("Stop playback locks up."));
398                 dialog->add_subwindow(alsa_workaround);
399         }
400
401 #endif
402
403         return 0;
404 }
405
406 int ADevicePrefs::create_esound_objs()
407 {
408         int x1 = x + menu->get_w() + 5;
409         char *output_char = 0;
410         int *output_int = 0;
411         BC_Resources *resources = BC_WindowBase::get_resources();
412
413         switch(mode) {
414         case MODEPLAY:
415                 output_char = out_config->esound_out_server;
416                 break;
417         case MODERECORD:
418                 output_char = in_config->esound_in_server;
419                 break;
420         case MODEDUPLEX:
421                 output_char = out_config->esound_out_server;
422                 break;
423         }
424         server_title = new BC_Title(x1, y, _("Server:"),
425                         MEDIUMFONT, resources->text_default);
426         dialog->add_subwindow(server_title);
427         esound_server = new ADeviceTextBox(x1, y + 20, output_char);
428         dialog->add_subwindow(esound_server);
429
430         switch(mode) {
431         case MODEPLAY:
432                 output_int = &out_config->esound_out_port;
433                 break;
434         case MODERECORD:
435                 output_int = &in_config->esound_in_port;
436                 break;
437         case MODEDUPLEX:
438                 output_int = &out_config->esound_out_port;
439                 break;
440         }
441         x1 += esound_server->get_w() + 5;
442         port_title = new BC_Title(x1, y, _("Port:"),
443                         MEDIUMFONT, resources->text_default);
444         dialog->add_subwindow(port_title);
445         esound_port = new ADeviceIntBox(x1, y + 20, output_int);
446         dialog->add_subwindow(esound_port);
447         return 0;
448 }
449
450 int ADevicePrefs::create_firewire_objs()
451 {
452         int x1 = x + menu->get_w() + 5;
453         int *output_int = 0;
454         char *output_char = 0;
455         BC_Resources *resources = BC_WindowBase::get_resources();
456
457 // Firewire path
458         switch(mode) {
459         case MODEPLAY:
460                 if(driver == AUDIO_DV1394)
461                         output_char = out_config->dv1394_path;
462                 else
463                 if(driver == AUDIO_1394)
464                         output_char = out_config->firewire_path;
465                 break;
466         case MODERECORD:
467                 if(driver == AUDIO_DV1394 || driver == AUDIO_1394)
468                         output_char = in_config->firewire_path;
469                 break;
470         }
471
472         if(output_char) {
473                 dialog->add_subwindow(path_title = new BC_Title(x1, y, _("Device Path:"), MEDIUMFONT, resources->text_default));
474                 dialog->add_subwindow(firewire_path = new ADeviceTextBox(x1, y + 20, output_char));
475                 x1 += firewire_path->get_w() + 5;
476         }
477
478 // Firewire port
479         switch(mode) {
480         case MODEPLAY:
481                 if(driver == AUDIO_DV1394)
482                         output_int = &out_config->dv1394_port;
483                 else
484                         output_int = &out_config->firewire_port;
485                 break;
486         case MODERECORD:
487                 output_int = &in_config->firewire_port;
488                 break;
489         case MODEDUPLEX:
490 //              output_int = &out_config->afirewire_out_port;
491                 break;
492         }
493         port_title = new BC_Title(x1, y, _("Port:"),
494                         MEDIUMFONT, resources->text_default);
495         dialog->add_subwindow(port_title);
496         firewire_port = new ADeviceIntBox(x1, y + 20, output_int);
497         dialog->add_subwindow(firewire_port);
498
499         x1 += firewire_port->get_w() + 5;
500
501 // Firewire channel
502         switch(mode) {
503         case MODEPLAY:
504                 if(driver == AUDIO_DV1394)
505                         output_int = &out_config->dv1394_channel;
506                 else
507                         output_int = &out_config->firewire_channel;
508                 break;
509         case MODERECORD:
510                 output_int = &in_config->firewire_channel;
511                 break;
512         }
513         channel_title = new BC_Title(x1, y, _("Channel:"),
514                         MEDIUMFONT, resources->text_default);
515         dialog->add_subwindow(channel_title);
516         firewire_channel = new ADeviceIntBox(x1, y + 20, output_int);
517         dialog->add_subwindow(firewire_channel);
518         x1 += firewire_channel->get_w() + 5;
519
520 // Syt offset
521         switch(mode) {
522         case MODEPLAY:
523                 if(driver == AUDIO_DV1394)
524                         output_int = &out_config->dv1394_syt;
525                 else
526                 if(driver == AUDIO_1394)
527                         output_int = &out_config->firewire_syt;
528                 else
529                         output_int = 0;
530                 break;
531         case MODERECORD:
532                 output_int = 0;
533                 break;
534         }
535
536         if(output_int) {
537                 syt_title = new BC_Title(x1, y, _("Syt Offset:"),
538                                 MEDIUMFONT, resources->text_default);
539                 dialog->add_subwindow(syt_title);
540                 firewire_syt = new ADeviceIntBox(x1, y + 20, output_int);
541                 dialog->add_subwindow(firewire_syt);
542                 x1 += firewire_syt->get_w() + 5;
543         }
544
545         return 0;
546 }
547
548
549
550 int ADevicePrefs::create_dvb_objs()
551 {
552         int x1 = x + menu->get_w() + 30;
553         int y1 = y + 10;
554         char *output_char = in_config->dvb_in_adapter;
555         int y2 = y1 - BC_Title::calculate_h(dialog, _("DVB Adapter:"), MEDIUMFONT) - 5;
556         BC_Resources *resources = BC_WindowBase::get_resources();
557         dvb_adapter_title = new BC_Title(x1, y2, _("DVB Adapter:"),
558                         MEDIUMFONT, resources->text_default);
559         dialog->add_subwindow(dvb_adapter_title);
560         dvb_adapter_path = new ADeviceTextBox(x1, y1, output_char);
561         dialog->add_subwindow(dvb_adapter_path);
562         int x2 = x1 + dvb_adapter_path->get_w() + 5;
563         dvb_device_title = new BC_Title(x2, y2, _("dev:"),
564                         MEDIUMFONT, resources->text_default);
565         dialog->add_subwindow(dvb_device_title);
566         int *output_int = &in_config->dvb_in_device;
567         dvb_adapter_device = new ADeviceTumbleBox(this, x2, y1, output_int, 0, 9, 20);
568         dvb_adapter_device->create_objects();
569         x2 += dvb_device_title->get_w() + 30;
570         bits_title = new BC_Title(x2, y2, _("Bits:"),
571                         MEDIUMFONT, resources->text_default);
572         dialog->add_subwindow(bits_title);
573         output_int = &in_config->dvb_in_bits;
574         dvb_bits = new BitsPopup(dialog, x2, y1, output_int, 0, 0, 0, 0, 1);
575         dvb_bits->create_objects();
576         x1 += 100;  y1 += dvb_adapter_path->get_h() + 5;
577         output_int =  &in_config->follow_audio;
578         follow_audio_config = new BC_CheckBox(x1, y1, output_int, _("Follow audio config"));
579         dialog->add_subwindow(follow_audio_config);
580         return 0;
581 }
582
583 int ADevicePrefs::create_v4l2mpeg_objs()
584 {
585         int x1 = x + menu->get_w() + 30;
586         int y1 = y + 10;
587         int y2 = y1 - BC_Title::calculate_h(dialog, _("Bits:"), MEDIUMFONT) - 5;
588         BC_Resources *resources = BC_WindowBase::get_resources();
589         bits_title = new BC_Title(x1, y2, _("Bits:"),
590                         MEDIUMFONT, resources->text_default);
591         dialog->add_subwindow(bits_title);
592         int *output_int = &in_config->v4l2_in_bits;
593         v4l2_bits = new BitsPopup(dialog, x1, y1, output_int, 0, 0, 0, 0, 1);
594         v4l2_bits->create_objects();
595         x1 += v4l2_bits->get_w() + 10;
596         follow_audio_config = new BC_CheckBox(x1, y1,
597                         &in_config->follow_audio, _("Follow audio config"));
598         dialog->add_subwindow(follow_audio_config);
599         return 0;
600 }
601
602
603 ADriverMenu::ADriverMenu(int x, int y, ADevicePrefs *device_prefs,
604         int do_input, int *output)
605  : BC_PopupMenu(x, y, 125, adriver_to_string(*output), 1)
606 {
607         this->output = output;
608         this->do_input = do_input;
609         this->device_prefs = device_prefs;
610 }
611
612 ADriverMenu::~ADriverMenu()
613 {
614 }
615
616 void ADriverMenu::create_objects()
617 {
618 #ifdef HAVE_OSS
619         add_item(new ADriverItem(this, AUDIO_OSS_TITLE, AUDIO_OSS));
620         add_item(new ADriverItem(this, AUDIO_OSS_ENVY24_TITLE, AUDIO_OSS_ENVY24));
621 #endif
622
623 #ifdef HAVE_ALSA
624         add_item(new ADriverItem(this, AUDIO_ALSA_TITLE, AUDIO_ALSA));
625 #endif
626
627 #ifdef HAVE_ESOUND
628         if(!do_input) add_item(new ADriverItem(this, AUDIO_ESOUND_TITLE, AUDIO_ESOUND));
629 #endif
630
631 #ifdef HAVE_FIREWIRE
632         if(!do_input) add_item(new ADriverItem(this, AUDIO_1394_TITLE, AUDIO_1394));
633         add_item(new ADriverItem(this, AUDIO_DV1394_TITLE, AUDIO_DV1394));
634         add_item(new ADriverItem(this, AUDIO_IEC61883_TITLE, AUDIO_IEC61883));
635 #endif
636
637 #ifdef HAVE_DVB
638         if(do_input) add_item(new ADriverItem(this, AUDIO_DVB_TITLE, AUDIO_DVB));
639 #endif
640
641 #ifdef HAVE_VIDEO4LINUX2
642         if(do_input) add_item(new ADriverItem(this, AUDIO_V4L2MPEG_TITLE, AUDIO_V4L2MPEG));
643 #endif
644 }
645
646 char* ADriverMenu::adriver_to_string(int driver)
647 {
648         switch(driver) {
649         case AUDIO_OSS:
650                 sprintf(string, AUDIO_OSS_TITLE);
651                 break;
652         case AUDIO_OSS_ENVY24:
653                 sprintf(string, AUDIO_OSS_ENVY24_TITLE);
654                 break;
655         case AUDIO_ESOUND:
656                 sprintf(string, AUDIO_ESOUND_TITLE);
657                 break;
658         case AUDIO_NAS:
659                 sprintf(string, AUDIO_NAS_TITLE);
660                 break;
661         case AUDIO_ALSA:
662                 sprintf(string, AUDIO_ALSA_TITLE);
663                 break;
664 #ifdef HAVE_FIREWIRE
665         case AUDIO_1394:
666                 sprintf(string, AUDIO_1394_TITLE);
667                 break;
668         case AUDIO_DV1394:
669                 sprintf(string, AUDIO_DV1394_TITLE);
670                 break;
671         case AUDIO_IEC61883:
672                 sprintf(string, AUDIO_IEC61883_TITLE);
673                 break;
674 #endif
675         case AUDIO_DVB:
676                 sprintf(string, AUDIO_DVB_TITLE);
677                 break;
678         case AUDIO_V4L2MPEG:
679                 sprintf(string, AUDIO_V4L2MPEG_TITLE);
680                 break;
681         }
682         return string;
683 }
684
685 ADriverItem::ADriverItem(ADriverMenu *popup, const char *text, int driver)
686  : BC_MenuItem(text)
687 {
688         this->popup = popup;
689         this->driver = driver;
690 }
691
692 ADriverItem::~ADriverItem()
693 {
694 }
695
696 int ADriverItem::handle_event()
697 {
698         popup->set_text(get_text());
699         *(popup->output) = driver;
700         popup->device_prefs->initialize(0);
701         popup->device_prefs->pwindow->show_dialog();
702         return 1;
703 }
704
705
706
707
708 OSSEnable::OSSEnable(int x, int y, int *output)
709  : BC_CheckBox(x, y, *output)
710 {
711         this->output = output;
712 }
713 int OSSEnable::handle_event()
714 {
715         *output = get_value();
716         return 1;
717 }
718
719
720
721
722 ADeviceTextBox::ADeviceTextBox(int x, int y, char *output)
723  : BC_TextBox(x, y, 150, 1, output)
724 {
725         this->output = output;
726 }
727
728 int ADeviceTextBox::handle_event()
729 {
730         strcpy(output, get_text());
731         return 1;
732 }
733
734 ADeviceIntBox::ADeviceIntBox(int x, int y, int *output)
735  : BC_TextBox(x, y, 80, 1, *output)
736 {
737         this->output = output;
738 }
739
740 int ADeviceIntBox::handle_event()
741 {
742         *output = atol(get_text());
743         return 1;
744 }
745
746
747
748 ADeviceTumbleBox::ADeviceTumbleBox(ADevicePrefs *prefs,
749         int x, int y, int *output, int min, int max, int text_w)
750  : BC_TumbleTextBox(prefs->dialog, *output, min, max, x, y, text_w)
751 {
752         this->output = output;
753 }
754
755 int ADeviceTumbleBox::handle_event()
756 {
757         *output = atol(get_text());
758         return 1;
759 }
760
761
762
763 ALSADevice::ALSADevice(PreferencesDialog *dialog,
764         int x,
765         int y,
766         char *output,
767         ArrayList<BC_ListBoxItem*> *devices)
768  : BC_PopupTextBox(dialog, devices, output, x, y, 200, 200)
769 {
770         this->output = output;
771 }
772
773 ALSADevice::~ALSADevice()
774 {
775 }
776
777 int ALSADevice::handle_event()
778 {
779         strcpy(output, get_text());
780         return 1;
781 }
782