cinelerra-5.1/plugins/reverb/reverbwindow.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 "bcdisplayinfo.h"
  23 #include "bchash.h"
  24 #include "bcsignals.h"
  25 #include "filesystem.h"
  26 #include "language.h"
  27 #include "reverb.h"
  28 #include "reverbwindow.h"
  29
  30 #include <string.h>
  31
  32
  33
  34 ReverbWindow::ReverbWindow(Reverb *reverb)
  35  : PluginClientWindow(reverb,
  36         xS(300),
  37         yS(230),
  38         xS(300),
  39         yS(230),
  40         0)
  41 {
  42         this->reverb = reverb;
  43 }
  44
  45 ReverbWindow::~ReverbWindow()
  46 {
  47 }
  48
  49 void ReverbWindow::create_objects()
  50 {
  51         int xs5 = xS(5), xs35 = xS(35), xs200 = xS(200);
  52         int ys10 = yS(10), ys25 = yS(25), ys40 = yS(40);
  53         int x = xs200, y = ys10;
  54         add_tool(new BC_Title(xs5, y + ys10, _("Initial signal level:")));
  55         add_tool(level_init = new ReverbLevelInit(reverb, x, y)); y += ys25;
  56         add_tool(new BC_Title(xs5, y + ys10, _("ms before reflections:")));
  57         add_tool(delay_init = new ReverbDelayInit(reverb, x + xs35, y)); y += ys25;
  58         add_tool(new BC_Title(xs5, y + ys10, _("First reflection level:")));
  59         add_tool(ref_level1 = new ReverbRefLevel1(reverb, x, y)); y += ys25;
  60         add_tool(new BC_Title(xs5, y + ys10, _("Last reflection level:")));
  61         add_tool(ref_level2 = new ReverbRefLevel2(reverb, x + xs35, y)); y += ys25;
  62         add_tool(new BC_Title(xs5, y + ys10, _("Number of reflections:")));
  63         add_tool(ref_total = new ReverbRefTotal(reverb, x, y)); y += ys25;
  64         add_tool(new BC_Title(xs5, y + ys10, _("ms of reflections:")));
  65         add_tool(ref_length = new ReverbRefLength(reverb, x + xs35, y)); y += ys25;
  66         add_tool(new BC_Title(xs5, y + ys10, _("Start band for lowpass:")));
  67         add_tool(lowpass1 = new ReverbLowPass1(reverb, x, y)); y += ys25;
  68         add_tool(new BC_Title(xs5, y + ys10, _("End band for lowpass:")));
  69         add_tool(lowpass2 = new ReverbLowPass2(reverb, x + xs35, y)); y += ys40;
  70         show_window();
  71         flush();
  72 }
  73
  74
  75
  76
  77
  78
  79 ReverbLevelInit::ReverbLevelInit(Reverb *reverb, int x, int y)
  80  : BC_FPot(x,
  81         y,
  82         reverb->config.level_init,
  83         INFINITYGAIN,
  84         0)
  85 {
  86         this->reverb = reverb;
  87 }
  88 ReverbLevelInit::~ReverbLevelInit()
  89 {
  90 }
  91 int ReverbLevelInit::handle_event()
  92 {
  93 //printf("ReverbLevelInit::handle_event 1 %p\n", reverb);
  94         reverb->config.level_init = get_value();
  95 //printf("ReverbLevelInit::handle_event 1\n");
  96         reverb->send_configure_change();
  97 //printf("ReverbLevelInit::handle_event 2\n");
  98         return 1;
  99 }
 100
 101 ReverbDelayInit::ReverbDelayInit(Reverb *reverb, int x, int y)
 102  : BC_IPot(x,
 103         y,
 104         reverb->config.delay_init,
 105         0,
 106         MAX_DELAY_INIT)
 107 {
 108         this->reverb = reverb;
 109 }
 110 ReverbDelayInit::~ReverbDelayInit()
 111 {
 112 }
 113 int ReverbDelayInit::handle_event()
 114 {
 115         reverb->config.delay_init = get_value();
 116         reverb->send_configure_change();
 117         return 1;
 118 }
 119
 120 ReverbRefLevel1::ReverbRefLevel1(Reverb *reverb, int x, int y)
 121  : BC_FPot(x,
 122         y,
 123         reverb->config.ref_level1,
 124         INFINITYGAIN,
 125         0)
 126 {
 127         this->reverb = reverb;
 128 }
 129 ReverbRefLevel1::~ReverbRefLevel1() {}
 130 int ReverbRefLevel1::handle_event()
 131 {
 132         reverb->config.ref_level1 = get_value();
 133         reverb->send_configure_change();
 134         return 1;
 135 }
 136
 137
 138 ReverbRefLevel2::ReverbRefLevel2(Reverb *reverb, int x, int y)
 139  : BC_FPot(x,
 140         y,
 141         reverb->config.ref_level2,
 142         INFINITYGAIN,
 143         0)
 144 {
 145         this->reverb = reverb;
 146 }
 147 ReverbRefLevel2::~ReverbRefLevel2() {}
 148 int ReverbRefLevel2::handle_event()
 149 {
 150         reverb->config.ref_level2 = get_value();
 151         reverb->send_configure_change();
 152         return 1;
 153 }
 154
 155 ReverbRefTotal::ReverbRefTotal(Reverb *reverb, int x, int y)
 156  : BC_IPot(x,
 157         y,
 158         reverb->config.ref_total,
 159         MIN_REFLECTIONS,
 160         MAX_REFLECTIONS)
 161 {
 162         this->reverb = reverb;
 163 }
 164 ReverbRefTotal::~ReverbRefTotal() {}
 165 int ReverbRefTotal::handle_event()
 166 {
 167         reverb->config.ref_total = get_value();
 168         reverb->send_configure_change();
 169         return 1;
 170 }
 171
 172
 173 ReverbRefLength::ReverbRefLength(Reverb *reverb, int x, int y)
 174  : BC_IPot(x,
 175         y,
 176         reverb->config.ref_length,
 177         0,
 178         MAX_REFLENGTH)
 179 {
 180         this->reverb = reverb;
 181 }
 182 ReverbRefLength::~ReverbRefLength() {}
 183 int ReverbRefLength::handle_event()
 184 {
 185         reverb->config.ref_length = get_value();
 186         reverb->send_configure_change();
 187         return 1;
 188 }
 189
 190 ReverbLowPass1::ReverbLowPass1(Reverb *reverb, int x, int y)
 191  : BC_QPot(x,
 192         y,
 193         reverb->config.lowpass1)
 194 {
 195         this->reverb = reverb;
 196 }
 197 ReverbLowPass1::~ReverbLowPass1() {}
 198 int ReverbLowPass1::handle_event()
 199 {
 200         reverb->config.lowpass1 = get_value();
 201         reverb->send_configure_change();
 202         return 1;
 203 }
 204
 205 ReverbLowPass2::ReverbLowPass2(Reverb *reverb, int x, int y)
 206  : BC_QPot(x,
 207         y,
 208         reverb->config.lowpass2)
 209 {
 210         this->reverb = reverb;
 211 }
 212 ReverbLowPass2::~ReverbLowPass2() {}
 213 int ReverbLowPass2::handle_event()
 214 {
 215         reverb->config.lowpass2 = get_value();
 216         reverb->send_configure_change();
 217         return 1;
 218 }
 219
 220 // ReverbMenu::ReverbMenu(Reverb *reverb, ReverbWindow *window)
 221 //  : BC_MenuBar(0, 0, window->get_w())
 222 // {
 223 //      this->window = window;
 224 //      this->reverb = reverb;
 225 // }
 226 //
 227 // ReverbMenu::~ReverbMenu()
 228 // {
 229 //      delete load;
 230 //      delete save;
 231 //      //delete set_default;
 232 //      for(int i = 0; i < total_loads; i++)
 233 //      {
 234 //              delete prev_load[i];
 235 //      }
 236 //      delete prev_load_thread;
 237 // }
 238 //
 239 // void ReverbMenu::create_objects(BC_Hash *defaults)
 240 // {
 241 //      add_menu(filemenu = new BC_Menu(_("File")));
 242 //      filemenu->add_item(load = new ReverbLoad(reverb, this));
 243 //      filemenu->add_item(save = new ReverbSave(reverb, this));
 244 //      //filemenu->add_item(set_default = new ReverbSetDefault);
 245 //      load_defaults(defaults);
 246 //      prev_load_thread = new ReverbLoadPrevThread(reverb, this);
 247 // }
 248 //
 249 // int ReverbMenu::load_defaults(BC_Hash *defaults)
 250 // {
 251 //      FileSystem fs;
 252 //      total_loads = defaults->get("TOTAL_LOADS", 0);
 253 //      if(total_loads > 0)
 254 //      {
 255 //              filemenu->add_item(new BC_MenuItem("-"));
 256 //              char string[1024], path[1024], filename[1024];
 257 //
 258 //              for(int i = 0; i < total_loads; i++)
 259 //              {
 260 //                      sprintf(string, "LOADPREVIOUS%d", i);
 261 //                      defaults->get(string, path);
 262 //                      fs.extract_name(filename, path);
 263 // //printf("ReverbMenu::load_defaults %s\n", path);
 264 //                      filemenu->add_item(prev_load[i] = new ReverbLoadPrev(reverb, this, filename, path));
 265 //              }
 266 //      }
 267 //      return 0;
 268 // }
 269 //
 270 // int ReverbMenu::save_defaults(BC_Hash *defaults)
 271 // {
 272 //      if(total_loads > 0)
 273 //      {
 274 //              defaults->update("TOTAL_LOADS",  total_loads);
 275 //              char string[1024];
 276 //
 277 //              for(int i = 0; i < total_loads; i++)
 278 //              {
 279 //                      sprintf(string, "LOADPREVIOUS%d", i);
 280 //                      defaults->update(string, prev_load[i]->path);
 281 //              }
 282 //      }
 283 //      return 0;
 284 // }
 285 //
 286 // int ReverbMenu::add_load(char *path)
 287 // {
 288 //      if(total_loads == 0)
 289 //      {
 290 //              filemenu->add_item(new BC_MenuItem("-"));
 291 //      }
 292 //
 293 // // test for existing copy
 294 //      FileSystem fs;
 295 //      char text[1024], new_path[1024];      // get text and path
 296 //      fs.extract_name(text, path);
 297 //      strcpy(new_path, path);
 298 //
 299 //      for(int i = 0; i < total_loads; i++)
 300 //      {
 301 //              if(!strcmp(prev_load[i]->get_text(), text))     // already exists
 302 //              {                                // swap for top load
 303 //                      for(int j = i; j > 0; j--)   // move preceeding loads down
 304 //                      {
 305 //                              prev_load[j]->set_text(prev_load[j - 1]->get_text());
 306 //                              prev_load[j]->set_path(prev_load[j - 1]->path);
 307 //                      }
 308 //                      prev_load[0]->set_text(text);
 309 //                      prev_load[0]->set_path(new_path);
 310 //                      return 1;
 311 //              }
 312 //      }
 313 //
 314 // // add another load
 315 //      if(total_loads < TOTAL_LOADS)
 316 //      {
 317 //              filemenu->add_item(prev_load[total_loads] = new ReverbLoadPrev(reverb, this));
 318 //              total_loads++;
 319 //      }
 320 //
 321 // // cycle loads down
 322 //      for(int i = total_loads - 1; i > 0; i--)
 323 //      {
 324 //      // set menu item text
 325 //              prev_load[i]->set_text(prev_load[i - 1]->get_text());
 326 //      // set filename
 327 //              prev_load[i]->set_path(prev_load[i - 1]->path);
 328 //      }
 329 //
 330 // // set up the new load
 331 //      prev_load[0]->set_text(text);
 332 //      prev_load[0]->set_path(new_path);
 333 //      return 0;
 334 // }
 335 //
 336 // ReverbLoad::ReverbLoad(Reverb *reverb, ReverbMenu *menu)
 337 //  : BC_MenuItem(_("Load..."))
 338 // {
 339 //      this->reverb = reverb;
 340 //      this->menu = menu;
 341 //      thread = new ReverbLoadThread(reverb, menu);
 342 // }
 343 // ReverbLoad::~ReverbLoad()
 344 // {
 345 //      delete thread;
 346 // }
 347 // int ReverbLoad::handle_event()
 348 // {
 349 //      thread->start();
 350 //      return 0;
 351 // }
 352 //
 353 // ReverbSave::ReverbSave(Reverb *reverb, ReverbMenu *menu)
 354 //  : BC_MenuItem(_("Save..."))
 355 // {
 356 //      this->reverb = reverb;
 357 //      this->menu = menu;
 358 //      thread = new ReverbSaveThread(reverb, menu);
 359 // }
 360 // ReverbSave::~ReverbSave()
 361 // {
 362 //      delete thread;
 363 // }
 364 // int ReverbSave::handle_event()
 365 // {
 366 //      thread->start();
 367 //      return 0;
 368 // }
 369 //
 370 // ReverbSetDefault::ReverbSetDefault()
 371 //  : BC_MenuItem(_("Set default"))
 372 // {
 373 // }
 374 // int ReverbSetDefault::handle_event()
 375 // {
 376 //      return 0;
 377 // }
 378 //
 379 // ReverbLoadPrev::ReverbLoadPrev(Reverb *reverb, ReverbMenu *menu, char *filename, char *path)
 380 //  : BC_MenuItem(filename)
 381 // {
 382 //      this->reverb = reverb;
 383 //      this->menu = menu;
 384 //      strcpy(this->path, path);
 385 // }
 386 // ReverbLoadPrev::ReverbLoadPrev(Reverb *reverb, ReverbMenu *menu)
 387 //  : BC_MenuItem("")
 388 // {
 389 //      this->reverb = reverb;
 390 //      this->menu = menu;
 391 // }
 392 // int ReverbLoadPrev::handle_event()
 393 // {
 394 //      menu->prev_load_thread->set_path(path);
 395 //      menu->prev_load_thread->start();
 396 // }
 397 // int ReverbLoadPrev::set_path(char *path)
 398 // {
 399 //      strcpy(this->path, path);
 400 // }
 401 //
 402 //
 403 // ReverbSaveThread::ReverbSaveThread(Reverb *reverb, ReverbMenu *menu)
 404 //  : Thread()
 405 // {
 406 //      this->reverb = reverb;
 407 //      this->menu = menu;
 408 // }
 409 // ReverbSaveThread::~ReverbSaveThread()
 410 // {
 411 // }
 412 // void ReverbSaveThread::run()
 413 // {
 414 //      int result = 0;
 415 //      {
 416 //              ReverbSaveDialog dialog(reverb);
 417 //              dialog.create_objects();
 418 //              result = dialog.run_window();
 419 // //           if(!result) strcpy(reverb->config_directory, dialog.get_path());
 420 //      }
 421 //      if(!result)
 422 //      {
 423 //              result = reverb->save_to_file(reverb->config_directory);
 424 //              menu->add_load(reverb->config_directory);
 425 //      }
 426 // }
 427 //
 428 // ReverbSaveDialog::ReverbSaveDialog(Reverb *reverb)
 429 //  : BC_FileBox(0,
 430 //                      0,
 431 //                      reverb->config_directory,
 432 //                      _("Save reverb"),
 433 //                      _("Select the reverb file to save as"), 0, 0)
 434 // {
 435 //      this->reverb = reverb;
 436 // }
 437 // ReverbSaveDialog::~ReverbSaveDialog()
 438 // {
 439 // }
 440 // int ReverbSaveDialog::ok_event()
 441 // {
 442 //      set_done(0);
 443 //      return 0;
 444 // }
 445 // int ReverbSaveDialog::cancel_event()
 446 // {
 447 //      set_done(1);
 448 //      return 0;
 449 // }
 450 //
 451 //
 452 //
 453 // ReverbLoadThread::ReverbLoadThread(Reverb *reverb, ReverbMenu *menu)
 454 //  : Thread()
 455 // {
 456 //      this->reverb = reverb;
 457 //      this->menu = menu;
 458 // }
 459 // ReverbLoadThread::~ReverbLoadThread()
 460 // {
 461 // }
 462 // void ReverbLoadThread::run()
 463 // {
 464 //      int result = 0;
 465 //      {
 466 //              ReverbLoadDialog dialog(reverb);
 467 //              dialog.create_objects();
 468 //              result = dialog.run_window();
 469 // //           if(!result) strcpy(reverb->config_directory, dialog.get_path());
 470 //      }
 471 //      if(!result)
 472 //      {
 473 //              result = reverb->load_from_file(reverb->config_directory);
 474 //              if(!result)
 475 //              {
 476 //                      menu->add_load(reverb->config_directory);
 477 //                      reverb->send_configure_change();
 478 //              }
 479 //      }
 480 // }
 481 //
 482 // ReverbLoadPrevThread::ReverbLoadPrevThread(Reverb *reverb, ReverbMenu *menu) : Thread()
 483 // {
 484 //      this->reverb = reverb;
 485 //      this->menu = menu;
 486 // }
 487 // ReverbLoadPrevThread::~ReverbLoadPrevThread()
 488 // {
 489 // }
 490 // void ReverbLoadPrevThread::run()
 491 // {
 492 //      int result = 0;
 493 //      strcpy(reverb->config_directory, path);
 494 //      result = reverb->load_from_file(path);
 495 //      if(!result)
 496 //      {
 497 //              menu->add_load(path);
 498 //              reverb->send_configure_change();
 499 //      }
 500 // }
 501 // int ReverbLoadPrevThread::set_path(char *path)
 502 // {
 503 //      strcpy(this->path, path);
 504 //      return 0;
 505 // }
 506 //
 507 //
 508 //
 509 //
 510 //
 511 // ReverbLoadDialog::ReverbLoadDialog(Reverb *reverb)
 512 //  : BC_FileBox(0,
 513 //                      0,
 514 //                      reverb->config_directory,
 515 //                      _("Load reverb"),
 516 //                      _("Select the reverb file to load from"), 0, 0)
 517 // {
 518 //      this->reverb = reverb;
 519 // }
 520 // ReverbLoadDialog::~ReverbLoadDialog()
 521 // {
 522 // }
 523 // int ReverbLoadDialog::ok_event()
 524 // {
 525 //      set_done(0);
 526 //      return 0;
 527 // }
 528 // int ReverbLoadDialog::cancel_event()
 529 // {
 530 //      set_done(1);
 531 //      return 0;
 532 // }
 533