show_all();
name_changed ();
- bounds_changed (PropertyChange (StartChanged|LengthChanged|PositionChanged|Region::SyncOffsetChanged));
+
+ PropertyChange change;
+
+ change.add (ARDOUR::Properties::start);
+ change.add (ARDOUR::Properties::length);
+ change.add (ARDOUR::Properties::position);
+ change.add (ARDOUR::Properties::sync_position);
+
+ bounds_changed (change);
+
gain_changed ();
- _region->StateChanged.connect (state_connection, ui_bind (&AudioRegionEditor::region_changed, this, _1), gui_context());
+ _region->PropertyChanged.connect (state_connection, ui_bind (&AudioRegionEditor::region_changed, this, _1), gui_context());
spin_arrow_grab = false;
}
void
-AudioRegionEditor::region_changed (PBD::PropertyChange what_changed)
+AudioRegionEditor::region_changed (const PBD::PropertyChange& what_changed)
{
- if (what_changed & NameChanged) {
+ if (what_changed.contains (ARDOUR::Properties::name)) {
name_changed ();
}
- if (what_changed & PropertyChange (BoundsChanged|StartChanged|Region::SyncOffsetChanged)) {
+ PropertyChange interesting_stuff;
+
+ interesting_stuff.add (ARDOUR::Properties::position);
+ interesting_stuff.add (ARDOUR::Properties::length);
+ interesting_stuff.add (ARDOUR::Properties::start);
+ interesting_stuff.add (ARDOUR::Properties::sync_position);
+
+ if (what_changed.contains (interesting_stuff)) {
bounds_changed (what_changed);
}
- if (what_changed & AudioRegion::ScaleAmplitudeChanged) {
+ if (what_changed.contains (ARDOUR::Properties::scale_amplitude)) {
gain_changed ();
}
}
}
void
-AudioRegionEditor::bounds_changed (PropertyChange what_changed)
+AudioRegionEditor::bounds_changed (const PropertyChange& what_changed)
{
- if ((what_changed & PropertyChange (PositionChanged|LengthChanged)) == PropertyChange (PositionChanged|LengthChanged)) {
+ if (what_changed.contains (ARDOUR::Properties::position) && what_changed.contains (ARDOUR::Properties::length)) {
position_clock.set (_region->position(), true);
end_clock.set (_region->position() + _region->length() - 1, true);
length_clock.set (_region->length(), true);
- } else if (what_changed & PropertyChange (PositionChanged)) {
+ } else if (what_changed.contains (ARDOUR::Properties::position)) {
position_clock.set (_region->position(), true);
end_clock.set (_region->position() + _region->length() - 1, true);
- } else if (what_changed & PropertyChange (LengthChanged)) {
+ } else if (what_changed.contains (ARDOUR::Properties::length)) {
end_clock.set (_region->position() + _region->length() - 1, true);
length_clock.set (_region->length(), true);
}
- if ((what_changed & Region::SyncOffsetChanged) || (what_changed & PositionChanged)) {
+ if (what_changed.contains (ARDOUR::Properties::sync_position) || what_changed.contains (ARDOUR::Properties::position)) {
int dir;
nframes_t off = _region->sync_offset (dir);
if (dir == -1) {
off = -off;
}
- if (what_changed & Region::SyncOffsetChanged) {
+ if (what_changed.contains (ARDOUR::Properties::sync_position)) {
sync_offset_relative_clock.set (off, true);
}
sync_offset_absolute_clock.set (off + _region->position (), true);
}
- if (what_changed & StartChanged) {
+ if (what_changed.contains (ARDOUR::Properties::start)) {
start_clock.set (_region->start(), true);
}
}
bool
AudioRegionEditor::on_delete_event (GdkEventAny* ev)
{
- bounds_changed (PropertyChange (StartChanged|LengthChanged|PositionChanged|Region::SyncOffsetChanged));
+ PropertyChange change;
+
+ change.add (ARDOUR::Properties::start);
+ change.add (ARDOUR::Properties::length);
+ change.add (ARDOUR::Properties::position);
+ change.add (ARDOUR::Properties::sync_position);
+
+ bounds_changed (change);
+
return RegionEditor::on_delete_event (ev);
}
PBD::ScopedConnection state_connection;
PBD::ScopedConnection audition_connection;
- void region_changed (PBD::PropertyChange);
- void bounds_changed (PBD::PropertyChange);
+ void region_changed (const PBD::PropertyChange&);
+ void bounds_changed (const PBD::PropertyChange&);
void name_changed ();
void gain_changed ();
region_muted ();
region_sync_changed ();
- region_resized (BoundsChanged);
+
+ region_resized (ARDOUR::bounds_change);
set_waveview_data_src();
region_locked ();
envelope_active_changed ();
}
void
-AudioRegionView::region_changed (PropertyChange what_changed)
+AudioRegionView::region_changed (const PropertyChange& what_changed)
{
ENSURE_GUI_THREAD (*this, &AudioRegionView::region_changed, what_changed)
//cerr << "AudioRegionView::region_changed() called" << endl;
- RegionView::region_changed(what_changed);
+ RegionView::region_changed (what_changed);
- if (what_changed & AudioRegion::ScaleAmplitudeChanged) {
+ if (what_changed.contains (ARDOUR::Properties::scale_amplitude)) {
region_scale_amplitude_changed ();
}
- if (what_changed & AudioRegion::FadeInChanged) {
- fade_in_changed ();
+ if (what_changed.contains (ARDOUR::Properties::fade_in)) {
+ fade_in_changed ();
}
- if (what_changed & AudioRegion::FadeOutChanged) {
+ if (what_changed.contains (ARDOUR::Properties::fade_out)) {
fade_out_changed ();
}
- if (what_changed & AudioRegion::FadeInActiveChanged) {
+ if (what_changed.contains (ARDOUR::Properties::fade_in_active)) {
fade_in_active_changed ();
}
- if (what_changed & AudioRegion::FadeOutActiveChanged) {
+ if (what_changed.contains (ARDOUR::Properties::fade_out_active)) {
fade_out_active_changed ();
}
- if (what_changed & AudioRegion::EnvelopeActiveChanged) {
+ if (what_changed.contains (ARDOUR::Properties::envelope_active)) {
envelope_active_changed ();
}
}
}
void
-AudioRegionView::region_resized (PropertyChange what_changed)
+AudioRegionView::region_resized (const PropertyChange& what_changed)
{
AudioGhostRegion* agr;
RegionView::region_resized(what_changed);
+ PropertyChange interesting_stuff;
+
+ interesting_stuff.add (ARDOUR::Properties::start);
+ interesting_stuff.add (ARDOUR::Properties::length);
- if (what_changed & PropertyChange (StartChanged|LengthChanged)) {
+ if (what_changed.contains (interesting_stuff)) {
for (uint32_t n = 0; n < waves.size(); ++n) {
waves[n]->property_region_start() = _region->start();
AudioRegionGainLine* get_gain_line() const { return gain_line; }
- void region_changed (PBD::PropertyChange);
+ void region_changed (const PBD::PropertyChange&);
void envelope_active_changed ();
GhostRegion* add_ghost (TimeAxisView&);
void fade_in_active_changed ();
void fade_out_active_changed ();
- void region_resized (PBD::PropertyChange);
+ void region_resized (const PBD::PropertyChange&);
void region_muted ();
void region_scale_amplitude_changed ();
void region_renamed ();
set_height (trackview.current_height());
- _region->StateChanged.connect (*this, ui_bind (&RegionView::region_changed, this, _1), gui_context());
+ _region->PropertyChanged.connect (*this, ui_bind (&RegionView::region_changed, this, _1), gui_context());
set_colors ();
void
-AutomationRegionView::region_resized (PBD::PropertyChange what_changed)
+AutomationRegionView::region_resized (const PBD::PropertyChange& what_changed)
{
RegionView::region_resized(what_changed);
protected:
void create_line(boost::shared_ptr<ARDOUR::AutomationList> list);
bool set_position(nframes64_t pos, void* src, double* ignored);
- void region_resized (PBD::PropertyChange what_changed);
+ void region_resized (const PBD::PropertyChange&);
bool canvas_event(GdkEvent* ev);
void add_automation_event (GdkEvent* event, nframes_t when, double y);
void entered();
curve_select_clicked (In);
- xfade->StateChanged.connect (state_connection, ui_bind (&CrossfadeEditor::xfade_changed, this, _1), gui_context());
+ xfade->PropertyChanged.connect (state_connection, ui_bind (&CrossfadeEditor::xfade_changed, this, _1), gui_context());
_session->AuditionActive.connect (_session_connections, ui_bind (&CrossfadeEditor::audition_state_changed, this, _1), gui_context());
show_all_children();
void
-CrossfadeEditor::xfade_changed (PropertyChange)
+CrossfadeEditor::xfade_changed (const PropertyChange&)
{
set (xfade->fade_in(), In);
set (xfade->fade_out(), Out);
void audition_right_dry ();
void audition_right ();
- void xfade_changed (PBD::PropertyChange);
+ void xfade_changed (const PBD::PropertyChange&);
void dump ();
};
group->signal_event().connect (sigc::bind (sigc::mem_fun (tv.editor(), &PublicEditor::canvas_crossfade_view_event), group, this));
- crossfade_changed (PropertyChange (~0));
+ PropertyChange all_crossfade_properties;
+ all_crossfade_properties.add (ARDOUR::Properties::active);
+ all_crossfade_properties.add (ARDOUR::Properties::follow_overlap);
+ crossfade_changed (all_crossfade_properties);
- crossfade->StateChanged.connect (*this, ui_bind (&CrossfadeView::crossfade_changed, this, _1), gui_context());
+ crossfade->PropertyChanged.connect (*this, ui_bind (&CrossfadeView::crossfade_changed, this, _1), gui_context());
ColorsChanged.connect (sigc::mem_fun (*this, &CrossfadeView::color_handler));
}
}
void
-CrossfadeView::crossfade_changed (PropertyChange what_changed)
+CrossfadeView::crossfade_changed (const PropertyChange& what_changed)
{
bool need_redraw_curves = false;
- if (what_changed & BoundsChanged) {
+ if (what_changed.contains (ARDOUR::bounds_change)) {
set_position (crossfade->position(), this);
set_duration (crossfade->length(), this);
need_redraw_curves = false;
}
- if (what_changed & Crossfade::FollowOverlapChanged) {
+ if (what_changed.contains (ARDOUR::Properties::follow_overlap)) {
need_redraw_curves = true;
}
- if (what_changed & Crossfade::ActiveChanged) {
+ if (what_changed.contains (ARDOUR::Properties::active)) {
/* calls redraw_curves */
active_changed ();
} else if (need_redraw_curves) {
ArdourCanvas::Line *fade_out;
ArdourCanvas::Item *active_button;
- void crossfade_changed (PBD::PropertyChange);
+ void crossfade_changed (const PBD::PropertyChange&);
void active_changed ();
- void redraw_curves ();
- void color_handler ();
+ void redraw_curves ();
+ void color_handler ();
};
#endif /* __gtk_ardour_crossfade_view_h__ */
_session->DurationChanged.connect (_session_connections, boost::bind (&Editor::handle_new_duration, this), gui_context());
_session->DirtyChanged.connect (_session_connections, boost::bind (&Editor::update_title, this), gui_context());
_session->TimecodeOffsetChanged.connect (_session_connections, boost::bind (&Editor::update_just_timecode, this), gui_context());
- _session->tempo_map().StateChanged.connect (_session_connections, ui_bind (&Editor::tempo_map_changed, this, _1), gui_context());
+ _session->tempo_map().PropertyChanged.connect (_session_connections, ui_bind (&Editor::tempo_map_changed, this, _1), gui_context());
_session->Located.connect (_session_connections, boost::bind (&Editor::located, this), gui_context());
_session->config.ParameterChanged.connect (_session_connections, ui_bind (&Editor::parameter_changed, this, _1), gui_context());
_session->StateSaved.connect (_session_connections, ui_bind (&Editor::session_state_saved, this, _1), gui_context());
}
cew.apply ();
- xfade->StateChanged (PropertyChange (~0));
+ PropertyChange all_crossfade_properties;
+ all_crossfade_properties.add (ARDOUR::Properties::active);
+ all_crossfade_properties.add (ARDOUR::Properties::follow_overlap);
+ xfade->PropertyChanged (all_crossfade_properties);
}
PlaylistSelector&
void location_changed (ARDOUR::Location *);
void location_flags_changed (ARDOUR::Location *, void *);
void refresh_location_display ();
- void refresh_location_display_s (PBD::PropertyChange);
+ void refresh_location_display_s (const PBD::PropertyChange&);
void refresh_location_display_internal (ARDOUR::Locations::LocationList&);
void add_new_location (ARDOUR::Location *);
void location_gone (ARDOUR::Location *);
void draw_metric_marks (const ARDOUR::Metrics& metrics);
void compute_current_bbt_points (nframes_t left, nframes_t right);
- void tempo_map_changed (PBD::PropertyChange);
+ void tempo_map_changed (const PBD::PropertyChange&);
void redisplay_tempo (bool immediate_redraw);
void snap_to (nframes64_t& first, int32_t direction = 0, bool for_mark = false);
}
void
-Editor::refresh_location_display_s (PropertyChange)
+Editor::refresh_location_display_s (const PropertyChange&)
{
ENSURE_GUI_THREAD (*this, &Editor::refresh_location_display_s, ignored)
snap_to (new_bound);
}
region->trim_start ((nframes64_t) (new_bound * speed), this);
- rv.region_changed (StartChanged);
+ rv.region_changed (PropertyChange (ARDOUR::Properties::start));
}
void
}
}
- rv.region_changed (PropertyChange (LengthChanged|PositionChanged|StartChanged));
+ rv.region_changed (ARDOUR::bounds_change);
}
void
region_right->trim_front(region->last_frame() + 1, this);
}
- rv.region_changed (PropertyChange (LengthChanged|PositionChanged|StartChanged));
- }
- else {
- rv.region_changed (LengthChanged);
+ rv.region_changed (ARDOUR::bounds_change);
+
+ } else {
+ rv.region_changed (PropertyChange (ARDOUR::Properties::length));
}
}
}
region->trim_end((nframes64_t) (next_region->first_frame() * speed), this);
- arv->region_changed (PropertyChange (LengthChanged));
+ arv->region_changed (PropertyChange (ARDOUR::Properties::length));
}
else {
}
region->trim_front((nframes64_t) ((next_region->last_frame() + 1) * speed), this);
- arv->region_changed (PropertyChange (LengthChanged|PositionChanged|StartChanged));
+
+ arv->region_changed (ARDOUR::bounds_change);
}
XMLNode &after = playlist->get_state();
void
-EditorRegions::region_changed (PropertyChange what_changed, boost::weak_ptr<Region> region)
+EditorRegions::region_changed (const PropertyChange& what_changed, boost::weak_ptr<Region> region)
{
ENSURE_GUI_THREAD (*this, &EditorRegions::region_changed, what_changed, region)
return;
}
- if (what_changed & ARDOUR::NameChanged) {
+ if (what_changed.contains (ARDOUR::Properties::name)) {
/* find the region in our model and change its name */
TreeModel::Children rows = _model->children ();
TreeModel::iterator i = rows.begin ();
break;
case AudioClock::Frames:
- snprintf (start_str, sizeof (start_str), "%u", region->position());
- snprintf (end_str, sizeof (end_str), "%u", (region->position() + region->length() - 1));
- snprintf (length_str, sizeof (length_str), "%u", region->length());
- snprintf (sync_str, sizeof (sync_str), "%u", region->sync_position() + region->position());
+ snprintf (start_str, sizeof (start_str), "%" PRId64, region->position());
+ snprintf (end_str, sizeof (end_str), "%" PRId64, (region->position() + region->length() - 1));
+ snprintf (length_str, sizeof (length_str), "%" PRId64, region->length());
+ snprintf (sync_str, sizeof (sync_str), "%" PRId64, region->sync_position() + region->position());
if (audioRegion && !fades_in_seconds) {
snprintf (fadein_str, sizeof (fadein_str), "%u", uint (audioRegion->fade_in()->back()->when));
Columns _columns;
- void region_changed (
PBD::PropertyChange, boost::weak_ptr<ARDOUR::Region>);
+ void region_changed (
const PBD::PropertyChange&, boost::weak_ptr<ARDOUR::Region>);
void selection_changed ();
sigc::connection _change_connection;
bool set_selected_in_subrow (boost::shared_ptr<ARDOUR::Region>, Gtk::TreeModel::Row const &, int);
boost::weak_ptr<Route> wr ((*x)->route());
(*x)->route()->gui_changed.connect (*this, ui_bind (&EditorRoutes::handle_gui_changes, this, _1, _2), gui_context());
- (*x)->route()->NameChanged.connect (*this, boost::bind (&EditorRoutes::route_name_changed, this, wr), gui_context());
+ (*x)->route()->PropertyChanged.connect (*this, ui_bind (&EditorRoutes::route_property_changed, this, _1, wr), gui_context());
if ((*x)->is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> ((*x)->route());
}
void
-EditorRoutes::route_name_changed (boost::weak_ptr<Route> r)
+EditorRoutes::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> r)
{
+ if (!what_changed.contains (ARDOUR::Properties::name)) {
+ return;
+ }
+
ENSURE_GUI_THREAD (*this, &EditorRoutes::route_name_changed, r)
boost::shared_ptr<Route> route = r.lock ();
+
if (!route) {
return;
}
void visible_changed (Glib::ustring const &);
void reordered (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &, int *);
bool button_press (GdkEventButton *);
- void route_
name_changed (boost::weak_ptr<ARDOUR::Route>);
+ void route_
property_changed (const PBD::PropertyChange&, boost::weak_ptr<ARDOUR::Route>);
void handle_gui_changes (std::string const &, void *);
void update_rec_display ();
void update_mute_display ();
}
void
-Editor::tempo_map_changed (PropertyChange ignored)
+Editor::tempo_map_changed (const PropertyChange& ignored)
{
if (!_session) {
return;
}
- ENSURE_GUI_THREAD (*this, &Editor::tempo_map_changed ignored);
+ ENSURE_GUI_THREAD (*this, &Editor::tempo_map_changed, ignored);
if (tempo_lines) {
tempo_lines->tempo_map_changed();
*/
void change_line_width(double coord, double width);
- /** PropertyChange the color of a line.
+ /** Change the color of a line.
*/
void change_line_color(double coord, uint32_t color);
region_muted ();
region_sync_changed ();
- region_resized (BoundsChanged);
+ region_resized (ARDOUR::bounds_change);
region_locked ();
reset_width_dependent_items (_pixel_width);
}
void
-MidiRegionView::region_resized (PropertyChange what_changed)
+MidiRegionView::region_resized (const PropertyChange& what_changed)
{
RegionView::region_resized(what_changed);
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (ARDOUR::Properties::position)) {
set_duration(_region->length(), 0);
if (_enable_display) {
redisplay_model();
*/
void get_patch_key_at(double time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key);
- /** PropertyChange the 'automation' data of old_program to new values which correspond to new_patch.
+ /** Change the 'automation' data of old_program to new values which correspond to new_patch.
* @param old_program the program change event which is to be altered
* @param new_patch the new lsb, msb and program number which are to be set
*/
*/
void change_velocity(ArdourCanvas::CanvasNoteEvent* ev, int8_t velocity, bool relative=false);
- /** PropertyChange the channel of the selection.
+ /** Change the channel of the selection.
* @param channel - the channel number of the new channel, zero-based
*/
void change_channel(uint8_t channel);
Gdk::Color& basic_color,
TimeAxisViewItem::Visibility);
- void region_resized (PBD::PropertyChange);
+ void region_resized (const PBD::PropertyChange&);
void set_flags (XMLNode *);
void store_flags ();
{
switch (_width) {
case Wide:
- RouteUI::name_changed ();
+ RouteUI::property_changed (PropertyChange (ARDOUR::Properties::name));
break;
case Narrow:
name_label.set_text (PBD::short_version (_route->name(), 5));
route->set_order_key (N_("signal"), track_model->children().size()-1);
}
- route->NameChanged.connect (*this, boost::bind (&Mixer_UI::strip_name_changed, this, strip), gui_context());
+ route->PropertyChanged.connect (*this, ui_bind (&Mixer_UI::strip_property_changed, this, _1, strip), gui_context());
strip->WidthChanged.connect (sigc::mem_fun(*this, &Mixer_UI::strip_width_changed));
strip->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &Mixer_UI::strip_button_release_event), strip));
}
void
-Mixer_UI::strip_name_changed (MixerStrip* mx)
+Mixer_UI::strip_property_changed (const PropertyChange& what_changed, MixerStrip* mx)
{
- ENSURE_GUI_THREAD (*this, &Mixer_UI::strip_name_changed, mx)
+ if (!what_changed.contains (ARDOUR::Properties::name)) {
+ return;
+ }
+
+ ENSURE_GUI_THREAD (*this, &Mixer_UI::strip_name_changed, what_changed, mx)
TreeModel::Children rows = track_model->children();
TreeModel::Children::iterator i;
PluginSelector *_plugin_selector;
- void strip_name_changed (MixerStrip *);
+ void strip_property_changed (const PBD::PropertyChange&, MixerStrip *);
void group_flags_changed (void *src, ARDOUR::RouteGroup *);
_active.signal_toggled().connect (sigc::mem_fun (*this, &ProcessorEntry::active_toggled));
_processor->ActiveChanged.connect (active_connection, boost::bind (&ProcessorEntry::processor_active_changed, this), gui_context());
- _processor->NameChanged.connect (name_connection, boost::bind (&ProcessorEntry::processor_name_changed, this), gui_context());
+ _processor->PropertyChanged.connect (name_connection, ui_bind (&ProcessorEntry::processor_property_changed, this, _1), gui_context());
}
EventBox&
}
void
-ProcessorEntry::processor_name_changed ()
+ProcessorEntry::processor_property_changed (const PropertyChange& what_changed)
{
- _name.set_text (name ());
+ if (what_changed.contains (ARDOUR::Properties::name)) {
+ _name.set_text (name ());
+ }
}
string
_route->processors_changed.connect (connections, ui_bind (&ProcessorBox::route_processors_changed, this, _1), gui_context());
_route->DropReferences.connect (connections, boost::bind (&ProcessorBox::route_going_away, this), gui_context());
- _route->NameChanged.connect (connections, boost::bind (&ProcessorBox::route_name_changed, this), gui_context());
+ _route->PropertyChanged.connect (connections, ui_bind (&ProcessorBox::route_property_changed, this, _1), gui_context());
redisplay_processors ();
}
}
void
-ProcessorBox::route_name_changed ()
+ProcessorBox::route_property_changed (const PropertyChange& what_changed)
{
- ENSURE_GUI_THREAD (*this, &ProcessorBox::route_name_changed)
+ if (!what_changed.contains (ARDOUR::Properties::name)) {
+ return;
+ }
+
+ ENSURE_GUI_THREAD (*this, &ProcessorBox::route_property_changed, what_changed);
boost::shared_ptr<Processor> processor;
boost::shared_ptr<PluginInsert> plugin_insert;
void active_toggled ();
void processor_active_changed ();
- void processor_name_changed ();
+ void processor_property_changed (const PBD::PropertyChange&);
std::string name () const;
Gtk::EventBox _event_box;
static void rb_ab_plugins ();
static void rb_edit ();
- void route_name_changed ();
+ void route_property_changed (const PBD::PropertyChange&);
std::string generate_processor_title (boost::shared_ptr<ARDOUR::PluginInsert> pi);
};
set_height (trackview.current_height());
- _region->StateChanged.connect (*this, ui_bind (&RegionView::region_changed, this, _1), gui_context());
+ _region->PropertyChanged.connect (*this, ui_bind (&RegionView::region_changed, this, _1), gui_context());
group->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_event), group, this));
}
void
-RegionView::region_changed (PropertyChange what_changed)
+RegionView::region_changed (const PropertyChange& what_changed)
{
- ENSURE_GUI_THREAD (*this, &RegionView::region_changed, what_changed)
+ ENSURE_GUI_THREAD (*this, &RegionView::region_changed, what_changed);
- if (what_changed & BoundsChanged) {
+ if (what_changed.contains (ARDOUR::bounds_change)) {
region_resized (what_changed);
region_sync_changed ();
}
- if (what_changed & Region::MuteChanged) {
+ if (what_changed.contains (ARDOUR::Properties::muted)) {
region_muted ();
}
- if (what_changed & Region::OpacityChanged) {
+ if (what_changed.contains (ARDOUR::Properties::opaque)) {
region_opacity ();
}
- if (what_changed & ARDOUR::NameChanged) {
+ if (what_changed.contains (ARDOUR::Properties::name)) {
region_renamed ();
}
- if (what_changed & Region::SyncOffsetChanged) {
+ if (what_changed.contains (ARDOUR::Properties::sync_position)) {
region_sync_changed ();
}
- if (what_changed & Region::LockChanged) {
+ if (what_changed.contains (ARDOUR::Properties::locked)) {
region_locked ();
}
}
}
void
-RegionView::region_resized (PropertyChange what_changed)
+RegionView::region_resized (const PropertyChange& what_changed)
{
double unit_length;
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (ARDOUR::Properties::position)) {
set_position (_region->position(), 0);
_time_converter.set_origin(_region->position());
}
- if (what_changed & PropertyChange (StartChanged|LengthChanged)) {
+ PropertyChange s_and_l;
+ s_and_l.add (ARDOUR::Properties::start);
+ s_and_l.add (ARDOUR::Properties::length);
+
+ if (what_changed.contains (s_and_l)) {
set_duration (_region->length(), 0);
virtual void show_region_editor () {}
virtual void hide_region_editor();
- virtual void region_changed (PBD::PropertyChange);
+ virtual void region_changed (const PBD::PropertyChange&);
virtual GhostRegion* add_ghost (TimeAxisView&) = 0;
void remove_ghost_in (TimeAxisView&);
bool recording,
TimeAxisViewItem::Visibility);
- virtual void region_resized (PBD::PropertyChange);
+ virtual void region_resized (const PBD::PropertyChange&);
virtual void region_muted ();
void region_locked ();
void region_opacity ();
//route_select_list.rows().back().select ();
- route->NameChanged.connect (*this, boost::bind (&RouteParams_UI::route_name_changed, this, boost::weak_ptr<Route>(route)), gui_context());
+ route->PropertyChanged.connect (*this, ui_bind (&RouteParams_UI::route_property_changed, this, _1, boost::weak_ptr<Route>(route)), gui_context());
route->DropReferences.connect (*this, boost::bind (&RouteParams_UI::route_removed, this, boost::weak_ptr<Route>(route)), gui_context());
}
}
void
-RouteParams_UI::route_name_changed (boost::weak_ptr<Route> wr)
+RouteParams_UI::route_property_changed (const PropertyChange& what_changed, boost::weak_ptr<Route> wr)
{
+ if (!what_changed.contains (ARDOUR::Properties::name)) {
+ return;
+ }
+
boost::shared_ptr<Route> route (wr.lock());
if (!route) {
void add_routes (ARDOUR::RouteList&);
- void route_
name_changed (boost::weak_ptr<ARDOUR::Route> route);
+ void route_
property_changed (const PBD::PropertyChange&, boost::weak_ptr<ARDOUR::Route> route);
void route_removed (boost::weak_ptr<ARDOUR::Route> route);
_y_position = -1;
_route->processors_changed.connect (*this, ui_bind (&RouteTimeAxisView::processors_changed, this, _1), gui_context());
- _route->NameChanged.connect (*this, boost::bind (&RouteTimeAxisView::route_name_changed, this), gui_context());
+ _route->PropertyChanged.connect (*this, ui_bind (&RouteTimeAxisView::route_property_changed, this, _1), gui_context());
if (is_track()) {
}
void
-RouteTimeAxisView::route_name_changed ()
+RouteTimeAxisView::route_property_changed (const PropertyChange& what_changed)
{
- label_view ();
+ if (what_changed.contains (ARDOUR::Properties::name)) {
+ label_view ();
+ }
}
void
void reset_processor_automation_curves ();
void take_name_changed (void *src);
- void route_name_changed ();
+ void route_property_changed (const PBD::PropertyChange&);
void name_entry_changed ();
void update_rec_display ();
_route->solo_changed.connect (route_connections, ui_bind (&RouteUI::solo_changed, this, _1), gui_context());
_route->listen_changed.connect (route_connections, ui_bind (&RouteUI::listen_changed, this, _1), gui_context());
_route->solo_isolated_changed.connect (route_connections, ui_bind (&RouteUI::solo_changed, this, _1), gui_context());
- _route->NameChanged.connect (route_connections, boost::bind (&RouteUI::name_changed, this), gui_context());
+ _route->PropertyChanged.connect (route_connections, ui_bind (&RouteUI::property_changed, this, _1), gui_context());
if (_session->writable() && is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
}
void
-RouteUI::name_changed ()
+RouteUI::property_changed (const PropertyChange& what_changed)
{
- ENSURE_GUI_THREAD (*this, &RouteUI::name_changed);
-
- name_label.set_text (_route->name());
+ if (what_changed.contains (ARDOUR::Properties::name)) {
+ name_label.set_text (_route->name());
+ }
}
void
void route_rename();
- virtual void name_changed ();
+ virtual void property_changed (const PBD::PropertyChange&);
void route_removed ();
Gtk::CheckMenuItem *route_active_menu_item;
void init_post_engine ();
int cleanup ();
bool no_auto_connect ();
+ void make_property_quarks ();
+
+ extern PBD::PropertyChange bounds_change;
std::string get_ardour_revision ();
extern const char* const ardour_config_info;
return (microseconds_t) jack_get_time();
}
- extern PBD::PropertyChange StartChanged;
- extern PBD::PropertyChange LengthChanged;
- extern PBD::PropertyChange PositionChanged;
- extern PBD::PropertyChange NameChanged;
- extern PBD::PropertyChange BoundsChanged;
-
static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
void setup_fpu ();
XMLNode& state (bool full_state);
void dump () const;
- bool region_changed (PBD::PropertyChange, boost::shared_ptr<Region>);
- void crossfade_changed (PBD::PropertyChange);
+ bool region_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
+ void crossfade_changed (const PBD::PropertyChange&);
void add_crossfade (boost::shared_ptr<Crossfade>);
void source_offset_changed (boost::shared_ptr<AudioRegion> region);
extern PBD::PropertyDescriptor<bool> fade_in_active;
extern PBD::PropertyDescriptor<bool> fade_out_active;
extern PBD::PropertyDescriptor<float> scale_amplitude;
+ extern PBD::PropertyDescriptor<float> scale_amplitude;
+
+ /* the envelope and fades are not scalar items and so
+ currently (2010/02) are not stored using Property.
+ However, these descriptors enable us to notify
+ about changes to them via PropertyChange.
+ */
+
+ extern PBD::PropertyDescriptor<bool> envelope;
+ extern PBD::PropertyDescriptor<bool> fade_in;
+ extern PBD::PropertyDescriptor<bool> fade_out;
}
class Route;
public:
static void make_property_quarks ();
- static PBD::PropertyChange FadeInChanged;
- static PBD::PropertyChange FadeOutChanged;
- static PBD::PropertyChange FadeInActiveChanged;
- static PBD::PropertyChange FadeOutActiveChanged;
- static PBD::PropertyChange EnvelopeActiveChanged;
- static PBD::PropertyChange ScaleAmplitudeChanged;
- static PBD::PropertyChange EnvelopeChanged;
-
~AudioRegion();
void copy_settings (boost::shared_ptr<const AudioRegion>);
AudioRegion (const SourceList &);
AudioRegion (boost::shared_ptr<const AudioRegion>, frameoffset_t offset = 0, bool offset_relative = true);
AudioRegion (boost::shared_ptr<const AudioRegion>, const SourceList&);
- AudioRegion (boost::shared_ptr<AudioSource>, const XMLNode&);
- AudioRegion (SourceList &, const XMLNode&);
+ AudioRegion (SourceList &);
private:
PBD::Property<bool> _envelope_active;
PBD::Property<gain_t> _scale_amplitude;
void register_properties ();
- PBD::PropertyChange set_property (const PBD::PropertyBase& prop);
+ bool set_property (const PBD::PropertyBase& prop);
void post_set ();
void init ();
#include "evoral/Curve.hpp"
namespace ARDOUR {
+ namespace Properties {
+ /* "active" is defined elsewhere but we use it with crossfade also */
+ extern PBD::PropertyDescriptor<bool> active;
+ extern PBD::PropertyDescriptor<bool> follow_overlap;
+ }
class AudioRegion;
class Playlist;
Crossfade (const Playlist&, XMLNode&);
virtual ~Crossfade();
+ static void make_property_quarks ();
+
bool operator== (const ARDOUR::Crossfade&);
XMLNode& get_state (void);
framecnt_t overlap_length() const;
PBD::Signal1<void,boost::shared_ptr<Region> > Invalidated;
- PBD::Signal1<void,PBD::PropertyChange> StateChanged;
bool covers (framecnt_t frame) const {
return _position <= frame && frame < _position + _length;
static framecnt_t short_xfade_length() { return _short_xfade_length; }
static void set_short_xfade_length (framecnt_t n);
- static PBD::PropertyChange ActiveChanged;
- static PBD::PropertyChange FollowOverlapChanged;
-
private:
friend struct CrossfadeComparePtr;
friend class AudioPlaylist;
boost::shared_ptr<ARDOUR::AudioRegion> _in;
boost::shared_ptr<ARDOUR::AudioRegion> _out;
- bool _active;
+ PBD::Property<bool> _active;
+ PBD::Property<bool> _follow_overlap;
bool _in_update;
OverlapType overlap_type;
AnchorPoint _anchor_point;
- bool _follow_overlap;
bool _fixed;
int32_t layer_relation;
/* XXX fix this redundancy ... */
- virtual void playlist_changed (PBD::PropertyChange);
+ virtual void playlist_changed (const PBD::PropertyChange&);
virtual void playlist_deleted (boost::weak_ptr<Playlist>);
virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<framepos_t> > const &);
PBD::ScopedConnection connect_c;
void send_to_going_away ();
- void send_to_name_changed ();
+ void send_to_property_changed (const PBD::PropertyChange&);
int connect_when_legal ();
int set_our_state (XMLNode const &, int);
};
PBD::Signal0<void> changed;
PBD::Signal1<void,Location*> added;
PBD::Signal1<void,Location*> removed;
- PBD::Signal1<void,PBD::PropertyChange> StateChanged;
+ PBD::Signal1<void,const PBD::PropertyChange&> StateChanged;
template<class T> void apply (T& obj, void (T::*method)(LocationList&)) {
Glib::Mutex::Lock lm (lock);
};
- /** PropertyChange note properties.
+ /** Change note properties.
* More efficient than DeltaCommand and has the important property that
* it leaves the objects in the MidiModel (Notes) the same, thus
* enabling selection and other state to persist across command
boost::shared_ptr<MidiModel> _model;
const std::string _name;
- struct NotePropertyChange {
+ struct NoteChange {
DiffCommand::Property property;
boost::shared_ptr< Evoral::Note<TimeType> > note;
union {
};
};
- typedef std::list<NotePropertyChange> ChangeList;
+ typedef std::list<NoteChange> ChangeList;
ChangeList _changes;
- XMLNode &marshal_change(const NotePropertyChange&);
- NotePropertyChange unmarshal_change(XMLNode *xml_note);
+ XMLNode &marshal_change(const NoteChange&);
+ NoteChange unmarshal_change(XMLNode *xml_note);
};
MidiModel::DeltaCommand* new_delta_command(const std::string name="midi edit");
private:
void dump () const;
- bool region_changed (PBD::PropertyChange, boost::shared_ptr<Region>);
+ bool region_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
NoteMode _note_mode;
private:
friend class RegionFactory;
- MidiRegion (boost::shared_ptr<MidiSource>);
MidiRegion (const SourceList&);
MidiRegion (boost::shared_ptr<const MidiRegion>, frameoffset_t offset = 0, bool offset_relative = true);
- MidiRegion (boost::shared_ptr<MidiSource>, const XMLNode&);
- MidiRegion (const SourceList &, const XMLNode&);
private:
framecnt_t _read_at (const SourceList&, Evoral::EventSink<nframes_t>& dst,
void notify_length_changed ();
void notify_layering_changed ();
void notify_contents_changed ();
- void notify_state_changed (PBD::PropertyChange);
+ void notify_state_changed (const PBD::PropertyChange&);
void notify_region_moved (boost::shared_ptr<Region>);
void mark_session_dirty();
- void region_changed_proxy (PBD::PropertyChange, boost::weak_ptr<Region>);
- virtual bool region_changed (PBD::PropertyChange, boost::shared_ptr<Region>);
+ void region_changed_proxy (const PBD::PropertyChange&, boost::weak_ptr<Region>);
+ virtual bool region_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
- void region_bounds_changed (PBD::PropertyChange, boost::shared_ptr<Region>);
+ void region_bounds_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
void region_deleted (boost::shared_ptr<Region>);
void sort_regions ();
MusicTime
};
- static PBD::PropertyChange FadeChanged;
- static PBD::PropertyChange SyncOffsetChanged;
- static PBD::PropertyChange MuteChanged;
- static PBD::PropertyChange OpacityChanged;
- static PBD::PropertyChange LockChanged;
- static PBD::PropertyChange LayerChanged;
- static PBD::PropertyChange HiddenChanged;
-
- PBD::Signal1<void,PBD::PropertyChange> StateChanged;
- static PBD::Signal1<void,boost::shared_ptr<ARDOUR::Region> > RegionPropertyChanged;
+ static PBD::Signal2<void,boost::shared_ptr<ARDOUR::Region>, const PBD::PropertyChange&> RegionPropertyChanged;
void unlock_property_changes () { _no_property_changes = false; }
void block_property_changes () { _no_property_changes = true; }
protected:
friend class RegionFactory;
- /** Construct a region from a single source */
- Region (boost::shared_ptr<Source> src);
/** Construct a region from multiple sources*/
Region (const SourceList& srcs);
/** Construct a region from another region, at an offset within that region */
/** normal Region copy constructor */
Region (boost::shared_ptr<const Region>);
- /** Construct a region from 1 source and XML state */
- Region (boost::shared_ptr<Source> src, const XMLNode&);
- /** Construct a region from multiple sources and XML state */
- Region (const SourceList& srcs, const XMLNode&);
-
/** Constructor for derived types only */
Region (Session& s, framepos_t start, framecnt_t length, const std::string& name, DataType);
protected:
- void send_change (PBD::PropertyChange);
+ void send_change (const PBD::PropertyChange&);
void trim_to_internal (framepos_t position, framecnt_t length, void *src);
virtual void set_position_internal (framepos_t pos, bool allow_bbt_recompute);
AnalysisFeatureList _transients;
bool _valid_transients;
mutable uint64_t _read_data_count; ///< modified in read()
- PBD::PropertyChange _pending_changed;
+ PBD::PropertyChange _pending_changed;
uint64_t _last_layer_op; ///< timestamp
Glib::Mutex _lock;
SourceList _sources;
virtual int _set_state (const XMLNode&, int version, PBD::PropertyChange& what_changed, bool send_signal);
- PBD::PropertyChange set_property (const PBD::PropertyBase&);
+ bool set_property (const PBD::PropertyBase&);
void register_properties ();
private:
PBD::Signal0<void> changed;
PBD::Signal1<void,void*> FlagsChanged;
- static PBD::PropertyChange FlagsChange;
- static PBD::PropertyChange PropertiesChange;
-
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
void xrun_recovery ();
TempoMap *_tempo_map;
- void tempo_map_changed (PBD::PropertyChange);
+ void tempo_map_changed (const PBD::PropertyChange&);
/* edit/mix groups */
RegionList regions;
void add_region (boost::shared_ptr<Region>);
- void region_changed (PBD::PropertyChange, boost::weak_ptr<Region>);
+ void region_changed (const PBD::PropertyChange&, boost::weak_ptr<Region>);
void remove_region (boost::weak_ptr<Region>);
int load_regions (const XMLNode& node);
SessionObject (Session& session, const std::string& name)
: SessionHandleRef (session)
- , _name (Properties::name, PBD::PropertyChange (0), name)
+ , _name (Properties::name, name)
{
add_property (_name);
}
Session& session() const { return _session; }
std::string name() const { return _name; }
- PBD::PropertyChange set_property (const PBD::PropertyBase& prop);
+ bool set_property (const PBD::PropertyBase& prop);
virtual bool set_name (const std::string& str) {
if (_name != str) {
_name = str;
- NameChanged();
+ PropertyChanged (PBD::PropertyChange (Properties::name));
}
return true;
}
- PBD::Signal0<void> NameChanged;
-
protected:
PBD::Property<std::string> _name;
};
nframes_t frame_rate () const { return _frame_rate; }
- PBD::Signal1<void,PBD::PropertyChange> StateChanged;
-
private:
static Tempo _default_tempo;
static Meter _default_meter;
_crossfades.push_back (xfade);
xfade->Invalidated.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
- xfade->StateChanged.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
+ xfade->PropertyChanged.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
notify_crossfade_added (xfade);
}
boost::shared_ptr<Crossfade> xfade = boost::shared_ptr<Crossfade> (new Crossfade (*((const Playlist *)this), *child));
_crossfades.push_back (xfade);
xfade->Invalidated.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_invalidated, this, _1));
- xfade->StateChanged.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
+ xfade->PropertyChanged.connect_same_thread (*this, boost::bind (&AudioPlaylist::crossfade_changed, this, _1));
NewCrossfade(xfade);
}
}
void
-AudioPlaylist::crossfade_changed (PropertyChange)
+AudioPlaylist::crossfade_changed (const PropertyChange&)
{
if (in_flush || in_set_state) {
return;
}
bool
-AudioPlaylist::region_changed (PropertyChange what_changed, boost::shared_ptr<Region> region)
+AudioPlaylist::region_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
if (in_flush || in_set_state) {
return false;
}
- PropertyChange our_interests = PropertyChange (AudioRegion::FadeInChanged|
- AudioRegion::FadeOutChanged|
- AudioRegion::FadeInActiveChanged|
- AudioRegion::FadeOutActiveChanged|
- AudioRegion::EnvelopeActiveChanged|
- AudioRegion::ScaleAmplitudeChanged|
- AudioRegion::EnvelopeChanged);
+ PropertyChange our_interests;
+
+ our_interests.add (Properties::fade_in_active);
+ our_interests.add (Properties::fade_out_active);
+ our_interests.add (Properties::scale_amplitude);
+ our_interests.add (Properties::envelope_active);
+ our_interests.add (Properties::envelope);
+ our_interests.add (Properties::fade_in);
+ our_interests.add (Properties::fade_out);
+
bool parent_wants_notify;
parent_wants_notify = Playlist::region_changed (what_changed, region);
- if ((parent_wants_notify || (what_changed & our_interests))) {
+ if (parent_wants_notify || (what_changed.contains (our_interests))) {
notify_contents_changed ();
}
}
#define AUDIOREGION_STATE_DEFAULT \
- _envelope_active (Properties::envelope_active, EnvelopeActiveChanged, false) \
- , _default_fade_in (Properties::default_fade_in, FadeInChanged, true) \
- , _default_fade_out (Properties::default_fade_out, FadeOutChanged, true) \
- , _fade_in_active (Properties::fade_in_active, FadeInActiveChanged, true) \
- , _fade_out_active (Properties::fade_out_active, FadeOutActiveChanged, true) \
- , _scale_amplitude (Properties::scale_amplitude, ScaleAmplitudeChanged, 1.0)
+ _envelope_active (Properties::envelope_active, false) \
+ , _default_fade_in (Properties::default_fade_in, true) \
+ , _default_fade_out (Properties::default_fade_out, true) \
+ , _fade_in_active (Properties::fade_in_active, true) \
+ , _fade_out_active (Properties::fade_out_active, true) \
+ , _scale_amplitude (Properties::scale_amplitude, 0.0)
#define AUDIOREGION_COPY_STATE(other) \
_envelope_active (other->_envelope_active) \
, _fade_out_active (other->_fade_out_active) \
, _scale_amplitude (other->_scale_amplitude)
-PropertyChange AudioRegion::FadeInChanged = PBD::new_change();
-PropertyChange AudioRegion::FadeOutChanged = PBD::new_change();
-PropertyChange AudioRegion::FadeInActiveChanged = PBD::new_change();
-PropertyChange AudioRegion::FadeOutActiveChanged = PBD::new_change();
-PropertyChange AudioRegion::EnvelopeActiveChanged = PBD::new_change();
-PropertyChange AudioRegion::ScaleAmplitudeChanged = PBD::new_change();
-PropertyChange AudioRegion::EnvelopeChanged = PBD::new_change();
-
/* a Session will reset these to its chosen defaults by calling AudioRegion::set_default_fade() */
void
assert (_sources.size() == _master_sources.size());
}
-/** Basic AudioRegion constructor (one channel) */
-AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src)
- : Region (boost::static_pointer_cast<Source>(src))
- , AUDIOREGION_STATE_DEFAULT
- , _automatable(src->session())
- , _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation)))
- , _fade_out (new AutomationList(Evoral::Parameter(FadeOutAutomation)))
- , _envelope (new AutomationList(Evoral::Parameter(EnvelopeAutomation)))
- , _fade_in_suspended (0)
- , _fade_out_suspended (0)
-{
- init ();
-
- /* XXX why is this set here ? - set in a property list given to RegionFactory */
- _external = true;
-
- assert (_sources.size() == _master_sources.size());
-}
-
-/** Basic AudioRegion constructor (many channels) */
+/** Basic AudioRegion constructor */
AudioRegion::AudioRegion (const SourceList& srcs)
: Region (srcs)
, AUDIOREGION_STATE_DEFAULT
assert (_sources.size() == _master_sources.size());
}
-AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, const XMLNode& node)
- : Region (src, node)
- , AUDIOREGION_STATE_DEFAULT
- , _automatable(src->session())
- , _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation)))
- , _fade_out (new AutomationList(Evoral::Parameter(FadeOutAutomation)))
- , _envelope (new AutomationList(Evoral::Parameter(EnvelopeAutomation)))
-{
- init ();
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- assert(_type == DataType::AUDIO);
- assert (_sources.size() == _master_sources.size());
-}
-
-AudioRegion::AudioRegion (SourceList& srcs, const XMLNode& node)
- : Region (srcs, node)
+AudioRegion::AudioRegion (SourceList& srcs)
+ : Region (srcs)
, AUDIOREGION_STATE_DEFAULT
, _automatable(srcs[0]->session())
, _fade_in (new AutomationList(Evoral::Parameter(FadeInAutomation)))
{
init ();
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
assert(_type == DataType::AUDIO);
- connect_to_analysis_changed ();
assert (_sources.size() == _master_sources.size());
}
{
if (envelope_active() != yn) {
_envelope_active = yn;
- send_change (EnvelopeActiveChanged);
+ send_change (PropertyChange (Properties::envelope_active));
}
}
float a = atof (prop->value().c_str());
if (a != _scale_amplitude) {
_scale_amplitude = a;
- what_changed = PropertyChange (what_changed|ScaleAmplitudeChanged);
- cerr << _name << " amp changed\n";
+ what_changed.add (Properties::scale_amplitude);
}
}
thaw ();
if (send) {
- cerr << _name << ": audio final change: " << hex << what_changed << dec << endl;
send_change (what_changed);
}
return 0;
}
-PropertyChange
+bool
AudioRegion::set_property (const PropertyBase& prop)
{
- PropertyChange c = PropertyChange (0);
-
DEBUG_TRACE (DEBUG::Properties, string_compose ("audio region %1 set property %2\n", _name.val(), prop.property_name()));
if (prop == Properties::envelope_active.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _envelope_active) {
_envelope_active = val;
- c = EnvelopeActiveChanged;
+ return true;
}
} else if (prop == Properties::default_fade_in.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _default_fade_in) {
_default_fade_in = val;
- c = FadeInChanged;
+ return true;
}
} else if (prop == Properties::default_fade_out.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _default_fade_out) {
_default_fade_out = val;
- c = FadeOutChanged;
+ return true;
}
} else if (prop == Properties::fade_in_active.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _fade_in_active) {
_fade_in_active = val;
- c = FadeInActiveChanged;
+ return true;
}
} else if (prop == Properties::fade_out_active.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _fade_out_active) {
_fade_out_active = val;
- c = FadeOutChanged;
+ return true;
}
} else if (prop == Properties::scale_amplitude.id) {
gain_t val = dynamic_cast<const PropertyTemplate<gain_t>*>(&prop)->val();
if (val != _scale_amplitude) {
_scale_amplitude = val;
- c = ScaleAmplitudeChanged;
+ return true;
}
} else {
return Region::set_property (prop);
}
-
- return c;
+
+ return false;
}
int
*_fade_in = *f;
_fade_in->thaw ();
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
void
*_fade_out = *f;
_fade_out->thaw ();
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
void
if (changed) {
_default_fade_in = false;
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
}
if (changed) {
_default_fade_out = false;
- send_change (FadeOutChanged);
+ send_change (PropertyChange (Properties::fade_out));
}
}
}
_fade_in_active = yn;
- send_change (FadeInActiveChanged);
+ send_change (PropertyChange (Properties::fade_in_active));
}
void
return;
}
_fade_out_active = yn;
- send_change (FadeOutActiveChanged);
+ send_change (PropertyChange (Properties::fade_out_active));
}
bool
if (_fade_in->back()->when > _length) {
_fade_in->extend_to (_length);
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
if (_fade_out->back()->when > _length) {
_fade_out->extend_to (_length);
- send_change (FadeOutChanged);
+ send_change (PropertyChange (Properties::fade_out));
}
}
if (_fade_in->back()->when > _length) {
_fade_in->extend_to (_length);
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
if (_fade_out->back()->when > _length) {
_fade_out->extend_to (_length);
- send_change (FadeOutChanged);
+ send_change (PropertyChange (Properties::fade_out));
}
}
/* tell everybody else */
- send_change (ScaleAmplitudeChanged);
+ send_change (PropertyChange (Properties::scale_amplitude));
}
void
/* tell everybody else */
- send_change (ScaleAmplitudeChanged);
+ send_change (PropertyChange (Properties::scale_amplitude));
}
void
AudioRegion::fade_in_changed ()
{
- send_change (FadeInChanged);
+ send_change (PropertyChange (Properties::fade_in));
}
void
AudioRegion::fade_out_changed ()
{
- send_change (FadeOutChanged);
+ send_change (PropertyChange (Properties::fade_out));
}
void
AudioRegion::envelope_changed ()
{
- send_change (EnvelopeChanged);
+ send_change (PropertyChange (Properties::envelope));
}
void
using namespace PBD;
framecnt_t Crossfade::_short_xfade_length = 0;
-PropertyChange Crossfade::ActiveChanged = new_change();
-PropertyChange Crossfade::FollowOverlapChanged = new_change();
/* XXX if and when we ever implement parallel processing of the process()
callback, these will need to be handled on a per-thread basis.
Sample* Crossfade::crossfade_buffer_out = 0;
Sample* Crossfade::crossfade_buffer_in = 0;
+
+#define CROSSFADE_DEFAULT_PROPERTIES \
+ _active (Properties::active, _session.config.get_xfades_active ()) \
+ , _follow_overlap (Properties::follow_overlap, false)
+
+
+namespace ARDOUR {
+ namespace Properties {
+ PropertyDescriptor<bool> follow_overlap;
+ }
+}
+
+void
+Crossfade::make_property_quarks ()
+{
+ Properties::follow_overlap.id = g_quark_from_static_string (X_("follow-overlap"));
+}
+
void
Crossfade::set_buffer_size (framecnt_t sz)
{
framecnt_t length,
framepos_t position,
AnchorPoint ap)
- : AudioRegion (in->session(), position, length, in->name() + string ("<>") + out->name()),
- _fade_in (Evoral::Parameter(FadeInAutomation)), // linear (gain coefficient) => -inf..+6dB
- _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
+ : AudioRegion (in->session(), position, length, in->name() + string ("<>") + out->name())
+ , CROSSFADE_DEFAULT_PROPERTIES
+ , _fade_in (Evoral::Parameter(FadeInAutomation)) // linear (gain coefficient) => -inf..+6dB
+ , _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
{
_in = in;
_out = out;
_anchor_point = ap;
- _follow_overlap = false;
-
- _active = _session.config.get_xfades_active ();
_fixed = true;
initialize ();
}
Crossfade::Crossfade (boost::shared_ptr<AudioRegion> a, boost::shared_ptr<AudioRegion> b, CrossfadeModel model, bool act)
- : AudioRegion (a->session(), 0, 0, a->name() + string ("<>") + b->name()),
- _fade_in (Evoral::Parameter(FadeInAutomation)), // linear (gain coefficient) => -inf..+6dB
- _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
+ : AudioRegion (a->session(), 0, 0, a->name() + string ("<>") + b->name())
+ , CROSSFADE_DEFAULT_PROPERTIES
+ , _fade_in (Evoral::Parameter(FadeInAutomation)) // linear (gain coefficient) => -inf..+6dB
+ , _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
{
_in_update = false;
_fixed = false;
}
Crossfade::Crossfade (const Playlist& playlist, XMLNode& node)
- : AudioRegion (playlist.session(), 0, 0, "unnamed crossfade"),
- _fade_in (Evoral::Parameter(FadeInAutomation)), // linear (gain coefficient) => -inf..+6dB
- _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
+ : AudioRegion (playlist.session(), 0, 0, "unnamed crossfade")
+ , CROSSFADE_DEFAULT_PROPERTIES
+ , _fade_in (Evoral::Parameter(FadeInAutomation)) // linear (gain coefficient) => -inf..+6dB
+ , _fade_out (Evoral::Parameter(FadeOutAutomation)) // linear (gain coefficient) => -inf..+6dB
{
boost::shared_ptr<Region> r;
Crossfade::Crossfade (boost::shared_ptr<Crossfade> orig, boost::shared_ptr<AudioRegion> newin, boost::shared_ptr<AudioRegion> newout)
: AudioRegion (boost::dynamic_pointer_cast<const AudioRegion> (orig), 0, true)
+ , CROSSFADE_DEFAULT_PROPERTIES
, _fade_in (orig->_fade_in)
, _fade_out (orig->_fade_out)
{
{
if (_active != yn) {
_active = yn;
- StateChanged (ActiveChanged);
+ PropertyChanged (PropertyChange (Properties::active));
}
}
}
if (send_signal) {
- StateChanged (BoundsChanged); /* EMIT SIGNAL */
+ PropertyChange bounds;
+ bounds.add (Properties::start);
+ bounds.add (Properties::position);
+ bounds.add (Properties::length);
+ PropertyChanged (bounds); /* EMIT SIGNAL */
}
_in_update = false;
XMLNode* fo;
const XMLProperty* prop;
LocaleGuard lg (X_("POSIX"));
- PropertyChange what_changed = PropertyChange (0);
+ PropertyChange what_changed;
framepos_t val;
if ((prop = node.property ("position")) != 0) {
sscanf (prop->value().c_str(), "%" PRId64, &val);
if (val != _position) {
_position = val;
- what_changed = PropertyChange (what_changed | PositionChanged);
+ what_changed.add (Properties::position);
}
} else {
warning << _("old-style crossfade information - no position information") << endmsg;
bool x = string_is_affirmative (prop->value());
if (x != _active) {
_active = x;
- what_changed = PropertyChange (what_changed | ActiveChanged);
+ what_changed.add (Properties::active);
}
} else {
_active = true;
sscanf (prop->value().c_str(), "%" PRId64, &val);
if (val != _length) {
_length = val;
- what_changed = PropertyChange (what_changed | LengthChanged);
+ what_changed.add (Properties::length);
}
} else {
_fade_out.thaw ();
- StateChanged (what_changed); /* EMIT SIGNAL */
+ PropertyChanged (what_changed); /* EMIT SIGNAL */
return 0;
}
set_xfade_length (_out->first_frame() + _out->length() - _in->first_frame());
}
- StateChanged (FollowOverlapChanged);
+ PropertyChanged (PropertyChange (Properties::follow_overlap));
}
framecnt_t
_length = len;
- StateChanged (LengthChanged);
-
+ PropertyChanged (PropertyChange (Properties::length));
+
return len;
}
}
void
-Diskstream::playlist_changed (PropertyChange)
+Diskstream::playlist_changed (const PropertyChange&)
{
playlist_modified ();
}
MIDI::Port *ARDOUR::default_midi_port = 0;
MIDI::Port *ARDOUR::default_midi_clock_port = 0;
-PropertyChange ARDOUR::StartChanged = PBD::new_change ();
-PropertyChange ARDOUR::LengthChanged = PBD::new_change ();
-PropertyChange ARDOUR::PositionChanged = PBD::new_change ();
-PropertyChange ARDOUR::NameChanged = PBD::new_change ();
-PropertyChange ARDOUR::BoundsChanged = PropertyChange (0); // see init(), below
-
compute_peak_t ARDOUR::compute_peak = 0;
find_peaks_t ARDOUR::find_peaks = 0;
apply_gain_to_buffer_t ARDOUR::apply_gain_to_buffer = 0;
void ARDOUR::setup_enum_writer ();
+/* this is useful for quite a few things that want to check
+ if any bounds-related property has changed
+*/
+PBD::PropertyChange ARDOUR::bounds_change;
+
+namespace ARDOUR {
+ namespace Properties {
+
+ /* the envelope and fades are not scalar items and so
+ currently (2010/02) are not stored using Property.
+ However, these descriptors enable us to notify
+ about changes to them via PropertyChange.
+
+ Declared in ardour/audioregion.h ...
+ */
+
+ PBD::PropertyDescriptor<bool> fade_in;
+ PBD::PropertyDescriptor<bool> fade_out;
+ PBD::PropertyDescriptor<bool> envelope;
+ }
+}
+
+void
+ARDOUR::make_property_quarks ()
+{
+ Properties::fade_in.id = g_quark_from_static_string (X_("fade_in_FAKE"));
+ Properties::fade_out.id = g_quark_from_static_string (X_("fade_out_FAKE"));
+ Properties::envelope.id = g_quark_from_static_string (X_("envelope_FAKE"));
+}
+
int
ARDOUR::setup_midi ()
{
PBD::ID::init ();
SessionEvent::init_event_pool ();
-
+
+ make_property_quarks ();
SessionObject::make_property_quarks ();
Region::make_property_quarks ();
AudioRegion::make_property_quarks ();
RouteGroup::make_property_quarks ();
+ /* this is a useful ready to use PropertyChange that many
+ things need to check. This avoids having to compose
+ it every time we want to check for any of the relevant
+ property changes.
+ */
+
+ bounds_change.add (ARDOUR::Properties::start);
+ bounds_change.add (ARDOUR::Properties::position);
+ bounds_change.add (ARDOUR::Properties::length);
+
/* provide a state version for the few cases that need it and are not
driven by reading state from disk (e.g. undo/redo)
*/
/* singleton - first object is "it" */
new PluginManager ();
- BoundsChanged = PropertyChange (StartChanged|PositionChanged|LengthChanged);
-
return 0;
}
set_name (sendto->name());
_send_to->DropReferences.connect_same_thread (*this, boost::bind (&InternalSend::send_to_going_away, this));
- _send_to->NameChanged.connect_same_thread (*this, boost::bind (&InternalSend::send_to_name_changed, this));
+ _send_to->PropertyChanged.connect_same_thread (*this, boost::bind (&InternalSend::send_to_property_changed, this, _1));;
}
InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
}
void
-InternalSend::send_to_name_changed ()
+InternalSend::send_to_property_changed (const PropertyChange& what_changed)
{
- set_name (_send_to->name ());
+ if (what_changed.contains (Properties::name)) {
+ set_name (_send_to->name ());
+ }
}
MidiModel::DiffCommand::change(const boost::shared_ptr< Evoral::Note<TimeType> > note, Property prop,
uint8_t new_value)
{
- NotePropertyChange change;
+ NoteChange change;
change.note = note;
change.property = prop;
MidiModel::DiffCommand::change(const boost::shared_ptr< Evoral::Note<TimeType> > note, Property prop,
TimeType new_time)
{
- NotePropertyChange change;
+ NoteChange change;
change.note = note;
change.property = prop;
}
XMLNode&
-MidiModel::DiffCommand::marshal_change(const NotePropertyChange& change)
+MidiModel::DiffCommand::marshal_change(const NoteChange& change)
{
XMLNode* xml_change = new XMLNode("change");
return *xml_change;
}
-MidiModel::DiffCommand::NotePropertyChange
+MidiModel::DiffCommand::NoteChange
MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
{
XMLProperty* prop;
- NotePropertyChange change;
+ NoteChange change;
unsigned int note;
unsigned int channel;
unsigned int velocity;
bool
-MidiPlaylist::region_changed (PBD::PropertyChange what_changed, boost::shared_ptr<Region> region)
+MidiPlaylist::region_changed (const PBD::PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
if (in_flush || in_set_state) {
return false;
// Feeling rather uninterested today, but thanks for the heads up anyway!
- PBD::PropertyChange our_interests = PBD::PropertyChange (/*MidiRegion::FadeInChanged|
- MidiRegion::FadeOutChanged|
- MidiRegion::FadeInActiveChanged|
- MidiRegion::FadeOutActiveChanged|
- MidiRegion::EnvelopeActiveChanged|
- MidiRegion::ScaleAmplitudeChanged|
- MidiRegion::EnvelopeChanged*/);
+ PBD::PropertyChange our_interests;
+
bool parent_wants_notify;
parent_wants_notify = Playlist::region_changed (what_changed, region);
- if ((parent_wants_notify || (what_changed & our_interests))) {
+ if (parent_wants_notify || what_changed.contains (our_interests)) {
notify_contents_changed ();
}
using namespace ARDOUR;
using namespace PBD;
-/** Basic MidiRegion constructor (one channel) */
-MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src)
- : Region (src)
-{
- assert(_name.val().find("/") == string::npos);
- midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
-}
-
/* Basic MidiRegion constructor (many channels) */
MidiRegion::MidiRegion (const SourceList& srcs)
: Region (srcs)
{
- assert(_name.val().find("/") == string::npos);
midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
+ assert(_name.val().find("/") == string::npos);
+ assert(_type == DataType::MIDI);
}
-
/** Create a new MidiRegion, that is part of an existing one */
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, frameoffset_t offset, bool offset_relative)
: Region (other, offset, offset_relative)
midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
}
-MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, const XMLNode& node)
- : Region (src, node)
-{
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
- assert(_name.val().find("/") == string::npos);
- assert(_type == DataType::MIDI);
-}
-
-MidiRegion::MidiRegion (const SourceList& srcs, const XMLNode& node)
- : Region (srcs, node)
-{
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
- assert(_name.val().find("/") == string::npos);
- assert(_type == DataType::MIDI);
-}
-
MidiRegion::~MidiRegion ()
{
}
}
}
- region->StateChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+ region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
return true;
}
}
void
-Playlist::region_bounds_changed (PropertyChange what_changed, boost::shared_ptr<Region> region)
+Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
if (in_set_state || _splicing || _nudging || _shuffling) {
return;
}
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (Properties::position)) {
/* remove it from the list then add it back in
the right place again.
regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
}
- if (what_changed & PropertyChange (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) {
+ if (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) {
frameoffset_t delta = 0;
- if (what_changed & ARDOUR::PositionChanged) {
+ if (what_changed.contains (Properties::position)) {
delta = region->position() - region->last_position();
}
- if (what_changed & ARDOUR::LengthChanged) {
+ if (what_changed.contains (Properties::length)) {
delta += region->length() - region->last_length();
}
}
void
-Playlist::region_changed_proxy (PropertyChange what_changed, boost::weak_ptr<Region> weak_region)
+Playlist::region_changed_proxy (const PropertyChange& what_changed, boost::weak_ptr<Region> weak_region)
{
boost::shared_ptr<Region> region (weak_region.lock());
}
bool
-Playlist::region_changed (PropertyChange what_changed, boost::shared_ptr<Region> region)
+Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
{
- PropertyChange our_interests = PropertyChange (Region::MuteChanged|Region::LayerChanged|Region::OpacityChanged);
+ PropertyChange our_interests;
+ PropertyChange bounds;
+ PropertyChange pos_and_length;
bool save = false;
if (in_set_state || in_flush) {
return false;
}
- if (what_changed & BoundsChanged) {
+ our_interests.add (Properties::muted);
+ our_interests.add (Properties::layer);
+ our_interests.add (Properties::opaque);
+
+ bounds.add (Properties::start);
+ bounds.add (Properties::position);
+ bounds.add (Properties::length);
+
+ pos_and_length.add (Properties::position);
+ pos_and_length.add (Properties::length);
+
+ if (what_changed.contains (bounds)) {
region_bounds_changed (what_changed, region);
save = !(_splicing || _nudging);
}
- if ((what_changed & our_interests) &&
- !(what_changed & PropertyChange (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+ if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) {
check_dependents (region, false);
}
- if (what_changed & PropertyChange (ARDOUR::PositionChanged)) {
+ if (what_changed.contains (Properties::position)) {
notify_region_moved (region);
}
them, and we notify in ::relayer()
*/
- if (what_changed & our_interests) {
+ if (what_changed.contains (our_interests)) {
save = true;
}
error << _("region state node has no ID, ignored") << endmsg;
continue;
}
-
+
ID id = prop->value ();
if ((region = region_by_id (id))) {
using namespace ARDOUR;
using namespace PBD;
-PropertyChange Region::FadeChanged = PBD::new_change ();
-PropertyChange Region::SyncOffsetChanged = PBD::new_change ();
-PropertyChange Region::MuteChanged = PBD::new_change ();
-PropertyChange Region::OpacityChanged = PBD::new_change ();
-PropertyChange Region::LockChanged = PBD::new_change ();
-PropertyChange Region::LayerChanged = PBD::new_change ();
-PropertyChange Region::HiddenChanged = PBD::new_change ();
-
namespace ARDOUR {
namespace Properties {
PBD::PropertyDescriptor<bool> muted;
}
}
-PBD::Signal1<void,boost::shared_ptr<ARDOUR::Region> > Region::RegionPropertyChanged;
+PBD::Signal2<void,boost::shared_ptr<ARDOUR::Region>,const PropertyChange&> Region::RegionPropertyChanged;
void
Region::make_property_quarks ()
}
#define REGION_DEFAULT_STATE(s,l) \
- _muted (Properties::muted, MuteChanged, false) \
- , _opaque (Properties::opaque, OpacityChanged, true) \
- , _locked (Properties::locked, LockChanged, false) \
- , _automatic (Properties::automatic, PropertyChange (0), false) \
- , _whole_file (Properties::whole_file, PropertyChange (0), false) \
- , _import (Properties::import, PropertyChange (0), false) \
- , _external (Properties::external, PropertyChange (0), false) \
- , _sync_marked (Properties::sync_marked, SyncOffsetChanged, false) \
- , _left_of_split (Properties::left_of_split, PropertyChange (0), false) \
- , _right_of_split (Properties::right_of_split, PropertyChange (0), false) \
- , _hidden (Properties::hidden, HiddenChanged, false) \
- , _position_locked (Properties::position_locked, PropertyChange (0), false) \
- , _start (Properties::start, StartChanged, (s)) \
- , _length (Properties::length, LengthChanged, (l)) \
- , _position (Properties::position, PositionChanged, 0) \
- , _sync_position (Properties::sync_position, SyncOffsetChanged, (s)) \
- , _layer (Properties::layer, LayerChanged, 0) \
- , _ancestral_start (Properties::ancestral_start, PropertyChange (0), (s)) \
- , _ancestral_length (Properties::ancestral_length, PropertyChange (0), (l)) \
- , _stretch (Properties::stretch, PropertyChange (0), 1.0) \
- , _shift (Properties::shift, PropertyChange (0), 1.0)
+ _muted (Properties::muted, false) \
+ , _opaque (Properties::opaque, true) \
+ , _locked (Properties::locked, false) \
+ , _automatic (Properties::automatic, false) \
+ , _whole_file (Properties::whole_file, false) \
+ , _import (Properties::import, false) \
+ , _external (Properties::external, false) \
+ , _sync_marked (Properties::sync_marked, false) \
+ , _left_of_split (Properties::left_of_split, false) \
+ , _right_of_split (Properties::right_of_split, false) \
+ , _hidden (Properties::hidden, false) \
+ , _position_locked (Properties::position_locked, false) \
+ , _start (Properties::start, (s)) \
+ , _length (Properties::length, (l)) \
+ , _position (Properties::position, 0) \
+ , _sync_position (Properties::sync_position, (s)) \
+ , _layer (Properties::layer, 0) \
+ , _ancestral_start (Properties::ancestral_start, (s)) \
+ , _ancestral_length (Properties::ancestral_length, (l)) \
+ , _stretch (Properties::stretch, 1.0) \
+ , _shift (Properties::shift, 1.0)
#define REGION_COPY_STATE(other) \
_muted (other->_muted) \
, _first_edit (EditChangesNothing)
, _frozen(0)
, _read_data_count(0)
- , _pending_changed(PropertyChange (0))
, _last_layer_op(0)
, _pending_explicit_relayer (false)
{
/* no sources at this point */
}
-/** Basic Region constructor (single source) */
-Region::Region (boost::shared_ptr<Source> src)
- : SessionObject(src->session(), "toBeRenamed")
- , _type (src->type())
- , _no_property_changes (true)
- , REGION_DEFAULT_STATE(0,0)
- , _last_length (0)
- , _last_position (0)
- , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
- , _first_edit (EditChangesNothing)
- , _frozen(0)
- , _valid_transients(false)
- , _read_data_count(0)
- , _pending_changed(PropertyChange (0))
- , _last_layer_op(0)
- , _pending_explicit_relayer (false)
-{
- register_properties ();
-
- _sources.push_back (src);
- _master_sources.push_back (src);
-
- src->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(src)));
-
- assert (_sources.size() > 0);
- assert (_type == src->type());
-}
-
/** Basic Region constructor (many sources) */
Region::Region (const SourceList& srcs)
: SessionObject(srcs.front()->session(), "toBeRenamed")
, _frozen (0)
, _valid_transients(false)
, _read_data_count(0)
- , _pending_changed(PropertyChange (0))
, _last_layer_op (0)
, _pending_explicit_relayer (false)
{
, _frozen (0)
, _valid_transients(false)
, _read_data_count(0)
- , _pending_changed(PropertyChange (0))
, _last_layer_op (0)
, _pending_explicit_relayer (false)
, _frozen (0)
, _valid_transients (false)
, _read_data_count (0)
- , _pending_changed (PropertyChange(0))
, _last_layer_op (other->_last_layer_op)
, _pending_explicit_relayer (false)
{
, _frozen(0)
, _valid_transients(false)
, _read_data_count(0)
- , _pending_changed(PropertyChange(0))
, _last_layer_op(other->_last_layer_op)
, _pending_explicit_relayer (false)
{
assert(_sources.size() > 0);
}
-Region::Region (const SourceList& srcs, const XMLNode& node)
- : SessionObject(srcs.front()->session(), X_("error: XML did not reset this"))
- , _type (srcs.front()->type())
- , REGION_DEFAULT_STATE(0,0)
- , _last_length (0)
- , _last_position (0)
- , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
- , _first_edit (EditChangesNothing)
- , _frozen(0)
- , _valid_transients(false)
- , _read_data_count(0)
- , _pending_changed(PropertyChange(0))
- , _last_layer_op(0)
- , _pending_explicit_relayer (false)
-{
- const XMLProperty* prop;
-
- register_properties ();
-
- if ((prop = node.property (X_("id")))) {
- _id = prop->value();
- }
-
- use_sources (srcs);
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- assert(_type != DataType::NIL);
- assert(_sources.size() > 0);
- assert (_type == srcs.front()->type());
-
-}
-
-Region::Region (boost::shared_ptr<Source> src, const XMLNode& node)
- : SessionObject(src->session(), X_("error: XML did not reset this"))
- , _type (src->type())
- , REGION_DEFAULT_STATE(0,0)
- , _last_length (0)
- , _last_position (0)
- , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
- , _first_edit (EditChangesNothing)
- , _frozen (0)
- , _read_data_count (0)
- , _pending_changed (PropertyChange(0))
- , _last_layer_op (0)
- , _pending_explicit_relayer (false)
-{
- const XMLProperty *prop;
-
- register_properties ();
-
- _sources.push_back (src);
-
- if ((prop = node.property (X_("id")))) {
- _id = prop->value();
- }
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- assert (_type != DataType::NIL);
- assert (_sources.size() > 0);
- assert (_type == src->type());
-}
-
Region::~Region ()
{
DEBUG_TRACE (DEBUG::Destruction, string_compose ("Region %1 destructor @ %2\n", _name, this));
if (_name != str) {
SessionObject::set_name(str); // EMIT SIGNAL NameChanged()
assert(_name == str);
- send_change (ARDOUR::NameChanged);
+ send_change (Properties::name);
}
return true;
recompute_at_end ();
}
- send_change (LengthChanged);
+ send_change (Properties::length);
}
}
_name = _session.new_region_name (_name);
_first_edit = EditChangesNothing;
- send_change (ARDOUR::NameChanged);
+ send_change (Properties::name);
RegionFactory::CheckNewRegion (shared_from_this());
}
}
a GUI that has moved its representation already.
*/
- send_change (PositionChanged);
+ send_change (Properties::position);
}
void
a GUI that has moved its representation already.
*/
- send_change (PositionChanged);
+ send_change (Properties::position);
}
void
}
}
- send_change (PositionChanged);
+ send_change (Properties::position);
}
void
first_edit ();
invalidate_transients ();
- send_change (StartChanged);
+ send_change (Properties::start);
}
}
_whole_file = false;
first_edit ();
- send_change (StartChanged);
+ send_change (Properties::start);
}
void
return;
}
- PropertyChange what_changed = PropertyChange (0);
+ PropertyChange what_changed;
if (_start != new_start) {
_start = new_start;
- what_changed = PropertyChange (what_changed|StartChanged);
+ what_changed.add (Properties::start);
}
if (_length != length) {
if (!_frozen) {
_last_length = _length;
}
_length = length;
- what_changed = PropertyChange (what_changed|LengthChanged);
+ what_changed.add (Properties::length);
}
if (_position != position) {
if (!_frozen) {
_last_position = _position;
}
_position = position;
- what_changed = PropertyChange (what_changed|PositionChanged);
+ what_changed.add (Properties::position);
}
_whole_file = false;
- if (what_changed & (StartChanged|LengthChanged)) {
+ PropertyChange start_and_length;
+
+ start_and_length.add (Properties::start);
+ start_and_length.add (Properties::length);
+
+ if (what_changed.contains (start_and_length)) {
first_edit ();
}
- if (what_changed) {
+ if (!what_changed.empty()) {
send_change (what_changed);
}
}
{
if (hidden() != yn) {
_hidden = yn;
- send_change (HiddenChanged);
+ send_change (Properties::hidden);
}
}
{
if (muted() != yn) {
_muted = yn;
- send_change (MuteChanged);
+ send_change (Properties::muted);
}
}
{
if (opaque() != yn) {
_opaque = yn;
- send_change (OpacityChanged);
+ send_change (Properties::opaque);
}
}
{
if (locked() != yn) {
_locked = yn;
- send_change (LockChanged);
+ send_change (Properties::locked);
}
}
{
if (position_locked() != yn) {
_position_locked = yn;
- send_change (LockChanged);
+ send_change (Properties::locked);
}
}
if (!_frozen) {
maybe_uncopy ();
}
- send_change (SyncOffsetChanged);
+ send_change (Properties::sync_position);
}
}
if (!_frozen) {
maybe_uncopy ();
}
- send_change (SyncOffsetChanged);
+ send_change (Properties::sync_position);
}
}
if (_layer != l) {
_layer = l;
- send_change (LayerChanged);
+ send_change (Properties::layer);
}
}
int
Region::set_state (const XMLNode& node, int version)
{
- PropertyChange what_changed = PropertyChange (0);
+ PropertyChange what_changed;
return _set_state (node, version, what_changed, true);
}
{
const XMLProperty* prop;
+ cerr << "about to call ::set_properties for an XMLNode\n";
+
what_changed = set_properties (node);
if ((prop = node.property (X_("id")))) {
}
if (send) {
- cerr << _name << ": final change to be sent: " << hex << what_changed << dec << endl;
+ cerr << _name << ": final change to be sent: ";
+ for (PropertyChange::iterator i = what_changed.begin(); i != what_changed.end(); ++i) {
+ cerr << g_quark_to_string ((GQuark) *i) << ' ';
+ }
+ cerr << endl;
send_change (what_changed);
}
void
Region::thaw ()
{
- PropertyChange what_changed = PropertyChange (0);
+ PropertyChange what_changed;
{
Glib::Mutex::Lock lm (_lock);
return;
}
- if (_pending_changed) {
+ if (!_pending_changed.empty()) {
what_changed = _pending_changed;
- _pending_changed = PropertyChange (0);
+ _pending_changed.clear ();
}
}
- if (what_changed == PropertyChange (0)) {
+ if (what_changed.empty()) {
return;
}
- if (what_changed & LengthChanged) {
- if (what_changed & PositionChanged) {
+ if (what_changed.contains (Properties::length)) {
+ if (what_changed.contains (Properties::position)) {
recompute_at_start ();
}
recompute_at_end ();
}
void
-Region::send_change (PropertyChange what_changed)
+Region::send_change (const PropertyChange& what_changed)
{
+ if (what_changed.empty()) {
+ return;
+ }
{
Glib::Mutex::Lock lm (_lock);
if (_frozen) {
- _pending_changed = PropertyChange (_pending_changed|what_changed);
+ _pending_changed.add (what_changed);
return;
}
}
- cerr << _name << " actually sends " << hex << what_changed << dec << " @" << get_microseconds() << endl;
- StateChanged (what_changed);
- cerr << _name << " done with " << hex << what_changed << dec << " @" << get_microseconds() << endl;
+ PropertyChanged (what_changed);
if (!_no_property_changes) {
try {
boost::shared_ptr<Region> rptr = shared_from_this();
- cerr << _name << " actually sends prop change " << hex << what_changed << dec << " @ " << get_microseconds() << endl;
- RegionPropertyChanged (rptr);
- cerr << _name << " done with prop change @ " << get_microseconds() << endl;
+ RegionPropertyChanged (rptr, what_changed);
} catch (...) {
/* no shared_ptr available, relax; */
}
-PropertyChange
+bool
Region::set_property (const PropertyBase& prop)
{
- PropertyChange c = PropertyChange (0);
-
DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 set property %2\n", _name.val(), prop.property_name()));
if (prop == Properties::muted.id) {
DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 muted changed from %2 to %3",
_name.val(), _muted.val(), val));
_muted = val;
- c = MuteChanged;
+ return true;
}
} else if (prop == Properties::opaque.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 opaque changed from %2 to %3",
_name.val(), _opaque.val(), val));
_opaque = val;
- c = OpacityChanged;
+ return true;
}
} else if (prop == Properties::locked.id) {
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 locked changed from %2 to %3",
_name.val(), _locked.val(), val));
_locked = val;
- c = LockChanged;
+ return true;
}
} else if (prop == Properties::automatic.id) {
_automatic = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
if (val != _hidden) {
_hidden = val;
- c = HiddenChanged;
+ return true;
}
} else if (prop == Properties::position_locked.id) {
_position_locked = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
} else if (prop == Properties::start.id) {
_start = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
} else if (prop == Properties::length.id) {
- const PropertyTemplate<framecnt_t>* pt1 = dynamic_cast<const PropertyTemplate<framecnt_t>* >(&prop);
- const PropertyTemplate<int>* pt2 = dynamic_cast<const PropertyTemplate<int>* >(&prop);
-
- cerr << "Cast to frmecnt = " << pt1 << " to int = " << pt2 << endl;
-
framecnt_t val = dynamic_cast<const PropertyTemplate<framecnt_t>* > (&prop)->val();
if (val != _length) {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 length changed from %2 to %3",
- _name.val(), _length.val(), val));
_length = val;
- c = LengthChanged;
- } else {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("length %1 matches %2\n", _length.val(), val));
+ return true;
}
-
} else if (prop == Properties::position.id) {
framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
if (val != _position) {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 position changed from %2 to %3",
- _name.val(), _position.val(), val));
_position = val;
- c = PositionChanged;
+ return true;
}
} else if (prop == Properties::sync_position.id) {
framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
if (val != _sync_position) {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 syncpos changed from %2 to %3",
- _name.val(), _sync_position, val));
_sync_position = val;
- c = SyncOffsetChanged;
+ return true;
}
} else if (prop == Properties::layer.id) {
layer_t val = dynamic_cast<const PropertyTemplate<layer_t>*>(&prop)->val();
if (val != _layer) {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 syncpos changed from %2 to %3",
- _name.val(), _sync_position, val));
_layer = val;
- c = LayerChanged;
+ return true;
}
} else if (prop == Properties::ancestral_start.id) {
_ancestral_start = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
return SessionObject::set_property (prop);
}
- return c;
+ return false;
}
boost::shared_ptr<Region>
RegionFactory::create (boost::shared_ptr<Source> src, const PropertyList& plist, bool announce)
{
- boost::shared_ptr<Region> ret;
- boost::shared_ptr<AudioSource> as;
- boost::shared_ptr<MidiSource> ms;
-
- if ((as = boost::dynamic_pointer_cast<AudioSource>(src)) != 0) {
-
- AudioRegion* ar = new AudioRegion (as);
- boost_debug_shared_ptr_mark_interesting (ar, "Region");
-
- boost::shared_ptr<AudioRegion> arp (ar);
- ret = boost::static_pointer_cast<Region> (arp);
-
- } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(src)) != 0) {
- MidiRegion* mr = new MidiRegion (ms);
- boost_debug_shared_ptr_mark_interesting (mr, "Region");
-
- boost::shared_ptr<MidiRegion> mrp (mr);
- ret = boost::static_pointer_cast<Region> (mrp);
- }
-
- if (ret) {
- ret->set_properties (plist);
- ret->unlock_property_changes ();
-
- map_add (ret);
-
- if (announce) {
- CheckNewRegion (ret);
- }
- }
-
- return ret;
+ SourceList srcs;
+ srcs.push_back (src);
+ return create (srcs, plist, announce);
}
boost::shared_ptr<Region>
boost::shared_ptr<Region>
RegionFactory::create (Session& session, XMLNode& node, bool yn)
{
- boost::shared_ptr<Region> r = session.XMLRegionFactory (node, yn);
-
- if (r) {
- r->unlock_property_changes ();
- map_add (r);
- CheckNewRegion (r);
- }
-
- return r;
+ return session.XMLRegionFactory (node, yn);
}
-
boost::shared_ptr<Region>
RegionFactory::create (SourceList& srcs, const XMLNode& node)
{
if (srcs[0]->type() == DataType::AUDIO) {
- AudioRegion* ar = new AudioRegion (srcs, node);
+ AudioRegion* ar = new AudioRegion (srcs);
boost_debug_shared_ptr_mark_interesting (ar, "Region");
boost::shared_ptr<AudioRegion> arp (ar);
} else if (srcs[0]->type() == DataType::MIDI) {
- MidiRegion* mr = new MidiRegion (srcs, node);
+ MidiRegion* mr = new MidiRegion (srcs);
boost::shared_ptr<MidiRegion> mrp (mr);
ret = boost::static_pointer_cast<Region> (mrp);
}
if (ret) {
- ret->unlock_property_changes ();
- map_add (ret);
- CheckNewRegion (ret);
+
+ if (ret->set_state (node, Stateful::loading_state_version)) {
+ ret.reset ();
+ } else {
+ ret->unlock_property_changes ();
+ map_add (ret);
+ CheckNewRegion (ret);
+ }
}
return ret;
using namespace PBD;
using namespace std;
-PropertyChange RouteGroup::FlagsChange = new_change ();
-PropertyChange RouteGroup::PropertiesChange = new_change ();
-
namespace ARDOUR {
namespace Properties {
PropertyDescriptor<bool> relative;
Properties::edit.id = g_quark_from_static_string (X_("edit"));
}
-#define ROUTE_GROUP_DEFAULT_PROPERTIES _relative (Properties::relative, FlagsChange, false) \
- , _active (Properties::active, FlagsChange, false) \
- , _hidden (Properties::hidden, FlagsChange, false) \
- , _gain (Properties::gain, PropertiesChange, false) \
- , _mute (Properties::mute, PropertiesChange, false) \
- , _solo (Properties::solo, PropertiesChange , false) \
- , _recenable (Properties::recenable, PropertiesChange, false) \
- , _select (Properties::select, PropertiesChange, false) \
- , _edit (Properties::edit, PropertiesChange , false)
+#define ROUTE_GROUP_DEFAULT_PROPERTIES _relative (Properties::relative, false) \
+ , _active (Properties::active, false) \
+ , _hidden (Properties::hidden, false) \
+ , _gain (Properties::gain, false) \
+ , _mute (Properties::mute, false) \
+ , _solo (Properties::solo, false) \
+ , _recenable (Properties::recenable, false) \
+ , _select (Properties::select, false) \
+ , _edit (Properties::edit, false)
RouteGroup::RouteGroup (Session& s, const string &n)
: SessionObject (s, n)
}
}
- region->StateChanged.connect_same_thread (*this, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
+ region->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::region_changed, this, _1, boost::weak_ptr<Region>(region)));
update_region_name_map (region);
}
}
void
-Session::region_changed (PropertyChange what_changed, boost::weak_ptr<Region> weak_region)
+Session::region_changed (const PropertyChange& what_changed, boost::weak_ptr<Region> weak_region)
{
boost::shared_ptr<Region> region (weak_region.lock ());
return;
}
- if (what_changed & Region::HiddenChanged) {
+ if (what_changed.contains (Properties::hidden)) {
/* relay hidden changes */
RegionHiddenChange (region);
}
- if (what_changed & NameChanged) {
+ if (what_changed.contains (Properties::name)) {
update_region_name_map (region);
}
}
}
void
-Session::tempo_map_changed (PropertyChange)
+Session::tempo_map_changed (const PropertyChange&)
{
clear_clicks ();
Properties::name.id = g_quark_from_static_string (X_("name"));
}
-PropertyChange
+bool
SessionObject::set_property (const PropertyBase& prop)
{
- PropertyChange c = PropertyChange (0);
-
- DEBUG_TRACE (DEBUG::Properties, string_compose ("session object %1 set property %2\n", _name.val(), prop.property_name()));
-
if (prop == Properties::name.id) {
std::string str = dynamic_cast<const PropertyTemplate<std::string>*>(&prop)->val();
- cerr << "prop @ " << &prop << " has quark " << prop.id() << " str value = " << str << endl;
- cerr << "nameprop @ " << &_name << " has quark " << _name.id() << " str value = " << _name.val() << endl;
if (_name != str) {
DEBUG_TRACE (DEBUG::Properties, string_compose ("session object named %1 renamed %2\n",
_name.val(), str));
_name = str;
- c = _name.change();
- } else {
- DEBUG_TRACE (DEBUG::Properties, string_compose ("name %1 matches %2\n", _name.val(), str));
- }
+ return true;
+ }
}
-
- return c;
+
+ return false;
}
_base_frame_rate = _current_frame_rate;
_tempo_map = new TempoMap (_current_frame_rate);
- _tempo_map->StateChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
+ _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
_non_soloed_outs_muted = false;
TempoMap::move_tempo (TempoSection& tempo, const BBT_Time& when)
{
if (move_metric_section (tempo, when) == 0) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
TempoMap::move_meter (MeterSection& meter, const BBT_Time& when)
{
if (move_metric_section (meter, when) == 0) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
}
if (removed) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
}
if (removed) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
do_insert (new TempoSection (where, tempo.beats_per_minute(), tempo.note_type()), true);
}
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
void
do_insert (new TempoSection (where, tempo.beats_per_minute(), tempo.note_type()), false);
}
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
void
}
if (replaced) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
do_insert (new MeterSection (where, meter.beats_per_bar(), meter.note_divisor()), true);
}
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
void
do_insert (new MeterSection (where, meter.beats_per_bar(), meter.note_divisor()), false);
}
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
void
}
if (replaced) {
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
}
for (Metrics::iterator i = metrics->begin(); i != metrics->end(); ++i) {
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
*((Tempo*) t) = newtempo;
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
break;
}
}
/* reset */
*((Tempo*)prev) = newtempo;
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
const MeterSection&
}
}
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
return 0;
}
timestamp_metrics (false);
- StateChanged (PropertyChange (0));
+ PropertyChanged (PropertyChange ());
}
BBT_Time
#define MIDI_CMD_NOTE_OFF 0x80 /**< Note Off */
#define MIDI_CMD_NOTE_ON 0x90 /**< Note On */
#define MIDI_CMD_NOTE_PRESSURE 0xA0 /**< Key Pressure */
-#define MIDI_CMD_CONTROL 0xB0 /**< Control PropertyChange */
-#define MIDI_CMD_PGM_CHANGE 0xC0 /**< Program PropertyChange */
+#define MIDI_CMD_CONTROL 0xB0 /**< Control Change */
+#define MIDI_CMD_PGM_CHANGE 0xC0 /**< Program Change */
#define MIDI_CMD_CHANNEL_PRESSURE 0xD0 /**< Channel Pressure */
#define MIDI_CMD_BENDER 0xE0 /**< Pitch Bender */
#define MIDI_CMD_COMMON_SYSEX 0xF0 /**< Sysex (System Exclusive) Begin */
#include <string>
#include <sstream>
#include <list>
+#include <set>
#include <glib.h>
#include "pbd/xml++.h"
namespace PBD {
-enum PropertyChange {
- range_guarantee = ~0ULL
-};
-
-PropertyChange new_change ();
-
typedef GQuark PropertyID;
template<typename T>
typedef T value_type;
};
+class PropertyChange : public std::set<PropertyID>
+{
+ public:
+ PropertyChange() { }
+ template<typename T> PropertyChange(PropertyDescriptor<T> p) { insert (p.id); }
+ PropertyChange(const PropertyChange& other) : std::set<PropertyID> (other) { }
+
+ PropertyChange operator= (const PropertyChange& other) {
+ clear ();
+ insert (other.begin(), other.end());
+ return *this;
+ }
+
+ template<typename T> PropertyChange operator= (PropertyDescriptor<T> p) {
+ clear ();
+ insert (p.id);
+ return *this;
+ }
+
+ template<typename T> bool contains (PropertyDescriptor<T> p) const { return find (p.id) != end(); }
+
+ bool contains (const PropertyChange& other) const {
+ for (const_iterator x = other.begin(); x != other.end(); ++x) {
+ if (find (*x) != end()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void add (PropertyID id) { (void) insert (id); }
+ void add (const PropertyChange& other) { (void) insert (other.begin(), other.end()); }
+ template<typename T> void add (PropertyDescriptor<T> p) { (void) insert (p.id); }
+};
+
/** Base (non template) part of Property */
class PropertyBase
{
public:
- PropertyBase (PropertyID pid, PropertyChange c)
+ PropertyBase (PropertyID pid)
: _have_old (false)
, _property_id (pid)
- , _change (c)
{
}
virtual void diff (XMLNode *, XMLNode *) const = 0;
virtual void diff (PropertyChange&) const = 0;
- virtual PropertyChange set_state (XMLNode const &) = 0;
+ virtual bool set_state (XMLNode const &) = 0;
virtual void add_state (XMLNode &) const = 0;
const gchar* property_name() const { return g_quark_to_string (_property_id); }
- PropertyChange change() const { return _change; }
PropertyID id() const { return _property_id; }
bool operator== (PropertyID pid) const {
protected:
bool _have_old;
PropertyID _property_id;
- PropertyChange _change;
};
/** Parent class for classes which represent a single property in a Stateful object */
class PropertyTemplate : public PropertyBase
{
public:
- PropertyTemplate (PropertyDescriptor<T> p, PropertyChange c, T const & v)
- : PropertyBase (p.id, c)
+ PropertyTemplate (PropertyDescriptor<T> p, T const & v)
+ : PropertyBase (p.id)
, _current (v)
{
/* XXX: isn't there a nicer place to do this? */
_have_old = s._have_old;
_property_id = s._property_id;
- _change = s._change;
_current = s._current;
_old = s._old;
void diff (XMLNode* old, XMLNode* current) const {
if (_have_old) {
- old->add_property (g_quark_to_string (_property_id), to_string (_old));
- current->add_property (g_quark_to_string (_property_id), to_string (_current));
+ old->add_property (property_name(), to_string (_old));
+ current->add_property (property_name(), to_string (_current));
}
}
void diff (PropertyChange& c) const {
- if (_have_old && _change) {
- c = PropertyChange (c | _change);
+ if (_have_old) {
+ c.add (_property_id);
}
}
/** Try to set state from the property of an XML node.
* @param node XML node.
- * @return PropertyChange effected, or 0.
+ * @return true if the value of the property is changed
*/
- PropertyChange set_state (XMLNode const & node) {
- XMLProperty const * p = node.property (g_quark_to_string (_property_id));
- PropertyChange c = PropertyChange (0);
+ bool set_state (XMLNode const & node) {
+ XMLProperty const * p = node.property (property_name());
if (p) {
T const v = from_string (p->value ());
if (v != _current) {
set (v);
- c = _change;
+ return true;
}
- }
+ }
- return c;
+ return false;
}
void add_state (XMLNode & node) const {
- node.add_property (g_quark_to_string (_property_id), to_string (_current));
+ node.add_property (property_name(), to_string (_current));
}
protected:
class Property : public PropertyTemplate<T>
{
public:
- Property (PropertyDescriptor<T> q, PropertyChange c, T const & v)
- : PropertyTemplate<T> (q, c, v)
- {
-
- }
-
Property (PropertyDescriptor<T> q, T const & v)
- : PropertyTemplate<T> (q, PropertyChange (0), v)
+ : PropertyTemplate<T> (q, v)
{
}
s << v;
return s.str ();
}
-
+
T from_string (std::string const & s) const {
std::stringstream t (s);
T v;
}
};
+/** Specialization, for std::string which is common and special (see to_string() and from_string()
+ Using stringstream to read from a std::string is easy to get wrong because of whitespace
+ delineation, etc.
+ */
+template <>
+class Property<std::string> : public PropertyTemplate<std::string>
+{
+public:
+ Property (PropertyDescriptor<std::string> q, std::string const & v)
+ : PropertyTemplate<std::string> (q, v)
+ {
+
+ }
+
+ std::string & operator= (std::string const & v) {
+ this->set (v);
+ return this->_current;
+ }
+
+private:
+ std::string to_string (std::string const & v) const {
+ return _current;
+ }
+
+ std::string from_string (std::string const & s) const {
+ return s;
+ }
+};
+
class PropertyList : public std::map<PropertyID,PropertyBase*>
{
public:
#include <string>
#include <list>
#include <cassert>
+
#include "pbd/id.h"
#include "pbd/xml++.h"
-#include "pbd/enumwriter.h"
#include "pbd/properties.h"
+#include "pbd/signals.h"
class XMLNode;
/* derived types do not have to implement this, but probably should
give it serious attention.
*/
- virtual PropertyChange set_property (const PropertyBase&) { return PropertyChange (0); }
+ virtual bool set_property (const PropertyBase&) { return false; }
PropertyChange set_properties (const PropertyList&);
std::pair<XMLNode *, XMLNode*> diff () const;
void changed (PropertyChange&) const;
+ /* How stateful's notify of changes to their properties
+ */
+ PBD::Signal1<void,const PropertyChange&> PropertyChanged;
+
static int current_state_version;
static int loading_state_version;
using namespace PBD;
-PropertyChange
-PBD::new_change ()
-{
- static uint64_t change_bit = 1;
-
- /* catch out-of-range */
- if (!change_bit) {
- fatal << _("programming error: ")
- << "change_bit out of range in ARDOUR::new_change()"
- << endmsg;
- /*NOTREACHED*/
- }
-
- PropertyChange c = PropertyChange (change_bit);
- change_bit <<= 1; // if it shifts too far, change_bit == 0
-
- return c;
-}
-
PropertyChange
Stateful::set_properties (XMLNode const & node)
{
- PropertyChange c = PropertyChange (0);
+ PropertyChange c;
for (OwnedPropertyList::iterator i = _properties.begin(); i != _properties.end(); ++i) {
- c = PropertyChange (c | i->second->set_state (node));
+ if (i->second->set_state (node)) {
+ c.add (i->first);
+ }
}
post_set ();
PropertyChange
Stateful::set_properties (const PropertyList& property_list)
{
- PropertyChange c = PropertyChange (0);
+ PropertyChange c;
PropertyList::const_iterator p;
for (OwnedPropertyList::iterator i = _properties.begin(); i != _properties.end(); ++i) {
if ((p = property_list.find (i->first)) != property_list.end()) {
- c = PropertyChange (c|set_property (*(p->second)));
+ if (set_property (*p->second)) {
+ c.add (i->first);
+ }
}
}
mountpoint.cc
pathscanner.cc
pool.cc
- property.cc
pthread_utils.cc
receiver.cc
search_path.cc
}
void
-MackieControlProtocol::notify_name_changed (RouteSignal * route_signal)
+MackieControlProtocol::notify_property_changed (const PropertyChange& what_changed, RouteSignal * route_signal)
{
+ if (!what_changed.contains (Properties::name)) {
+ return;
+ }
+
try
{
Strip & strip = route_signal->strip();
/// Signal handler for Route::gain_changed (from IO)
void notify_gain_changed(Mackie::RouteSignal *, bool force_update = true);
/// Signal handler for Route::name_change
- void notify_name_changed(Mackie::RouteSignal *);
+ void notify_property_changed(const PBD::PropertyChange&, Mackie::RouteSignal *);
/// Signal handler from Panner::Change
void notify_panner_changed(Mackie::RouteSignal *, bool force_update = true);
/// Signal handler for new routes added
#include "ardour/track.h"
#include "ardour/midi_ui.h"
#include "ardour/panner.h"
+#include "ardour/session_object.h" // for Properties::name
#include "mackie_control_protocol.h"
_route->gain_control()->Changed.connect(connections, ui_bind (&MackieControlProtocol::notify_gain_changed, &_mcp, this, false), midi_ui_context());
}
- _route->NameChanged.connect (connections, ui_bind (&MackieControlProtocol::notify_name_changed, &_mcp, this), midi_ui_context());
+ _route->PropertyChanged.connect (connections, ui_bind (&MackieControlProtocol::notify_property_changed, &_mcp, _1, this), midi_ui_context());
if (_route->panner()) {
_route->panner()->Changed.connect(connections, ui_bind (&MackieControlProtocol::notify_panner_changed, &_mcp, this, false), midi_ui_context());
if ( _strip.has_gain() )
_mcp.notify_gain_changed( this );
- _mcp.notify_name_changed( this );
+ _mcp.notify_property_changed (PBD::PropertyChange (ARDOUR::Properties::name), this );
if ( _strip.has_vpot() )
_mcp.notify_panner_changed( this );
projects / ardour.git / commitdiff