cinelerra-5.0/cinelerra/channeledit.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2011 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 "batch.h"
  23 #include "bcprogressbox.h"
  24 #include "bcsignals.h"
  25 #include "channel.h"
  26 #include "channeldb.h"
  27 #include "channeledit.h"
  28 #include "channelpicker.h"
  29 #include "chantables.h"
  30 #include "clip.h"
  31 #include "condition.h"
  32 #include "language.h"
  33 #include "mainsession.h"
  34 #include "mwindow.h"
  35 #include "picture.h"
  36 #include "theme.h"
  37 #include "videodevice.h"
  38 #include <ctype.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42
  43 ChannelEditThread::ChannelEditThread(ChannelPicker *channel_picker,
  44         ChannelDB *channeldb)
  45  : Thread()
  46 {
  47         this->channel_picker = channel_picker;
  48         this->channeldb = channeldb;
  49         in_progress = 0;
  50         this->window = 0;
  51         new_channels = new ChannelDB;
  52         completion = new Condition(1, "ChannelEditThread::completion");
  53         scan_thread = 0;
  54 }
  55 ChannelEditThread::~ChannelEditThread()
  56 {
  57         channel_picker->get_subwindow()->unlock_window();
  58         delete scan_thread;
  59         channel_picker->get_subwindow()->lock_window("ChannelEditThread::~ChannelEditThread");
  60         delete new_channels;
  61         delete completion;
  62 }
  63
  64 void ChannelEditThread::run()
  65 {
  66         if(in_progress)
  67         {
  68                 if(window)
  69                 {
  70                         window->lock_window("ChannelEditThread::run");
  71                         window->raise_window(1);
  72                         window->unlock_window();
  73                 }
  74                 return;
  75         }
  76         in_progress = 1;
  77         completion->lock("ChannelEditThread::run");
  78
  79 // Copy master channel list to temporary.
  80         new_channels->copy_from(channel_picker->channeldb);
  81         Channel *channel = channel_picker->get_current_channel();
  82         current_channel = channel_picker->channeldb->number_of(channel);
  83 //printf("ChannelEditThread::run 1 %d\n", current_channel);
  84
  85 // Run the channel list window using the temporary list.
  86         ChannelEditWindow window(this, channel_picker);
  87         window.create_objects();
  88         this->window = &window;
  89         int result = window.run_window();
  90         this->window = 0;
  91
  92         if(!result)
  93         {
  94 // Copy new channels to master list
  95                 channel_picker->channeldb->clear();
  96
  97                 channel_picker->channeldb->copy_from(new_channels);
  98                 channel_picker->update_channel_list();
  99
 100         }
 101
 102         channel_picker->handle_channel_edit(result);
 103
 104         window.edit_thread->close_threads();
 105
 106         completion->unlock();
 107         in_progress = 0;
 108
 109 }
 110
 111 void ChannelEditThread::close_threads()
 112 {
 113         if(in_progress && window)
 114         {
 115                 window->edit_thread->close_threads();
 116                 window->set_done(1);
 117                 completion->lock("ChannelEditThread::close_threads");
 118                 completion->unlock();
 119         }
 120 }
 121
 122 char *ChannelEditThread::value_to_freqtable(int value)
 123 {
 124         switch(value)
 125         {
 126                 case NTSC_DVB: return _("NTSC_DVB");
 127                 case CATV_DVB: return _("CATV_DVB");
 128                 case NTSC_BCAST: return _("NTSC_BCAST");
 129                 case NTSC_CABLE: return _("NTSC_CABLE");
 130                 case NTSC_HRC: return _("NTSC_HRC");
 131                 case NTSC_BCAST_JP: return _("NTSC_BCAST_JP");
 132                 case NTSC_CABLE_JP: return _("NTSC_CABLE_JP");
 133                 case PAL_AUSTRALIA: return _("PAL_AUSTRALIA");
 134                 case PAL_EUROPE: return _("PAL_EUROPE");
 135                 case PAL_E_EUROPE: return _("PAL_E_EUROPE");
 136                 case PAL_ITALY: return _("PAL_ITALY");
 137                 case PAL_IRELAND: return _("PAL_IRELAND");
 138                 case PAL_NEWZEALAND: return _("PAL_NEWZEALAND");
 139         }
 140         return _("ERROR");
 141 }
 142
 143 char* ChannelEditThread::value_to_norm(int value)
 144 {
 145         switch(value)
 146         {
 147                 case NTSC: return _("NTSC");
 148                 case PAL: return _("PAL");
 149                 case SECAM: return _("SECAM");
 150         }
 151         return _("ERROR");
 152 }
 153
 154 char* ChannelEditThread::value_to_input(int value)
 155 {
 156         ArrayList<Channel*> *inputs = channel_picker->get_video_inputs();
 157         return value >= inputs->total ? _("None") :
 158                 inputs->values[value]->device_name;
 159 }
 160
 161
 162
 163
 164
 165
 166
 167 ChannelEditWindow::ChannelEditWindow(ChannelEditThread *thread,
 168         ChannelPicker *channel_picker)
 169  : BC_Window(PROGRAM_NAME ": Channels",
 170         channel_picker->mwindow->session->channels_x,
 171         channel_picker->mwindow->session->channels_y,
 172         350,
 173         400,
 174         350,
 175         400,
 176         0,
 177         0,
 178         1)
 179 {
 180         this->thread = thread;
 181         this->channel_picker = channel_picker;
 182         scan_confirm_thread = 0;
 183 }
 184 ChannelEditWindow::~ChannelEditWindow()
 185 {
 186         int i;
 187         for(i = 0; i < channel_list.total; i++)
 188         {
 189                 delete channel_list.values[i];
 190         }
 191         channel_list.remove_all();
 192         delete edit_thread;
 193         delete picture_thread;
 194         delete scan_confirm_thread;
 195 }
 196
 197 void ChannelEditWindow::create_objects()
 198 {
 199         int x = 10, y = 10;
 200
 201 // Create channel list
 202         for(int i = 0; i < thread->new_channels->size(); i++)
 203         {
 204                 channel_list.append(new BC_ListBoxItem(thread->new_channels->get(i)->title));
 205         }
 206
 207         add_subwindow(list_box = new ChannelEditList(this, x, y));
 208         x += 200;
 209         if(channel_picker->use_select())
 210         {
 211                 add_subwindow(new ChannelEditSelect(this, x, y));
 212                 y += 30;
 213         }
 214         add_subwindow(new ChannelEditAdd(this, x, y));
 215         y += 30;
 216         add_subwindow(new ChannelEdit(this, x, y));
 217         y += 30;
 218         add_subwindow(new ChannelEditMoveUp(this, x, y));
 219         y += 30;
 220         add_subwindow(new ChannelEditMoveDown(this, x, y));
 221         y += 30;
 222         add_subwindow(new ChannelEditSort(this, x, y));
 223         y += 30;
 224
 225         Channel *channel_usage = channel_picker->get_channel_usage();
 226         if(channel_usage && channel_usage->has_scanning)
 227         {
 228                 add_subwindow(new ChannelEditScan(this, x, y));
 229                 y += 30;
 230         }
 231         add_subwindow(new ChannelEditDel(this, x, y));
 232         y += 30;
 233         add_subwindow(new ChannelEditPicture(this, x, y));
 234         y += 100;
 235         x = 10;
 236         add_subwindow(new BC_OKButton(this));
 237         x += 150;
 238         add_subwindow(new BC_CancelButton(this));
 239
 240
 241         edit_thread = new ChannelEditEditThread(this,
 242                 channel_picker);
 243         picture_thread = new ChannelEditPictureThread(channel_picker);
 244         show_window();
 245 }
 246
 247 int ChannelEditWindow::close_event()
 248 {
 249         set_done(0);
 250         return 1;
 251 }
 252
 253 int ChannelEditWindow::translation_event()
 254 {
 255         channel_picker->mwindow->session->channels_x = get_x();
 256         channel_picker->mwindow->session->channels_y = get_y();
 257         return 0;
 258 }
 259
 260
 261 int ChannelEditWindow::add_channel()
 262 {
 263         Channel *new_channel;
 264         Channel *prev_channel = 0;
 265
 266 // Create new channel
 267         new_channel = new Channel;
 268
 269 // Reuse parameters from previous channel
 270         if(thread->new_channels->size())
 271         {
 272                 prev_channel = thread->new_channels->get(
 273                                 thread->new_channels->size() - 1);
 274                 new_channel->copy_settings(prev_channel);
 275         }
 276         else
 277 // Use default channel parameters
 278         if(channel_picker->get_master_channel())
 279         {
 280                 new_channel->copy_settings(channel_picker->get_master_channel());
 281         }
 282
 283 // Copy device usage.  Need the same thing for playback.
 284         if(channel_picker->get_master_channel())
 285         {
 286                 new_channel->copy_usage(channel_picker->get_master_channel());
 287         }
 288
 289 // Add to channel table
 290         channel_list.append(new BC_ListBoxItem(new_channel->title));
 291         thread->new_channels->append(new_channel);
 292         update_list();
 293
 294 // Start common routing
 295         edit_thread->edit_channel(new_channel, 0);
 296         return 0;
 297 }
 298
 299 void ChannelEditWindow::update_list()
 300 {
 301 // Create channel list
 302         channel_list.remove_all_objects();
 303         for(int i = 0; i < thread->new_channels->size(); i++)
 304         {
 305                 channel_list.append(
 306                         new BC_ListBoxItem(
 307                                 thread->new_channels->get(i)->title));
 308         }
 309
 310         list_box->update(&channel_list, 0, 0, 1, list_box->get_yposition());
 311 }
 312
 313 void ChannelEditWindow::update_list(Channel *channel)
 314 {
 315         int i;
 316         for(i = 0; i < thread->new_channels->size(); i++)
 317                 if(thread->new_channels->get(i) == channel) break;
 318
 319         if(i < thread->new_channels->size())
 320         {
 321                 channel_list.values[i]->set_text(channel->title);
 322         }
 323
 324         update_list();
 325 }
 326
 327
 328 void ChannelEditWindow::edit_channel()
 329 {
 330         if(list_box->get_selection_number(0, 0) > -1)
 331         {
 332                 thread->current_channel = list_box->get_selection_number(0, 0);
 333                 edit_thread->edit_channel(
 334                         thread->new_channels->get(
 335                                 list_box->get_selection_number(0, 0)),
 336                         1);
 337         }
 338 }
 339
 340 void ChannelEditWindow::edit_picture()
 341 {
 342         picture_thread->edit_picture();
 343 }
 344
 345 void ChannelEditWindow::scan_confirm()
 346 {
 347         channel_picker->load_scan_defaults(&thread->scan_params);
 348         if(!scan_confirm_thread) scan_confirm_thread = new ConfirmScanThread(this);
 349         unlock_window();
 350         scan_confirm_thread->start();
 351         lock_window("ChannelEditWindow::scan_confirm");
 352 }
 353
 354 void ChannelEditWindow::scan()
 355 {
 356         thread->new_channels->clear();
 357         update_list();
 358
 359         if(!thread->scan_thread) thread->scan_thread = new ScanThread(thread);
 360         thread->scan_thread->start();
 361 }
 362
 363
 364 void ChannelEditWindow::get_chan_num(Channel *channel, int &chan, int &stream)
 365 {
 366         const char *cp = channel->title;
 367         int chn = 0, str = 0;
 368         while( isdigit(*cp) ) chn = 10*chn + (*cp++ -'0');
 369         if( chn != 0 && *cp != 0 ) {
 370                 if( *cp++ == '.' )
 371                         while( isdigit(*cp) ) str = 10*str + (*cp++ -'0');
 372                 if( !str ) chn = 0;
 373         }
 374         chan = chn;  stream = str;
 375 }
 376
 377 void ChannelEditWindow::sort()
 378 {
 379         int done = 0;
 380         while(!done) {
 381                 done = 1;
 382                 for(int i = 0; i < thread->new_channels->size() - 1; i++) {
 383                         Channel *channel1 = thread->new_channels->get(i);
 384                         Channel *channel2 = thread->new_channels->get(i + 1);
 385                         int ch1, st1;  get_chan_num(channel1, ch1, st1);
 386                         int ch2, st2;  get_chan_num(channel2, ch2, st2);
 387                         if( (ch1 > 0 && ch2 > 0) ?
 388                              (ch1 > ch2 || (ch1 == ch2 && (st1 > st2 || (st1 == st2 &&
 389                                 strcasecmp(channel2->title, channel1->title) < 0)))) :
 390                              strcasecmp(channel2->title, channel1->title) < 0) {
 391                                 thread->new_channels->set(i, channel2);
 392                                 thread->new_channels->set(i + 1, channel1);
 393                                 done = 0;
 394                         }
 395                 }
 396         }
 397         update_list();
 398 }
 399
 400
 401 void ChannelEditWindow::delete_channel(int number)
 402 {
 403         delete thread->new_channels->get(number);
 404         channel_list.remove_number(number);
 405         thread->new_channels->remove_number(number);
 406         update_list();
 407 }
 408
 409 void ChannelEditWindow::delete_channel(Channel *channel)
 410 {
 411         int i;
 412         for(i = 0; i < thread->new_channels->size(); i++)
 413         {
 414                 if(thread->new_channels->get(i) == channel)
 415                 {
 416                         break;
 417                 }
 418         }
 419         if(i < thread->new_channels->size()) delete_channel(i);
 420 }
 421
 422 int ChannelEditWindow::move_channel_up()
 423 {
 424         if(list_box->get_selection_number(0, 0) > -1)
 425         {
 426                 int number2 = list_box->get_selection_number(0, 0);
 427                 int number1 = number2 - 1;
 428                 Channel *temp;
 429                 BC_ListBoxItem *temp_text;
 430
 431                 if(number1 < 0) number1 = thread->new_channels->size() - 1;
 432
 433                 temp = thread->new_channels->get(number1);
 434                 thread->new_channels->set(number1, thread->new_channels->get(number2));
 435                 thread->new_channels->set(number2, temp);
 436
 437                 temp_text = channel_list.values[number1];
 438                 channel_list.values[number1] = channel_list.values[number2];
 439                 channel_list.values[number2] = temp_text;
 440                 list_box->update(&channel_list,
 441                         0,
 442                         0,
 443                         1,
 444                         list_box->get_xposition(),
 445                         list_box->get_yposition(),
 446                         number1,
 447                         1);
 448         }
 449         return 0;
 450 }
 451
 452 int ChannelEditWindow::move_channel_down()
 453 {
 454         if(list_box->get_selection_number(0, 0) > -1)
 455         {
 456                 int number2 = list_box->get_selection_number(0, 0);
 457                 int number1 = number2 + 1;
 458                 Channel *temp;
 459                 BC_ListBoxItem *temp_text;
 460
 461                 if(number1 > thread->new_channels->size() - 1) number1 = 0;
 462
 463                 temp = thread->new_channels->get(number1);
 464                 thread->new_channels->set(number1, thread->new_channels->get(number2));
 465                 thread->new_channels->set(number2, temp);
 466                 temp_text = channel_list.values[number1];
 467                 channel_list.values[number1] = channel_list.values[number2];
 468                 channel_list.values[number2] = temp_text;
 469                 list_box->update(&channel_list,
 470                         0,
 471                         0,
 472                         1,
 473                         list_box->get_xposition(),
 474                         list_box->get_yposition(),
 475                         number1,
 476                         1);
 477         }
 478         return 0;
 479 }
 480
 481 int ChannelEditWindow::change_channel_from_list(int channel_number)
 482 {
 483         if(channel_number > -1 && channel_number < thread->new_channels->size())
 484         {
 485                 thread->current_channel = channel_number;
 486                 channel_picker->set_channel(thread->new_channels->get(channel_number));
 487         }
 488         return 0;
 489 }
 490
 491 ChannelEditSelect::ChannelEditSelect(ChannelEditWindow *window, int x, int y)
 492  : BC_GenericButton(x, y, _("Select"))
 493 {
 494         this->window = window;
 495 }
 496 ChannelEditSelect::~ChannelEditSelect()
 497 {
 498 }
 499 int ChannelEditSelect::handle_event()
 500 {
 501         window->change_channel_from_list(
 502                 window->list_box->get_selection_number(0, 0));
 503         return 1;
 504 }
 505
 506 ChannelEditAdd::ChannelEditAdd(ChannelEditWindow *window, int x, int y)
 507  : BC_GenericButton(x, y, _("Add..."))
 508 {
 509         this->window = window;
 510 }
 511 ChannelEditAdd::~ChannelEditAdd()
 512 {
 513 }
 514 int ChannelEditAdd::handle_event()
 515 {
 516         window->add_channel();
 517         return 1;
 518 }
 519
 520 ChannelEditList::ChannelEditList(ChannelEditWindow *window, int x, int y)
 521  : BC_ListBox(x,
 522                         y,
 523                         185,
 524                         window->get_h() - BC_OKButton::calculate_h() - y - 10,
 525                         LISTBOX_TEXT,
 526                         &(window->channel_list))
 527 {
 528         this->window = window;
 529 }
 530 ChannelEditList::~ChannelEditList()
 531 {
 532 }
 533 int ChannelEditList::handle_event()
 534 {
 535         window->edit_channel();
 536         return 1;
 537 }
 538
 539 ChannelEditMoveUp::ChannelEditMoveUp(ChannelEditWindow *window, int x, int y)
 540  : BC_GenericButton(x, y, _("Move up"))
 541 {
 542         this->window = window;
 543 }
 544 ChannelEditMoveUp::~ChannelEditMoveUp()
 545 {
 546 }
 547 int ChannelEditMoveUp::handle_event()
 548 {
 549         lock_window("ChannelEditMoveUp::handle_event");
 550         window->move_channel_up();
 551         unlock_window();
 552         return 1;
 553 }
 554
 555 ChannelEditMoveDown::ChannelEditMoveDown(ChannelEditWindow *window, int x, int y)
 556  : BC_GenericButton(x, y, _("Move down"))
 557 {
 558         this->window = window;
 559 }
 560 ChannelEditMoveDown::~ChannelEditMoveDown()
 561 {
 562 }
 563 int ChannelEditMoveDown::handle_event()
 564 {
 565         lock_window("ChannelEditMoveDown::handle_event");
 566         window->move_channel_down();
 567         unlock_window();
 568         return 1;
 569 }
 570
 571 ChannelEditSort::ChannelEditSort(ChannelEditWindow *window, int x, int y)
 572  : BC_GenericButton(x, y, _("Sort"))
 573 {
 574         this->window = window;
 575 }
 576 int ChannelEditSort::handle_event()
 577 {
 578         lock_window("ChannelEditSort::handle_event");
 579         window->sort();
 580         unlock_window();
 581         return 1;
 582 }
 583
 584 ChannelEditScan::ChannelEditScan(ChannelEditWindow *window, int x, int y)
 585  : BC_GenericButton(x, y, _("Scan"))
 586 {
 587         this->window = window;
 588 }
 589 int ChannelEditScan::handle_event()
 590 {
 591         window->scan_confirm();
 592         return 1;
 593 }
 594
 595 ChannelEditDel::ChannelEditDel(ChannelEditWindow *window, int x, int y)
 596  : BC_GenericButton(x, y, _("Delete"))
 597 {
 598         this->window = window;
 599 }
 600 ChannelEditDel::~ChannelEditDel()
 601 {
 602 }
 603 int ChannelEditDel::handle_event()
 604 {
 605         if(window->list_box->get_selection_number(0, 0) > -1)
 606                 window->delete_channel(window->list_box->get_selection_number(0, 0));
 607         return 1;
 608 }
 609
 610 ChannelEdit::ChannelEdit(ChannelEditWindow *window, int x, int y)
 611  : BC_GenericButton(x, y, _("Edit..."))
 612 {
 613         this->window = window;
 614 }
 615 ChannelEdit::~ChannelEdit()
 616 {
 617 }
 618 int ChannelEdit::handle_event()
 619 {
 620         window->edit_channel();
 621         return 1;
 622 }
 623
 624 ChannelEditPicture::ChannelEditPicture(ChannelEditWindow *window, int x, int y)
 625  : BC_GenericButton(x, y, _("Picture..."))
 626 {
 627         this->window = window;
 628 }
 629 ChannelEditPicture::~ChannelEditPicture()
 630 {
 631 }
 632 int ChannelEditPicture::handle_event()
 633 {
 634         window->edit_picture();
 635         return 1;
 636 }
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649 // ========================= confirm overwrite by channel scannin
 650
 651
 652 ConfirmScan::ConfirmScan(ChannelEditWindow *gui, int x, int y)
 653  : BC_Window(PROGRAM_NAME ": Scan confirm",
 654         x,
 655         y,
 656         350,
 657         BC_OKButton::calculate_h() + 130,
 658         0,
 659         0,
 660         0,
 661         0,
 662         1)
 663 {
 664         this->gui = gui;
 665 }
 666
 667 void ConfirmScan::create_objects()
 668 {
 669         int x = 10, y = 10;
 670         int y2 = 0, x2 = 0;
 671         BC_Title *title;
 672         add_subwindow(title = new BC_Title(x, y, _("Set parameters for channel scanning.")));
 673         y += title->get_h() + 10;
 674         y2 = y;
 675
 676         add_subwindow(title = new BC_Title(x, y, _("Frequency table:")));
 677         x2 = title->get_w();
 678         y += BC_PopupMenu::calculate_h();
 679         add_subwindow(title = new BC_Title(x, y, _("Norm:")));
 680         x2 = MAX(x2, title->get_w());
 681         y += BC_PopupMenu::calculate_h();
 682         add_subwindow(title = new BC_Title(x, y, _("Input:")));
 683         x2 = MAX(x2, title->get_w());
 684         y += BC_PopupMenu::calculate_h();
 685         x2 += x + 5;
 686
 687         y = y2;
 688         x = x2;
 689         ChannelEditEditFreqtable *table;
 690         add_subwindow(table = new ChannelEditEditFreqtable(x,
 691                 y,
 692                 0,
 693                 gui->thread));
 694         table->add_items();
 695         y += table->get_h() + 10;
 696
 697         ChannelEditEditNorm *norm;
 698         add_subwindow(norm = new ChannelEditEditNorm(x,
 699                 y,
 700                 0,
 701                 gui->thread));
 702         norm->add_items();
 703         y += norm->get_h() + 10;
 704
 705         ChannelEditEditInput *input;
 706         add_subwindow(input = new ChannelEditEditInput(x,
 707                 y,
 708                 0,
 709                 gui->thread));
 710         input->add_items();
 711
 712
 713         add_subwindow(new BC_OKButton(this));
 714         add_subwindow(new BC_CancelButton(this));
 715         show_window();
 716 }
 717
 718
 719
 720
 721
 722
 723
 724 ConfirmScanThread::ConfirmScanThread(ChannelEditWindow *gui)
 725  : BC_DialogThread()
 726 {
 727         this->gui = gui;
 728 }
 729
 730 void ConfirmScanThread::handle_done_event(int result)
 731 {
 732         gui->channel_picker->save_scan_defaults(&gui->thread->scan_params);
 733         if(!result)
 734         {
 735                 get_gui()->hide_window();
 736                 gui->lock_window("ConfirmScanThread::handle_done_event");
 737                 gui->scan();
 738                 gui->unlock_window();
 739         }
 740 }
 741
 742 BC_Window* ConfirmScanThread::new_gui()
 743 {
 744         int x = gui->get_abs_cursor_x(1);
 745         int y = gui->get_abs_cursor_y(1);
 746         ConfirmScan *result = new ConfirmScan(gui, x, y);
 747         result->create_objects();
 748         return result;
 749 }
 750
 751
 752
 753
 754
 755
 756 ScanThread::ScanThread(ChannelEditThread *edit)
 757  : Thread(1, 0, 0)
 758 {
 759         this->edit = edit;
 760         interrupt = 0;
 761         progress = 0;
 762 }
 763
 764 ScanThread::~ScanThread()
 765 {
 766         interrupt = 1;
 767         Thread::join();
 768
 769         delete progress;
 770 }
 771
 772
 773 void ScanThread::start()
 774 {
 775 // Cancel previous job
 776         interrupt = 1;
 777         Thread::join();
 778         delete progress;
 779         interrupt = 0;
 780
 781
 782         progress = new BC_ProgressBox(
 783                 edit->channel_picker->parent_window->get_abs_cursor_x(1),
 784                 edit->channel_picker->parent_window->get_abs_cursor_y(1),
 785                 "Scanning",
 786                 chanlists[edit->scan_params.freqtable].count);
 787         progress->start();
 788         Thread::start();
 789 }
 790
 791 void ScanThread::run()
 792 {
 793         for(int i = 0; i < chanlists[edit->scan_params.freqtable].count &&
 794                         !interrupt && !progress->is_cancelled(); i++) {
 795                 edit->scan_params.entry = i;
 796                 char string[BCTEXTLEN];
 797                 sprintf(edit->scan_params.title, "%s",
 798                         chanlists[edit->scan_params.freqtable].list[i].name);
 799                 sprintf(string, "Scanning %s", edit->scan_params.title);
 800                 progress->update_title(string, 1);
 801                 progress->update(i, 1);
 802                 edit->channel_picker->set_channel(&edit->scan_params);
 803                 sleep(1); // has_signal should do whatever it takes
 804                 int got_signal = edit->channel_picker->has_signal();
 805                 if(!got_signal) continue;
 806                 if(edit->channel_picker->get_channel_usage()->has_subchan) {
 807                         ArrayList<Channel*> channels;
 808                         edit->channel_picker->create_channeldb(&channels);
 809                         if( channels.total ) {
 810                                 edit->window->lock_window("ScanThread::run");
 811                                 for( int i=0; i<channels.total; ++i ) {
 812                                         Channel *new_channel = channels.values[i];
 813                                         new_channel->copy_usage(&edit->scan_params);
 814                                         edit->new_channels->append(new_channel);
 815                                 }
 816                                 edit->window->update_list();
 817                                 edit->window->unlock_window();
 818                                 continue;
 819                         }
 820                 }
 821                 Channel *new_channel = new Channel;
 822                 new_channel->copy_usage(&edit->scan_params);
 823                 new_channel->copy_settings(&edit->scan_params);
 824                 edit->window->lock_window("ScanThread::run");
 825                 edit->new_channels->append(new_channel);
 826                 edit->window->update_list();
 827                 edit->window->unlock_window();
 828         }
 829         progress->stop_progress();
 830         delete progress;
 831         progress = 0;
 832 }
 833
 834
 835
 836
 837
 838
 839
 840 // ================================= Edit a single channel
 841
 842
 843
 844 ChannelEditEditThread::ChannelEditEditThread(ChannelEditWindow *window,
 845         ChannelPicker *channel_picker)
 846  : Thread()
 847 {
 848         this->window = window;
 849         this->channel_picker = channel_picker;
 850         in_progress = 0;
 851         edit_window = 0;
 852         editing = 0;
 853         completion = new Condition(1, "ChannelEditEditThread::completion");
 854 }
 855
 856 ChannelEditEditThread::~ChannelEditEditThread()
 857 {
 858         delete completion;
 859 }
 860
 861 void ChannelEditEditThread::close_threads()
 862 {
 863         if(edit_window)
 864         {
 865                 edit_window->set_done(1);
 866                 completion->lock("ChannelEditEditThread::close_threads");
 867                 completion->unlock();
 868         }
 869 }
 870
 871 int ChannelEditEditThread::edit_channel(Channel *channel, int editing)
 872 {
 873         if(in_progress)
 874         {
 875                 edit_window->lock_window("ChannelEditEditThread::edit_channel");
 876                 edit_window->raise_window(1);
 877                 edit_window->unlock_window();
 878                 return 1;
 879         }
 880         in_progress = 1;
 881
 882 // Copy the channel to edit into a temporary
 883         completion->lock("ChannelEditEditThread::edit_channel");
 884         this->editing = editing;
 885         this->output_channel = channel;
 886         new_channel.copy_settings(output_channel);
 887         new_channel.copy_usage(output_channel);
 888
 889         if(editing && new_channel.title[0])
 890                 user_title = 1;
 891         else
 892                 user_title = 0;
 893         set_synchronous(0);
 894         Thread::start();
 895         return 0;
 896 }
 897
 898
 899 void ChannelEditEditThread::set_device()
 900 {
 901         channel_picker->set_channel(&new_channel);
 902 }
 903
 904 void ChannelEditEditThread::change_source(const char *source_name)
 905 {
 906         for(int i = 0; i < chanlists[new_channel.freqtable].count; i++)
 907         {
 908                 if(!strcasecmp(chanlists[new_channel.freqtable].list[i].name, source_name))
 909                 {
 910                         new_channel.entry = i;
 911                         i = chanlists[new_channel.freqtable].count;
 912                         set_device();
 913                 }
 914         }
 915         if(!user_title)
 916         {
 917                 strcpy(new_channel.title, source_name);
 918                 if(edit_window->title_text)
 919                 {
 920                         edit_window->title_text->update(source_name);
 921                 }
 922         }
 923 }
 924
 925 void ChannelEditEditThread::source_up()
 926 {
 927         new_channel.entry++;
 928         if(new_channel.entry > chanlists[new_channel.freqtable].count - 1) new_channel.entry = 0;
 929         source_text->update(chanlists[new_channel.freqtable].list[new_channel.entry].name);
 930         set_device();
 931 }
 932
 933 void ChannelEditEditThread::source_down()
 934 {
 935         new_channel.entry--;
 936         if(new_channel.entry < 0) new_channel.entry = chanlists[new_channel.freqtable].count - 1;
 937         source_text->update(chanlists[new_channel.freqtable].list[new_channel.entry].name);
 938         set_device();
 939 }
 940
 941 void ChannelEditEditThread::set_input(int value)
 942 {
 943         new_channel.input = value;
 944         set_device();
 945 }
 946
 947 void ChannelEditEditThread::set_norm(int value)
 948 {
 949         new_channel.norm = value;
 950         set_device();
 951 }
 952
 953 void ChannelEditEditThread::set_freqtable(int value)
 954 {
 955         new_channel.freqtable = value;
 956         if(new_channel.entry > chanlists[new_channel.freqtable].count - 1) new_channel.entry = 0;
 957         source_text->update(chanlists[new_channel.freqtable].list[new_channel.entry].name);
 958         set_device();
 959 }
 960
 961 void ChannelEditEditThread::run()
 962 {
 963         ChannelEditEditWindow edit_window(this, window, channel_picker);
 964         edit_window.create_objects(&new_channel);
 965         this->edit_window = &edit_window;
 966         int result = edit_window.run_window();
 967         this->edit_window = 0;
 968
 969 // Done editing channel.  Keep channel.
 970         if(!result)
 971         {
 972                 output_channel->copy_settings(&new_channel);
 973                 window->lock_window();
 974                 window->update_list(output_channel);
 975                 window->unlock_window();
 976         }
 977         else
 978         {
 979 // Discard channel.
 980                 if(!editing)
 981                 {
 982                         window->lock_window();
 983                         window->delete_channel(output_channel);
 984                         window->unlock_window();
 985                 }
 986         }
 987         editing = 0;
 988         completion->unlock();
 989         in_progress = 0;
 990 }
 991
 992 ChannelEditEditWindow::ChannelEditEditWindow(ChannelEditEditThread *thread,
 993         ChannelEditWindow *window,
 994         ChannelPicker *channel_picker)
 995  : BC_Window(PROGRAM_NAME ": Edit Channel",
 996         channel_picker->parent_window->get_abs_cursor_x(1),
 997         channel_picker->parent_window->get_abs_cursor_y(1),
 998         390,
 999         300,
1000         390,
1001         300,
1002         0,
1003         0,
1004         1)
1005 {
1006         this->channel_picker = channel_picker;
1007         this->window = window;
1008         this->thread = thread;
1009 }
1010 ChannelEditEditWindow::~ChannelEditEditWindow()
1011 {
1012 }
1013 void ChannelEditEditWindow::create_objects(Channel *channel)
1014 {
1015         this->new_channel = channel;
1016         Channel *channel_usage = channel_picker->get_channel_usage();
1017         title_text = 0;
1018
1019         int x = 10, y = 10;
1020 //      if(!channel_usage ||
1021 //              (!channel_usage->use_frequency &&
1022 //              !channel_usage->use_fine &&
1023 //              !channel_usage->use_norm &&
1024 //              !channel_usage->use_input))
1025 //      {
1026 //              add_subwindow(new BC_Title(x, y, "Device has no input selection."));
1027 //              y += 30;
1028 //      }
1029 //      else
1030 //      {
1031                 add_subwindow(new BC_Title(x, y, _("Title:")));
1032                 add_subwindow(title_text = new ChannelEditEditTitle(x, y + 20, thread));
1033                 y += 50;
1034 //      }
1035
1036         if(channel_usage && channel_usage->use_frequency)
1037         {
1038                 add_subwindow(new BC_Title(x, y, _("Channel:")));
1039                 y += 20;
1040                 add_subwindow(thread->source_text = new ChannelEditEditSource(x, y, thread));
1041                 add_subwindow(new ChannelEditEditSourceTumbler(x + 160, y, thread));
1042                 y += 40;
1043
1044                 add_subwindow(new BC_Title(x, y, _("Frequency table:")));
1045                 ChannelEditEditFreqtable *table;
1046                 add_subwindow(table = new ChannelEditEditFreqtable(x + 130,
1047                         y,
1048                         thread,
1049                         window->thread));
1050                 table->add_items();
1051                 y += 30;
1052         }
1053
1054         if(channel_usage && channel_usage->use_fine)
1055         {
1056                 add_subwindow(new BC_Title(x, y, _("Fine:")));
1057                 add_subwindow(new ChannelEditEditFine(x + 130, y, thread));
1058                 y += 30;
1059         }
1060
1061         if(channel_usage && channel_usage->use_norm)
1062         {
1063                 add_subwindow(new BC_Title(x, y, _("Norm:")));
1064                 ChannelEditEditNorm *norm;
1065                 add_subwindow(norm = new ChannelEditEditNorm(x + 130,
1066                         y,
1067                         thread,
1068                         window->thread));
1069                 norm->add_items();
1070                 y += 30;
1071         }
1072
1073         if( (channel_usage && channel_usage->use_input) ||
1074                 !channel_usage)
1075         {
1076                 add_subwindow(new BC_Title(x, y, _("Input:")));
1077                 ChannelEditEditInput *input;
1078                 add_subwindow(input = new ChannelEditEditInput(x + 130,
1079                         y,
1080                         thread,
1081                         window->thread));
1082                 input->add_items();
1083                 y += 30;
1084         }
1085
1086         add_subwindow(new BC_OKButton(this));
1087         x += 200;
1088         add_subwindow(new BC_CancelButton(this));
1089         show_window();
1090 }
1091
1092 ChannelEditEditTitle::ChannelEditEditTitle(int x,
1093         int y,
1094         ChannelEditEditThread *thread)
1095  : BC_TextBox(x, y, 150, 1, thread->new_channel.title)
1096 {
1097         this->thread = thread;
1098 }
1099 ChannelEditEditTitle::~ChannelEditEditTitle()
1100 {
1101 }
1102 int ChannelEditEditTitle::handle_event()
1103 {
1104         if(strlen(get_text()) < 1024)
1105         {
1106                 strcpy(thread->new_channel.title, get_text());
1107         }
1108         thread->user_title = get_text()[0] ? 1 : 0;
1109         return 1;
1110 }
1111
1112
1113 ChannelEditEditSource::ChannelEditEditSource(int x, int y, ChannelEditEditThread *thread)
1114  : BC_TextBox(x, y, 150, 1, chanlists[thread->new_channel.freqtable].list[thread->new_channel.entry].name)
1115 {
1116         this->thread = thread;
1117 }
1118
1119 ChannelEditEditSource::~ChannelEditEditSource()
1120 {
1121 }
1122 int ChannelEditEditSource::handle_event()
1123 {
1124         thread->change_source(get_text());
1125         return 1;
1126 }
1127
1128
1129 ChannelEditEditSourceTumbler::ChannelEditEditSourceTumbler(int x, int y, ChannelEditEditThread *thread)
1130  : BC_Tumbler(x, y)
1131 {
1132         this->thread = thread;
1133 }
1134 ChannelEditEditSourceTumbler::~ChannelEditEditSourceTumbler()
1135 {
1136 }
1137 int ChannelEditEditSourceTumbler::handle_up_event()
1138 {
1139         thread->source_up();
1140         return 1;
1141 }
1142 int ChannelEditEditSourceTumbler::handle_down_event()
1143 {
1144         thread->source_down();
1145         return 1;
1146 }
1147
1148 ChannelEditEditInput::ChannelEditEditInput(int x,
1149         int y,
1150         ChannelEditEditThread *thread,
1151         ChannelEditThread *edit)
1152  : BC_PopupMenu(x,
1153         y,
1154         150,
1155         edit->value_to_input(thread ? thread->new_channel.input : edit->scan_params.input))
1156 {
1157         this->thread = thread;
1158         this->edit = edit;
1159 }
1160 ChannelEditEditInput::~ChannelEditEditInput()
1161 {
1162 }
1163 void ChannelEditEditInput::add_items()
1164 {
1165         ArrayList<Channel*> *inputs;
1166         inputs = edit->channel_picker->get_video_inputs();
1167
1168         if(inputs)
1169         {
1170                 for(int i = 0; i < inputs->total; i++)
1171                 {
1172                         add_item(new ChannelEditEditInputItem(thread,
1173                                 edit,
1174                                 inputs->values[i]->device_name,
1175                                 i));
1176                 }
1177         }
1178 }
1179 int ChannelEditEditInput::handle_event()
1180 {
1181         return 0;
1182 }
1183
1184 ChannelEditEditInputItem::ChannelEditEditInputItem(ChannelEditEditThread *thread,
1185         ChannelEditThread *edit,
1186         char *text,
1187         int value)
1188  : BC_MenuItem(text)
1189 {
1190         this->thread = thread;
1191         this->edit = edit;
1192         this->value = value;
1193 }
1194 ChannelEditEditInputItem::~ChannelEditEditInputItem()
1195 {
1196 }
1197 int ChannelEditEditInputItem::handle_event()
1198 {
1199         get_popup_menu()->set_text(get_text());
1200         if(thread && !thread->user_title)
1201         {
1202                 strcpy(thread->new_channel.title, get_text());
1203                 if(thread->edit_window->title_text)
1204                 {
1205                         thread->edit_window->title_text->update(get_text());
1206                 }
1207         }
1208         if(thread)
1209                 thread->set_input(value);
1210         else
1211                 edit->scan_params.input = value;
1212         return 1;
1213 }
1214
1215 ChannelEditEditNorm::ChannelEditEditNorm(int x,
1216         int y,
1217         ChannelEditEditThread *thread,
1218         ChannelEditThread *edit)
1219  : BC_PopupMenu(x,
1220         y,
1221         100,
1222         edit->value_to_norm(thread ? thread->new_channel.norm : edit->scan_params.norm))
1223 {
1224         this->thread = thread;
1225         this->edit = edit;
1226 }
1227 ChannelEditEditNorm::~ChannelEditEditNorm()
1228 {
1229 }
1230 void ChannelEditEditNorm::add_items()
1231 {
1232         add_item(new ChannelEditEditNormItem(thread,
1233                 edit,
1234                 edit->value_to_norm(NTSC), NTSC));
1235         add_item(new ChannelEditEditNormItem(thread,
1236                 edit,
1237                 edit->value_to_norm(PAL), PAL));
1238         add_item(new ChannelEditEditNormItem(thread,
1239                 edit,
1240                 edit->value_to_norm(SECAM), SECAM));
1241 }
1242
1243
1244 ChannelEditEditNormItem::ChannelEditEditNormItem(ChannelEditEditThread *thread,
1245         ChannelEditThread *edit,
1246         char *text,
1247         int value)
1248  : BC_MenuItem(text)
1249 {
1250         this->value = value;
1251         this->edit = edit;
1252         this->thread = thread;
1253 }
1254 ChannelEditEditNormItem::~ChannelEditEditNormItem()
1255 {
1256 }
1257 int ChannelEditEditNormItem::handle_event()
1258 {
1259         get_popup_menu()->set_text(get_text());
1260         if(thread)
1261                 thread->set_norm(value);
1262         else
1263                 edit->scan_params.norm = value;
1264         return 1;
1265 }
1266
1267
1268 ChannelEditEditFreqtable::ChannelEditEditFreqtable(int x,
1269         int y,
1270         ChannelEditEditThread *thread,
1271         ChannelEditThread *edit)
1272  : BC_PopupMenu(x,
1273         y,
1274         150,
1275         edit->value_to_freqtable(thread ? thread->new_channel.freqtable : edit->scan_params.freqtable))
1276 {
1277         this->thread = thread;
1278         this->edit = edit;
1279 }
1280 ChannelEditEditFreqtable::~ChannelEditEditFreqtable()
1281 {
1282 }
1283 void ChannelEditEditFreqtable::add_items()
1284 {
1285         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_DVB), NTSC_DVB));
1286         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(CATV_DVB), CATV_DVB));
1287         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_BCAST), NTSC_BCAST));
1288         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_CABLE), NTSC_CABLE));
1289         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_HRC), NTSC_HRC));
1290         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_BCAST_JP), NTSC_BCAST_JP));
1291         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(NTSC_CABLE_JP), NTSC_CABLE_JP));
1292         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_AUSTRALIA), PAL_AUSTRALIA));
1293         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_EUROPE), PAL_EUROPE));
1294         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_E_EUROPE), PAL_E_EUROPE));
1295         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_ITALY), PAL_ITALY));
1296         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_IRELAND), PAL_IRELAND));
1297         add_item(new ChannelEditEditFreqItem(thread, edit, edit->value_to_freqtable(PAL_NEWZEALAND), PAL_NEWZEALAND));
1298 }
1299
1300 ChannelEditEditFreqItem::ChannelEditEditFreqItem(ChannelEditEditThread *thread,
1301         ChannelEditThread *edit,
1302         char *text, int value)
1303  : BC_MenuItem(text)
1304 {
1305         this->value = value;
1306         this->edit = edit;
1307         this->thread = thread;
1308 }
1309 ChannelEditEditFreqItem::~ChannelEditEditFreqItem()
1310 {
1311 }
1312 int ChannelEditEditFreqItem::handle_event()
1313 {
1314         get_popup_menu()->set_text(get_text());
1315         if(thread)
1316                 thread->set_freqtable(value);
1317         else
1318                 edit->scan_params.freqtable = value;
1319         return 1;
1320 }
1321
1322
1323
1324 ChannelEditEditFine::ChannelEditEditFine(int x,
1325         int y,
1326         ChannelEditEditThread *thread)
1327  : BC_ISlider(x,
1328                 y,
1329                 0,
1330                 240,
1331                 240,
1332                 -100,
1333                 100,
1334                 thread->new_channel.fine_tune)
1335 {
1336         this->thread = thread;
1337 }
1338 ChannelEditEditFine::~ChannelEditEditFine()
1339 {
1340 }
1341 int ChannelEditEditFine::handle_event()
1342 {
1343         return 1;
1344 }
1345 int ChannelEditEditFine::button_release_event()
1346 {
1347         if(BC_Slider::button_release_event())
1348         {
1349                 thread->new_channel.fine_tune = get_value();
1350                 thread->set_device();
1351                 return 1;
1352         }
1353         return 0;
1354 }
1355
1356
1357 // ========================== picture quality
1358
1359 ChannelEditPictureThread::ChannelEditPictureThread(
1360         ChannelPicker *channel_picker)
1361  : BC_DialogThread()
1362 {
1363         this->channel_picker = channel_picker;
1364 }
1365 ChannelEditPictureThread::~ChannelEditPictureThread()
1366 {
1367 }
1368
1369 void ChannelEditPictureThread::handle_done_event(int result)
1370 {
1371         if(channel_picker->get_picture_usage())
1372                 channel_picker->get_picture_usage()->save_defaults();
1373 }
1374
1375 BC_Window* ChannelEditPictureThread::new_gui()
1376 {
1377         ChannelEditPictureWindow *edit_window = new ChannelEditPictureWindow(this,
1378                 channel_picker);
1379         edit_window->create_objects();
1380         return edit_window;
1381 }
1382
1383 void ChannelEditPictureThread::edit_picture()
1384 {
1385         start();
1386 }
1387
1388
1389
1390
1391 ChannelEditPictureWindow::ChannelEditPictureWindow(ChannelEditPictureThread *thread,
1392         ChannelPicker *channel_picker)
1393  : BC_Window(PROGRAM_NAME ": Picture",
1394         channel_picker->mwindow->session->picture_x,
1395         channel_picker->mwindow->session->picture_y,
1396         calculate_w(channel_picker),
1397         calculate_h(channel_picker),
1398         calculate_w(channel_picker),
1399         calculate_h(channel_picker))
1400 {
1401         this->thread = thread;
1402         this->channel_picker = channel_picker;
1403 }
1404 ChannelEditPictureWindow::~ChannelEditPictureWindow()
1405 {
1406 }
1407
1408 int ChannelEditPictureWindow::calculate_h(ChannelPicker *channel_picker)
1409 {
1410         PictureConfig *picture_usage = channel_picker->get_picture_usage();
1411         int pad = BC_Pot::calculate_h();
1412         int result = 20 +
1413                 channel_picker->parent_window->get_text_height(MEDIUMFONT) + 5 +
1414                 BC_OKButton::calculate_h();
1415
1416 // Only used for Video4Linux 1
1417         if(picture_usage)
1418         {
1419                 if(picture_usage->use_brightness)
1420                         result += pad;
1421                 if(picture_usage->use_contrast)
1422                         result += pad;
1423                 if(picture_usage->use_color)
1424                         result += pad;
1425                 if(picture_usage->use_hue)
1426                         result += pad;
1427                 if(picture_usage->use_whiteness)
1428                         result += pad;
1429         }
1430
1431         result += channel_picker->get_controls() * pad;
1432         return result;
1433 }
1434
1435 int ChannelEditPictureWindow::calculate_w(ChannelPicker *channel_picker)
1436 {
1437         PictureConfig *picture_usage = channel_picker->get_picture_usage();
1438         int widget_border = ((Theme*)channel_picker->get_theme())->widget_border;
1439         int pad = BC_Pot::calculate_w() + 4 * widget_border;
1440         int result = 0;
1441
1442 // Only used for Video4Linux 1
1443         if(!picture_usage ||
1444                 (!picture_usage->use_brightness &&
1445                 !picture_usage->use_contrast &&
1446                 !picture_usage->use_color &&
1447                 !picture_usage->use_hue &&
1448                 !picture_usage->use_whiteness &&
1449                 !channel_picker->get_controls()))
1450         {
1451                 result = BC_Title::calculate_w(channel_picker->parent_window,
1452                         "Device has no picture controls." +
1453                         2 * widget_border);
1454         }
1455
1456 // Only used for Video4Linux 1
1457         if(picture_usage)
1458         {
1459                 if(picture_usage->use_brightness)
1460                 {
1461                         int new_w = BC_Title::calculate_w(channel_picker->parent_window, "Brightness:") + pad;
1462                         result = MAX(result, new_w);
1463                 }
1464                 if(picture_usage->use_contrast)
1465                 {
1466                         int new_w = BC_Title::calculate_w(channel_picker->parent_window, "Contrast:") + pad;
1467                         result = MAX(result, new_w);
1468                 }
1469                 if(picture_usage->use_color)
1470                 {
1471                         int new_w = BC_Title::calculate_w(channel_picker->parent_window, "Color:") + pad;
1472                         result = MAX(result, new_w);
1473                 }
1474                 if(picture_usage->use_hue)
1475                 {
1476                         int new_w = BC_Title::calculate_w(channel_picker->parent_window, "Hue:") + pad;
1477                         result = MAX(result, new_w);
1478                 }
1479                 if(picture_usage->use_whiteness)
1480                 {
1481                         int new_w = BC_Title::calculate_w(channel_picker->parent_window, "Whiteness:") + pad;
1482                         result = MAX(result, new_w);
1483                 }
1484         }
1485
1486         for(int i = 0; i < channel_picker->get_controls(); i++)
1487         {
1488                 int new_w = BC_Title::calculate_w(channel_picker->parent_window,
1489                                 channel_picker->get_control(i)->name) +
1490                         pad;
1491                 result = MAX(result, new_w);
1492         }
1493
1494         return result;
1495 }
1496
1497
1498 void ChannelEditPictureWindow::create_objects()
1499 {
1500         int x = 10, y = 10;
1501         int widget_border = ((Theme*)channel_picker->get_theme())->widget_border;
1502         int x1 = get_w() - BC_Pot::calculate_w() * 2 - widget_border * 2;
1503         int x2 = get_w() - BC_Pot::calculate_w() - widget_border;
1504         int pad = BC_Pot::calculate_h();
1505
1506 #define SWAP_X x1 ^= x2; x2 ^= x1; x1 ^= x2;
1507
1508         PictureConfig *picture_usage = channel_picker->get_picture_usage();
1509
1510 // Only used for Video4Linux 1
1511         if(!picture_usage ||
1512                 (!picture_usage->use_brightness &&
1513                 !picture_usage->use_contrast &&
1514                 !picture_usage->use_color &&
1515                 !picture_usage->use_hue &&
1516                 !picture_usage->use_whiteness &&
1517                 !channel_picker->get_controls()))
1518         {
1519                 add_subwindow(new BC_Title(x, y, "Device has no picture controls."));
1520                 y += 50;
1521         }
1522
1523 // Only used for Video4Linux 1
1524         if(picture_usage && picture_usage->use_brightness)
1525         {
1526                 add_subwindow(new BC_Title(x, y + 10, _("Brightness:")));
1527                 add_subwindow(new ChannelEditBright(x1, y, channel_picker, channel_picker->get_brightness()));
1528                 y += pad;
1529                 SWAP_X
1530
1531         }
1532
1533         if(picture_usage && picture_usage->use_contrast)
1534         {
1535                 add_subwindow(new BC_Title(x, y + 10, _("Contrast:")));
1536                 add_subwindow(new ChannelEditContrast(x1, y, channel_picker, channel_picker->get_contrast()));
1537                 y += pad;
1538                 SWAP_X
1539         }
1540
1541         if(picture_usage && picture_usage->use_color)
1542         {
1543                 add_subwindow(new BC_Title(x, y + 10, _("Color:")));
1544                 add_subwindow(new ChannelEditColor(x1, y, channel_picker, channel_picker->get_color()));
1545                 y += pad;
1546                 SWAP_X
1547         }
1548
1549         if(picture_usage && picture_usage->use_hue)
1550         {
1551                 add_subwindow(new BC_Title(x, y + 10, _("Hue:")));
1552                 add_subwindow(new ChannelEditHue(x1, y, channel_picker, channel_picker->get_hue()));
1553                 y += pad;
1554                 SWAP_X
1555         }
1556
1557         if(picture_usage && picture_usage->use_whiteness)
1558         {
1559                 add_subwindow(new BC_Title(x, y + 10, _("Whiteness:")));
1560                 add_subwindow(new ChannelEditWhiteness(x1, y, channel_picker, channel_picker->get_whiteness()));
1561                 y += pad;
1562                 SWAP_X
1563         }
1564
1565         for(int i = 0; i < channel_picker->get_controls(); i++)
1566         {
1567                 BC_Title *title;
1568                 add_subwindow(title = new BC_Title(x,
1569                         y + 10,
1570                         _(channel_picker->get_control(i)->name)));
1571
1572                 int x3 = x1;
1573                 if(x3 < title->get_x() + title->get_w() + widget_border)
1574                         x3 = title->get_x() + title->get_w() + widget_border;
1575
1576                 add_subwindow(new ChannelEditCommon(x3,
1577                         y,
1578                         channel_picker,
1579                         channel_picker->get_control(i)));
1580                 y += pad;
1581                 SWAP_X
1582         }
1583
1584
1585         y += pad;
1586         add_subwindow(new BC_OKButton(this));
1587         show_window();
1588 }
1589
1590 int ChannelEditPictureWindow::translation_event()
1591 {
1592         channel_picker->mwindow->session->picture_x = get_x();
1593         channel_picker->mwindow->session->picture_y = get_y();
1594         return 0;
1595 }
1596
1597
1598
1599 ChannelEditBright::ChannelEditBright(int x, int y, ChannelPicker *channel_picker, int value)
1600  : BC_IPot(x,
1601                 y,
1602                 value,
1603                 -100,
1604                 100)
1605 {
1606         this->channel_picker = channel_picker;
1607 }
1608 ChannelEditBright::~ChannelEditBright() {}
1609 int ChannelEditBright::handle_event()
1610 {
1611         return 1;
1612 }
1613 int ChannelEditBright::button_release_event()
1614 {
1615         if(BC_Pot::button_release_event())
1616         {
1617                 channel_picker->set_brightness(get_value());
1618                 return 1;
1619         }
1620         return 0;
1621 }
1622
1623 ChannelEditContrast::ChannelEditContrast(int x, int y, ChannelPicker *channel_picker, int value)
1624  : BC_IPot(x,
1625                 y,
1626                 value,
1627                 -100,
1628                 100)
1629 {
1630         this->channel_picker = channel_picker;
1631 }
1632 ChannelEditContrast::~ChannelEditContrast() {}
1633 int ChannelEditContrast::handle_event()
1634 {
1635         return 1;
1636 }
1637 int ChannelEditContrast::button_release_event()
1638 {
1639         if(BC_Pot::button_release_event())
1640         {
1641                 channel_picker->set_contrast(get_value());
1642                 return 1;
1643         }
1644         return 0;
1645 }
1646
1647
1648 ChannelEditColor::ChannelEditColor(int x, int y, ChannelPicker *channel_picker, int value)
1649  : BC_IPot(x,
1650                 y,
1651                 value,
1652                 -100,
1653                 100)
1654 {
1655         this->channel_picker = channel_picker;
1656 }
1657 ChannelEditColor::~ChannelEditColor() {}
1658 int ChannelEditColor::handle_event()
1659 {
1660         return 1;
1661 }
1662 int ChannelEditColor::button_release_event()
1663 {
1664         if(BC_Pot::button_release_event())
1665         {
1666                 channel_picker->set_color(get_value());
1667                 return 1;
1668         }
1669         return 0;
1670 }
1671
1672 ChannelEditHue::ChannelEditHue(int x, int y, ChannelPicker *channel_picker, int value)
1673  : BC_IPot(x,
1674                 y,
1675                 value,
1676                 -100,
1677                 100)
1678 {
1679         this->channel_picker = channel_picker;
1680 }
1681 ChannelEditHue::~ChannelEditHue() {}
1682 int ChannelEditHue::handle_event()
1683 {
1684         return 1;
1685 }
1686 int ChannelEditHue::button_release_event()
1687 {
1688         if(BC_Pot::button_release_event())
1689         {
1690                 channel_picker->set_hue(get_value());
1691                 return 1;
1692         }
1693         return 0;
1694 }
1695
1696 ChannelEditWhiteness::ChannelEditWhiteness(int x, int y, ChannelPicker *channel_picker, int value)
1697  : BC_IPot(x,
1698                 y,
1699                 value,
1700                 -100,
1701                 100)
1702 {
1703         this->channel_picker = channel_picker;
1704 }
1705 ChannelEditWhiteness::~ChannelEditWhiteness()
1706 {
1707 }
1708 int ChannelEditWhiteness::handle_event()
1709 {
1710         return 1;
1711 }
1712 int ChannelEditWhiteness::button_release_event()
1713 {
1714         if(BC_Pot::button_release_event())
1715         {
1716                 channel_picker->set_whiteness(get_value());
1717                 return 1;
1718         }
1719         return 0;
1720 }
1721
1722
1723
1724 ChannelEditCommon::ChannelEditCommon(int x,
1725         int y,
1726         ChannelPicker *channel_picker,
1727         PictureItem *item)
1728  : BC_IPot(x,
1729                 y,
1730                 item->value,
1731                 item->min,
1732                 item->max)
1733 {
1734         this->channel_picker = channel_picker;
1735         this->device_id = item->device_id;
1736 }
1737
1738 ChannelEditCommon::~ChannelEditCommon()
1739 {
1740 }
1741
1742 int ChannelEditCommon::handle_event()
1743 {
1744         return 1;
1745 }
1746
1747 int ChannelEditCommon::button_release_event()
1748 {
1749         if(BC_Pot::button_release_event())
1750         {
1751                 channel_picker->set_picture(device_id, get_value());
1752                 return 1;
1753         }
1754         return 0;
1755 }
1756
1757 int ChannelEditCommon::keypress_event()
1758 {
1759         if(BC_Pot::keypress_event())
1760         {
1761                 channel_picker->set_picture(device_id, get_value());
1762                 return 1;
1763         }
1764         return 0;
1765 }
1766
1767
1768
1769
1770