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