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