1267 lines
34 KiB
C
1267 lines
34 KiB
C
|
||
/*******************************************************************************/
|
||
/* Copyright (C) 2009 Jonathan Moore Liles */
|
||
/* */
|
||
/* This program is free software; you can redistribute it and/or modify it */
|
||
/* under the terms of the GNU General Public License as published by the */
|
||
/* Free Software Foundation; either version 2 of the License, or (at your */
|
||
/* option) any later version. */
|
||
/* */
|
||
/* This program is distributed in the hope that it will be useful, but WITHOUT */
|
||
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
|
||
/* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for */
|
||
/* more details. */
|
||
/* */
|
||
/* You should have received a copy of the GNU General Public License along */
|
||
/* with This program; see the file COPYING. If not,write to the Free Software */
|
||
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||
/*******************************************************************************/
|
||
|
||
/* Mixer strip control. Handles GUI and control I/O for this strip. */
|
||
|
||
/* A mixer strip is home to some (JACK) input ports, a fader, some
|
||
* meters, and a filter chain which can terminate either at the input
|
||
* to the spacializer or some (JACK) output ports. Since mixer strips
|
||
* are not necessarily in a 1:1 association with Non-DAW tracks, there
|
||
* is no need for busses per se. If you want to route the output of
|
||
* several strips into a single fader or filter chain, then you just
|
||
* gives those strips JACK outputs and connect them to the common
|
||
* inputs. This mechanism can also do away with the need for 'sends'
|
||
* and 'inserts'.
|
||
|
||
*/
|
||
/* Each mixer strip comprises a fader and a panner */
|
||
|
||
#include "Project.H"
|
||
#include "Mixer_Strip.H"
|
||
#include <dsp.h>
|
||
#include <string.h>
|
||
#include "debug.h"
|
||
|
||
|
||
#include "FL/Fl_Flowpack.H"
|
||
#include <FL/Fl_Input.H>
|
||
#include <FL/fl_ask.H>
|
||
#include <FL/Fl_Color_Chooser.H>
|
||
#include <FL/Fl.H>
|
||
#include "Mixer.H"
|
||
|
||
#include "Chain.H"
|
||
#include "Gain_Module.H"
|
||
#include "Meter_Module.H"
|
||
#include "Controller_Module.H"
|
||
#include "Meter_Indicator_Module.H"
|
||
#include "debug.h"
|
||
#include "FL/focus_frame.H"
|
||
#include <FL/Fl_Menu_Button.H>
|
||
#include "FL/test_press.H"
|
||
#include "FL/menu_popup.H"
|
||
#include <FL/Fl_File_Chooser.H>
|
||
#include <FL/Fl_Choice.H>
|
||
#include "Group.H"
|
||
#include "FL/focus_frame.H"
|
||
|
||
extern Mixer *mixer;
|
||
|
||
|
||
|
||
/* add a new mixer strip (with default configuration) */
|
||
Mixer_Strip::Mixer_Strip( const char *strip_name ) : Fl_Group( 0, 0, 120, 600 )
|
||
{
|
||
label( strdup( strip_name ) );
|
||
labeltype( FL_NO_LABEL );
|
||
|
||
init();
|
||
|
||
_group = new Group(strip_name, true);
|
||
|
||
_group->add( this );
|
||
|
||
chain( new Chain() );
|
||
|
||
_chain->initialize_with_default();
|
||
|
||
_chain->configure_ports();
|
||
|
||
color( (Fl_Color)rand() );
|
||
|
||
// name( strdup( strip_name ) );
|
||
|
||
log_create();
|
||
}
|
||
|
||
/* virgin strip created from journal */
|
||
Mixer_Strip::Mixer_Strip() : Fl_Group( 0, 0, 120, 600 )
|
||
{
|
||
init();
|
||
|
||
log_create();
|
||
}
|
||
|
||
Mixer_Strip::~Mixer_Strip ( )
|
||
{
|
||
DMESSAGE( "Destroying mixer strip" );
|
||
|
||
// _chain->engine()->lock();
|
||
|
||
log_destroy();
|
||
|
||
mixer->remove( this );
|
||
|
||
/* make sure this gets destroyed before the chain */
|
||
fader_tab->clear();
|
||
|
||
delete _chain;
|
||
_chain = NULL;
|
||
}
|
||
|
||
|
||
|
||
void
|
||
Mixer_Strip::get ( Log_Entry &e ) const
|
||
{
|
||
e.add( ":name", name() );
|
||
e.add( ":width", width_button->value() ? "wide" : "narrow" );
|
||
e.add( ":tab", tab_button->value() ? "signal" : "fader" );
|
||
e.add( ":color", (unsigned long)color());
|
||
/* since the default controllers aren't logged, we have to store
|
||
* this setting as part of the mixer strip */
|
||
e.add( ":gain_mode", gain_controller->mode() );
|
||
e.add( ":mute_mode", mute_controller->mode() );
|
||
if ( ! _group->single() )
|
||
e.add( ":group", _group );
|
||
else
|
||
e.add( ":group", (Loggable*)0 );
|
||
e.add( ":auto_input", _auto_input );
|
||
e.add( ":manual_connection", _manual_connection );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::set ( Log_Entry &e )
|
||
{
|
||
for ( int i = 0; i < e.size(); ++i )
|
||
{
|
||
const char *s, *v;
|
||
|
||
e.get( i, &s, &v );
|
||
|
||
if ( ! strcmp( s, ":name" ) )
|
||
name( v );
|
||
else if ( ! strcmp( s, ":width" ) )
|
||
{
|
||
width_button->value( strcmp( v, "wide" ) == 0 );
|
||
width_button->do_callback();
|
||
}
|
||
else if ( ! strcmp( s, ":tab" ) )
|
||
{
|
||
tab_button->value( strcmp( v, "signal" ) == 0 );
|
||
tab_button->do_callback();
|
||
}
|
||
else if ( ! strcmp( s, ":color" ) )
|
||
{
|
||
color( (Fl_Color)atoll( v ) );
|
||
redraw();
|
||
}
|
||
else if ( ! strcmp( s, ":gain_mode" ) )
|
||
{
|
||
_gain_controller_mode = atoi( v );
|
||
}
|
||
else if ( ! strcmp( s, ":mute_mode" ) )
|
||
{
|
||
_mute_controller_mode = atoi( v );
|
||
}
|
||
else if ( ! strcmp( s, ":auto_input" ) )
|
||
{
|
||
auto_input( v );
|
||
}
|
||
else if ( ! strcmp( s, ":manual_connection" ) )
|
||
{
|
||
manual_connection( atoi( v ) );
|
||
}
|
||
else if ( ! strcmp( s, ":group" ) )
|
||
{
|
||
int i;
|
||
sscanf( v, "%X", &i );
|
||
|
||
if ( i )
|
||
{
|
||
Group *t = (Group*)Loggable::find( i );
|
||
|
||
/* Because of strip copy/paste and import, we can't assure that the group will exist by ID*/
|
||
// assert( t );
|
||
|
||
group( t );
|
||
}
|
||
else
|
||
group( 0 );
|
||
}
|
||
}
|
||
|
||
if ( ! _group )
|
||
group(0);
|
||
|
||
if ( ! mixer->contains( this ) )
|
||
mixer->add( this );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::log_children ( void ) const
|
||
{
|
||
log_create();
|
||
|
||
_chain->log_children();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::color ( Fl_Color c )
|
||
{
|
||
_color = c;
|
||
color_box->color( _color );
|
||
color_box->redraw();
|
||
}
|
||
|
||
Fl_Color
|
||
Mixer_Strip::color ( void ) const
|
||
{
|
||
return _color;
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::chain ( Chain *c )
|
||
{
|
||
if ( _chain )
|
||
delete _chain;
|
||
|
||
_chain = c;
|
||
|
||
c->strip( this );
|
||
|
||
Fl_Group *g = signal_tab;
|
||
|
||
c->resize( g->x(), g->y(), g->w(), g->h() );
|
||
g->add( c );
|
||
g->resizable( c );
|
||
|
||
c->labelsize( 10 );
|
||
c->align( FL_ALIGN_TOP );
|
||
c->color( FL_RED );
|
||
c->configure_outputs_callback( configure_outputs, this );
|
||
c->name( name() );
|
||
|
||
/* FIXME: don't hardcode this list of modules */
|
||
spatialization_controller->chain( c );
|
||
gain_controller->chain( c );
|
||
mute_controller->chain( c );
|
||
jack_input_controller->chain( c );
|
||
meter_indicator->chain( c );
|
||
}
|
||
|
||
|
||
void Mixer_Strip::cb_handle(Fl_Widget* o) {
|
||
// parent()->parent()->damage( FL_DAMAGE_ALL, x(), y(), w(), h() );
|
||
// DMESSAGE( "Callback for %s", o->label() );
|
||
|
||
if ( o == tab_button )
|
||
{
|
||
if ( tab_button->value() == 0 )
|
||
{
|
||
fader_tab->resize( tab_group->x(), tab_group->y(), tab_group->w(), tab_group->h() );
|
||
fader_tab->show();
|
||
signal_tab->hide();
|
||
tab_group->resizable( fader_tab );
|
||
}
|
||
else
|
||
{
|
||
signal_tab->resize( tab_group->x(), tab_group->y(), tab_group->w(), tab_group->h() );
|
||
signal_tab->show();
|
||
fader_tab->hide();
|
||
tab_group->resizable( signal_tab );
|
||
}
|
||
|
||
set_spatializer_visibility();
|
||
}
|
||
else if ( o == close_button )
|
||
{
|
||
if ( Fl::event_shift() || 1 == fl_choice( "Are you sure you want to remove this strip?\n\n(this action cannot be undone)", "Cancel", "Remove", NULL ) )
|
||
command_close();
|
||
}
|
||
else if ( o == name_field )
|
||
{
|
||
name( name_field->value() );
|
||
Fl::focus( this );
|
||
}
|
||
else if ( o == width_button )
|
||
{
|
||
if ( width_button->value() )
|
||
size( 220, h() );
|
||
else
|
||
size( 96, h() );
|
||
|
||
if ( parent() )
|
||
parent()->parent()->redraw();
|
||
}
|
||
else if ( o == output_connection_button )
|
||
{
|
||
if ( output_connection_button->value() == 1 )
|
||
o->label( output_connection_button->mvalue()->label() );
|
||
else
|
||
o->label( NULL );
|
||
|
||
manual_connection( output_connection_button->value() );
|
||
|
||
// _manual_connection = output_connection_button->value();
|
||
}
|
||
else if ( o == group_choice )
|
||
{
|
||
// group(group_choice->value());
|
||
Group *g = NULL;
|
||
|
||
if ( group_choice->value() == group_choice->size() - 2 )
|
||
{
|
||
/* create a new group */
|
||
const char *s = fl_input( "Name for Group:" );
|
||
if ( !s )
|
||
return;
|
||
|
||
char *n = mixer->get_unique_group_name( s );
|
||
|
||
g = new Group( n, false );
|
||
|
||
free( n );
|
||
|
||
mixer->add_group( g );
|
||
}
|
||
else
|
||
{
|
||
g = (Group*)group_choice->mvalue()->user_data();
|
||
}
|
||
|
||
group(g);
|
||
}
|
||
}
|
||
|
||
void Mixer_Strip::cb_handle(Fl_Widget* o, void* v) {
|
||
((Mixer_Strip*)(v))->cb_handle(o);
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::group ( Group *g )
|
||
{
|
||
if ( !g && _group && _group->single() )
|
||
return;
|
||
|
||
if ( _group )
|
||
{
|
||
_group->remove(this);
|
||
if ( ! _group->nstrips() )
|
||
{
|
||
if ( ! _group->single() )
|
||
mixer->remove_group( _group );
|
||
|
||
delete _group;
|
||
|
||
_group = NULL;
|
||
}
|
||
}
|
||
|
||
if ( ! g )
|
||
g = new Group(name(), true);
|
||
|
||
const Fl_Menu_Item *menu = group_choice->menu();
|
||
|
||
for ( unsigned int i = 0; menu[i].text; i++ )
|
||
if ( menu[i].user_data() == g )
|
||
group_choice->value( i );
|
||
|
||
// group_choice->color( (Fl_Color)n );
|
||
// group_choice->value( n );
|
||
|
||
_group = g;
|
||
|
||
g->add(this);
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::name ( const char *name )
|
||
{
|
||
if ( this->name() && !strcmp( name, this->name() ) )
|
||
return;
|
||
|
||
name = mixer->get_unique_track_name( name );
|
||
|
||
char *s = strdup( name );
|
||
|
||
if ( strlen( s ) > Chain::maximum_name_length() )
|
||
{
|
||
s[Chain::maximum_name_length() - 1] = '\0';
|
||
|
||
fl_alert( "Name \"%s\" is too long, truncating to \"%s\"", name, s );
|
||
}
|
||
|
||
name_field->value( s );
|
||
label( s );
|
||
if ( _chain )
|
||
_chain->name( s );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::configure_outputs ( Fl_Widget *, void *v )
|
||
{
|
||
((Mixer_Strip*)v)->configure_outputs();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::configure_outputs ( void )
|
||
{
|
||
DMESSAGE( "Got signal to configure outputs" );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::set_spatializer_visibility ( void )
|
||
{
|
||
if ( fader_tab->visible() && spatialization_controller->is_controlling() )
|
||
{
|
||
spatialization_controller->show();
|
||
spatialization_label->show();
|
||
}
|
||
else
|
||
{
|
||
spatialization_controller->hide();
|
||
spatialization_label->hide();
|
||
}
|
||
}
|
||
|
||
/* called by the chain to let us know that a module has been added */
|
||
void
|
||
Mixer_Strip::handle_module_added ( Module *m )
|
||
{
|
||
if ( m->is_default() )
|
||
{
|
||
DMESSAGE( "Connecting controls to default module \"%s\"", m->name() );
|
||
|
||
/* connect default modules to their default controllers/indicators */
|
||
if ( 0 == strcmp( m->name(), "JACK" ) && m->ninputs() == 0 )
|
||
{
|
||
if ( !jack_input_controller->control_output[0].connected() )
|
||
jack_input_controller->connect_to( &m->control_input[1] );
|
||
}
|
||
else if ( 0 == strcmp( m->name(), "Gain" ) )
|
||
{
|
||
gain_controller->connect_to( &m->control_input[0] );
|
||
gain_controller->mode( (Controller_Module::Mode)_gain_controller_mode );
|
||
mute_controller->connect_to( &m->control_input[1] );
|
||
mute_controller->mode( (Controller_Module::Mode)_mute_controller_mode );
|
||
}
|
||
else if ( 0 == strcmp( m->name(), "Meter" ) )
|
||
{
|
||
meter_indicator->connect_to( &m->control_output[0] );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ( spatialization_controller->connect_spatializer_to( m ) )
|
||
{
|
||
DMESSAGE( "Connected spatializer to module \"%s\"", m->name() );
|
||
set_spatializer_visibility();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* called by the chain to let us know that a module has been removed */
|
||
void
|
||
Mixer_Strip::handle_module_removed ( Module *m )
|
||
{
|
||
if ( spatialization_controller->control_output[0].connected() &&
|
||
spatialization_controller->control_output[0].connected_port()->module() == m )
|
||
{
|
||
set_spatializer_visibility();
|
||
DMESSAGE( "Module \"%s\" disconnected from spatialization controller", m->label() );
|
||
}
|
||
}
|
||
|
||
/* update GUI with values from RT thread */
|
||
void
|
||
Mixer_Strip::update ( void )
|
||
{
|
||
THREAD_ASSERT( UI );
|
||
|
||
meter_indicator->update();
|
||
gain_controller->update();
|
||
mute_controller->update();
|
||
|
||
if ( _chain )
|
||
{
|
||
_chain->update();
|
||
}
|
||
if ( group() )
|
||
{
|
||
if ( ( _dsp_load_index++ % 10 ) == 0 )
|
||
{
|
||
float l = group()->dsp_load();
|
||
|
||
dsp_load_progress->value( l );
|
||
|
||
{
|
||
char pat[20];
|
||
snprintf( pat, sizeof(pat), "%.1f%%", l * 100.0f );
|
||
dsp_load_progress->copy_tooltip( pat );
|
||
}
|
||
|
||
if ( l <= 0.15f )
|
||
dsp_load_progress->color2( fl_rgb_color( 127,127,127 ) );
|
||
else
|
||
dsp_load_progress->color2( FL_RED );
|
||
}
|
||
}
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::init ( )
|
||
{
|
||
selection_color( FL_YELLOW );
|
||
_manual_connection = 0;
|
||
_auto_input = 0;
|
||
_mute_controller_mode = 0;
|
||
_gain_controller_mode = 0;
|
||
_chain = 0;
|
||
_group = 0;
|
||
|
||
_dsp_load_index = 0;
|
||
|
||
box( FL_FLAT_BOX );
|
||
labeltype( FL_NO_LABEL );
|
||
|
||
Fl_Group::color( FL_BACKGROUND_COLOR );
|
||
|
||
set_visible_focus();
|
||
|
||
{ Fl_Scalepack *o = new Fl_Scalepack( 2, 2, 116, 595 );
|
||
o->type( FL_VERTICAL );
|
||
o->spacing( 2 );
|
||
|
||
{ Fl_Box *o = color_box = new Fl_Box( 0,0, 25, 10 );
|
||
o->box(FL_FLAT_BOX);
|
||
o->tooltip( "Drag and drop to move strip" );
|
||
}
|
||
|
||
{ Fl_Pack *o = new Fl_Pack( 2, 2, 114, 100 );
|
||
o->type( Fl_Pack::VERTICAL );
|
||
o->spacing( 2 );
|
||
{
|
||
Fl_Sometimes_Input *o = new Fl_Sometimes_Input( 2, 2, 144, 15 );
|
||
name_field = o;
|
||
|
||
o->up_box( FL_NO_BOX );
|
||
o->box( FL_FLAT_BOX );
|
||
o->selection_color( FL_BLACK );
|
||
o->labeltype( FL_NO_LABEL );
|
||
o->labelcolor( FL_GRAY0 );
|
||
o->textcolor( FL_FOREGROUND_COLOR );
|
||
o->textsize( 12 );
|
||
o->value( name() );
|
||
o->callback( cb_handle, (void*)this );
|
||
}
|
||
{ Fl_Scalepack *o = new Fl_Scalepack( 7, 143, 110, 18 );
|
||
o->type( Fl_Pack::HORIZONTAL );
|
||
|
||
{ Fl_Flip_Button* o = width_button = new Fl_Flip_Button(61, 183, 45, 22, "[]/[-]");
|
||
o->type(1);
|
||
o->tooltip( "Switch between wide and narrow views" );
|
||
o->labelfont( FL_COURIER_BOLD );
|
||
o->labelsize(10);
|
||
o->callback( ((Fl_Callback*)cb_handle), this );
|
||
o->when(FL_WHEN_RELEASE);
|
||
}
|
||
|
||
{ Fl_Button* o = close_button = new Fl_Button(7, 143, 35, 25, "X");
|
||
o->tooltip( "Remove strip" );
|
||
o->type(0);
|
||
o->labelfont( FL_COURIER_BOLD );
|
||
o->selection_color( FL_RED );
|
||
o->labelsize(10);
|
||
o->when( FL_WHEN_RELEASE );
|
||
o->callback( ((Fl_Callback*)cb_handle), this );
|
||
} // Fl_Button* o
|
||
|
||
o->end();
|
||
} // Fl_Group* o
|
||
{ Fl_Progress* o = dsp_load_progress = new Fl_Progress(61, 183, 45, 14, "group dsp");
|
||
o->box(FL_BORDER_BOX);
|
||
o->type(FL_HORIZONTAL);
|
||
o->labelsize( 9 );
|
||
o->minimum( 0 );
|
||
// o->maximum( 0.25f );
|
||
o->maximum( 1 );
|
||
o->color(fl_rgb_color( 10,10,10 ) );
|
||
o->color2(FL_CYAN);
|
||
}
|
||
{ Fl_Choice* o = group_choice = new Fl_Choice(61, 183, 45, 22);
|
||
o->tooltip( "Create or assign group" );
|
||
o->labeltype(FL_NO_LABEL);
|
||
o->labelsize(10);
|
||
o->textsize(10);
|
||
o->add("---");
|
||
o->value(0);
|
||
o->callback( ((Fl_Callback*)cb_handle), this );
|
||
}
|
||
{ Fl_Scalepack *o = new Fl_Scalepack( 0,0, 45, 22 );
|
||
o->type( FL_HORIZONTAL );
|
||
{ Fl_Flip_Button* o = tab_button = new Fl_Flip_Button(61, 183, 45, 22, "Fadr/Signl");
|
||
o->tooltip( "Switch between fader and signal views" );
|
||
o->type(1);
|
||
o->labelsize( 10 );
|
||
o->callback( ((Fl_Callback*)cb_handle), this );
|
||
o->when(FL_WHEN_RELEASE);
|
||
}
|
||
{ Controller_Module *o = mute_controller = new Controller_Module( true );
|
||
o->pad( false );
|
||
o->size( 45, 22 );
|
||
}
|
||
o->end();
|
||
}
|
||
o->end();
|
||
}
|
||
|
||
/* { Fl_Scalepack *o = new Fl_Scalepack( 2, 103, 114, 490 ); */
|
||
/* o->type( FL_VERTICAL ); */
|
||
// o->box( FL_FLAT_BOX );
|
||
// o->color( FL_BACKGROUND_COLOR );
|
||
{ Fl_Group *o = tab_group = new Fl_Group( 2, 116, 105, 330 );
|
||
o->box( FL_NO_BOX );
|
||
{ Fl_Group *o = fader_tab = new Fl_Group( 2, 116, 105, 330, "Fader" );
|
||
o->box( FL_NO_BOX );
|
||
o->labeltype( FL_NO_LABEL );
|
||
{ Fl_Pack *o = new Fl_Pack( 2, 116, 105, 15 );
|
||
o->type( FL_VERTICAL );
|
||
{
|
||
Controller_Module *m = jack_input_controller = new Controller_Module( true );
|
||
m->labeltype( FL_NO_LABEL );
|
||
m->chain( _chain );
|
||
m->pad( false );
|
||
m->size( 105, 15 );
|
||
}
|
||
o->resizable(0);
|
||
o->end();
|
||
}
|
||
{ Fl_Scalepack* o = new Fl_Scalepack(2, 135, 105, 311 );
|
||
// o->box( FL_BORDER_BOX );
|
||
// o->color( FL_RED );
|
||
o->spacing( 20 );
|
||
o->type( Fl_Scalepack::HORIZONTAL );
|
||
{ Controller_Module *o = gain_controller = new Controller_Module( true );
|
||
o->horizontal(false);
|
||
o->clear_visible_focus();
|
||
o->pad( false );
|
||
o->size( 33, 100 );
|
||
}
|
||
{ Meter_Indicator_Module *o = meter_indicator = new Meter_Indicator_Module( true );
|
||
o->disable_context_menu( true );
|
||
o->pad( false );
|
||
o->size( 38, 100 );
|
||
Fl_Group::current()->resizable(o);
|
||
}
|
||
o->end();
|
||
Fl_Group::current()->resizable(o);
|
||
} // Fl_Group* o
|
||
o->end();
|
||
Fl_Group::current()->resizable(o);
|
||
}
|
||
{ Fl_Group *o = signal_tab = new Fl_Group( 2, 116, 105, 330 );
|
||
o->box( FL_NO_BOX );
|
||
o->labeltype( FL_NO_LABEL );
|
||
o->hide();
|
||
o->end();
|
||
}
|
||
o->end();
|
||
Fl_Group::current()->resizable( o );
|
||
}
|
||
/* { Fl_Pack *o = panner_pack = new Fl_Pack( 2, 465, 114, 40 ); */
|
||
/* o->spacing( 2 ); */
|
||
/* o->type( Fl_Pack::VERTICAL ); */
|
||
{ Fl_Box *o = spatialization_label = new Fl_Box( 0, 0, 100, 12 );
|
||
o->align( (Fl_Align)(FL_ALIGN_BOTTOM | FL_ALIGN_INSIDE) );
|
||
o->labelsize( 10 );
|
||
o->hide();
|
||
o->label( "Spatialization" );
|
||
}
|
||
{ Controller_Module *o = spatialization_controller = new Controller_Module( true );
|
||
o->hide();
|
||
o->label( 0 );
|
||
o->pad( false );
|
||
o->size( 92,92 );
|
||
}
|
||
/* o->end(); */
|
||
/* } */
|
||
|
||
{ Fl_Menu_Button *o = output_connection_button = new Fl_Menu_Button( 0, 0, 10, 18 );
|
||
o->labelsize( 9 );
|
||
o->add("- auto -");
|
||
o->add("- manual -");
|
||
o->align( FL_ALIGN_CLIP );
|
||
o->labelcolor( FL_YELLOW );
|
||
o->callback( cb_handle, this );
|
||
o->hide();
|
||
}
|
||
|
||
o->end();
|
||
}
|
||
|
||
end();
|
||
|
||
color( FL_BLACK );
|
||
|
||
size( 96, h() );
|
||
|
||
update_group_choice();
|
||
// redraw();
|
||
|
||
// _chain->configure_ports();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::update_group_choice ( void )
|
||
{
|
||
Fl_Choice *o = group_choice;
|
||
|
||
o->clear();
|
||
o->add( "---" );
|
||
|
||
for ( std::list<Group*>::iterator i = mixer->groups.begin(); i != mixer->groups.end(); )
|
||
{
|
||
Group *g = *i;
|
||
|
||
i++;
|
||
|
||
if ( i == mixer->groups.end() )
|
||
{
|
||
o->add( g->name(), 0, 0, (void*)g, FL_MENU_DIVIDER );
|
||
break;
|
||
}
|
||
else
|
||
o->add( g->name(), 0, 0, (void*)g );
|
||
}
|
||
|
||
o->add( "New Group" );
|
||
|
||
const Fl_Menu_Item *menu = o->menu();
|
||
|
||
if ( ! group() || ( group() && group()->single() ) )
|
||
o->value(0);
|
||
else
|
||
{
|
||
for ( unsigned int i = 0; menu[i].text; i++ )
|
||
if ( menu[i].user_data() == group() )
|
||
o->value( i );
|
||
}
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::draw ( void )
|
||
{
|
||
/* don't bother drawing anything else, all we're doing is drawing the focus. */
|
||
// if ( damage() & ~FL_DAMAGE_USER1 )
|
||
Fl_Group::draw();
|
||
|
||
if ( focused_r( this ) )
|
||
draw_focus_frame( x(),y(),w(),h(), Fl_Group::selection_color() );
|
||
/* else */
|
||
/* clear_focus_frame( x(),y(),w(),h(), FL_BACKGROUND_COLOR ); */
|
||
}
|
||
|
||
/*****************/
|
||
/* Import/Export */
|
||
/*****************/
|
||
|
||
void
|
||
Mixer_Strip::snapshot ( void *v )
|
||
{
|
||
((Mixer_Strip*)v)->snapshot();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::snapshot ( void )
|
||
{
|
||
log_children();
|
||
}
|
||
|
||
bool
|
||
Mixer_Strip::export_strip ( const char *filename )
|
||
{
|
||
MESSAGE( "Exporting chain state" );
|
||
Loggable::snapshot_callback( &Mixer_Strip::snapshot, this );
|
||
Loggable::snapshot( filename );
|
||
return true;
|
||
}
|
||
|
||
bool
|
||
Mixer_Strip::import_strip ( const char *filename )
|
||
{
|
||
MESSAGE( "Importing new chain state" );
|
||
Loggable::begin_relative_id_mode();
|
||
int r = Loggable::replay( filename );
|
||
Loggable::end_relative_id_mode();
|
||
return r;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
void
|
||
Mixer_Strip::menu_cb ( const Fl_Menu_ *m )
|
||
{
|
||
char picked[256];
|
||
|
||
m->item_pathname( picked, sizeof( picked ) );
|
||
|
||
Logger log( this );
|
||
|
||
if ( ! strcmp( picked, "Width/Narrow" ) )
|
||
command_width( false );
|
||
else if ( ! strcmp( picked, "Width/Wide" ) )
|
||
command_width( true );
|
||
else if ( ! strcmp( picked, "View/Fader" ) )
|
||
command_view( false );
|
||
else if ( ! strcmp( picked, "View/Signal" ) )
|
||
command_view( true );
|
||
else if ( ! strcmp( picked, "/Move Left" ) )
|
||
command_move_left();
|
||
else if ( ! strcmp( picked, "/Move Right" ) )
|
||
command_move_right();
|
||
else if ( ! strcmp( picked, "/Rename" ) )
|
||
{
|
||
((Fl_Sometimes_Input*)name_field)->take_focus();
|
||
}
|
||
else if ( ! strcmp( picked, "/Copy" ) )
|
||
{
|
||
export_strip( "clipboard.strip" );
|
||
|
||
char *s;
|
||
asprintf( &s, "file://%s/%s\r\n", Project::path(), "clipboard.strip" );
|
||
|
||
Fl::copy( s, strlen(s), 0 );
|
||
|
||
free(s);
|
||
}
|
||
else if ( ! strcmp( picked, "/Color" ) )
|
||
{
|
||
unsigned char r, g, b;
|
||
|
||
Fl::get_color( color(), r, g, b );
|
||
|
||
if ( fl_color_chooser( "Strip Color", r, g, b ) )
|
||
color( fl_rgb_color( r, g, b ) );
|
||
|
||
redraw();
|
||
}
|
||
else if ( !strcmp( picked, "/Export Strip" ) )
|
||
{
|
||
char *suggested_name;
|
||
asprintf( &suggested_name, "%s.strip", name() );
|
||
|
||
const char *s = fl_file_chooser( "Export strip to filename:", "*.strip", suggested_name, 0 );
|
||
|
||
free( suggested_name );
|
||
|
||
if ( s )
|
||
export_strip( s );
|
||
|
||
fl_message( "Strip exported." );
|
||
}
|
||
else if ( ! strcmp( picked, "/Remove" ) )
|
||
{
|
||
if ( Fl::event_shift() || 1 == fl_choice( "Are you sure you want to remove this strip?\n\n(this action cannot be undone)", "Cancel", "Remove", NULL ) )
|
||
command_close();
|
||
}
|
||
else if ( ! strcmp( picked, "/Gain" ) )
|
||
{
|
||
gain_controller->take_focus();
|
||
}
|
||
else if ( ! strcmp( picked, "/Mute" ) )
|
||
{
|
||
((Fl_Button*)mute_controller->child(0))->value( !
|
||
((Fl_Button*)mute_controller->child(0))->value());
|
||
|
||
}
|
||
else if ( ! strcmp( picked, "Auto Output/On" ) )
|
||
{
|
||
manual_connection( false );
|
||
}
|
||
else if ( ! strcmp( picked, "Auto Output/Off" ) )
|
||
{
|
||
manual_connection( true );
|
||
}
|
||
else if ( ! strncmp( picked, "Auto Input/", strlen( "Auto Input/" ) ))
|
||
{
|
||
const char *s = index( picked, '/' ) + 1;
|
||
|
||
if ( ! strcmp( s, "Off" ) )
|
||
auto_input( NULL );
|
||
else
|
||
auto_input( s );
|
||
}
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::menu_cb ( Fl_Widget *w, void *v )
|
||
{
|
||
((Mixer_Strip*)v)->menu_cb( (Fl_Menu_*) w );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::auto_input ( const char *s )
|
||
{
|
||
if ( _auto_input )
|
||
free( _auto_input );
|
||
|
||
_auto_input = NULL;
|
||
|
||
if ( s )
|
||
_auto_input = strdup( s );
|
||
|
||
mixer->auto_connect();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::manual_connection ( bool b )
|
||
{
|
||
_manual_connection = b;
|
||
output_connection_button->value(b);
|
||
|
||
if ( chain() )
|
||
{
|
||
if ( b )
|
||
chain()->auto_disconnect_outputs();
|
||
else
|
||
chain()->auto_connect_outputs();
|
||
}
|
||
}
|
||
|
||
static bool matches_pattern ( const char *pattern, Module::Port *p )
|
||
{
|
||
char group_name[256];
|
||
char port_group[256];
|
||
|
||
if ( 2 == sscanf( pattern, "%[^/]/%[^\n]", group_name, port_group ))
|
||
{
|
||
if ( strcmp( group_name, "*" ) &&
|
||
strcmp( group_name, p->module()->chain()->strip()->group()->name() ))
|
||
{
|
||
/* group mismatch */
|
||
return false;
|
||
}
|
||
|
||
/* group matches... try port group */
|
||
if ( ! strcmp( port_group, "mains" ) )
|
||
{
|
||
if ( index( p->jack_port()->name(), '/' ) )
|
||
return false;
|
||
else
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
const char *pn = p->jack_port()->name();
|
||
const char *n = rindex( pn, '/' );
|
||
|
||
if ( n )
|
||
{
|
||
// *n = 0;
|
||
if ( ! strncmp( port_group, pn, ( n - 1 ) - pn ) )
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
#include "JACK_Module.H"
|
||
|
||
void
|
||
Mixer_Strip::auto_connect_outputs ( void )
|
||
{
|
||
chain()->auto_connect_outputs();
|
||
}
|
||
|
||
bool
|
||
Mixer_Strip::has_group_affinity ( void ) const
|
||
{
|
||
return _auto_input && strncmp( _auto_input, "*/", 2 );
|
||
}
|
||
|
||
|
||
bool
|
||
Mixer_Strip::maybe_auto_connect_output ( Module::Port *p )
|
||
{
|
||
if ( p->module()->chain()->strip()->_manual_connection )
|
||
return true;
|
||
|
||
if ( p->module()->chain()->strip() == this )
|
||
/* don't auto connect to self! */
|
||
return false;
|
||
|
||
if ( ! _auto_input )
|
||
{
|
||
if ( p->connected_port() && p->connected_port()->module()->chain()->strip() == this )
|
||
{
|
||
/* first break previous auto connection */
|
||
p->connected_port()->jack_port()->disconnect( p->jack_port()->jack_name() );
|
||
p->disconnect();
|
||
}
|
||
}
|
||
|
||
if ( _auto_input && matches_pattern( _auto_input, p ) )
|
||
{
|
||
DMESSAGE( "Auto connecting port" );
|
||
|
||
if ( p->connected_port() )
|
||
{
|
||
/* first break previous auto connection */
|
||
p->connected_port()->jack_port()->disconnect( p->jack_port()->jack_name() );
|
||
p->disconnect();
|
||
}
|
||
|
||
const char* jack_name = p->jack_port()->jack_name();
|
||
|
||
/* get port number */
|
||
const char *s = rindex( jack_name, '-' );
|
||
unsigned int n = atoi( s + 1 ) - 1;
|
||
|
||
/* FIXME: safe assumption? */
|
||
JACK_Module *m = (JACK_Module*)chain()->module(0);
|
||
|
||
if ( n < m->aux_audio_input.size() )
|
||
{
|
||
m->aux_audio_input[n].jack_port()->connect( jack_name );
|
||
/* make a note of the connection so we know to disconnected later */
|
||
m->aux_audio_input[n].connect_to( p );
|
||
}
|
||
|
||
if ( p->module()->is_default() )
|
||
{
|
||
/* only do this for mains */
|
||
p->module()->chain()->strip()->output_connection_button->copy_label( name() );
|
||
p->module()->chain()->strip()->output_connection_button->labelcolor( FL_FOREGROUND_COLOR );
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/** build the context menu */
|
||
Fl_Menu_Button &
|
||
Mixer_Strip::menu ( void ) const
|
||
{
|
||
static Fl_Menu_Button m( 0, 0, 0, 0, "Strip" );
|
||
static char label[256];
|
||
|
||
snprintf( label, sizeof(label), "Strip/%s", name() );
|
||
m.label( label );
|
||
|
||
// int c = output.size();
|
||
|
||
m.clear();
|
||
|
||
std::list<std::string> sl = mixer->get_auto_connect_targets();
|
||
|
||
|
||
m.add( "Auto Output/On", 0, 0, 0, FL_MENU_RADIO | ( _manual_connection ? 0 : FL_MENU_VALUE ) );
|
||
m.add( "Auto Output/Off", 0, 0, 0, FL_MENU_RADIO | ( ! _manual_connection ? 0 : FL_MENU_VALUE ) );
|
||
m.add( "Auto Input/Off", 0, 0, 0, FL_MENU_DIVIDER | FL_MENU_RADIO | ( _auto_input ? 0 : FL_MENU_VALUE ) );
|
||
|
||
for ( std::list<std::string>::iterator i = sl.begin(); i != sl.end(); i++ )
|
||
{
|
||
char *s;
|
||
asprintf( &s, "Auto Input/%s", i->c_str() );
|
||
|
||
m.add( s, 0,0,0, FL_MENU_RADIO | ( _auto_input && !strcmp( _auto_input, i->c_str() ) ? FL_MENU_VALUE : 0 ));
|
||
free(s );
|
||
}
|
||
|
||
m.add( "Width/Narrow", 'n', 0, 0, FL_MENU_RADIO | ( ! width_button->value() ? FL_MENU_VALUE : 0 ));
|
||
m.add( "Width/Wide", 'w', 0, 0, FL_MENU_RADIO | ( width_button->value() ? FL_MENU_VALUE : 0 ) );
|
||
m.add( "View/Fader", 'f', 0, 0, FL_MENU_RADIO | ( 0 == tab_button->value() ? FL_MENU_VALUE : 0 ) );
|
||
m.add( "View/Signal", 's', 0, 0, FL_MENU_RADIO | ( 1 == tab_button->value() ? FL_MENU_VALUE : 0 ) );
|
||
m.add( "Mute", 'm', 0, 0, 0 );
|
||
// ( 1 == mute_controller->control_output[0].connected_port()->control_value() ? FL_MENU_VALUE : 0 ) );
|
||
m.add( "Gain", 'g', 0, 0 );
|
||
m.add( "Move Left", '[', 0, 0 );
|
||
m.add( "Move Right", ']', 0, 0 );
|
||
m.add( "Color", 0, 0, 0 );
|
||
m.add( "Copy", FL_CTRL + 'c', 0, 0 );
|
||
m.add( "Export Strip", 0, 0, 0 );
|
||
m.add( "Rename", FL_CTRL + 'n', 0, 0 );
|
||
m.add( "Remove", FL_Delete, 0, 0 );
|
||
|
||
menu_set_callback( const_cast<Fl_Menu_Item*>(m.menu()), &Mixer_Strip::menu_cb, (void*)this );
|
||
|
||
return m;
|
||
}
|
||
|
||
Controller_Module *
|
||
Mixer_Strip::spatializer ( void )
|
||
{
|
||
return spatialization_controller;
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::get_output_ports ( std::list<std::string> &ports )
|
||
{
|
||
_chain->get_output_ports(ports);
|
||
}
|
||
|
||
int
|
||
Mixer_Strip::handle ( int m )
|
||
{
|
||
static int _button = 0;
|
||
|
||
Logger log( this );
|
||
|
||
static Fl_Widget *dragging = NULL;
|
||
|
||
if ( Fl_Group::handle( m ) )
|
||
return 1;
|
||
|
||
switch ( m )
|
||
{
|
||
case FL_FOCUS:
|
||
damage( FL_DAMAGE_USER1 );
|
||
return 1;
|
||
case FL_UNFOCUS:
|
||
damage( FL_DAMAGE_USER1 );
|
||
return 1;
|
||
}
|
||
|
||
/* if ( m == FL_PUSH ) */
|
||
/* take_focus(); */
|
||
|
||
switch ( m )
|
||
{
|
||
case FL_KEYBOARD:
|
||
{
|
||
if ( Fl::event_key() == FL_Menu )
|
||
{
|
||
menu_popup( &menu(), x(), y() );
|
||
return 1;
|
||
}
|
||
else
|
||
return menu().test_shortcut() != 0;
|
||
break;
|
||
}
|
||
case FL_PUSH:
|
||
if ( Fl::event_button1() && Fl::event_inside( color_box ) )
|
||
dragging = this;
|
||
else
|
||
dragging = NULL;
|
||
|
||
_button = Fl::event_button();
|
||
|
||
return 1;
|
||
|
||
break;
|
||
|
||
case FL_DRAG:
|
||
return 1;
|
||
break;
|
||
case FL_RELEASE:
|
||
if ( dragging == this && ! Fl::event_is_click() )
|
||
{
|
||
mixer->insert( this, mixer->event_inside() );
|
||
/* FIXME: do better! */
|
||
mixer->redraw();
|
||
dragging = NULL;
|
||
return 1;
|
||
}
|
||
|
||
dragging = NULL;
|
||
|
||
int b = _button;
|
||
_button = 0;
|
||
|
||
/* if ( 1 == b ) */
|
||
/* { */
|
||
/* take_focus(); */
|
||
/* } */
|
||
/* else */
|
||
if ( 3 == b )
|
||
{
|
||
menu_popup( &menu() );
|
||
return 1;
|
||
}
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::send_feedback ( void )
|
||
{
|
||
if ( _chain )
|
||
_chain->send_feedback();
|
||
}
|
||
|
||
int
|
||
Mixer_Strip::number ( void ) const
|
||
{
|
||
return mixer->find_strip( this );
|
||
}
|
||
|
||
/************/
|
||
/* Commands */
|
||
/************/
|
||
|
||
void
|
||
Mixer_Strip::command_toggle_fader_view ( void )
|
||
{
|
||
tab_button->value( ! tab_button->value() );
|
||
tab_button->do_callback();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_move_left ( void )
|
||
{
|
||
mixer->move_left( this );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_move_right ( void )
|
||
{
|
||
mixer->move_right( this );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_close ( void )
|
||
{
|
||
Fl::delete_widget( this );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_rename ( const char * s )
|
||
{
|
||
name( s );
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_width ( bool b )
|
||
{
|
||
width_button->value( b );
|
||
width_button->do_callback();
|
||
}
|
||
|
||
void
|
||
Mixer_Strip::command_view ( bool b )
|
||
{
|
||
tab_button->value( b );
|
||
tab_button->do_callback();
|
||
}
|