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         250,
  37         230,
  38         250,
  39         230,
  40         0)
  41 {
  42         this->reverb = reverb;
  43 }
  44
  45 ReverbWindow::~ReverbWindow()
  46 {
  47 }
  48
  49 void ReverbWindow::create_objects()
  50 {
  51         int x = 170, y = 10;
  52         add_tool(new BC_Title(5, y + 10, _("Initial signal level:")));
  53         add_tool(level_init = new ReverbLevelInit(reverb, x, y)); y += 25;
  54         add_tool(new BC_Title(5, y + 10, _("ms before reflections:")));
  55         add_tool(delay_init = new ReverbDelayInit(reverb, x + 35, y)); y += 25;
  56         add_tool(new BC_Title(5, y + 10, _("First reflection level:")));
  57         add_tool(ref_level1 = new ReverbRefLevel1(reverb, x, y)); y += 25;
  58         add_tool(new BC_Title(5, y + 10, _("Last reflection level:")));
  59         add_tool(ref_level2 = new ReverbRefLevel2(reverb, x + 35, y)); y += 25;
  60         add_tool(new BC_Title(5, y + 10, _("Number of reflections:")));
  61         add_tool(ref_total = new ReverbRefTotal(reverb, x, y)); y += 25;
  62         add_tool(new BC_Title(5, y + 10, _("ms of reflections:")));
  63         add_tool(ref_length = new ReverbRefLength(reverb, x + 35, y)); y += 25;
  64         add_tool(new BC_Title(5, y + 10, _("Start band for lowpass:")));
  65         add_tool(lowpass1 = new ReverbLowPass1(reverb, x, y)); y += 25;
  66         add_tool(new BC_Title(5, y + 10, _("End band for lowpass:")));
  67         add_tool(lowpass2 = new ReverbLowPass2(reverb, x + 35, y)); y += 40;
  68         show_window();
  69         flush();
  70 }
  71
  72
  73
  74
  75
  76
  77 ReverbLevelInit::ReverbLevelInit(Reverb *reverb, int x, int y)
  78  : BC_FPot(x,
  79         y,
  80         reverb->config.level_init,
  81         INFINITYGAIN,
  82         0)
  83 {
  84         this->reverb = reverb;
  85 }
  86 ReverbLevelInit::~ReverbLevelInit()
  87 {
  88 }
  89 int ReverbLevelInit::handle_event()
  90 {
  91 //printf("ReverbLevelInit::handle_event 1 %p\n", reverb);
  92         reverb->config.level_init = get_value();
  93 //printf("ReverbLevelInit::handle_event 1\n");
  94         reverb->send_configure_change();
  95 //printf("ReverbLevelInit::handle_event 2\n");
  96         return 1;
  97 }
  98
  99 ReverbDelayInit::ReverbDelayInit(Reverb *reverb, int x, int y)
 100  : BC_IPot(x,
 101         y,
 102         reverb->config.delay_init,
 103         0,
 104         MAX_DELAY_INIT)
 105 {
 106         this->reverb = reverb;
 107 }
 108 ReverbDelayInit::~ReverbDelayInit()
 109 {
 110 }
 111 int ReverbDelayInit::handle_event()
 112 {
 113         reverb->config.delay_init = get_value();
 114         reverb->send_configure_change();
 115         return 1;
 116 }
 117
 118 ReverbRefLevel1::ReverbRefLevel1(Reverb *reverb, int x, int y)
 119  : BC_FPot(x,
 120         y,
 121         reverb->config.ref_level1,
 122         INFINITYGAIN,
 123         0)
 124 {
 125         this->reverb = reverb;
 126 }
 127 ReverbRefLevel1::~ReverbRefLevel1() {}
 128 int ReverbRefLevel1::handle_event()
 129 {
 130         reverb->config.ref_level1 = get_value();
 131         reverb->send_configure_change();
 132         return 1;
 133 }
 134
 135
 136 ReverbRefLevel2::ReverbRefLevel2(Reverb *reverb, int x, int y)
 137  : BC_FPot(x,
 138         y,
 139         reverb->config.ref_level2,
 140         INFINITYGAIN,
 141         0)
 142 {
 143         this->reverb = reverb;
 144 }
 145 ReverbRefLevel2::~ReverbRefLevel2() {}
 146 int ReverbRefLevel2::handle_event()
 147 {
 148         reverb->config.ref_level2 = get_value();
 149         reverb->send_configure_change();
 150         return 1;
 151 }
 152
 153 ReverbRefTotal::ReverbRefTotal(Reverb *reverb, int x, int y)
 154  : BC_IPot(x,
 155         y,
 156         reverb->config.ref_total,
 157         MIN_REFLECTIONS,
 158         MAX_REFLECTIONS)
 159 {
 160         this->reverb = reverb;
 161 }
 162 ReverbRefTotal::~ReverbRefTotal() {}
 163 int ReverbRefTotal::handle_event()
 164 {
 165         reverb->config.ref_total = get_value();
 166         reverb->send_configure_change();
 167         return 1;
 168 }
 169
 170
 171 ReverbRefLength::ReverbRefLength(Reverb *reverb, int x, int y)
 172  : BC_IPot(x,
 173         y,
 174         reverb->config.ref_length,
 175         0,
 176         MAX_REFLENGTH)
 177 {
 178         this->reverb = reverb;
 179 }
 180 ReverbRefLength::~ReverbRefLength() {}
 181 int ReverbRefLength::handle_event()
 182 {
 183         reverb->config.ref_length = get_value();
 184         reverb->send_configure_change();
 185         return 1;
 186 }
 187
 188 ReverbLowPass1::ReverbLowPass1(Reverb *reverb, int x, int y)
 189  : BC_QPot(x,
 190         y,
 191         reverb->config.lowpass1)
 192 {
 193         this->reverb = reverb;
 194 }
 195 ReverbLowPass1::~ReverbLowPass1() {}
 196 int ReverbLowPass1::handle_event()
 197 {
 198         reverb->config.lowpass1 = get_value();
 199         reverb->send_configure_change();
 200         return 1;
 201 }
 202
 203 ReverbLowPass2::ReverbLowPass2(Reverb *reverb, int x, int y)
 204  : BC_QPot(x,
 205         y,
 206         reverb->config.lowpass2)
 207 {
 208         this->reverb = reverb;
 209 }
 210 ReverbLowPass2::~ReverbLowPass2() {}
 211 int ReverbLowPass2::handle_event()
 212 {
 213         reverb->config.lowpass2 = get_value();
 214         reverb->send_configure_change();
 215         return 1;
 216 }
 217
 218 ReverbMenu::ReverbMenu(Reverb *reverb, ReverbWindow *window)
 219  : BC_MenuBar(0, 0, window->get_w())
 220 {
 221         this->window = window;
 222         this->reverb = reverb;
 223 }
 224
 225 ReverbMenu::~ReverbMenu()
 226 {
 227         delete load;
 228         delete save;
 229         //delete set_default;
 230         for(int i = 0; i < total_loads; i++)
 231         {
 232                 delete prev_load[i];
 233         }
 234         delete prev_load_thread;
 235 }
 236
 237 void ReverbMenu::create_objects(BC_Hash *defaults)
 238 {
 239         add_menu(filemenu = new BC_Menu(_("File")));
 240         filemenu->add_item(load = new ReverbLoad(reverb, this));
 241         filemenu->add_item(save = new ReverbSave(reverb, this));
 242         //filemenu->add_item(set_default = new ReverbSetDefault);
 243         load_defaults(defaults);
 244         prev_load_thread = new ReverbLoadPrevThread(reverb, this);
 245 }
 246
 247 int ReverbMenu::load_defaults(BC_Hash *defaults)
 248 {
 249         FileSystem fs;
 250         total_loads = defaults->get("TOTAL_LOADS", 0);
 251         if(total_loads > 0)
 252         {
 253                 filemenu->add_item(new BC_MenuItem("-"));
 254                 char string[1024], path[1024], filename[1024];
 255
 256                 for(int i = 0; i < total_loads; i++)
 257                 {
 258                         sprintf(string, "LOADPREVIOUS%d", i);
 259                         defaults->get(string, path);
 260                         fs.extract_name(filename, path);
 261 //printf("ReverbMenu::load_defaults %s\n", path);
 262                         filemenu->add_item(prev_load[i] = new ReverbLoadPrev(reverb, this, filename, path));
 263                 }
 264         }
 265         return 0;
 266 }
 267
 268 int ReverbMenu::save_defaults(BC_Hash *defaults)
 269 {
 270         if(total_loads > 0)
 271         {
 272                 defaults->update("TOTAL_LOADS",  total_loads);
 273                 char string[1024];
 274
 275                 for(int i = 0; i < total_loads; i++)
 276                 {
 277                         sprintf(string, "LOADPREVIOUS%d", i);
 278                         defaults->update(string, prev_load[i]->path);
 279                 }
 280         }
 281         return 0;
 282 }
 283
 284 int ReverbMenu::add_load(char *path)
 285 {
 286         if(total_loads == 0)
 287         {
 288                 filemenu->add_item(new BC_MenuItem("-"));
 289         }
 290
 291 // test for existing copy
 292         FileSystem fs;
 293         char text[1024], new_path[1024];      // get text and path
 294         fs.extract_name(text, path);
 295         strcpy(new_path, path);
 296
 297         for(int i = 0; i < total_loads; i++)
 298         {
 299                 if(!strcmp(prev_load[i]->get_text(), text))     // already exists
 300                 {                                // swap for top load
 301                         for(int j = i; j > 0; j--)   // move preceeding loads down
 302                         {
 303                                 prev_load[j]->set_text(prev_load[j - 1]->get_text());
 304                                 prev_load[j]->set_path(prev_load[j - 1]->path);
 305                         }
 306                         prev_load[0]->set_text(text);
 307                         prev_load[0]->set_path(new_path);
 308                         return 1;
 309                 }
 310         }
 311
 312 // add another load
 313         if(total_loads < TOTAL_LOADS)
 314         {
 315                 filemenu->add_item(prev_load[total_loads] = new ReverbLoadPrev(reverb, this));
 316                 total_loads++;
 317         }
 318
 319 // cycle loads down
 320         for(int i = total_loads - 1; i > 0; i--)
 321         {
 322         // set menu item text
 323                 prev_load[i]->set_text(prev_load[i - 1]->get_text());
 324         // set filename
 325                 prev_load[i]->set_path(prev_load[i - 1]->path);
 326         }
 327
 328 // set up the new load
 329         prev_load[0]->set_text(text);
 330         prev_load[0]->set_path(new_path);
 331         return 0;
 332 }
 333
 334 ReverbLoad::ReverbLoad(Reverb *reverb, ReverbMenu *menu)
 335  : BC_MenuItem(_("Load..."))
 336 {
 337         this->reverb = reverb;
 338         this->menu = menu;
 339         thread = new ReverbLoadThread(reverb, menu);
 340 }
 341 ReverbLoad::~ReverbLoad()
 342 {
 343         delete thread;
 344 }
 345 int ReverbLoad::handle_event()
 346 {
 347         thread->start();
 348         return 0;
 349 }
 350
 351 ReverbSave::ReverbSave(Reverb *reverb, ReverbMenu *menu)
 352  : BC_MenuItem(_("Save..."))
 353 {
 354         this->reverb = reverb;
 355         this->menu = menu;
 356         thread = new ReverbSaveThread(reverb, menu);
 357 }
 358 ReverbSave::~ReverbSave()
 359 {
 360         delete thread;
 361 }
 362 int ReverbSave::handle_event()
 363 {
 364         thread->start();
 365         return 0;
 366 }
 367
 368 ReverbSetDefault::ReverbSetDefault()
 369  : BC_MenuItem(_("Set default"))
 370 {
 371 }
 372 int ReverbSetDefault::handle_event()
 373 {
 374         return 0;
 375 }
 376
 377 ReverbLoadPrev::ReverbLoadPrev(Reverb *reverb, ReverbMenu *menu, char *filename, char *path)
 378  : BC_MenuItem(filename)
 379 {
 380         this->reverb = reverb;
 381         this->menu = menu;
 382         strcpy(this->path, path);
 383 }
 384 ReverbLoadPrev::ReverbLoadPrev(Reverb *reverb, ReverbMenu *menu)
 385  : BC_MenuItem("")
 386 {
 387         this->reverb = reverb;
 388         this->menu = menu;
 389 }
 390 int ReverbLoadPrev::handle_event()
 391 {
 392         menu->prev_load_thread->set_path(path);
 393         menu->prev_load_thread->start();
 394         return 0;
 395 }
 396 int ReverbLoadPrev::set_path(char *path)
 397 {
 398         strcpy(this->path, path);
 399         return 0;
 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