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