← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to gtk2_ardour/mixer_actor.cc

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk2_ardour/mixer_actor.cc
 
1
/*
 
2
    Copyright (C) 2000-2004 Paul Davis
 
3
 
 
4
    This program is free software; you can redistribute it and/or modify
 
5
    it under the terms of the GNU General Public License as published by
 
6
    the Free Software Foundation; either version 2 of the License, or
 
7
    (at your option) any later version.
 
8
 
 
9
    This program is distributed in the hope that it will be useful,
 
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
    GNU General Public License for more details.
 
13
 
 
14
    You should have received a copy of the GNU General Public License
 
15
    along with this program; if not, write to the Free Software
 
16
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
17
 
 
18
*/
 
19
 
 
20
#ifdef WAF_BUILD
 
21
#include "gtk2ardour-config.h"
 
22
#endif
 
23
 
 
24
#include <boost/foreach.hpp>
 
25
 
 
26
#include "pbd/file_utils.h"
 
27
#include "pbd/error.h"
 
28
 
 
29
#include "ardour/filesystem_paths.h"
 
30
 
 
31
#include "actions.h"
 
32
#include "mixer_actor.h"
 
33
#include "mixer_strip.h"
 
34
#include "route_ui.h"
 
35
 
 
36
#include "i18n.h"
 
37
 
 
38
using namespace ARDOUR;
 
39
using namespace Gtk;
 
40
using namespace PBD;
 
41
 
 
42
MixerActor::MixerActor ()
 
43
{
 
44
        register_actions ();
 
45
        load_bindings ();
 
46
}
 
47
 
 
48
MixerActor::~MixerActor ()
 
49
{
 
50
}
 
51
 
 
52
void
 
53
MixerActor::register_actions ()
 
54
{
 
55
        myactions.register_action ("Mixer", "solo", _("Toggle Solo on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::solo_action));
 
56
        myactions.register_action ("Mixer", "mute", _("Toggle Mute on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::mute_action));
 
57
        myactions.register_action ("Mixer", "recenable", _("Toggle Rec-enable on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::rec_enable_action));
 
58
        myactions.register_action ("Mixer", "increment-gain", _("Decrease Gain on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::step_gain_up_action));
 
59
        myactions.register_action ("Mixer", "decrement-gain", _("Increase Gain on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::step_gain_down_action));
 
60
        myactions.register_action ("Mixer", "unity-gain", _("Set Gain to 0dB on Mixer-Selected Tracks/Busses"), sigc::mem_fun (*this, &MixerActor::unity_gain_action));
 
61
 
 
62
 
 
63
        myactions.register_action ("Mixer", "copy-processors", _("Copy Selected Processors"), sigc::mem_fun (*this, &MixerActor::copy_processors));
 
64
        myactions.register_action ("Mixer", "cut-processors", _("Cut Selected Processors"), sigc::mem_fun (*this, &MixerActor::cut_processors));
 
65
        myactions.register_action ("Mixer", "paste-processors", _("Paste Selected Processors"), sigc::mem_fun (*this, &MixerActor::paste_processors));
 
66
        myactions.register_action ("Mixer", "delete-processors", _("Delete Selected Processors"), sigc::mem_fun (*this, &MixerActor::delete_processors));
 
67
        myactions.register_action ("Mixer", "select-all-processors", _("Select All (visible) Processors"), sigc::mem_fun (*this, &MixerActor::select_all_processors));
 
68
        myactions.register_action ("Mixer", "toggle-processors", _("Toggle Selected Processors"), sigc::mem_fun (*this, &MixerActor::toggle_processors));
 
69
        myactions.register_action ("Mixer", "ab-plugins", _("Toggle Selected Plugins"), sigc::mem_fun (*this, &MixerActor::ab_plugins));
 
70
 
 
71
 
 
72
        myactions.register_action ("Mixer", "scroll-left", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_left));
 
73
        myactions.register_action ("Mixer", "scroll-right", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_right));
 
74
 
 
75
        myactions.register_action ("Mixer", "toggle-midi-input-active", _("Toggle MIDI Input Active for Mixer-Selected Tracks/Busses"), 
 
76
                                   sigc::bind (sigc::mem_fun (*this, &MixerActor::toggle_midi_input_active), false));
 
77
}
 
78
 
 
79
void
 
80
MixerActor::load_bindings ()
 
81
{
 
82
        /* XXX move this to a better place */
 
83
        
 
84
        bindings.set_action_map (myactions);
 
85
 
 
86
        std::string binding_file;
 
87
 
 
88
        if (find_file_in_search_path (ardour_config_search_path(), "mixer.bindings", binding_file)) {
 
89
                bindings.load (binding_file);
 
90
                info << string_compose (_("Loaded mixer bindings from %1"), binding_file) << endmsg;
 
91
        } else {
 
92
                error << string_compose (_("Could not find mixer.bindings in search path %1"), ardour_config_search_path().to_string()) << endmsg;
 
93
        }
 
94
}
 
95
 
 
96
void
 
97
MixerActor::solo_action ()
 
98
{
 
99
        GdkEventButton ev;
 
100
 
 
101
        ev.type = GDK_BUTTON_PRESS;
 
102
        ev.button = 1;
 
103
        ev.state = 0;
 
104
 
 
105
        set_route_targets_for_operation ();
 
106
 
 
107
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
108
                r->solo_press (&ev);
 
109
        }
 
110
}
 
111
 
 
112
void
 
113
MixerActor::mute_action ()
 
114
{
 
115
        GdkEventButton ev;
 
116
 
 
117
        ev.type = GDK_BUTTON_PRESS;
 
118
        ev.button = 1;
 
119
        ev.state = 0;
 
120
 
 
121
        set_route_targets_for_operation ();
 
122
 
 
123
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
124
                r->mute_press (&ev);
 
125
        }
 
126
}
 
127
 
 
128
void
 
129
MixerActor::rec_enable_action ()
 
130
{
 
131
        GdkEventButton ev;
 
132
 
 
133
        ev.type = GDK_BUTTON_PRESS;
 
134
        ev.button = 1;
 
135
        ev.state = 0;
 
136
 
 
137
        set_route_targets_for_operation ();
 
138
 
 
139
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
140
                r->rec_enable_press (&ev);
 
141
        }
 
142
}
 
143
 
 
144
void
 
145
MixerActor::step_gain_up_action ()
 
146
{
 
147
        set_route_targets_for_operation ();
 
148
 
 
149
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
150
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
151
                if (ms) {
 
152
                        ms->step_gain_up ();
 
153
                }
 
154
        }
 
155
}
 
156
 
 
157
void
 
158
MixerActor::step_gain_down_action ()
 
159
{
 
160
        set_route_targets_for_operation ();
 
161
 
 
162
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
163
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
164
                if (ms) {
 
165
                        ms->step_gain_down ();
 
166
                }
 
167
        }
 
168
}
 
169
 
 
170
void
 
171
MixerActor::unity_gain_action ()
 
172
{
 
173
        set_route_targets_for_operation ();
 
174
 
 
175
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
176
                boost::shared_ptr<Route> rp = r->route();
 
177
                if (rp) {
 
178
                        rp->set_gain (1.0, this);
 
179
                }
 
180
        }
 
181
}
 
182
 
 
183
void
 
184
MixerActor::copy_processors ()
 
185
{
 
186
        set_route_targets_for_operation ();
 
187
 
 
188
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
189
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
190
                if (ms) {
 
191
                        ms->copy_processors ();
 
192
                }
 
193
        }
 
194
}
 
195
void
 
196
MixerActor::cut_processors ()
 
197
{
 
198
        set_route_targets_for_operation ();
 
199
 
 
200
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
201
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
202
                if (ms) {
 
203
                        ms->cut_processors ();
 
204
                }
 
205
        }
 
206
}
 
207
void
 
208
MixerActor::paste_processors ()
 
209
{
 
210
        set_route_targets_for_operation ();
 
211
 
 
212
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
213
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
214
                if (ms) {
 
215
                        ms->paste_processors ();
 
216
                }
 
217
        }
 
218
}
 
219
void
 
220
MixerActor::select_all_processors ()
 
221
{
 
222
        set_route_targets_for_operation ();
 
223
 
 
224
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
225
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
226
                if (ms) {
 
227
                        ms->select_all_processors ();
 
228
                }
 
229
        }
 
230
}
 
231
void
 
232
MixerActor::delete_processors ()
 
233
{
 
234
        set_route_targets_for_operation ();
 
235
 
 
236
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
237
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
238
                if (ms) {
 
239
                        ms->delete_processors ();
 
240
                }
 
241
        }
 
242
}
 
243
void
 
244
MixerActor::toggle_processors ()
 
245
{
 
246
        set_route_targets_for_operation ();
 
247
 
 
248
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
249
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
250
                if (ms) {
 
251
                        ms->toggle_processors ();
 
252
                }
 
253
        }
 
254
}
 
255
void
 
256
MixerActor::ab_plugins ()
 
257
{
 
258
        set_route_targets_for_operation ();
 
259
 
 
260
        BOOST_FOREACH(RouteUI* r, _route_targets) {
 
261
                MixerStrip* ms = dynamic_cast<MixerStrip*> (r);
 
262
                if (ms) {
 
263
                        ms->ab_plugins ();
 
264
                }
 
265
        }
 
266
}
 
267