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