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