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