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         AudioALSA::list_devices(alsa_titles, 0, mode);
 346
 347
 348         alsa_drivers = new ArrayList<BC_ListBoxItem*>;
 349         for(int i = 0; i < alsa_titles->total; i++)
 350                 alsa_drivers->append(new BC_ListBoxItem(alsa_titles->values[i]));
 351         alsa_titles->remove_all_objects();
 352         delete alsa_titles;
 353
 354         switch(mode) {
 355         case MODEPLAY:
 356                 output_char = out_config->alsa_out_device;
 357                 break;
 358         case MODERECORD:
 359                 output_char = in_config->alsa_in_device;
 360                 break;
 361         case MODEDUPLEX:
 362                 output_char = out_config->alsa_out_device;
 363                 break;
 364         }
 365         path_title = new BC_Title(x1, y, _("Device:"),
 366                         MEDIUMFONT, resources->text_default);
 367         dialog->add_subwindow(path_title);
 368         alsa_device = new ALSADevice(dialog, x1, y1 + 20, output_char, alsa_drivers);
 369         alsa_device->create_objects();
 370         int x2 = x1;
 371
 372         x1 += alsa_device->get_w() + 5;
 373         switch(mode) {
 374         case MODEPLAY:
 375                 output_int = &out_config->alsa_out_bits;
 376                 break;
 377         case MODERECORD:
 378                 output_int = &in_config->alsa_in_bits;
 379                 break;
 380         case MODEDUPLEX:
 381                 output_int = &out_config->alsa_out_bits;
 382                 break;
 383         }
 384         bits_title = new BC_Title(x1, y, _("Bits:"),
 385                         MEDIUMFONT, resources->text_default);
 386         dialog->add_subwindow(bits_title);
 387         alsa_bits = new BitsPopup(dialog, x1, y1 + 20, output_int, 0, 0, 0, 0, 1);
 388         alsa_bits->create_objects();
 389
 390         y1 += alsa_bits->get_h() + 20 + 5;
 391         x1 = x2;
 392
 393         if(mode == MODEPLAY) {
 394                 alsa_workaround = new BC_CheckBox(x1, y1,
 395                                 &out_config->interrupt_workaround,
 396                                 _("Stop playback locks up."));
 397                 dialog->add_subwindow(alsa_workaround);
 398         }
 399
 400 #endif
 401
 402         return 0;
 403 }
 404
 405 int ADevicePrefs::create_esound_objs()
 406 {
 407         int x1 = x + menu->get_w() + 5;
 408         char *output_char = 0;
 409         int *output_int = 0;
 410         BC_Resources *resources = BC_WindowBase::get_resources();
 411
 412         switch(mode) {
 413         case MODEPLAY:
 414                 output_char = out_config->esound_out_server;
 415                 break;
 416         case MODERECORD:
 417                 output_char = in_config->esound_in_server;
 418                 break;
 419         case MODEDUPLEX:
 420                 output_char = out_config->esound_out_server;
 421                 break;
 422         }
 423         server_title = new BC_Title(x1, y, _("Server:"),
 424                         MEDIUMFONT, resources->text_default);
 425         dialog->add_subwindow(server_title);
 426         esound_server = new ADeviceTextBox(x1, y + 20, output_char);
 427         dialog->add_subwindow(esound_server);
 428
 429         switch(mode) {
 430         case MODEPLAY:
 431                 output_int = &out_config->esound_out_port;
 432                 break;
 433         case MODERECORD:
 434                 output_int = &in_config->esound_in_port;
 435                 break;
 436         case MODEDUPLEX:
 437                 output_int = &out_config->esound_out_port;
 438                 break;
 439         }
 440         x1 += esound_server->get_w() + 5;
 441         port_title = new BC_Title(x1, y, _("Port:"),
 442                         MEDIUMFONT, resources->text_default);
 443         dialog->add_subwindow(port_title);
 444         esound_port = new ADeviceIntBox(x1, y + 20, output_int);
 445         dialog->add_subwindow(esound_port);
 446         return 0;
 447 }
 448
 449 int ADevicePrefs::create_firewire_objs()
 450 {
 451         int x1 = x + menu->get_w() + 5;
 452         int *output_int = 0;
 453         char *output_char = 0;
 454         BC_Resources *resources = BC_WindowBase::get_resources();
 455
 456 // Firewire path
 457         switch(mode) {
 458         case MODEPLAY:
 459                 if(driver == AUDIO_DV1394)
 460                         output_char = out_config->dv1394_path;
 461                 else
 462                 if(driver == AUDIO_1394)
 463                         output_char = out_config->firewire_path;
 464                 break;
 465         case MODERECORD:
 466                 if(driver == AUDIO_DV1394 || driver == AUDIO_1394)
 467                         output_char = in_config->firewire_path;
 468                 break;
 469         }
 470
 471         if(output_char) {
 472                 dialog->add_subwindow(path_title = new BC_Title(x1, y, _("Device Path:"), MEDIUMFONT, resources->text_default));
 473                 dialog->add_subwindow(firewire_path = new ADeviceTextBox(x1, y + 20, output_char));
 474                 x1 += firewire_path->get_w() + 5;
 475         }
 476
 477 // Firewire port
 478         switch(mode) {
 479         case MODEPLAY:
 480                 if(driver == AUDIO_DV1394)
 481                         output_int = &out_config->dv1394_port;
 482                 else
 483                         output_int = &out_config->firewire_port;
 484                 break;
 485         case MODERECORD:
 486                 output_int = &in_config->firewire_port;
 487                 break;
 488         case MODEDUPLEX:
 489 //              output_int = &out_config->afirewire_out_port;
 490                 break;
 491         }
 492         port_title = new BC_Title(x1, y, _("Port:"),
 493                         MEDIUMFONT, resources->text_default);
 494         dialog->add_subwindow(port_title);
 495         firewire_port = new ADeviceIntBox(x1, y + 20, output_int);
 496         dialog->add_subwindow(firewire_port);
 497
 498         x1 += firewire_port->get_w() + 5;
 499
 500 // Firewire channel
 501         switch(mode) {
 502         case MODEPLAY:
 503                 if(driver == AUDIO_DV1394)
 504                         output_int = &out_config->dv1394_channel;
 505                 else
 506                         output_int = &out_config->firewire_channel;
 507                 break;
 508         case MODERECORD:
 509                 output_int = &in_config->firewire_channel;
 510                 break;
 511         }
 512         channel_title = new BC_Title(x1, y, _("Channel:"),
 513                         MEDIUMFONT, resources->text_default);
 514         dialog->add_subwindow(channel_title);
 515         firewire_channel = new ADeviceIntBox(x1, y + 20, output_int);
 516         dialog->add_subwindow(firewire_channel);
 517         x1 += firewire_channel->get_w() + 5;
 518
 519 // Syt offset
 520         switch(mode) {
 521         case MODEPLAY:
 522                 if(driver == AUDIO_DV1394)
 523                         output_int = &out_config->dv1394_syt;
 524                 else
 525                 if(driver == AUDIO_1394)
 526                         output_int = &out_config->firewire_syt;
 527                 else
 528                         output_int = 0;
 529                 break;
 530         case MODERECORD:
 531                 output_int = 0;
 532                 break;
 533         }
 534
 535         if(output_int) {
 536                 syt_title = new BC_Title(x1, y, _("Syt Offset:"),
 537                                 MEDIUMFONT, resources->text_default);
 538                 dialog->add_subwindow(syt_title);
 539                 firewire_syt = new ADeviceIntBox(x1, y + 20, output_int);
 540                 dialog->add_subwindow(firewire_syt);
 541                 x1 += firewire_syt->get_w() + 5;
 542         }
 543
 544         return 0;
 545 }
 546
 547
 548
 549 int ADevicePrefs::create_dvb_objs()
 550 {
 551         int x1 = x + menu->get_w() + 30;
 552         int y1 = y + 10;
 553         char *output_char = in_config->dvb_in_adapter;
 554         int y2 = y1 - BC_Title::calculate_h(dialog, _("DVB Adapter:"), MEDIUMFONT) - 5;
 555         BC_Resources *resources = BC_WindowBase::get_resources();
 556         dvb_adapter_title = new BC_Title(x1, y2, _("DVB Adapter:"),
 557                         MEDIUMFONT, resources->text_default);
 558         dialog->add_subwindow(dvb_adapter_title);
 559         dvb_adapter_path = new ADeviceTextBox(x1, y1, output_char);
 560         dialog->add_subwindow(dvb_adapter_path);
 561         int x2 = x1 + dvb_adapter_path->get_w() + 5;
 562         dvb_device_title = new BC_Title(x2, y2, _("dev:"),
 563                         MEDIUMFONT, resources->text_default);
 564         dialog->add_subwindow(dvb_device_title);
 565         int *output_int = &in_config->dvb_in_device;
 566         dvb_adapter_device = new ADeviceTumbleBox(this, x2, y1, output_int, 0, 9, 20);
 567         dvb_adapter_device->create_objects();
 568         x2 += dvb_device_title->get_w() + 30;
 569         bits_title = new BC_Title(x2, y2, _("Bits:"),
 570                         MEDIUMFONT, resources->text_default);
 571         dialog->add_subwindow(bits_title);
 572         output_int = &in_config->dvb_in_bits;
 573         dvb_bits = new BitsPopup(dialog, x2, y1, output_int, 0, 0, 0, 0, 1);
 574         dvb_bits->create_objects();
 575         x1 += 100;  y1 += dvb_adapter_path->get_h() + 5;
 576         output_int =  &in_config->follow_audio;
 577         follow_audio_config = new BC_CheckBox(x1, y1, output_int, _("Follow audio config"));
 578         dialog->add_subwindow(follow_audio_config);
 579         return 0;
 580 }
 581
 582 int ADevicePrefs::create_v4l2mpeg_objs()
 583 {
 584         int x1 = x + menu->get_w() + 30;
 585         int y1 = y + 10;
 586         int y2 = y1 - BC_Title::calculate_h(dialog, _("Bits:"), MEDIUMFONT) - 5;
 587         BC_Resources *resources = BC_WindowBase::get_resources();
 588         bits_title = new BC_Title(x1, y2, _("Bits:"),
 589                         MEDIUMFONT, resources->text_default);
 590         dialog->add_subwindow(bits_title);
 591         int *output_int = &in_config->v4l2_in_bits;
 592         v4l2_bits = new BitsPopup(dialog, x1, y1, output_int, 0, 0, 0, 0, 1);
 593         v4l2_bits->create_objects();
 594         x1 += v4l2_bits->get_w() + 10;
 595         follow_audio_config = new BC_CheckBox(x1, y1,
 596                         &in_config->follow_audio, _("Follow audio config"));
 597         dialog->add_subwindow(follow_audio_config);
 598         return 0;
 599 }
 600
 601
 602 ADriverMenu::ADriverMenu(int x, int y, ADevicePrefs *device_prefs,
 603         int do_input, int *output)
 604  : BC_PopupMenu(x, y, 125, adriver_to_string(*output), 1)
 605 {
 606         this->output = output;
 607         this->do_input = do_input;
 608         this->device_prefs = device_prefs;
 609 }
 610
 611 ADriverMenu::~ADriverMenu()
 612 {
 613 }
 614
 615 void ADriverMenu::create_objects()
 616 {
 617         add_item(new ADriverItem(this, AUDIO_OSS_TITLE, AUDIO_OSS));
 618         add_item(new ADriverItem(this, AUDIO_OSS_ENVY24_TITLE, AUDIO_OSS_ENVY24));
 619
 620 #ifdef HAVE_ALSA
 621         add_item(new ADriverItem(this, AUDIO_ALSA_TITLE, AUDIO_ALSA));
 622 #endif
 623
 624         if(!do_input) add_item(new ADriverItem(this, AUDIO_ESOUND_TITLE, AUDIO_ESOUND));
 625 //      add_item(new ADriverItem(this, AUDIO_NAS_TITLE, AUDIO_NAS));
 626 #ifdef HAVE_FIREWIRE
 627         if(!do_input) add_item(new ADriverItem(this, AUDIO_1394_TITLE, AUDIO_1394));
 628         add_item(new ADriverItem(this, AUDIO_DV1394_TITLE, AUDIO_DV1394));
 629         add_item(new ADriverItem(this, AUDIO_IEC61883_TITLE, AUDIO_IEC61883));
 630 #endif
 631         if(do_input) add_item(new ADriverItem(this, AUDIO_DVB_TITLE, AUDIO_DVB));
 632         if(do_input) add_item(new ADriverItem(this, AUDIO_V4L2MPEG_TITLE, AUDIO_V4L2MPEG));
 633 }
 634
 635 char* ADriverMenu::adriver_to_string(int driver)
 636 {
 637         switch(driver) {
 638         case AUDIO_OSS:
 639                 sprintf(string, AUDIO_OSS_TITLE);
 640                 break;
 641         case AUDIO_OSS_ENVY24:
 642                 sprintf(string, AUDIO_OSS_ENVY24_TITLE);
 643                 break;
 644         case AUDIO_ESOUND:
 645                 sprintf(string, AUDIO_ESOUND_TITLE);
 646                 break;
 647         case AUDIO_NAS:
 648                 sprintf(string, AUDIO_NAS_TITLE);
 649                 break;
 650         case AUDIO_ALSA:
 651                 sprintf(string, AUDIO_ALSA_TITLE);
 652                 break;
 653 #ifdef HAVE_FIREWIRE
 654         case AUDIO_1394:
 655                 sprintf(string, AUDIO_1394_TITLE);
 656                 break;
 657         case AUDIO_DV1394:
 658                 sprintf(string, AUDIO_DV1394_TITLE);
 659                 break;
 660         case AUDIO_IEC61883:
 661                 sprintf(string, AUDIO_IEC61883_TITLE);
 662                 break;
 663 #endif
 664         case AUDIO_DVB:
 665                 sprintf(string, AUDIO_DVB_TITLE);
 666                 break;
 667         case AUDIO_V4L2MPEG:
 668                 sprintf(string, AUDIO_V4L2MPEG_TITLE);
 669                 break;
 670         }
 671         return string;
 672 }
 673
 674 ADriverItem::ADriverItem(ADriverMenu *popup, const char *text, int driver)
 675  : BC_MenuItem(text)
 676 {
 677         this->popup = popup;
 678         this->driver = driver;
 679 }
 680
 681 ADriverItem::~ADriverItem()
 682 {
 683 }
 684
 685 int ADriverItem::handle_event()
 686 {
 687         popup->set_text(get_text());
 688         *(popup->output) = driver;
 689         popup->device_prefs->initialize(0);
 690         popup->device_prefs->pwindow->show_dialog();
 691         return 1;
 692 }
 693
 694
 695
 696
 697 OSSEnable::OSSEnable(int x, int y, int *output)
 698  : BC_CheckBox(x, y, *output)
 699 {
 700         this->output = output;
 701 }
 702 int OSSEnable::handle_event()
 703 {
 704         *output = get_value();
 705         return 1;
 706 }
 707
 708
 709
 710
 711 ADeviceTextBox::ADeviceTextBox(int x, int y, char *output)
 712  : BC_TextBox(x, y, 150, 1, output)
 713 {
 714         this->output = output;
 715 }
 716
 717 int ADeviceTextBox::handle_event()
 718 {
 719         strcpy(output, get_text());
 720         return 1;
 721 }
 722
 723 ADeviceIntBox::ADeviceIntBox(int x, int y, int *output)
 724  : BC_TextBox(x, y, 80, 1, *output)
 725 {
 726         this->output = output;
 727 }
 728
 729 int ADeviceIntBox::handle_event()
 730 {
 731         *output = atol(get_text());
 732         return 1;
 733 }
 734
 735
 736
 737 ADeviceTumbleBox::ADeviceTumbleBox(ADevicePrefs *prefs,
 738         int x, int y, int *output, int min, int max, int text_w)
 739  : BC_TumbleTextBox(prefs->dialog, *output, min, max, x, y, text_w)
 740 {
 741         this->output = output;
 742 }
 743
 744 int ADeviceTumbleBox::handle_event()
 745 {
 746         *output = atol(get_text());
 747         return 1;
 748 }
 749
 750
 751
 752 ALSADevice::ALSADevice(PreferencesDialog *dialog,
 753         int x,
 754         int y,
 755         char *output,
 756         ArrayList<BC_ListBoxItem*> *devices)
 757  : BC_PopupTextBox(dialog, devices, output, x, y, 200, 200)
 758 {
 759         this->output = output;
 760 }
 761
 762 ALSADevice::~ALSADevice()
 763 {
 764 }
 765
 766 int ALSADevice::handle_event()
 767 {
 768         strcpy(output, get_text());
 769         return 1;
 770 }
 771