cinelerra-5.1/plugins/compressormulti/comprmultigui.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2008-2019 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "asset.h"
  22 #include "bchash.h"
  23 #include "bcsignals.h"
  24 #include "clip.h"
  25 #include "comprmultigui.h"
  26 #include "cursors.h"
  27 #include "edl.h"
  28 #include "edlsession.h"
  29 #include "eqcanvas.h"
  30 #include "file.h"
  31 #include "language.h"
  32 #include "theme.h"
  33 #include "units.h"
  34
  35 #include <string.h>
  36
  37 ComprMultiWindow::ComprMultiWindow(ComprMultiEffect *plugin)
  38  : PluginClientWindow(plugin, xS(650),yS(560), xS(650),yS(560), 0)
  39 {
  40         this->plugin = plugin;
  41         char string[BCTEXTLEN];
  42 // set the default directory
  43         sprintf(string, "%s/compressormulti.rc", File::get_config_path());
  44         defaults = new BC_Hash(string);
  45         defaults->load();
  46         plugin->config.current_band = defaults->get("CURRENT_BAND", plugin->config.current_band);
  47         gain_frame = 0;
  48         freq_frame = 0;
  49 }
  50
  51 ComprMultiWindow::~ComprMultiWindow()
  52 {
  53         defaults->update("CURRENT_BAND", plugin->config.current_band);
  54         defaults->save();
  55         delete defaults;
  56
  57         delete eqcanvas;
  58         delete reaction;
  59         delete x_text;
  60         delete y_text;
  61         delete trigger;
  62         delete decay;
  63         delete gain_frame;
  64         delete freq_frame;
  65 }
  66
  67
  68 void ComprMultiWindow::create_objects()
  69 {
  70         int margin = client->get_theme()->widget_border;
  71         int x = margin, y = margin;
  72         int control_margin = xS(150);
  73         int canvas_y2 = get_h() * 2 / 3;
  74         BC_Title *title;
  75         add_subwindow(title = new BC_Title(x, y, "In:"));
  76         int y2 = y + title->get_h() + margin;
  77         EDL *edl = plugin->get_edl();
  78         add_subwindow(in = new BC_Meter(x, y2, METER_VERT,
  79                 canvas_y2 - y2,
  80                 edl->session->min_meter_db,
  81                 edl->session->max_meter_db,
  82                 edl->session->meter_format,
  83                 1, // use_titles
  84                 -1)); // span
  85         x += in->get_w() + margin;
  86
  87         add_subwindow(title = new BC_Title(x, y, "Gain:"));
  88         add_subwindow(gain_change = new BC_Meter(x, y2, METER_VERT,
  89                 canvas_y2 - y2,
  90                 MIN_GAIN_CHANGE,
  91                 MAX_GAIN_CHANGE,
  92                 METER_DB,
  93                 1, // use_titles
  94                 -1, // span
  95                 0, // downmix
  96                 1)); // is_gain_change
  97         x += gain_change->get_w() + xS(35);
  98
  99         add_subwindow(title = new BC_Title(x, y, _("Current band:")));
 100
 101         int x1 = title->get_x() + title->get_w() + margin;
 102         char string[BCTEXTLEN];
 103         for( int i = 0; i < TOTAL_BANDS; i++ ) {
 104                 sprintf(string, "%d", i + 1);
 105                 add_subwindow(band[i] = new ComprMultiBand(this, plugin,
 106                         x1, y, i, string));
 107                 x1 += band[i]->get_w() + margin;
 108         }
 109         y += band[0]->get_h() + 1;
 110
 111
 112         add_subwindow(title = new BC_Title(x, y,
 113                         _("Sound level (Press shift to snap to grid):")));
 114         y += title->get_h() + 1;
 115         add_subwindow(canvas = new ComprMultiCanvas(plugin, this,
 116                 x, y, get_w() - x - control_margin - xS(10), canvas_y2 - y));
 117         y += canvas->get_h() + yS(30);
 118
 119         add_subwindow(title = new BC_Title(margin, y, _("Bandwidth:")));
 120         y += title->get_h();
 121         eqcanvas = new EQCanvas(this, margin, y,
 122                 canvas->get_w() + x - margin, get_h() - y - margin,
 123                 plugin->config.min_db, 0.0);
 124         eqcanvas->freq_divisions = 10;
 125         eqcanvas->initialize();
 126
 127         x = get_w() - control_margin;
 128         y = margin;
 129         add_subwindow(title = new BC_Title(x, y, _("Attack secs:")));
 130         y += title->get_h();
 131         reaction = new ComprMultiReaction(plugin, this, x, y);
 132         reaction->create_objects();
 133         y += reaction->get_h() + margin;
 134
 135         add_subwindow(title = new BC_Title(x, y, _("Release secs:")));
 136         y += title->get_h();
 137         decay = new ComprMultiDecay(plugin, this, x, y);
 138         decay->create_objects();
 139         y += decay->get_h() + margin;
 140
 141         add_subwindow(solo = new ComprMultiSolo(plugin, x, y));
 142         y += solo->get_h() + margin;
 143         add_subwindow(bypass = new ComprMultiBypass(plugin, x, y));
 144         y += bypass->get_h() + margin;
 145         add_subwindow(title = new BC_Title(x, y, _("Output:")));
 146         y += title->get_h();
 147
 148         y_text = new ComprMultiY(plugin, this, x, y);
 149         y_text->create_objects();
 150         y += y_text->get_h() + margin;
 151
 152         add_subwindow(title = new BC_Title(x, y, _("Input:")));
 153         y += title->get_h();
 154         x_text = new ComprMultiX(plugin, this, x, y);
 155         x_text->create_objects();
 156         y += x_text->get_h() + margin;
 157
 158         add_subwindow(clear = new ComprMultiClear(plugin, this, x, y));
 159         y += clear->get_h() + margin;
 160
 161         add_subwindow(title = new BC_Title(x, y, _("Gain:")));
 162
 163         int x2 = get_w() - (margin + BC_Pot::calculate_w()) * 2;
 164         int x3 = get_w() - (margin + BC_Pot::calculate_w());
 165         add_subwindow(title = new BC_Title(x2, y, _("Freq range:")));
 166         y += title->get_h() + margin;
 167
 168         add_subwindow(mkup_gain = new ComprMultiMkupGain(plugin, this, x, y,
 169                 &plugin->config.bands[plugin->config.current_band].mkup_gain,
 170                 -10., 10.));
 171 // the previous high frequency
 172         add_subwindow(freq1 = new ComprMultiQPot(this, plugin, x2, y,
 173                 plugin->config.current_band == 0 ? 0 :
 174                 &plugin->config.bands[plugin->config.current_band-1].freq));
 175 // the current high frequency
 176         add_subwindow(freq2 = new ComprMultiQPot(this, plugin, x3, y,
 177                 plugin->config.current_band!=TOTAL_BANDS-1 ? 0 :
 178                 &plugin->config.bands[plugin->config.current_band].freq));
 179         y += freq1->get_h() + margin;
 180
 181         BC_Bar *bar;
 182         add_subwindow(bar = new BC_Bar(x, y, get_w() - x - margin));
 183         y += bar->get_h() + margin;
 184
 185         add_subwindow(title = new BC_Title(x, y, _("Trigger Type:")));
 186         y += title->get_h();
 187         add_subwindow(input = new ComprMultiInput(plugin, this, x, y));
 188         input->create_objects();
 189         y += input->get_h() + margin;
 190         add_subwindow(title = new BC_Title(x, y, _("Channel:")));
 191         y += title->get_h();
 192
 193         trigger = new ComprMultiTrigger(plugin, this, x, y);
 194         trigger->create_objects();
 195         if( plugin->config.input != ComprMultiConfig::TRIGGER ) trigger->disable();
 196         y += trigger->get_h() + margin;
 197
 198         add_subwindow(smooth = new ComprMultiSmooth(plugin, x, y));
 199         y += smooth->get_h() + margin;
 200
 201         add_subwindow(title = new BC_Title(x, y, _("Steepness:")));
 202         add_subwindow(q = new ComprMultiFPot(this, plugin,
 203                 get_w() - margin - BC_Pot::calculate_w(), y,
 204                 &plugin->config.q, 0, 1));
 205         y += q->get_h() + margin;
 206
 207         add_subwindow(title = new BC_Title(x, y, _("Window size:")));
 208         y += title->get_h();
 209         add_subwindow(size = new ComprMultiSize(this, plugin, x, y));
 210         size->create_objects();
 211         size->update(plugin->config.window_size);
 212         y += size->get_h() + margin;
 213
 214         add_subwindow(reset = new ComprMultiReset(plugin, this, x, y));
 215
 216         canvas->create_objects();
 217         update_eqcanvas();
 218         show_window();
 219 }
 220
 221 // called when the user selects a different band
 222 void ComprMultiWindow::update()
 223 {
 224         int curr_band = plugin->config.current_band;
 225         for( int i = 0; i < TOTAL_BANDS; i++ )
 226                 band[i]->update(curr_band == i);
 227
 228         int *ptr1 = !curr_band ? 0 :
 229                 &plugin->config.bands[curr_band-1].freq;
 230         freq1->output = ptr1;
 231         if( ptr1 ) {
 232                 freq1->update(*ptr1);
 233                 freq1->enable();
 234         }
 235         else {
 236                 freq1->update(0);
 237                 freq1->disable();
 238         }
 239
 240 // top band edits the penultimate band
 241         int *ptr2 = curr_band == TOTAL_BANDS-1 ? 0 :
 242                 &plugin->config.bands[curr_band].freq;
 243         freq2->output = ptr2;
 244         if( ptr2 ) {
 245                 freq2->update(*ptr2);
 246                 freq2->enable();
 247         }
 248         else {
 249                 freq2->update(0);
 250                 freq2->disable();
 251         }
 252
 253         q->update(plugin->config.q);
 254         BandConfig *band_config = &plugin->config.bands[curr_band];
 255         double *ptr3 = &band_config->mkup_gain;
 256         mkup_gain->output = ptr3;
 257         mkup_gain->update(*ptr3);
 258         solo->update(band_config->solo);
 259         bypass->update(band_config->bypass);
 260         size->update(plugin->config.window_size);
 261
 262         if( atol(trigger->get_text()) != plugin->config.trigger ) {
 263                 trigger->update((int64_t)plugin->config.trigger);
 264         }
 265
 266         if( strcmp(input->get_text(), ComprMultiInput::value_to_text(plugin->config.input)) ) {
 267                 input->set_text(ComprMultiInput::value_to_text(plugin->config.input));
 268         }
 269
 270         if( plugin->config.input != ComprMultiConfig::TRIGGER && trigger->get_enabled() ) {
 271                 trigger->disable();
 272         }
 273         else
 274         if( plugin->config.input == ComprMultiConfig::TRIGGER && !trigger->get_enabled() ) {
 275                 trigger->enable();
 276         }
 277
 278         if( !EQUIV(atof(reaction->get_text()), band_config->attack_len) ) {
 279                 reaction->update((float)band_config->attack_len);
 280         }
 281
 282         if( !EQUIV(atof(decay->get_text()), band_config->release_len) ) {
 283                 decay->update((float)band_config->release_len);
 284         }
 285
 286         smooth->update(plugin->config.smoothing_only);
 287         if( canvas->current_operation == ComprMultiCanvas::DRAG ) {
 288                 x_text->update((float)band_config->levels.values[canvas->current_point].x);
 289                 y_text->update((float)band_config->levels.values[canvas->current_point].y);
 290         }
 291
 292         canvas->update();
 293         update_eqcanvas();
 294 }
 295
 296
 297
 298
 299 void ComprMultiWindow::update_eqcanvas()
 300 {
 301         plugin->calculate_envelope();
 302 // filter GUI frames by band & data type
 303         int have_meter = 0;
 304         CompressorClientFrame *frame = 0;
 305 // gdb plugin->dump_frames();
 306         double tracking_position = plugin->get_tracking_position();
 307         int dir = plugin->get_tracking_direction() == PLAY_REVERSE ? -1 : 1;
 308         while( (frame = (CompressorClientFrame*)plugin->next_gui_frame()) ) {
 309                 if( dir*(frame->position - tracking_position) > 0 ) break;
 310                 if( frame->band == plugin->config.current_band ) {
 311 // only frames for desired band
 312                         switch( frame->type ) {
 313                         case FREQ_COMPRESSORFRAME: {
 314                                 delete freq_frame;
 315                                 freq_frame = (CompressorFreqFrame *)
 316                                         plugin->get_gui_frame(0, 0);
 317                                 continue; }
 318                         case GAIN_COMPRESSORFRAME: {
 319                                 delete gain_frame;
 320                                 gain_frame = (CompressorGainFrame *)
 321                                         plugin->get_gui_frame(0, 0);
 322                                 have_meter = 1;
 323                                 continue; }
 324                         }
 325                 }
 326                 delete plugin->get_gui_frame(0, 0);
 327         }
 328         if( have_meter ) {
 329                 gain_change->update(gain_frame->gain, 0);
 330                 in->update(gain_frame->level, 0);
 331         }
 332
 333 #ifndef DRAW_AFTER_BANDPASS
 334         eqcanvas->update_spectrogram(freq_frame);
 335 #else
 336         eqcanvas->update_spectrogram(freq_frame,
 337                 plugin->config.current_band * plugin->config.window_size / 2,
 338                 TOTAL_BANDS * plugin->config.window_size / 2,
 339                 plugin->config.window_size);
 340 #endif
 341
 342 // draw the active band on top of the others
 343         for( int pass = 0; pass < 2; pass++ ) {
 344                 for( int band = 0; band < TOTAL_BANDS; band++ ) {
 345                         if( band == plugin->config.current_band && pass == 0 ||
 346                                 band != plugin->config.current_band && pass == 1 ) {
 347                                 continue;
 348                         }
 349
 350                         eqcanvas->draw_envelope(plugin->band_states[band]->envelope,
 351                                 plugin->PluginAClient::project_sample_rate,
 352                                 plugin->config.window_size,
 353                                 band == plugin->config.current_band,
 354                                 0);
 355                 }
 356         }
 357         eqcanvas->canvas->flash(1);
 358 }
 359
 360 int ComprMultiWindow::resize_event(int w, int h)
 361 {
 362         return 1;
 363 }
 364
 365
 366 ComprMultiFPot::ComprMultiFPot(ComprMultiWindow *gui, ComprMultiEffect *plugin,
 367                 int x, int y, double *output, double min, double max)
 368  : BC_FPot(x, y, *output, min, max)
 369 {
 370         this->gui = gui;
 371         this->plugin = plugin;
 372         this->output = output;
 373         set_precision(0.01);
 374 }
 375
 376 int ComprMultiFPot::handle_event()
 377 {
 378         *output = get_value();
 379         plugin->send_configure_change();
 380         gui->update_eqcanvas();
 381         return 1;
 382 }
 383
 384
 385 ComprMultiQPot::ComprMultiQPot(ComprMultiWindow *gui, ComprMultiEffect *plugin,
 386                 int x, int y, int *output)
 387  : BC_QPot(x, y, output ? *output : 0)
 388 {
 389         this->gui = gui;
 390         this->plugin = plugin;
 391         this->output = output;
 392 }
 393
 394
 395 int ComprMultiQPot::handle_event()
 396 {
 397         if( output ) {
 398                 *output = get_value();
 399                 plugin->send_configure_change();
 400                 gui->update_eqcanvas();
 401         }
 402         return 1;
 403 }
 404
 405
 406 ComprMultiSize::ComprMultiSize(ComprMultiWindow *gui,
 407         ComprMultiEffect *plugin, int x, int y)
 408  : BC_PopupMenu(x, y, xS(100), "4096", 1)
 409 {
 410         this->gui = gui;
 411         this->plugin = plugin;
 412 }
 413
 414 int ComprMultiSize::handle_event()
 415 {
 416         plugin->config.window_size = atoi(get_text());
 417         plugin->send_configure_change();
 418         gui->update_eqcanvas();
 419         return 1;
 420 }
 421
 422 void ComprMultiSize::create_objects()
 423 {
 424         add_item(new BC_MenuItem("2048"));
 425         add_item(new BC_MenuItem("4096"));
 426         add_item(new BC_MenuItem("8192"));
 427         add_item(new BC_MenuItem("16384"));
 428         add_item(new BC_MenuItem("32768"));
 429         add_item(new BC_MenuItem("65536"));
 430         add_item(new BC_MenuItem("131072"));
 431         add_item(new BC_MenuItem("262144"));
 432 }
 433
 434 void ComprMultiSize::update(int size)
 435 {
 436         char string[BCTEXTLEN];
 437         sprintf(string, "%d", size);
 438         set_text(string);
 439 }
 440
 441
 442 ComprMultiMkupGain::ComprMultiMkupGain(ComprMultiEffect *plugin,
 443                 ComprMultiWindow *window, int x, int y,
 444                 double *output, double min, double max)
 445  : BC_FPot(x, y, *output, min, max)
 446 {
 447         this->window = window;
 448         this->plugin = plugin;
 449         this->output = output;
 450         set_precision(0.01);
 451 }
 452
 453 int ComprMultiMkupGain::handle_event()
 454 {
 455         *output = get_value();
 456         plugin->send_configure_change();
 457         window->canvas->update();
 458         return 1;
 459 }
 460
 461
 462 ComprMultiCanvas::ComprMultiCanvas(ComprMultiEffect *plugin,
 463                 ComprMultiWindow *window, int x, int y, int w, int h)
 464  : CompressorCanvasBase(&plugin->config, plugin, window, x, y, w, h)
 465 {
 466 }
 467
 468 void ComprMultiCanvas::update_window()
 469 {
 470         ((ComprMultiWindow*)window)->update();
 471 }
 472
 473
 474 ComprMultiReaction::ComprMultiReaction(ComprMultiEffect *plugin,
 475                 ComprMultiWindow *window, int x, int y)
 476  : BC_TumbleTextBox(window,
 477         (float)plugin->config.bands[plugin->config.current_band].attack_len,
 478         (float)MIN_ATTACK, (float)MAX_ATTACK, x, y, xS(100))
 479 {
 480         this->plugin = plugin;
 481         set_increment(0.1);
 482         set_precision(2);
 483 }
 484
 485 int ComprMultiReaction::handle_event()
 486 {
 487         plugin->config.bands[plugin->config.current_band].attack_len = atof(get_text());
 488         plugin->send_configure_change();
 489         return 1;
 490 }
 491
 492
 493
 494 ComprMultiDecay::ComprMultiDecay(ComprMultiEffect *plugin,
 495                 ComprMultiWindow *window, int x, int y)
 496  : BC_TumbleTextBox(window,
 497         (float)plugin->config.bands[plugin->config.current_band].release_len,
 498         (float)MIN_DECAY, (float)MAX_DECAY, x, y, xS(100))
 499 {
 500         this->plugin = plugin;
 501         set_increment(0.1);
 502         set_precision(2);
 503 }
 504 int ComprMultiDecay::handle_event()
 505 {
 506         plugin->config.bands[plugin->config.current_band].release_len = atof(get_text());
 507         plugin->send_configure_change();
 508         return 1;
 509 }
 510
 511
 512 ComprMultiX::ComprMultiX(ComprMultiEffect *plugin,
 513                 ComprMultiWindow *window, int x, int y)
 514  : BC_TumbleTextBox(window, (float)0.0,
 515         plugin->config.min_db, plugin->config.max_db, x, y, xS(100))
 516 {
 517         this->plugin = plugin;
 518         this->window = window;
 519         set_increment(0.1);
 520         set_precision(2);
 521 }
 522 int ComprMultiX::handle_event()
 523 {
 524         BandConfig *band_config = &plugin->config.bands[plugin->config.current_band];
 525
 526         int current_point = window->canvas->current_point;
 527         if( current_point < band_config->levels.total ) {
 528                 band_config->levels.values[current_point].x = atof(get_text());
 529                 window->canvas->update();
 530                 plugin->send_configure_change();
 531         }
 532         return 1;
 533 }
 534
 535
 536 ComprMultiY::ComprMultiY(ComprMultiEffect *plugin,
 537                 ComprMultiWindow *window, int x, int y)
 538  : BC_TumbleTextBox(window, (float)0.0,
 539         plugin->config.min_db, plugin->config.max_db, x, y, xS(100))
 540 {
 541         this->plugin = plugin;
 542         this->window = window;
 543         set_increment(0.1);
 544         set_precision(2);
 545 }
 546 int ComprMultiY::handle_event()
 547 {
 548         BandConfig *band_config = &plugin->config.bands[plugin->config.current_band];
 549
 550         int current_point = window->canvas->current_point;
 551         if( current_point < band_config->levels.total ) {
 552                 band_config->levels.values[current_point].y = atof(get_text());
 553                 window->canvas->update();
 554                 plugin->send_configure_change();
 555         }
 556         return 1;
 557 }
 558
 559
 560 ComprMultiTrigger::ComprMultiTrigger(ComprMultiEffect *plugin,
 561                 ComprMultiWindow *window, int x, int y)
 562  : BC_TumbleTextBox(window, (int)plugin->config.trigger,
 563         MIN_TRIGGER, MAX_TRIGGER, x, y, xS(100))
 564 {
 565         this->plugin = plugin;
 566 }
 567 int ComprMultiTrigger::handle_event()
 568 {
 569         plugin->config.trigger = atol(get_text());
 570         plugin->send_configure_change();
 571         return 1;
 572 }
 573
 574
 575 ComprMultiInput::ComprMultiInput(ComprMultiEffect *plugin,
 576         ComprMultiWindow *window, int x, int y)
 577  : BC_PopupMenu(x, y, xS(100),
 578         ComprMultiInput::value_to_text(plugin->config.input), 1)
 579 {
 580         this->plugin = plugin;
 581         this->window = window;
 582 }
 583 int ComprMultiInput::handle_event()
 584 {
 585         plugin->config.input = text_to_value(get_text());
 586         window->update();
 587         plugin->send_configure_change();
 588         return 1;
 589 }
 590
 591 void ComprMultiInput::create_objects()
 592 {
 593         for( int i = 0; i < 3; i++ ) {
 594                 add_item(new BC_MenuItem(value_to_text(i)));
 595         }
 596 }
 597
 598 const char* ComprMultiInput::value_to_text(int value)
 599 {
 600         switch( value ) {
 601         case ComprMultiConfig::TRIGGER: return "Trigger";
 602         case ComprMultiConfig::MAX: return "Maximum";
 603         case ComprMultiConfig::SUM: return "Total";
 604         }
 605
 606         return "Trigger";
 607 }
 608
 609 int ComprMultiInput::text_to_value(char *text)
 610 {
 611         for( int i = 0; i < 3; i++ ) {
 612                 if( !strcmp(value_to_text(i), text) ) return i;
 613         }
 614
 615         return ComprMultiConfig::TRIGGER;
 616 }
 617
 618
 619 ComprMultiClear::ComprMultiClear(ComprMultiEffect *plugin,
 620                 ComprMultiWindow *window, int x, int y)
 621  : BC_GenericButton(x, y, _("Clear"))
 622 {
 623         this->plugin = plugin;
 624         this->window = window;
 625 }
 626
 627 int ComprMultiClear::handle_event()
 628 {
 629         BandConfig *band_config = &plugin->config.bands[plugin->config.current_band];
 630         band_config->mkup_gain = 0.0;
 631         band_config->levels.remove_all();
 632 //plugin->config.dump();
 633         window->update();
 634         plugin->send_configure_change();
 635         return 1;
 636 }
 637
 638 ComprMultiReset::ComprMultiReset(ComprMultiEffect *plugin,
 639                 ComprMultiWindow *window, int x, int y)
 640  : BC_GenericButton(x, y, _("Reset"))
 641 {
 642         this->plugin = plugin;
 643         this->window = window;
 644 }
 645
 646 int ComprMultiReset::handle_event()
 647 {
 648         plugin->config.q = 1.0;
 649         plugin->config.window_size = 4096;
 650         plugin->config.reset_bands();
 651         plugin->config.reset_base();
 652 //plugin->config.dump();
 653         window->update();
 654         plugin->send_configure_change();
 655         return 1;
 656 }
 657
 658
 659 ComprMultiSmooth::ComprMultiSmooth(ComprMultiEffect *plugin, int x, int y)
 660  : BC_CheckBox(x, y, plugin->config.smoothing_only, _("Smooth only"))
 661 {
 662         this->plugin = plugin;
 663 }
 664
 665 int ComprMultiSmooth::handle_event()
 666 {
 667         plugin->config.smoothing_only = get_value();
 668         plugin->send_configure_change();
 669         return 1;
 670 }
 671
 672
 673 ComprMultiSolo::ComprMultiSolo(ComprMultiEffect *plugin, int x, int y)
 674  : BC_CheckBox(x, y, plugin->config.bands[plugin->config.current_band].solo, _("Solo band"))
 675 {
 676         this->plugin = plugin;
 677 }
 678
 679 int ComprMultiSolo::handle_event()
 680 {
 681         plugin->config.bands[plugin->config.current_band].solo = get_value();
 682         for( int i = 0; i < TOTAL_BANDS; i++ ) {
 683                 if( i != plugin->config.current_band ) {
 684                         plugin->config.bands[i].solo = 0;
 685                 }
 686         }
 687         plugin->send_configure_change();
 688         return 1;
 689 }
 690
 691
 692 ComprMultiBypass::ComprMultiBypass(ComprMultiEffect *plugin, int x, int y)
 693  : BC_CheckBox(x, y, plugin->config.bands[plugin->config.current_band].bypass, _("Bypass band"))
 694 {
 695         this->plugin = plugin;
 696 }
 697
 698 int ComprMultiBypass::handle_event()
 699 {
 700         plugin->config.bands[plugin->config.current_band].bypass = get_value();
 701         plugin->send_configure_change();
 702         return 1;
 703 }
 704
 705
 706 ComprMultiBand::ComprMultiBand(ComprMultiWindow *window,
 707                 ComprMultiEffect *plugin, int x, int y, int number,
 708                 char *text)
 709  : BC_Radial(x, y, plugin->config.current_band == number, text)
 710 {
 711         this->window = window;
 712         this->plugin = plugin;
 713         this->number = number;
 714 }
 715
 716 int ComprMultiBand::handle_event()
 717 {
 718         if( plugin->config.current_band != number ) {
 719                 plugin->config.current_band = number;
 720                 window->update();
 721         }
 722         return 1;
 723 }
 724
 725 // dump envelope sum
 726 //       printf("ComprMultiWindow::update_eqcanvas %d\n", __LINE__);
 727 //       for( int i = 0; i < plugin->config.window_size / 2; i++ )
 728 //       {
 729 //               double sum = 0;
 730 //               for( int band = 0; band < TOTAL_BANDS; band++ )
 731 //               {
 732 //                       sum += plugin->engines[band]->envelope[i];
 733 //               }
 734 //
 735 //               printf("%f ", sum);
 736 //               for( int band = 0; band < TOTAL_BANDS; band++ )
 737 //               {
 738 //                       printf("%f ", plugin->engines[band]->envelope[i]);
 739 //               }
 740 //               printf("\n");
 741 //       }
 742
 743