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