X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_tempodisplay.cc;h=7af6fef05979db04b521db1b7614e6ff5e1baaf4;hb=a5ae129a066747901ff1ed95368729b63cb6a70d;hp=3285d44e01ddb35606f751aef288f3e50b48befa;hpb=71c94e69438c7c282b2dcac5ead080119944b290;p=ardour.git diff --git a/gtk2_ardour/editor_tempodisplay.cc b/gtk2_ardour/editor_tempodisplay.cc index 3285d44e01..7af6fef059 100644 --- a/gtk2_ardour/editor_tempodisplay.cc +++ b/gtk2_ardour/editor_tempodisplay.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002 Paul Davis + Copyright (C) 2002 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,41 +15,45 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ -#include // for sprintf, grrr +#ifdef WAF_BUILD +#include "gtk2ardour-config.h" +#endif + +#include // for sprintf, grrr #include #include #include #include -#include - -#include -#include +#include "pbd/error.h" +#include "pbd/memento_command.h" #include #include -#include -#include +#include "ardour/session.h" +#include "ardour/tempo.h" #include #include +#include "canvas/canvas.h" +#include "canvas/item.h" +#include "canvas/line_set.h" + #include "editor.h" #include "marker.h" -#include "simpleline.h" #include "tempo_dialog.h" #include "rgb_macros.h" #include "gui_thread.h" -#include "color.h" #include "time_axis_view.h" +#include "tempo_lines.h" +#include "ui_config.h" #include "i18n.h" using namespace std; -using namespace sigc; using namespace ARDOUR; using namespace PBD; using namespace Gtk; @@ -65,260 +69,274 @@ Editor::remove_metric_marks () delete_when_idle (*x); } metric_marks.clear (); -} + + for (Curves::iterator x = tempo_curves.begin(); x != tempo_curves.end(); ++x) { + delete (*x); + } + tempo_curves.clear (); +} void Editor::draw_metric_marks (const Metrics& metrics) { - - const MeterSection *ms; - const TempoSection *ts; char buf[64]; - - remove_metric_marks (); - + double max_tempo = 0.0; + double min_tempo = DBL_MAX; + + remove_metric_marks (); // also clears tempo curves + for (Metrics::const_iterator i = metrics.begin(); i != metrics.end(); ++i) { - + const MeterSection *ms; + const TempoSection *ts; + if ((ms = dynamic_cast(*i)) != 0) { - snprintf (buf, sizeof(buf), "%g/%g", ms->beats_per_bar(), ms->note_divisor ()); - metric_marks.push_back (new MeterMarker (*this, *meter_group, color_map[cMeterMarker], buf, + snprintf (buf, sizeof(buf), "%g/%g", ms->divisions_per_bar(), ms->note_divisor ()); + metric_marks.push_back (new MeterMarker (*this, *meter_group, UIConfiguration::instance().color ("meter marker"), buf, *(const_cast(ms)))); } else if ((ts = dynamic_cast(*i)) != 0) { - snprintf (buf, sizeof (buf), "%.2f", ts->beats_per_minute()); - metric_marks.push_back (new TempoMarker (*this, *tempo_group, color_map[cTempoMarker], buf, - *(const_cast(ts)))); - } - - } - -} - -void -Editor::tempo_map_changed (Change ignored) -{ - if (!session) { - return; - } + if (UIConfiguration::instance().get_allow_non_quarter_pulse()) { + snprintf (buf, sizeof (buf), "%.3f/%.0f", ts->beats_per_minute(), ts->note_type()); + } else { + snprintf (buf, sizeof (buf), "%.3f", ts->beats_per_minute()); + } - ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::tempo_map_changed), ignored)); + max_tempo = max (max_tempo, ts->beats_per_minute()); + min_tempo = min (min_tempo, ts->beats_per_minute()); - BBT_Time previous_beat, next_beat; // the beats previous to the leftmost frame and after the rightmost frame + tempo_curves.push_back (new TempoCurve (*this, *tempo_group, UIConfiguration::instance().color ("color 62"), + *(const_cast(ts)), ts->frame(), false)); + metric_marks.push_back (new TempoMarker (*this, *tempo_group, UIConfiguration::instance().color ("tempo marker"), buf, + *(const_cast(ts)))); - session->bbt_time(leftmost_frame, previous_beat); - session->bbt_time(leftmost_frame + current_page_frames(), next_beat); + } - if (previous_beat.beats > 1) { - previous_beat.beats -= 1; - } else if (previous_beat.bars > 1) { - previous_beat.bars--; - previous_beat.beats += 1; } - previous_beat.ticks = 0; - if (session->tempo_map().meter_at(leftmost_frame + current_page_frames()).beats_per_bar () > next_beat.beats + 1) { - next_beat.beats += 1; - } else { - next_beat.bars += 1; - next_beat.beats = 1; - } - next_beat.ticks = 0; - - if (current_bbt_points) { - delete current_bbt_points; - current_bbt_points = 0; - } + const double min_tempo_range = 5.0; + const double tempo_delta = fabs (max_tempo - min_tempo); - if (session) { - current_bbt_points = session->tempo_map().get_points (session->tempo_map().frame_time (previous_beat), session->tempo_map().frame_time (next_beat)); - update_tempo_based_rulers (); - } else { - current_bbt_points = 0; + if (tempo_delta < min_tempo_range) { + max_tempo += min_tempo_range - tempo_delta; + min_tempo += tempo_delta - min_tempo_range; } - redisplay_tempo (); -} + for (Curves::iterator x = tempo_curves.begin(); x != tempo_curves.end(); ) { + Curves::iterator tmp = x; + (*x)->set_max_tempo (max_tempo); + (*x)->set_min_tempo (min_tempo); + ++tmp; + if (tmp != tempo_curves.end()) { + (*x)->set_position ((*x)->tempo().frame(), (*tmp)->tempo().frame()); + } else { + (*x)->set_position ((*x)->tempo().frame(), UINT32_MAX); + } + ++x; + } -void -Editor::redisplay_tempo () -{ + for (Marks::iterator x = metric_marks.begin(); x != metric_marks.end(); ++x) { + TempoMarker* tempo_marker; - if (session && current_bbt_points) { - Glib::signal_idle().connect (mem_fun (*this, &Editor::lazy_hide_and_draw_measures)); - } else { - hide_measures (); + if ((tempo_marker = dynamic_cast (*x)) != 0) { + tempo_marker->update_height_mark ((tempo_marker->tempo().beats_per_minute() - min_tempo) / max (10.0, max_tempo - min_tempo)); + } } } + void -Editor::hide_measures () +Editor::tempo_map_changed (const PropertyChange& /*ignored*/) { - for (TimeLineList::iterator i = used_measure_lines.begin(); i != used_measure_lines.end(); ++i) { - (*i)->hide(); - free_measure_lines.push_back (*i); + if (!_session) { + return; } - used_measure_lines.clear (); -} -ArdourCanvas::SimpleLine * -Editor::get_time_line () -{ - ArdourCanvas::SimpleLine *line; + ENSURE_GUI_THREAD (*this, &Editor::tempo_map_changed, ignored); - if (free_measure_lines.empty()) { - line = new ArdourCanvas::SimpleLine (*time_line_group); - used_measure_lines.push_back (line); - } else { - line = free_measure_lines.front(); - free_measure_lines.erase (free_measure_lines.begin()); - used_measure_lines.push_back (line); + if (tempo_lines) { + tempo_lines->tempo_map_changed(); } - return line; + std::vector grid; + compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples()); + _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); // redraw metric markers + draw_measures (grid); + update_tempo_based_rulers (grid); } -bool -Editor::lazy_hide_and_draw_measures () -{ - hide_measures (); - draw_measures (); - return false; -} +struct CurveComparator { + bool operator() (TempoCurve const * a, TempoCurve const * b) { + return a->position() < b->position(); + } +}; void -Editor::draw_measures () +Editor::marker_position_changed () { - if (session == 0 || _show_measures == false) { + if (!_session) { return; } - TempoMap::BBTPointList::iterator i; - ArdourCanvas::SimpleLine *line; - gdouble xpos; - double x1, x2, y1, y2, beat_density; + ENSURE_GUI_THREAD (*this, &Editor::tempo_map_changed); + + if (tempo_lines) { + tempo_lines->tempo_map_changed(); + } - uint32_t beats = 0; - uint32_t bars = 0; - uint32_t color; + double max_tempo = 0.0; + double min_tempo = DBL_MAX; - if (current_bbt_points == 0 || current_bbt_points->empty()) { - return; + for (Marks::iterator x = metric_marks.begin(); x != metric_marks.end(); ++x) { + TempoMarker* tempo_marker; + MeterMarker* meter_marker; + const TempoSection *ts; + const MeterSection *ms; + + if ((tempo_marker = dynamic_cast (*x)) != 0) { + if ((ts = &tempo_marker->tempo()) != 0) { + tempo_marker->set_position (ts->frame ()); + char buf[64]; + snprintf (buf, sizeof (buf), "%.3f", ts->beats_per_minute()); + tempo_marker->set_name (buf); + + max_tempo = max (max_tempo, ts->beats_per_minute()); + min_tempo = min (min_tempo, ts->beats_per_minute()); + } + } + if ((meter_marker = dynamic_cast (*x)) != 0) { + if ((ms = &meter_marker->meter()) != 0) { + meter_marker->set_position (ms->frame ()); + } + } } - track_canvas.get_scroll_region (x1, y1, x2, y2); - y2 = TimeAxisView::hLargest*5000; // five thousand largest tracks should be enough.. :) + tempo_curves.sort (CurveComparator()); - /* get the first bar spacing */ + const double min_tempo_range = 5.0; + const double tempo_delta = fabs (max_tempo - min_tempo); - i = current_bbt_points->end(); - i--; - bars = (*i).bar - (*current_bbt_points->begin()).bar; - beats = current_bbt_points->size() - bars; + if (tempo_delta < min_tempo_range) { + max_tempo += min_tempo_range - tempo_delta; + min_tempo += tempo_delta - min_tempo_range; + } - beat_density = (beats * 10.0f) / track_canvas.get_width (); + for (Curves::iterator x = tempo_curves.begin(); x != tempo_curves.end(); ) { + Curves::iterator tmp = x; + (*x)->set_max_tempo (max_tempo); + (*x)->set_min_tempo (min_tempo); + ++tmp; + if (tmp != tempo_curves.end()) { + (*x)->set_position ((*x)->tempo().frame(), (*tmp)->tempo().frame()); + } else { + (*x)->set_position ((*x)->tempo().frame(), UINT32_MAX); + } + ++x; + } - if (beat_density > 4.0f) { - /* if the lines are too close together, they become useless - */ - return; + for (Marks::iterator x = metric_marks.begin(); x != metric_marks.end(); ++x) { + TempoMarker* tempo_marker; + if ((tempo_marker = dynamic_cast (*x)) != 0) { + tempo_marker->update_height_mark ((tempo_marker->tempo().beats_per_minute() - min_tempo) / max (max_tempo - min_tempo, 10.0)); + } } - for (i = current_bbt_points->begin(); i != current_bbt_points->end(); ++i) { + std::vector grid; + compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples()); + draw_measures (grid); + update_tempo_based_rulers (grid); +} - switch ((*i).type) { - case TempoMap::Bar: - break; +void +Editor::redisplay_tempo (bool immediate_redraw) +{ + if (!_session) { + return; + } - case TempoMap::Beat: - - if ((*i).beat == 1) { - color = color_map[cMeasureLineBeat]; - } else { - color = color_map[cMeasureLineBar]; + if (immediate_redraw) { + std::vector grid; - if (beat_density > 2.0) { - /* only draw beat lines if the gaps between beats are large. - */ - break; - } - } + compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples()); + draw_measures (grid); + update_tempo_based_rulers (grid); // redraw rulers and measure lines - xpos = frame_to_unit ((*i).frame); - line = get_time_line (); - line->property_x1() = xpos; - line->property_x2() = xpos; - line->property_y2() = y2; - line->property_color_rgba() = color; - //line->raise_to_top(); - line->show(); - break; - } + } else { + Glib::signal_idle().connect (sigc::bind_return (sigc::bind (sigc::mem_fun (*this, &Editor::redisplay_tempo), true), false)); + } +} + +/* computes a grid starting a beat before and ending a beat after leftmost and rightmost respectively */ +void +Editor::compute_current_bbt_points (std::vector& grid, framepos_t leftmost, framepos_t rightmost) +{ + if (!_session) { + return; } - /* the cursors are always on top of everything */ + /* prevent negative values of leftmost from creeping into tempomap + */ + const double lower_beat = floor (_session->tempo_map().beat_at_frame (leftmost)) - 1.0; + _session->tempo_map().get_grid (grid, max (_session->tempo_map().frame_at_beat (lower_beat), (framepos_t) 0), rightmost); +} - cursor_group->raise_to_top(); - time_line_group->lower_to_bottom(); - return; +void +Editor::hide_measures () +{ + if (tempo_lines) { + tempo_lines->hide(); + } } void -Editor::mouse_add_new_tempo_event (nframes_t frame) +Editor::draw_measures (std::vector& grid) { - if (session == 0) { + if (_session == 0 || _show_measures == false || distance (grid.begin(), grid.end()) == 0) { return; } - TempoMap& map(session->tempo_map()); - TempoDialog tempo_dialog (map, frame, _("add")); - - tempo_dialog.set_position (Gtk::WIN_POS_MOUSE); - tempo_dialog.signal_realize().connect (bind (sigc::ptr_fun (set_decoration), &tempo_dialog, Gdk::WMDecoration (Gdk::DECOR_BORDER|Gdk::DECOR_RESIZEH))); + if (tempo_lines == 0) { + tempo_lines = new TempoLines (time_line_group, ArdourCanvas::LineSet::Vertical); + } - ensure_float (tempo_dialog); + const unsigned divisions = get_grid_beat_divisions(leftmost_frame); + tempo_lines->draw (grid, divisions, leftmost_frame, _session->frame_rate()); +} - switch (tempo_dialog.run()) { - case RESPONSE_ACCEPT: - break; - default: +void +Editor::mouse_add_new_tempo_event (framepos_t frame) +{ + if (_session == 0) { return; } - double bpm = 0; - BBT_Time requested; - - bpm = tempo_dialog.get_bpm (); - bpm = max (0.01, bpm); - - tempo_dialog.get_bbt_time (requested); - + TempoMap& map(_session->tempo_map()); + begin_reversible_command (_("add tempo mark")); - XMLNode &before = map.get_state(); - map.add_tempo (Tempo (bpm), requested); - XMLNode &after = map.get_state(); - session->add_command(new MementoCommand(map, &before, &after)); - commit_reversible_command (); - - map.dump (cerr); + const double pulse = map.pulse_at_frame (frame); + + if (pulse > 0.0) { + XMLNode &before = map.get_state(); + /* add music-locked ramped (?) tempo using the bpm/note type at frame*/ + map.add_tempo (map.tempo_at_frame (frame), pulse, 0, TempoSection::Ramp, MusicTime); - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); + XMLNode &after = map.get_state(); + _session->add_command(new MementoCommand(map, &before, &after)); + commit_reversible_command (); + } + + //map.dump (cerr); } void -Editor::mouse_add_new_meter_event (nframes_t frame) +Editor::mouse_add_new_meter_event (framepos_t frame) { - if (session == 0) { + if (_session == 0) { return; } - TempoMap& map(session->tempo_map()); + TempoMap& map(_session->tempo_map()); MeterDialog meter_dialog (map, frame, _("add")); - meter_dialog.set_position (Gtk::WIN_POS_MOUSE); - meter_dialog.signal_realize().connect (bind (sigc::ptr_fun (set_decoration), &meter_dialog, Gdk::WMDecoration (Gdk::DECOR_BORDER|Gdk::DECOR_RESIZEH))); - - ensure_float (meter_dialog); - switch (meter_dialog.run ()) { case RESPONSE_ACCEPT: break; @@ -328,52 +346,52 @@ Editor::mouse_add_new_meter_event (nframes_t frame) double bpb = meter_dialog.get_bpb (); bpb = max (1.0, bpb); // XXX is this a reasonable limit? - + double note_type = meter_dialog.get_note_type (); - BBT_Time requested; - + Timecode::BBT_Time requested; + meter_dialog.get_bbt_time (requested); - + begin_reversible_command (_("add meter mark")); XMLNode &before = map.get_state(); - map.add_meter (Meter (bpb, note_type), requested); - session->add_command(new MementoCommand(map, &before, &map.get_state())); + + if (meter_dialog.get_lock_style() == MusicTime) { + map.add_meter (Meter (bpb, note_type), map.beat_at_bbt (requested), requested, 0, MusicTime); + } else { + map.add_meter (Meter (bpb, note_type), map.beat_at_bbt (requested), requested, map.frame_at_bbt (requested), AudioTime); + } + + _session->add_command(new MementoCommand(map, &before, &map.get_state())); commit_reversible_command (); - - map.dump (cerr); - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); + //map.dump (cerr); } void Editor::remove_tempo_marker (ArdourCanvas::Item* item) { - Marker* marker; + ArdourMarker* marker; TempoMarker* tempo_marker; - if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { + if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ } if ((tempo_marker = dynamic_cast (marker)) == 0) { fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg; - /*NOTREACHED*/ - } + abort(); /*NOTREACHED*/ + } if (tempo_marker->tempo().movable()) { - Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::real_remove_tempo_marker), &tempo_marker->tempo())); + Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::real_remove_tempo_marker), &tempo_marker->tempo())); } } void Editor::edit_meter_section (MeterSection* section) { - MeterDialog meter_dialog (*section, _("done")); - - meter_dialog.set_position (Gtk::WIN_POS_MOUSE); - - ensure_float (meter_dialog); + MeterDialog meter_dialog (_session->tempo_map(), *section, _("done")); switch (meter_dialog.run()) { case RESPONSE_ACCEPT: @@ -384,28 +402,27 @@ Editor::edit_meter_section (MeterSection* section) double bpb = meter_dialog.get_bpb (); bpb = max (1.0, bpb); // XXX is this a reasonable limit? - - double note_type = meter_dialog.get_note_type (); - begin_reversible_command (_("replace tempo mark")); - XMLNode &before = session->tempo_map().get_state(); - session->tempo_map().replace_meter (*section, Meter (bpb, note_type)); - XMLNode &after = session->tempo_map().get_state(); - session->add_command(new MementoCommand(session->tempo_map(), &before, &after)); - commit_reversible_command (); + double const note_type = meter_dialog.get_note_type (); + Timecode::BBT_Time when; + meter_dialog.get_bbt_time (when); + framepos_t const frame = _session->tempo_map().frame_at_bbt (when); + + begin_reversible_command (_("replace meter mark")); + XMLNode &before = _session->tempo_map().get_state(); - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); + _session->tempo_map().replace_meter (*section, Meter (bpb, note_type), when, frame, meter_dialog.get_lock_style()); + + XMLNode &after = _session->tempo_map().get_state(); + _session->add_command(new MementoCommand(_session->tempo_map(), &before, &after)); + commit_reversible_command (); } void Editor::edit_tempo_section (TempoSection* section) { - TempoDialog tempo_dialog (*section, _("done")); + TempoDialog tempo_dialog (_session->tempo_map(), *section, _("done")); - tempo_dialog.set_position (Gtk::WIN_POS_MOUSE); - - ensure_float (tempo_dialog); - switch (tempo_dialog.run ()) { case RESPONSE_ACCEPT: break; @@ -414,92 +431,72 @@ Editor::edit_tempo_section (TempoSection* section) } double bpm = tempo_dialog.get_bpm (); - BBT_Time when; - tempo_dialog.get_bbt_time(when); + double nt = tempo_dialog.get_note_type (); + Timecode::BBT_Time when; + + tempo_dialog.get_bbt_time (when); + bpm = max (0.01, bpm); - + begin_reversible_command (_("replace tempo mark")); - XMLNode &before = session->tempo_map().get_state(); - session->tempo_map().replace_tempo (*section, Tempo (bpm)); - session->tempo_map().move_tempo (*section, when); - XMLNode &after = session->tempo_map().get_state(); - session->add_command (new MementoCommand(session->tempo_map(), &before, &after)); - commit_reversible_command (); + XMLNode &before = _session->tempo_map().get_state(); + + if (tempo_dialog.get_lock_style() == AudioTime) { + framepos_t const f = _session->tempo_map().predict_tempo_position (section, when).second; + _session->tempo_map().replace_tempo (*section, Tempo (bpm, nt), 0.0, f, tempo_dialog.get_tempo_type(), AudioTime); + } else { + double const p = _session->tempo_map().predict_tempo_position (section, when).first; + _session->tempo_map().replace_tempo (*section, Tempo (bpm, nt), p, 0, tempo_dialog.get_tempo_type(), MusicTime); + } - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); + XMLNode &after = _session->tempo_map().get_state(); + _session->add_command (new MementoCommand(_session->tempo_map(), &before, &after)); + commit_reversible_command (); } void -Editor::edit_tempo_marker (ArdourCanvas::Item *item) +Editor::edit_tempo_marker (TempoMarker& tm) { - Marker* marker; - TempoMarker* tempo_marker; - - if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { - fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg; - /*NOTREACHED*/ - } - - if ((tempo_marker = dynamic_cast (marker)) == 0) { - fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg; - /*NOTREACHED*/ - } - - edit_tempo_section (&tempo_marker->tempo()); + edit_tempo_section (&tm.tempo()); } void -Editor::edit_meter_marker (ArdourCanvas::Item *item) +Editor::edit_meter_marker (MeterMarker& mm) { - Marker* marker; - MeterMarker* meter_marker; - - if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { - fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg; - /*NOTREACHED*/ - } - - if ((meter_marker = dynamic_cast (marker)) == 0) { - fatal << _("programming error: marker for meter is not a meter marker!") << endmsg; - /*NOTREACHED*/ - } - - edit_meter_section (&meter_marker->meter()); + edit_meter_section (&mm.meter()); } gint Editor::real_remove_tempo_marker (TempoSection *section) { begin_reversible_command (_("remove tempo mark")); - XMLNode &before = session->tempo_map().get_state(); - session->tempo_map().remove_tempo (*section); - XMLNode &after = session->tempo_map().get_state(); - session->add_command(new MementoCommand(session->tempo_map(), &before, &after)); + XMLNode &before = _session->tempo_map().get_state(); + _session->tempo_map().remove_tempo (*section, true); + XMLNode &after = _session->tempo_map().get_state(); + _session->add_command(new MementoCommand(_session->tempo_map(), &before, &after)); commit_reversible_command (); - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); - return FALSE; } void Editor::remove_meter_marker (ArdourCanvas::Item* item) { - Marker* marker; + ArdourMarker* marker; MeterMarker* meter_marker; - if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { + if ((marker = reinterpret_cast (item->get_data ("marker"))) == 0) { fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ } if ((meter_marker = dynamic_cast (marker)) == 0) { fatal << _("programming error: marker for meter is not a meter marker!") << endmsg; - /*NOTREACHED*/ - } + abort(); /*NOTREACHED*/ + } if (meter_marker->meter().movable()) { - Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::real_remove_meter_marker), &meter_marker->meter())); + Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::real_remove_meter_marker), &meter_marker->meter())); } } @@ -507,13 +504,11 @@ gint Editor::real_remove_meter_marker (MeterSection *section) { begin_reversible_command (_("remove tempo mark")); - XMLNode &before = session->tempo_map().get_state(); - session->tempo_map().remove_meter (*section); - XMLNode &after = session->tempo_map().get_state(); - session->add_command(new MementoCommand(session->tempo_map(), &before, &after)); + XMLNode &before = _session->tempo_map().get_state(); + _session->tempo_map().remove_meter (*section, true); + XMLNode &after = _session->tempo_map().get_state(); + _session->add_command(new MementoCommand(_session->tempo_map(), &before, &after)); commit_reversible_command (); - session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); - return FALSE; }