cinelerra-5.0/cinelerra/performanceprefs.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 "bcsignals.h"
  23 #include "clip.h"
  24 #include "edl.h"
  25 #include "edlsession.h"
  26 #include "formattools.h"
  27 #include "language.h"
  28 #include "mwindow.h"
  29 #include "performanceprefs.h"
  30 #include "preferences.h"
  31 #include <string.h>
  32 #include "theme.h"
  33
  34 #define MASTER_NODE_FRAMERATE_TEXT "Master node framerate: %0.3f"
  35 #if 0
  36 N_(MASTER_NODE_FRAMERATE_TEXT)
  37 #endif
  38
  39 PerformancePrefs::PerformancePrefs(MWindow *mwindow, PreferencesWindow *pwindow)
  40  : PreferencesDialog(mwindow, pwindow)
  41 {
  42         hot_node = -1;
  43 }
  44
  45 PerformancePrefs::~PerformancePrefs()
  46 {
  47         delete brender_tools;
  48         nodes[0].remove_all_objects();
  49         nodes[1].remove_all_objects();
  50         nodes[2].remove_all_objects();
  51         nodes[3].remove_all_objects();
  52 }
  53
  54 void PerformancePrefs::create_objects()
  55 {
  56         int x, y;
  57         int xmargin1;
  58         int xmargin2 = 170;
  59         int xmargin3 = 250;
  60         int xmargin4 = 380;
  61         char string[BCTEXTLEN];
  62         BC_Resources *resources = BC_WindowBase::get_resources();
  63
  64         node_list = 0;
  65         generate_node_list();
  66
  67         xmargin1 = x = mwindow->theme->preferencesoptions_x;
  68         y = mwindow->theme->preferencesoptions_y;
  69
  70 //      add_subwindow(new BC_Title(x,
  71 //              y,
  72 //              _("Time Format"),
  73 //              LARGEFONT,
  74 //              resources->text_default));
  75 //
  76 //      y += get_text_height(LARGEFONT) + 5;
  77
  78         add_subwindow(new BC_Title(x, y + 5, _("Cache size (MB):"), MEDIUMFONT, resources->text_default));
  79         cache_size = new CICacheSize(x + 230,
  80                 y,
  81                 pwindow,
  82                 this);
  83         cache_size->create_objects();
  84         y += 30;
  85         add_subwindow(new BC_Title(x, y + 5, _("Seconds to preroll renders:")));
  86         PrefsRenderPreroll *preroll = new PrefsRenderPreroll(pwindow,
  87                 this,
  88                 x + 230,
  89                 y);
  90         preroll->create_objects();
  91         y += 30;
  92         PrefsForceUniprocessor *force_1cpu = new PrefsForceUniprocessor(pwindow, x, y);
  93         add_subwindow(force_1cpu);
  94
  95         int x1 = force_1cpu->get_x() + force_1cpu->get_w() + 50;
  96         int y1 = force_1cpu->get_y();
  97
  98         PrefsTrapSigSEGV *trap_segv = new PrefsTrapSigSEGV(this, x1, y1);
  99         add_subwindow(trap_segv);
 100         int x2 = x1 + trap_segv->get_w() + 10;
 101         add_subwindow(new BC_Title(x2, y1, _("(must be root)"), MEDIUMFONT, RED));
 102         y1 += 30;
 103         PrefsTrapSigINTR *trap_intr = new PrefsTrapSigINTR(this, x1, y1);
 104         add_subwindow(trap_intr);
 105         add_subwindow(new BC_Title(x2, y1, _("(must be root)"), MEDIUMFONT, RED));
 106         y += 30;
 107
 108         file_forking = new PrefsFileForking(this, x, y);
 109         add_subwindow(file_forking);
 110         file_forking->check_enable();
 111         y += 30;
 112
 113         ffmpeg_early_probe = new PrefsFFMPEGEarlyProbe(this, x, y);
 114         add_subwindow(ffmpeg_early_probe);
 115         x1 = x + ffmpeg_early_probe->get_w() + 24;
 116         ffmpeg_marker_indecies = new PrefsFFMPEGMarkerIndecies(this, x1, y);
 117         add_subwindow(ffmpeg_marker_indecies);
 118         y += 30;
 119
 120
 121
 122
 123 // Background rendering
 124         add_subwindow(new BC_Bar(5, y,  get_w() - 10));
 125         y += 5;
 126
 127
 128         add_subwindow(new BC_Title(x, y, _("Background Rendering (Video only)"), LARGEFONT, resources->text_default));
 129         y += 30;
 130
 131         add_subwindow(new PrefsUseBRender(pwindow,
 132                 x,
 133                 y));
 134
 135
 136         add_subwindow(new BC_Title(x, y + 40, _("Frames per background rendering job:")));
 137         PrefsBRenderFragment *brender_fragment = new PrefsBRenderFragment(pwindow,
 138                 this,
 139                 x,
 140                 y + 60);
 141         brender_fragment->create_objects();
 142         add_subwindow(new BC_Title(x, y + 95, _("Frames to preroll background:")));
 143         PrefsBRenderPreroll *bpreroll = new PrefsBRenderPreroll(pwindow,
 144                 this,
 145                 x + xmargin3,
 146                 y + 90);
 147         bpreroll->create_objects();
 148
 149
 150         x += xmargin4;
 151         add_subwindow(new BC_Title(x, y, _("Output for background rendering:")));
 152         y += 20;
 153         brender_tools =
 154                 new FormatTools(mwindow,
 155                         this,
 156                         pwindow->thread->preferences->brender_asset);
 157         brender_tools->create_objects(x,
 158                 y,
 159                 0,  // Include tools for audio
 160                 1,  // Include tools for video
 161                 0,  // Include checkbox for audio
 162                 0,  // Include checkbox for video
 163                 0,
 164                 1,
 165                 0,  // Select compressors to be offered
 166                 0,  // Prompt for recording options
 167                 0,  // If nonzero, prompt for insertion strategy
 168                 1); // Supply file formats for background rendering
 169         x = xmargin1;
 170
 171
 172 // Renderfarm
 173         add_subwindow(new BC_Bar(5, y,  get_w() - 10));
 174         y += 5;
 175         add_subwindow(new BC_Title(x, y, _("Render Farm"), LARGEFONT, resources->text_default));
 176         x1 = x + xmargin4;
 177         BC_Title *node_title = new BC_Title(x1, y, _("Nodes:"));
 178         add_subwindow(node_title);
 179         x1 += node_title->get_w() + 25;
 180         sprintf(string, _(MASTER_NODE_FRAMERATE_TEXT),
 181                 pwindow->thread->preferences->local_rate);
 182         add_subwindow(master_rate = new BC_Title(x1, y, string));
 183         y += 25;
 184         add_subwindow(node_list = new PrefsRenderFarmNodes(pwindow,
 185                 this,
 186                 x + xmargin4,
 187                 y));
 188         y += 5;
 189         add_subwindow(new PrefsRenderFarm(pwindow, x, y));
 190         y += 30;
 191         add_subwindow(new BC_Title(x, y, _("Hostname:")));
 192         add_subwindow(new BC_Title(x + xmargin3, y, _("Port:")));
 193
 194         y += 25;
 195         add_subwindow(edit_node = new PrefsRenderFarmEditNode(pwindow,
 196                 this,
 197                 x,
 198                 y));
 199         edit_port = new PrefsRenderFarmPort(pwindow,
 200                 this,
 201                 x + xmargin3,
 202                 y);
 203         edit_port->create_objects();
 204
 205         y += 30;
 206
 207
 208         add_subwindow(new PrefsRenderFarmReplaceNode(pwindow,
 209                 this,
 210                 x,
 211                 y));
 212         add_subwindow(new PrefsRenderFarmNewNode(pwindow,
 213                 this,
 214                 x + xmargin2,
 215                 y));
 216         y += 30;
 217         add_subwindow(new PrefsRenderFarmDelNode(pwindow,
 218                 this,
 219                 x + xmargin2,
 220                 y));
 221         add_subwindow(new PrefsRenderFarmSortNodes(pwindow,
 222                 this,
 223                 x,
 224                 y));
 225         y += 30;
 226         add_subwindow(new PrefsRenderFarmReset(pwindow,
 227                 this,
 228                 x,
 229                 y));
 230         y += 35;
 231         add_subwindow(new BC_Title(x,
 232                 y,
 233                 _("Total jobs to create:")));
 234         add_subwindow(new BC_Title(x,
 235                 y + 30,
 236                 _("(overridden if new file at each label is checked)")));
 237         PrefsRenderFarmJobs *jobs = new PrefsRenderFarmJobs(pwindow,
 238                 this,
 239                 x + xmargin3,
 240                 y);
 241         jobs->create_objects();
 242         y += 55;
 243 //      add_subwindow(new PrefsRenderFarmVFS(pwindow,
 244 //              this,
 245 //              x,
 246 //              y));
 247 //      add_subwindow(new BC_Title(x,
 248 //              y,
 249 //              _("Filesystem prefix on remote nodes:")));
 250 //      add_subwindow(new PrefsRenderFarmMountpoint(pwindow,
 251 //              this,
 252 //              x + xmargin3,
 253 //              y));
 254 //      y += 30;
 255 }
 256
 257 void PerformancePrefs::generate_node_list()
 258 {
 259         int selected_row = node_list ? node_list->get_selection_number(0, 0) : -1;
 260
 261         for(int i = 0; i < TOTAL_COLUMNS; i++)
 262                 nodes[i].remove_all_objects();
 263
 264         for(int i = 0;
 265                 i < pwindow->thread->preferences->renderfarm_nodes.size();
 266                 i++)
 267         {
 268                 BC_ListBoxItem *item;
 269                 nodes[ENABLED_COLUMN].append(item = new BC_ListBoxItem(
 270                         (char*)(pwindow->thread->preferences->renderfarm_enabled.get(i) ? "X" : " ")));
 271                 if(i == selected_row) item->set_selected(1);
 272
 273                 nodes[HOSTNAME_COLUMN].append(item = new BC_ListBoxItem(
 274                         pwindow->thread->preferences->renderfarm_nodes.get(i)));
 275                 if(i == selected_row) item->set_selected(1);
 276
 277                 char string[BCTEXTLEN];
 278                 sprintf(string, "%d", pwindow->thread->preferences->renderfarm_ports.get(i));
 279                 nodes[PORT_COLUMN].append(item = new BC_ListBoxItem(string));
 280                 if(i == selected_row) item->set_selected(1);
 281
 282                 sprintf(string, "%0.3f", pwindow->thread->preferences->renderfarm_rate.get(i));
 283                 nodes[RATE_COLUMN].append(item = new BC_ListBoxItem(string));
 284                 if(i == selected_row) item->set_selected(1);
 285         }
 286 }
 287
 288 static const char *titles[] =
 289 {
 290         N_("On"),
 291         N_("Hostname"),
 292         N_("Port"),
 293         N_("Framerate")
 294 };
 295
 296 static int widths[] =
 297 {
 298         30,
 299         150,
 300         50,
 301         50
 302 };
 303
 304
 305 void PerformancePrefs::update_node_list()
 306 {
 307         node_list->update(nodes,
 308                                                 titles,
 309                                                 widths,
 310                                                 TOTAL_COLUMNS,
 311                                                 node_list->get_xposition(),
 312                                                 node_list->get_yposition(),
 313                                                 node_list->get_selection_number(0, 0));
 314 }
 315
 316
 317 void PerformancePrefs::update_rates()
 318 {
 319 //printf("PerformancePrefs::update_rates %d\n", __LINE__);
 320         char string[BCTEXTLEN];
 321         for(int i = 0;
 322                 i < mwindow->preferences->renderfarm_rate.size();
 323                 i++)
 324         {
 325                 if(i < nodes[RATE_COLUMN].size())
 326                 {
 327                         sprintf(string, "%0.3f", mwindow->preferences->renderfarm_rate.get(i));
 328                         nodes[RATE_COLUMN].get(i)->set_text(string);
 329                 }
 330         }
 331
 332         sprintf(string, _(MASTER_NODE_FRAMERATE_TEXT),
 333                 mwindow->preferences->local_rate);
 334         master_rate->update(string);
 335
 336         update_node_list();
 337 }
 338
 339
 340 PrefsUseBRender::PrefsUseBRender(PreferencesWindow *pwindow,
 341         int x,
 342         int y)
 343  : BC_CheckBox(x,
 344         y,
 345         pwindow->thread->preferences->use_brender,
 346         _("Use background rendering"))
 347 {
 348         this->pwindow = pwindow;
 349 }
 350
 351 int PrefsUseBRender::handle_event()
 352 {
 353         pwindow->thread->redraw_overlays = 1;
 354         pwindow->thread->redraw_times = 1;
 355         pwindow->thread->preferences->use_brender = get_value();
 356         return 1;
 357 }
 358
 359
 360
 361
 362
 363
 364 PrefsBRenderFragment::PrefsBRenderFragment(PreferencesWindow *pwindow,
 365         PerformancePrefs *subwindow,
 366         int x,
 367         int y)
 368  : BC_TumbleTextBox(subwindow,
 369         (int64_t)pwindow->thread->preferences->brender_fragment,
 370         (int64_t)1,
 371         (int64_t)65535,
 372         x,
 373         y,
 374         100)
 375 {
 376         this->pwindow = pwindow;
 377 }
 378 int PrefsBRenderFragment::handle_event()
 379 {
 380         pwindow->thread->preferences->brender_fragment = atol(get_text());
 381         return 1;
 382 }
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394 CICacheSize::CICacheSize(int x,
 395         int y,
 396         PreferencesWindow *pwindow,
 397         PerformancePrefs *subwindow)
 398  : BC_TumbleTextBox(subwindow,
 399         (int64_t)pwindow->thread->preferences->cache_size / 0x100000,
 400         (int64_t)MIN_CACHE_SIZE / 0x100000,
 401         (int64_t)MAX_CACHE_SIZE / 0x100000,
 402         x,
 403         y,
 404         100)
 405 {
 406         this->pwindow = pwindow;
 407         set_increment(1);
 408 }
 409
 410 int CICacheSize::handle_event()
 411 {
 412         int64_t result;
 413         result = (int64_t)atol(get_text()) * 0x100000;
 414         CLAMP(result, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 415         pwindow->thread->preferences->cache_size = result;
 416         return 0;
 417 }
 418
 419
 420 PrefsRenderPreroll::PrefsRenderPreroll(PreferencesWindow *pwindow,
 421                 PerformancePrefs *subwindow,
 422                 int x,
 423                 int y)
 424  : BC_TumbleTextBox(subwindow,
 425         (float)pwindow->thread->preferences->render_preroll,
 426         (float)0,
 427         (float)100,
 428         x,
 429         y,
 430         100)
 431 {
 432         this->pwindow = pwindow;
 433         set_increment(0.1);
 434 }
 435 PrefsRenderPreroll::~PrefsRenderPreroll()
 436 {
 437 }
 438 int PrefsRenderPreroll::handle_event()
 439 {
 440         pwindow->thread->preferences->render_preroll = atof(get_text());
 441         return 1;
 442 }
 443
 444
 445 PrefsBRenderPreroll::PrefsBRenderPreroll(PreferencesWindow *pwindow,
 446                 PerformancePrefs *subwindow,
 447                 int x,
 448                 int y)
 449  : BC_TumbleTextBox(subwindow,
 450         (int64_t)pwindow->thread->preferences->brender_preroll,
 451         (int64_t)0,
 452         (int64_t)100,
 453         x,
 454         y,
 455         100)
 456 {
 457         this->pwindow = pwindow;
 458 }
 459 int PrefsBRenderPreroll::handle_event()
 460 {
 461         pwindow->thread->preferences->brender_preroll = atol(get_text());
 462         return 1;
 463 }
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475 PrefsRenderFarm::PrefsRenderFarm(PreferencesWindow *pwindow, int x, int y)
 476  : BC_CheckBox(x,
 477         y,
 478         pwindow->thread->preferences->use_renderfarm,
 479         _("Use render farm"))
 480 {
 481         this->pwindow = pwindow;
 482 }
 483 PrefsRenderFarm::~PrefsRenderFarm()
 484 {
 485 }
 486 int PrefsRenderFarm::handle_event()
 487 {
 488         pwindow->thread->preferences->use_renderfarm = get_value();
 489         return 1;
 490 }
 491
 492
 493
 494
 495 PrefsForceUniprocessor::PrefsForceUniprocessor(PreferencesWindow *pwindow, int x, int y)
 496  : BC_CheckBox(x,
 497         y,
 498         pwindow->thread->preferences->force_uniprocessor,
 499         _("Force single processor use"))
 500 {
 501         this->pwindow = pwindow;
 502 }
 503 PrefsForceUniprocessor::~PrefsForceUniprocessor()
 504 {
 505 }
 506 int PrefsForceUniprocessor::handle_event()
 507 {
 508         pwindow->thread->preferences->force_uniprocessor = get_value();
 509         return 1;
 510 }
 511
 512 PrefsTrapSigSEGV::PrefsTrapSigSEGV(PerformancePrefs *perf_prefs, int x, int y)
 513  : BC_CheckBox(x, y,
 514         perf_prefs->pwindow->thread->preferences->trap_sigsegv,
 515         _("trap sigSEGV"))
 516 {
 517         this->perf_prefs = perf_prefs;
 518 }
 519 PrefsTrapSigSEGV::~PrefsTrapSigSEGV()
 520 {
 521 }
 522 int PrefsTrapSigSEGV::handle_event()
 523 {
 524         perf_prefs->pwindow->thread->preferences->trap_sigsegv = get_value();
 525         perf_prefs->file_forking->check_enable();
 526         return 1;
 527 }
 528
 529 PrefsTrapSigINTR::PrefsTrapSigINTR(PerformancePrefs *perf_prefs, int x, int y)
 530  : BC_CheckBox(x, y,
 531         perf_prefs->pwindow->thread->preferences->trap_sigintr,
 532         _("trap sigINT"))
 533 {
 534         this->perf_prefs = perf_prefs;
 535 }
 536 PrefsTrapSigINTR::~PrefsTrapSigINTR()
 537 {
 538 }
 539 int PrefsTrapSigINTR::handle_event()
 540 {
 541         perf_prefs->pwindow->thread->preferences->trap_sigintr = get_value();
 542         perf_prefs->file_forking->check_enable();
 543         return 1;
 544 }
 545
 546
 547 PrefsFileForking::PrefsFileForking(PerformancePrefs *perf_prefs, int x, int y)
 548  : BC_CheckBox(x, y,
 549         perf_prefs->pwindow->thread->preferences->file_forking,
 550         _("enable/disable file fork"))
 551 {
 552         this->perf_prefs = perf_prefs;
 553 }
 554 PrefsFileForking::~PrefsFileForking()
 555 {
 556 }
 557 int PrefsFileForking::handle_event()
 558 {
 559         perf_prefs->pwindow->thread->preferences->file_forking = get_value();
 560         return 1;
 561 }
 562
 563 void PrefsFileForking::check_enable()
 564 {
 565         Preferences *preferences = perf_prefs->pwindow->thread->preferences;
 566         if( preferences->trap_sigsegv || preferences->trap_sigintr ) {
 567                 preferences->file_forking = 0;
 568                 update(0, 0);
 569                 disable();
 570         }
 571         else if( !preferences->trap_sigsegv && !preferences->trap_sigintr ) {
 572                 enable();
 573         }
 574 }
 575
 576
 577 PrefsFFMPEGEarlyProbe::PrefsFFMPEGEarlyProbe(PerformancePrefs *perf_prefs, int x, int y)
 578  : BC_CheckBox(x, y,
 579         perf_prefs->pwindow->thread->preferences->ffmpeg_early_probe,
 580         _("On file open, ffmpeg probes early"))
 581 {
 582         this->perf_prefs = perf_prefs;
 583 }
 584 PrefsFFMPEGEarlyProbe::~PrefsFFMPEGEarlyProbe()
 585 {
 586 }
 587
 588 int PrefsFFMPEGEarlyProbe::handle_event()
 589 {
 590         perf_prefs->pwindow->thread->preferences->ffmpeg_early_probe = get_value();
 591         return 1;
 592 }
 593
 594
 595 PrefsFFMPEGMarkerIndecies::PrefsFFMPEGMarkerIndecies(PerformancePrefs *perf_prefs, int x, int y)
 596  : BC_CheckBox(x, y,
 597         perf_prefs->pwindow->thread->preferences->ffmpeg_marker_indecies,
 598         _("build ffmpeg marker indecies"))
 599 {
 600         this->perf_prefs = perf_prefs;
 601 }
 602 PrefsFFMPEGMarkerIndecies::~PrefsFFMPEGMarkerIndecies()
 603 {
 604 }
 605
 606 int PrefsFFMPEGMarkerIndecies::handle_event()
 607 {
 608         perf_prefs->pwindow->thread->preferences->ffmpeg_marker_indecies = get_value();
 609         return 1;
 610 }
 611
 612
 613
 614
 615
 616
 617 PrefsRenderFarmConsolidate::PrefsRenderFarmConsolidate(PreferencesWindow *pwindow, int x, int y)
 618  : BC_CheckBox(x,
 619         y,
 620         pwindow->thread->preferences->renderfarm_consolidate,
 621         _("Consolidate output files on completion"))
 622 {
 623         this->pwindow = pwindow;
 624 }
 625 PrefsRenderFarmConsolidate::~PrefsRenderFarmConsolidate()
 626 {
 627 }
 628 int PrefsRenderFarmConsolidate::handle_event()
 629 {
 630         pwindow->thread->preferences->renderfarm_consolidate = get_value();
 631         return 1;
 632 }
 633
 634
 635
 636
 637
 638 PrefsRenderFarmPort::PrefsRenderFarmPort(PreferencesWindow *pwindow,
 639         PerformancePrefs *subwindow,
 640         int x,
 641         int y)
 642  : BC_TumbleTextBox(subwindow,
 643         (int64_t)pwindow->thread->preferences->renderfarm_port,
 644         (int64_t)1,
 645         (int64_t)65535,
 646         x,
 647         y,
 648         100)
 649 {
 650         this->pwindow = pwindow;
 651 }
 652
 653 PrefsRenderFarmPort::~PrefsRenderFarmPort()
 654 {
 655 }
 656
 657 int PrefsRenderFarmPort::handle_event()
 658 {
 659         pwindow->thread->preferences->renderfarm_port = atol(get_text());
 660         return 1;
 661 }
 662
 663
 664
 665 PrefsRenderFarmNodes::PrefsRenderFarmNodes(PreferencesWindow *pwindow,
 666         PerformancePrefs *subwindow,
 667         int x,
 668         int y)
 669  : BC_ListBox(x,
 670                 y,
 671                 340,
 672                 230,
 673                 LISTBOX_TEXT,                         // Display text list or icons
 674                 subwindow->nodes,
 675                 titles,
 676                 widths,
 677                 4)
 678 {
 679         this->subwindow = subwindow;
 680         this->pwindow = pwindow;
 681 }
 682 PrefsRenderFarmNodes::~PrefsRenderFarmNodes()
 683 {
 684 }
 685
 686 int PrefsRenderFarmNodes::column_resize_event()
 687 {
 688         for(int i = 0; i < 3; i++)
 689                 widths[i] = get_column_width(i);
 690         return 1;
 691 }
 692
 693 int PrefsRenderFarmNodes::handle_event()
 694 {
 695 SET_TRACE
 696         if(get_selection_number(0, 0) >= 0)
 697         {
 698                 subwindow->hot_node = get_selection_number(1, 0);
 699                 subwindow->edit_node->update(get_selection(1, 0)->get_text());
 700                 subwindow->edit_port->update(get_selection(2, 0)->get_text());
 701                 if(get_cursor_x() < widths[0])
 702                 {
 703                         pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node] =
 704                                 !pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node];
 705                         subwindow->generate_node_list();
 706                         subwindow->update_node_list();
 707                 }
 708         }
 709         else
 710         {
 711                 subwindow->hot_node = -1;
 712                 subwindow->edit_node->update("");
 713         }
 714 SET_TRACE
 715         return 1;
 716 }
 717 int PrefsRenderFarmNodes::selection_changed()
 718 {
 719         handle_event();
 720         return 1;
 721 }
 722
 723
 724
 725
 726
 727
 728
 729 PrefsRenderFarmEditNode::PrefsRenderFarmEditNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 730  : BC_TextBox(x, y, 240, 1, "")
 731 {
 732         this->pwindow = pwindow;
 733         this->subwindow = subwindow;
 734 }
 735
 736 PrefsRenderFarmEditNode::~PrefsRenderFarmEditNode()
 737 {
 738 }
 739
 740 int PrefsRenderFarmEditNode::handle_event()
 741 {
 742         return 1;
 743 }
 744
 745
 746
 747
 748
 749
 750 PrefsRenderFarmNewNode::PrefsRenderFarmNewNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 751  : BC_GenericButton(x, y, _("Add Node"))
 752 {
 753         this->pwindow = pwindow;
 754         this->subwindow = subwindow;
 755 }
 756 PrefsRenderFarmNewNode::~PrefsRenderFarmNewNode()
 757 {
 758 }
 759 int PrefsRenderFarmNewNode::handle_event()
 760 {
 761         pwindow->thread->preferences->add_node(subwindow->edit_node->get_text(),
 762                 pwindow->thread->preferences->renderfarm_port,
 763                 1,
 764                 0.0);
 765         pwindow->thread->preferences->reset_rates();
 766         subwindow->generate_node_list();
 767         subwindow->update_node_list();
 768         subwindow->hot_node = -1;
 769         return 1;
 770 }
 771
 772
 773
 774
 775
 776
 777
 778 PrefsRenderFarmReplaceNode::PrefsRenderFarmReplaceNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 779  : BC_GenericButton(x, y, _("Apply Changes"))
 780 {
 781         this->pwindow = pwindow;
 782         this->subwindow = subwindow;
 783 }
 784 PrefsRenderFarmReplaceNode::~PrefsRenderFarmReplaceNode()
 785 {
 786 }
 787 int PrefsRenderFarmReplaceNode::handle_event()
 788 {
 789         if(subwindow->hot_node >= 0)
 790         {
 791                 pwindow->thread->preferences->edit_node(subwindow->hot_node,
 792                         subwindow->edit_node->get_text(),
 793                         pwindow->thread->preferences->renderfarm_port,
 794                         pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node]);
 795                 subwindow->generate_node_list();
 796                 subwindow->update_node_list();
 797         }
 798         return 1;
 799 }
 800
 801
 802
 803
 804
 805 PrefsRenderFarmDelNode::PrefsRenderFarmDelNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 806  : BC_GenericButton(x, y, _("Delete Node"))
 807 {
 808         this->pwindow = pwindow;
 809         this->subwindow = subwindow;
 810 }
 811 PrefsRenderFarmDelNode::~PrefsRenderFarmDelNode()
 812 {
 813 }
 814 int PrefsRenderFarmDelNode::handle_event()
 815 {
 816         if(strlen(subwindow->edit_node->get_text()) &&
 817                 subwindow->hot_node >= 0)
 818         {
 819
 820                 pwindow->thread->preferences->delete_node(subwindow->hot_node);
 821
 822                 subwindow->generate_node_list();
 823                 subwindow->update_node_list();
 824                 subwindow->hot_node = -1;
 825         }
 826         return 1;
 827 }
 828
 829
 830
 831
 832
 833 PrefsRenderFarmSortNodes::PrefsRenderFarmSortNodes(PreferencesWindow *pwindow,
 834         PerformancePrefs *subwindow,
 835         int x,
 836         int y)
 837  : BC_GenericButton(x, y, _("Sort nodes"))
 838 {
 839         this->pwindow = pwindow;
 840         this->subwindow = subwindow;
 841 }
 842
 843 PrefsRenderFarmSortNodes::~PrefsRenderFarmSortNodes()
 844 {
 845 }
 846
 847 int PrefsRenderFarmSortNodes::handle_event()
 848 {
 849         pwindow->thread->preferences->sort_nodes();
 850         subwindow->generate_node_list();
 851         subwindow->update_node_list();
 852         subwindow->hot_node = -1;
 853         return 1;
 854 }
 855
 856
 857
 858
 859
 860 PrefsRenderFarmReset::PrefsRenderFarmReset(PreferencesWindow *pwindow,
 861         PerformancePrefs *subwindow,
 862         int x,
 863         int y)
 864  : BC_GenericButton(x, y, _("Reset rates"))
 865 {
 866         this->pwindow = pwindow;
 867         this->subwindow = subwindow;
 868 }
 869
 870 int PrefsRenderFarmReset::handle_event()
 871 {
 872         pwindow->thread->preferences->reset_rates();
 873         subwindow->generate_node_list();
 874         subwindow->update_node_list();
 875
 876         char string[BCTEXTLEN];
 877         sprintf(string,
 878                 MASTER_NODE_FRAMERATE_TEXT,
 879                 pwindow->thread->preferences->local_rate);
 880         subwindow->master_rate->update(string);
 881         subwindow->hot_node = -1;
 882         return 1;
 883 }
 884
 885
 886
 887
 888
 889
 890
 891 PrefsRenderFarmJobs::PrefsRenderFarmJobs(PreferencesWindow *pwindow,
 892                 PerformancePrefs *subwindow,
 893                 int x,
 894                 int y)
 895  : BC_TumbleTextBox(subwindow,
 896         (int64_t)pwindow->thread->preferences->renderfarm_job_count,
 897         (int64_t)1,
 898         (int64_t)100,
 899         x,
 900         y,
 901         100)
 902 {
 903         this->pwindow = pwindow;
 904 }
 905 PrefsRenderFarmJobs::~PrefsRenderFarmJobs()
 906 {
 907 }
 908 int PrefsRenderFarmJobs::handle_event()
 909 {
 910         pwindow->thread->preferences->renderfarm_job_count = atol(get_text());
 911         return 1;
 912 }
 913
 914
 915
 916 PrefsRenderFarmMountpoint::PrefsRenderFarmMountpoint(PreferencesWindow *pwindow,
 917                 PerformancePrefs *subwindow,
 918                 int x,
 919                 int y)
 920  : BC_TextBox(x,
 921         y,
 922         100,
 923         1,
 924         pwindow->thread->preferences->renderfarm_mountpoint)
 925 {
 926         this->pwindow = pwindow;
 927         this->subwindow = subwindow;
 928 }
 929 PrefsRenderFarmMountpoint::~PrefsRenderFarmMountpoint()
 930 {
 931 }
 932 int PrefsRenderFarmMountpoint::handle_event()
 933 {
 934         strcpy(pwindow->thread->preferences->renderfarm_mountpoint, get_text());
 935         return 1;
 936 }
 937
 938
 939
 940
 941 PrefsRenderFarmVFS::PrefsRenderFarmVFS(PreferencesWindow *pwindow,
 942         PerformancePrefs *subwindow,
 943         int x,
 944         int y)
 945  : BC_CheckBox(x, y, pwindow->thread->preferences->renderfarm_vfs, _("Use virtual filesystem"))
 946 {
 947         this->pwindow = pwindow;
 948         this->subwindow = subwindow;
 949 }
 950
 951 int PrefsRenderFarmVFS::handle_event()
 952 {
 953         pwindow->thread->preferences->renderfarm_vfs = get_value();
 954         return 1;
 955 }
 956