cinelerra-5.1/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 <ctype.h>
  32 #include <string.h>
  33 #include "theme.h"
  34
  35 #define MASTER_NODE_FRAMERATE_TEXT "Master node framerate: %0.3f"
  36 #if 0
  37 N_(MASTER_NODE_FRAMERATE_TEXT)
  38 #endif
  39
  40 PerformancePrefs::PerformancePrefs(MWindow *mwindow, PreferencesWindow *pwindow)
  41  : PreferencesDialog(mwindow, pwindow)
  42 {
  43         hot_node = -1;
  44 }
  45
  46 PerformancePrefs::~PerformancePrefs()
  47 {
  48         delete brender_tools;
  49         nodes[0].remove_all_objects();
  50         nodes[1].remove_all_objects();
  51         nodes[2].remove_all_objects();
  52         nodes[3].remove_all_objects();
  53 }
  54
  55 void PerformancePrefs::create_objects()
  56 {
  57         int x, y;
  58         int xmargin1;
  59         int xmargin2 = 180;
  60         int xmargin3 = 260;
  61         int xmargin4 = 420;
  62         char string[BCTEXTLEN];
  63         BC_Resources *resources = BC_WindowBase::get_resources();
  64         BC_WindowBase *win;
  65         int maxw, curw;
  66
  67         node_list = 0;
  68         generate_node_list();
  69
  70         xmargin1 = x = mwindow->theme->preferencesoptions_x;
  71         y = mwindow->theme->preferencesoptions_y;
  72
  73         int y0 = y;
  74         win = add_subwindow(new BC_Title(x, y + 5, _("Cache size (MB):"), MEDIUMFONT, resources->text_default));
  75         maxw = win->get_w();
  76         int x1 = x + xmargin4;
  77         win = add_subwindow(new BC_Title(x1, y + 5, _("Use HW Device:")));
  78         x1 += win->get_w() + 5;
  79         PrefsUseHWDev *use_hw_dev = new PrefsUseHWDev(pwindow, this, x1, y);
  80         use_hw_dev->create_objects();
  81
  82         int y1 = y += 30;
  83         win = add_subwindow(new BC_Title(x, y + 5, _("Seconds to preroll renders:")));
  84         if((curw = win->get_w()) > maxw)
  85                 maxw = curw;
  86         maxw += x + 5;
  87
  88         cache_size = new CICacheSize(maxw, y0, pwindow, this);
  89         cache_size->create_objects();
  90
  91         add_subwindow(new BC_Title(x, y + 5, _("Seconds to preroll renders:")));
  92         PrefsRenderPreroll *preroll = new PrefsRenderPreroll(pwindow, this, maxw, y1);
  93         preroll->create_objects();
  94         y += 30;
  95
  96         x1 = x + xmargin4;
  97         BC_Title *smp_title = new BC_Title(x1, y + 5, _("Project SMP cpus:"));
  98         add_subwindow(smp_title);
  99         x1 += smp_title->get_w() + 5;
 100         PrefsProjectSMP *proj_smp = new PrefsProjectSMP(pwindow, this, x1, y);
 101         proj_smp->create_objects();
 102
 103         PrefsForceUniprocessor *force_1cpu = new PrefsForceUniprocessor(pwindow, x, y);
 104         add_subwindow(force_1cpu);
 105         y += 30;
 106
 107 // Background rendering
 108         add_subwindow(new BC_Bar(5, y,  get_w() - 10));
 109         y += 5;
 110
 111
 112         add_subwindow(new BC_Title(x, y, _("Background Rendering (Video only)"), LARGEFONT, resources->text_default));
 113         y1 = y += 30;
 114
 115         win = add_subwindow(new PrefsUseBRender(pwindow, x, y));
 116
 117         y += win->get_h() + 10;
 118         win = add_subwindow(new BC_Title(x, y, _("Frames per background rendering job:")));
 119         y += win->get_h() + 5;
 120         PrefsBRenderFragment *brender_fragment = new PrefsBRenderFragment(pwindow, this,
 121                 x + xmargin3, y);
 122         brender_fragment->create_objects();
 123         y += brender_fragment->get_h() + 5;
 124         win = add_subwindow(new BC_Title(x, y, _("Frames to preroll background:")));
 125         y += win->get_h() + 5;
 126         PrefsBRenderPreroll *bpreroll = new PrefsBRenderPreroll(pwindow, this,
 127                 x + xmargin3, y + 5);
 128         bpreroll->create_objects();
 129         y += bpreroll->get_h() + 20;
 130
 131         x += xmargin4;
 132         add_subwindow(new BC_Title(x, y1, _("Output for background rendering:")));
 133         y1 += 20;
 134         brender_tools = new FormatTools(mwindow, this,
 135                         pwindow->thread->preferences->brender_asset);
 136         brender_tools->create_objects(x, y1,
 137                 0,  // Include tools for audio
 138                 1,  // Include tools for video
 139                 0,  // Include checkbox for audio
 140                 0,  // Include checkbox for video
 141                 0,
 142                 1,
 143                 0,  // Select compressors to be offered
 144                 0,  // Prompt for recording options
 145                 0,  // prompt for use labels
 146                 1); // Supply file formats for background rendering
 147         x = xmargin1;
 148
 149
 150 // Renderfarm
 151         add_subwindow(new BC_Bar(5, y, get_w() - 10));
 152         y += 5;
 153         add_subwindow(new BC_Title(x, y, _("Render Farm"), LARGEFONT, resources->text_default));
 154         x1 = get_w() - BC_GenericButton::calculate_w(this, _("Reset rates")) - x;
 155         add_subwindow(new PrefsRenderFarmReset(pwindow, this, x1, y));
 156         x1 = x + xmargin4;
 157         BC_Title *node_title = new BC_Title(x1, y, _("Nodes:"));
 158         add_subwindow(node_title);
 159         x1 += node_title->get_w() + 15;
 160         sprintf(string, _(MASTER_NODE_FRAMERATE_TEXT),
 161                 pwindow->thread->preferences->local_rate);
 162         add_subwindow(master_rate = new BC_Title(x1, y, string));
 163         add_subwindow(node_list = new PrefsRenderFarmNodes(pwindow, this, x + xmargin4, y+=25));
 164         add_subwindow(new PrefsRenderFarm(pwindow, x, y+=5));
 165         add_subwindow(new BC_Title(x, y+=30, _("Hostname:")));
 166         add_subwindow(new BC_Title(x + xmargin3, y, _("Port:")));
 167         add_subwindow(edit_node = new PrefsRenderFarmEditNode(pwindow, this, x, y+=25));
 168         edit_port = new PrefsRenderFarmPort(pwindow, this, x+xmargin3, y);
 169         edit_port->create_objects();
 170
 171         add_subwindow(new PrefsRenderFarmReplaceNode(pwindow, this, x, y+=30));
 172         add_subwindow(new PrefsRenderFarmNewNode(pwindow, this, x+xmargin2, y));
 173         add_subwindow(new PrefsRenderFarmSortNodes(pwindow, this, x, y+=30));
 174         add_subwindow(new PrefsRenderFarmDelNode(pwindow, this, x+xmargin2, y));
 175         add_subwindow(new BC_Title(x, y+=35, _("Client Watchdog Timeout:")));
 176         renderfarm_watchdog = new PrefsRenderFarmWatchdog(pwindow, this, x+xmargin3, y-5);
 177         renderfarm_watchdog->create_objects();
 178         add_subwindow(new BC_Title(x, y+=35, _("Total jobs to create:")));
 179         PrefsRenderFarmJobs *jobs = new PrefsRenderFarmJobs(pwindow, this,
 180                 x + xmargin3, y-5);
 181         jobs->create_objects();
 182         y += jobs->get_h() + 5;
 183         win = add_subwindow(new BC_Title(x, y,
 184                 _("(overridden if new file at each label is checked)")));
 185 //      y += win->get_h() + 5;
 186 //      add_subwindow(new PrefsRenderFarmVFS(pwindow, this, x, y));
 187 //      add_subwindow(new BC_Title(x, y,
 188 //              _("Filesystem prefix on remote nodes:")));
 189 //      add_subwindow(new PrefsRenderFarmMountpoint(pwindow, this, x + xmargin3, y));
 190 //      y += 30;
 191 }
 192
 193 void PerformancePrefs::generate_node_list()
 194 {
 195         int selected_row = node_list ? node_list->get_selection_number(0, 0) : -1;
 196
 197         for(int i = 0; i < TOTAL_COLUMNS; i++)
 198                 nodes[i].remove_all_objects();
 199
 200         for(int i = 0;
 201                 i < pwindow->thread->preferences->renderfarm_nodes.size();
 202                 i++)
 203         {
 204                 BC_ListBoxItem *item;
 205                 nodes[ENABLED_COLUMN].append(item = new BC_ListBoxItem(
 206                         (char*)(pwindow->thread->preferences->renderfarm_enabled.get(i) ? "X" : " ")));
 207                 if(i == selected_row) item->set_selected(1);
 208
 209                 nodes[HOSTNAME_COLUMN].append(item = new BC_ListBoxItem(
 210                         pwindow->thread->preferences->renderfarm_nodes.get(i)));
 211                 if(i == selected_row) item->set_selected(1);
 212
 213                 char string[BCTEXTLEN];
 214                 sprintf(string, "%d", pwindow->thread->preferences->renderfarm_ports.get(i));
 215                 nodes[PORT_COLUMN].append(item = new BC_ListBoxItem(string));
 216                 if(i == selected_row) item->set_selected(1);
 217
 218                 sprintf(string, "%0.3f", pwindow->thread->preferences->renderfarm_rate.get(i));
 219                 nodes[RATE_COLUMN].append(item = new BC_ListBoxItem(string));
 220                 if(i == selected_row) item->set_selected(1);
 221         }
 222 }
 223
 224
 225 static const char *default_titles[] = {
 226         N_("On"), N_("Hostname"), N_("Port"), N_("Framerate")
 227 };
 228
 229 static int default_widths[] = {
 230         30, 150, 50, 50
 231 };
 232
 233
 234 void PerformancePrefs::update_node_list()
 235 {
 236         node_list->update_list();
 237 }
 238
 239 void PrefsRenderFarmNodes::update_list()
 240 {
 241         update(subwindow->nodes, titles, widths, PerformancePrefs::TOTAL_COLUMNS,
 242                 get_xposition(), get_yposition(), get_selection_number(0, 0));
 243 }
 244
 245
 246 void PerformancePrefs::update_rates()
 247 {
 248 //printf("PerformancePrefs::update_rates %d\n", __LINE__);
 249         char string[BCTEXTLEN];
 250         for(int i = 0;
 251                 i < mwindow->preferences->renderfarm_rate.size();
 252                 i++)
 253         {
 254                 if(i < nodes[RATE_COLUMN].size())
 255                 {
 256                         sprintf(string, "%0.3f", mwindow->preferences->renderfarm_rate.get(i));
 257                         nodes[RATE_COLUMN].get(i)->set_text(string);
 258                 }
 259         }
 260
 261         sprintf(string, _(MASTER_NODE_FRAMERATE_TEXT),
 262                 mwindow->preferences->local_rate);
 263         master_rate->update(string);
 264
 265         update_node_list();
 266 }
 267
 268
 269 PrefsUseBRender::PrefsUseBRender(PreferencesWindow *pwindow,
 270         int x,
 271         int y)
 272  : BC_CheckBox(x,
 273         y,
 274         pwindow->thread->preferences->use_brender,
 275         _("Use background rendering"))
 276 {
 277         this->pwindow = pwindow;
 278 }
 279
 280 int PrefsUseBRender::handle_event()
 281 {
 282         pwindow->thread->redraw_overlays = 1;
 283         pwindow->thread->redraw_times = 1;
 284         pwindow->thread->preferences->use_brender = get_value();
 285         return 1;
 286 }
 287
 288
 289 PrefsBRenderFragment::PrefsBRenderFragment(PreferencesWindow *pwindow,
 290         PerformancePrefs *subwindow, int x, int y)
 291  : BC_TumbleTextBox(subwindow,
 292         (int64_t)pwindow->thread->preferences->brender_fragment,
 293         (int64_t)1, (int64_t)65535, x, y, 100)
 294 {
 295         this->pwindow = pwindow;
 296 }
 297 int PrefsBRenderFragment::handle_event()
 298 {
 299         pwindow->thread->preferences->brender_fragment = atol(get_text());
 300         return 1;
 301 }
 302
 303 CICacheSize::CICacheSize(int x, int y,
 304         PreferencesWindow *pwindow, PerformancePrefs *subwindow)
 305  : BC_TumbleTextBox(subwindow,
 306         (int64_t)pwindow->thread->preferences->cache_size / 0x100000,
 307         (int64_t)MIN_CACHE_SIZE / 0x100000,
 308         (int64_t)MAX_CACHE_SIZE / 0x100000,
 309         x, y, 100)
 310 {
 311         this->pwindow = pwindow;
 312         set_increment(1);
 313 }
 314
 315 int CICacheSize::handle_event()
 316 {
 317         int64_t result;
 318         result = (int64_t)atol(get_text()) * 0x100000;
 319         CLAMP(result, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 320         pwindow->thread->preferences->cache_size = result;
 321         return 0;
 322 }
 323
 324
 325 PrefsUseHWDev::PrefsUseHWDev(PreferencesWindow *pwindow,
 326                 PerformancePrefs *subwindow, int x, int y)
 327  : BC_PopupTextBox(subwindow,0,0,x,y,100,80,LISTBOX_TEXT)
 328 {
 329         this->pwindow = pwindow;
 330 }
 331
 332 void PrefsUseHWDev::create_objects()
 333 {
 334         BC_PopupTextBox::create_objects();
 335         set_tooltip(_("vdpau - Nvidia, Nouveau\n"
 336                 "vaapi - Broadcom, Intel HD graphics, Amdgpu, Radeon\n"
 337                 "cuda  - Nvidia + Cuda SDK"));
 338         hw_dev_names.append(new BC_ListBoxItem(_("none")));
 339 #ifdef HAVE_VAAPI
 340         hw_dev_names.append(new BC_ListBoxItem("vaapi"));
 341 #endif
 342 #ifdef HAVE_VDPAU
 343         hw_dev_names.append(new BC_ListBoxItem("vdpau"));
 344 #endif
 345 #ifdef HAVE_NV
 346         hw_dev_names.append(new BC_ListBoxItem("cuda"));
 347 #endif
 348         update_list(&hw_dev_names);
 349         update(&pwindow->thread->preferences->use_hw_dev[0]);
 350 }
 351
 352 int PrefsUseHWDev::handle_event()
 353 {
 354         strncpy(&pwindow->thread->preferences->use_hw_dev[0],
 355                 get_text(), sizeof(pwindow->thread->preferences->use_hw_dev));
 356         return 1;
 357 }
 358
 359 PrefsRenderPreroll::PrefsRenderPreroll(PreferencesWindow *pwindow,
 360                 PerformancePrefs *subwindow,
 361                 int x,
 362                 int y)
 363  : BC_TumbleTextBox(subwindow,
 364         (float)pwindow->thread->preferences->render_preroll,
 365         (float)0,
 366         (float)100,
 367         x,
 368         y,
 369         100)
 370 {
 371         this->pwindow = pwindow;
 372         set_increment(0.1);
 373 }
 374 PrefsRenderPreroll::~PrefsRenderPreroll()
 375 {
 376 }
 377 int PrefsRenderPreroll::handle_event()
 378 {
 379         pwindow->thread->preferences->render_preroll = atof(get_text());
 380         return 1;
 381 }
 382
 383
 384 PrefsBRenderPreroll::PrefsBRenderPreroll(PreferencesWindow *pwindow,
 385                 PerformancePrefs *subwindow,
 386                 int x,
 387                 int y)
 388  : BC_TumbleTextBox(subwindow,
 389         (int64_t)pwindow->thread->preferences->brender_preroll,
 390         (int64_t)0,
 391         (int64_t)100,
 392         x,
 393         y,
 394         100)
 395 {
 396         this->pwindow = pwindow;
 397 }
 398 int PrefsBRenderPreroll::handle_event()
 399 {
 400         pwindow->thread->preferences->brender_preroll = atol(get_text());
 401         return 1;
 402 }
 403
 404
 405 PrefsRenderFarm::PrefsRenderFarm(PreferencesWindow *pwindow, int x, int y)
 406  : BC_CheckBox(x,
 407         y,
 408         pwindow->thread->preferences->use_renderfarm,
 409         _("Use render farm"))
 410 {
 411         this->pwindow = pwindow;
 412 }
 413 PrefsRenderFarm::~PrefsRenderFarm()
 414 {
 415 }
 416 int PrefsRenderFarm::handle_event()
 417 {
 418         pwindow->thread->preferences->use_renderfarm = get_value();
 419         return 1;
 420 }
 421
 422
 423 PrefsForceUniprocessor::PrefsForceUniprocessor(PreferencesWindow *pwindow, int x, int y)
 424  : BC_CheckBox(x,
 425         y,
 426         pwindow->thread->preferences->force_uniprocessor,
 427         _("Force single processor use"))
 428 {
 429         this->pwindow = pwindow;
 430 }
 431 PrefsForceUniprocessor::~PrefsForceUniprocessor()
 432 {
 433 }
 434 int PrefsForceUniprocessor::handle_event()
 435 {
 436         pwindow->thread->preferences->force_uniprocessor = get_value();
 437         return 1;
 438 }
 439
 440
 441
 442 PrefsRenderFarmConsolidate::PrefsRenderFarmConsolidate(PreferencesWindow *pwindow, int x, int y)
 443  : BC_CheckBox(x,
 444         y,
 445         pwindow->thread->preferences->renderfarm_consolidate,
 446         _("Consolidate output files on completion"))
 447 {
 448         this->pwindow = pwindow;
 449 }
 450 PrefsRenderFarmConsolidate::~PrefsRenderFarmConsolidate()
 451 {
 452 }
 453 int PrefsRenderFarmConsolidate::handle_event()
 454 {
 455         pwindow->thread->preferences->renderfarm_consolidate = get_value();
 456         return 1;
 457 }
 458
 459
 460 PrefsRenderFarmPort::PrefsRenderFarmPort(PreferencesWindow *pwindow,
 461         PerformancePrefs *subwindow,
 462         int x,
 463         int y)
 464  : BC_TumbleTextBox(subwindow,
 465         (int64_t)pwindow->thread->preferences->renderfarm_port,
 466         (int64_t)1,
 467         (int64_t)65535,
 468         x,
 469         y,
 470         100)
 471 {
 472         this->pwindow = pwindow;
 473 }
 474
 475 PrefsRenderFarmPort::~PrefsRenderFarmPort()
 476 {
 477 }
 478
 479 int PrefsRenderFarmPort::handle_event()
 480 {
 481         pwindow->thread->preferences->renderfarm_port = atol(get_text());
 482         return 1;
 483 }
 484
 485
 486
 487 PrefsRenderFarmNodes::PrefsRenderFarmNodes(PreferencesWindow *pwindow,
 488         PerformancePrefs *subwindow, int x, int y)
 489  : BC_ListBox(x, y, 340, 230, LISTBOX_TEXT, 0,0,0,1, 0,0, LISTBOX_MULTIPLE)
 490 {
 491         for( int i=0; i<PerformancePrefs::TOTAL_COLUMNS; ++i ) {
 492                 titles[i] = _(default_titles[i]);
 493                 widths[i] = default_widths[i];
 494         }
 495         update(subwindow->nodes, titles, widths, PerformancePrefs::TOTAL_COLUMNS,
 496                 0, 0, -1, 0, 0);
 497         this->subwindow = subwindow;
 498         this->pwindow = pwindow;
 499 }
 500 PrefsRenderFarmNodes::~PrefsRenderFarmNodes()
 501 {
 502 }
 503
 504 int PrefsRenderFarmNodes::column_resize_event()
 505 {
 506         for( int i=0; i<PerformancePrefs::TOTAL_COLUMNS; ++i )
 507                 widths[i] = get_column_width(i);
 508         return 1;
 509 }
 510
 511 int PrefsRenderFarmNodes::handle_event()
 512 {
 513 SET_TRACE
 514         if(get_selection_number(0, 0) >= 0)
 515         {
 516                 subwindow->hot_node = get_selection_number(1, 0);
 517                 subwindow->edit_node->update(get_selection(1, 0)->get_text());
 518                 const char *text = get_selection(2, 0)->get_text();
 519                 subwindow->edit_port->update(text);
 520                 pwindow->thread->preferences->renderfarm_port = atol(text);
 521                 if(get_cursor_x() < widths[0])
 522                 {
 523                         pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node] =
 524                                 !pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node];
 525                         subwindow->generate_node_list();
 526                         subwindow->update_node_list();
 527                 }
 528         }
 529         else
 530         {
 531                 subwindow->hot_node = -1;
 532                 subwindow->edit_node->update("");
 533         }
 534 SET_TRACE
 535         return 1;
 536 }
 537 int PrefsRenderFarmNodes::selection_changed()
 538 {
 539         handle_event();
 540         return 1;
 541 }
 542
 543
 544 PrefsRenderFarmEditNode::PrefsRenderFarmEditNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 545  : BC_TextBox(x, y, 240, 1, "")
 546 {
 547         this->pwindow = pwindow;
 548         this->subwindow = subwindow;
 549 }
 550
 551 PrefsRenderFarmEditNode::~PrefsRenderFarmEditNode()
 552 {
 553 }
 554
 555 int PrefsRenderFarmEditNode::handle_event()
 556 {
 557         return 1;
 558 }
 559
 560
 561 PrefsRenderFarmNewNode::PrefsRenderFarmNewNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 562  : BC_GenericButton(x, y, _("Add Nodes"))
 563 {
 564         this->pwindow = pwindow;
 565         this->subwindow = subwindow;
 566 }
 567 PrefsRenderFarmNewNode::~PrefsRenderFarmNewNode()
 568 {
 569 }
 570 int PrefsRenderFarmNewNode::handle_event()
 571 {
 572         const char *name = subwindow->edit_node->get_text();
 573         char *cp = (char*)subwindow->edit_port->get_text();
 574         int64_t start_port = strtol(cp, &cp, 0), end_port = start_port;
 575         while( isspace(*cp) ) ++cp;
 576         if( *cp++ == '-' )
 577                 end_port = strtol(cp, &cp, 0);
 578         for( int port=start_port; port<=end_port; ++port ) {
 579                 pwindow->thread->preferences->add_node(name, port, 1, 0.0);
 580         }
 581         pwindow->thread->preferences->renderfarm_port = end_port;
 582         subwindow->edit_port->update(end_port);
 583         pwindow->thread->preferences->reset_rates();
 584         subwindow->generate_node_list();
 585         subwindow->update_node_list();
 586         subwindow->hot_node = -1;
 587         return 1;
 588 }
 589
 590
 591 PrefsRenderFarmReplaceNode::PrefsRenderFarmReplaceNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 592  : BC_GenericButton(x, y, _("Apply Changes"))
 593 {
 594         this->pwindow = pwindow;
 595         this->subwindow = subwindow;
 596 }
 597 PrefsRenderFarmReplaceNode::~PrefsRenderFarmReplaceNode()
 598 {
 599 }
 600 int PrefsRenderFarmReplaceNode::handle_event()
 601 {
 602         if(subwindow->hot_node >= 0)
 603         {
 604                 pwindow->thread->preferences->edit_node(subwindow->hot_node,
 605                         subwindow->edit_node->get_text(),
 606                         pwindow->thread->preferences->renderfarm_port,
 607                         pwindow->thread->preferences->renderfarm_enabled.values[subwindow->hot_node]);
 608                 subwindow->generate_node_list();
 609                 subwindow->update_node_list();
 610         }
 611         return 1;
 612 }
 613
 614
 615 PrefsRenderFarmDelNode::PrefsRenderFarmDelNode(PreferencesWindow *pwindow, PerformancePrefs *subwindow, int x, int y)
 616  : BC_GenericButton(x, y, _("Delete Nodes"))
 617 {
 618         this->pwindow = pwindow;
 619         this->subwindow = subwindow;
 620 }
 621 PrefsRenderFarmDelNode::~PrefsRenderFarmDelNode()
 622 {
 623 }
 624 int PrefsRenderFarmDelNode::handle_event()
 625 {
 626         ArrayList<BC_ListBoxItem *> &item_list = subwindow->nodes[0];
 627         for( int i=item_list.size(); --i>=0; ) {
 628                 if( !item_list[i]->get_selected() ) continue;
 629                 pwindow->thread->preferences->delete_node(i);
 630         }
 631         subwindow->generate_node_list();
 632         subwindow->update_node_list();
 633         subwindow->hot_node = -1;
 634         return 1;
 635 }
 636
 637
 638 PrefsRenderFarmSortNodes::PrefsRenderFarmSortNodes(PreferencesWindow *pwindow,
 639         PerformancePrefs *subwindow,
 640         int x,
 641         int y)
 642  : BC_GenericButton(x, y, _("Sort nodes"))
 643 {
 644         this->pwindow = pwindow;
 645         this->subwindow = subwindow;
 646 }
 647
 648 PrefsRenderFarmSortNodes::~PrefsRenderFarmSortNodes()
 649 {
 650 }
 651
 652 int PrefsRenderFarmSortNodes::handle_event()
 653 {
 654         pwindow->thread->preferences->sort_nodes();
 655         subwindow->generate_node_list();
 656         subwindow->update_node_list();
 657         subwindow->hot_node = -1;
 658         return 1;
 659 }
 660
 661
 662 PrefsRenderFarmReset::PrefsRenderFarmReset(PreferencesWindow *pwindow,
 663         PerformancePrefs *subwindow, int x, int y)
 664  : BC_GenericButton(x, y, _("Reset rates"))
 665 {
 666         this->pwindow = pwindow;
 667         this->subwindow = subwindow;
 668 }
 669
 670 int PrefsRenderFarmReset::handle_event()
 671 {
 672         pwindow->thread->preferences->reset_rates();
 673         subwindow->generate_node_list();
 674         subwindow->update_node_list();
 675
 676         char string[BCTEXTLEN];
 677         sprintf(string,
 678                 _(MASTER_NODE_FRAMERATE_TEXT),
 679                 pwindow->thread->preferences->local_rate);
 680         subwindow->master_rate->update(string);
 681         subwindow->hot_node = -1;
 682         return 1;
 683 }
 684
 685
 686 PrefsProjectSMP::PrefsProjectSMP(PreferencesWindow *pwindow,
 687                 PerformancePrefs *subwindow, int x, int y)
 688  : BC_TumbleTextBox(subwindow,
 689         (int64_t)pwindow->thread->preferences->project_smp,
 690         (int64_t)1, (int64_t)100, x, y, 100)
 691 {
 692         this->pwindow = pwindow;
 693 }
 694 PrefsProjectSMP::~PrefsProjectSMP()
 695 {
 696 }
 697 int PrefsProjectSMP::handle_event()
 698 {
 699         pwindow->thread->preferences->project_smp = atol(get_text());
 700         return 1;
 701 }
 702
 703
 704 PrefsRenderFarmJobs::PrefsRenderFarmJobs(PreferencesWindow *pwindow,
 705                 PerformancePrefs *subwindow,
 706                 int x,
 707                 int y)
 708  : BC_TumbleTextBox(subwindow,
 709         (int64_t)pwindow->thread->preferences->renderfarm_job_count,
 710         (int64_t)1, (int64_t)100, x, y, 100)
 711 {
 712         this->pwindow = pwindow;
 713 }
 714 PrefsRenderFarmJobs::~PrefsRenderFarmJobs()
 715 {
 716 }
 717 int PrefsRenderFarmJobs::handle_event()
 718 {
 719         pwindow->thread->preferences->renderfarm_job_count = atol(get_text());
 720         return 1;
 721 }
 722
 723
 724 PrefsRenderFarmMountpoint::PrefsRenderFarmMountpoint(PreferencesWindow *pwindow,
 725                 PerformancePrefs *subwindow, int x, int y)
 726  : BC_TextBox(x, y, 100, 1,
 727         pwindow->thread->preferences->renderfarm_mountpoint)
 728 {
 729         this->pwindow = pwindow;
 730         this->subwindow = subwindow;
 731 }
 732 PrefsRenderFarmMountpoint::~PrefsRenderFarmMountpoint()
 733 {
 734 }
 735 int PrefsRenderFarmMountpoint::handle_event()
 736 {
 737         strcpy(pwindow->thread->preferences->renderfarm_mountpoint, get_text());
 738         return 1;
 739 }
 740
 741
 742 PrefsRenderFarmVFS::PrefsRenderFarmVFS(PreferencesWindow *pwindow,
 743         PerformancePrefs *subwindow, int x, int y)
 744  : BC_CheckBox(x, y, pwindow->thread->preferences->renderfarm_vfs,
 745         _("Use virtual filesystem"))
 746 {
 747         this->pwindow = pwindow;
 748         this->subwindow = subwindow;
 749 }
 750
 751 int PrefsRenderFarmVFS::handle_event()
 752 {
 753         pwindow->thread->preferences->renderfarm_vfs = get_value();
 754         return 1;
 755 }
 756
 757
 758 PrefsRenderFarmWatchdog::PrefsRenderFarmWatchdog(PreferencesWindow *pwindow,
 759                 PerformancePrefs *subwindow, int x, int y)
 760  : BC_TumbleTextBox(subwindow,
 761         (int64_t)pwindow->thread->preferences->renderfarm_watchdog_timeout,
 762         (int64_t)0, (int64_t)1000, x, y, 100)
 763 {
 764         this->pwindow = pwindow;
 765         set_increment(15);
 766 }
 767
 768 int PrefsRenderFarmWatchdog::handle_event()
 769 {
 770         pwindow->thread->preferences->renderfarm_watchdog_timeout = atol(get_text());
 771         return 1;
 772 }
 773
 774