2005-09-25 14:42:24 -04:00
|
|
|
/*
|
2019-08-02 17:26:43 -04:00
|
|
|
* Copyright (C) 2005-2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2005 Taybin Rutkin <taybin@taybin.com>
|
|
|
|
* Copyright (C) 2006-2015 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2006-2015 Tim Mayberry <mojofunk@gmail.com>
|
|
|
|
* Copyright (C) 2007 Doug McLain <doug@nostar.net>
|
|
|
|
* Copyright (C) 2008-2011 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2014-2015 Robin Gareus <robin@gareus.org>
|
|
|
|
* Copyright (C) 2015-2017 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
|
|
* Copyright (C) 2017-2018 Ben Loftis <ben@harrisonconsoles.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2010-11-13 00:14:48 -05:00
|
|
|
#ifdef WAF_BUILD
|
|
|
|
#include "gtk2ardour-config.h"
|
|
|
|
#endif
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
#include <cstdio> // for sprintf, grrr
|
2005-09-25 14:42:24 -04:00
|
|
|
#include <cstdlib>
|
|
|
|
#include <cmath>
|
|
|
|
#include <string>
|
|
|
|
#include <climits>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/memento_command.h"
|
2022-06-28 12:16:31 -04:00
|
|
|
#include "pbd/unwind.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-09-25 16:33:00 -04:00
|
|
|
#include <gtkmm2ext/utils.h>
|
|
|
|
#include <gtkmm2ext/gtk_ui.h>
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/session.h"
|
|
|
|
#include "ardour/tempo.h"
|
2005-09-25 16:33:00 -04:00
|
|
|
#include <gtkmm2ext/doi.h>
|
2005-12-08 13:53:43 -05:00
|
|
|
#include <gtkmm2ext/utils.h>
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2013-04-04 00:32:52 -04:00
|
|
|
#include "canvas/canvas.h"
|
|
|
|
#include "canvas/item.h"
|
2014-06-09 15:39:57 -04:00
|
|
|
#include "canvas/line_set.h"
|
2013-04-04 00:32:52 -04:00
|
|
|
|
2022-08-17 18:27:53 -04:00
|
|
|
#include "bbt_marker_dialog.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
#include "editor.h"
|
|
|
|
#include "marker.h"
|
|
|
|
#include "tempo_dialog.h"
|
|
|
|
#include "rgb_macros.h"
|
|
|
|
#include "gui_thread.h"
|
2006-10-21 15:01:50 -04:00
|
|
|
#include "time_axis_view.h"
|
2018-02-09 10:59:39 -05:00
|
|
|
#include "grid_lines.h"
|
2022-06-28 13:44:25 -04:00
|
|
|
#include "region_view.h"
|
2015-01-02 09:44:54 -05:00
|
|
|
#include "ui_config.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2016-07-14 14:44:52 -04:00
|
|
|
#include "pbd/i18n.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
using namespace ARDOUR;
|
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
|
|
|
using namespace PBD;
|
2005-09-25 14:42:24 -04:00
|
|
|
using namespace Gtk;
|
2005-12-08 13:53:43 -05:00
|
|
|
using namespace Gtkmm2ext;
|
2005-09-25 14:42:24 -04:00
|
|
|
using namespace Editing;
|
2020-11-16 13:19:22 -05:00
|
|
|
using namespace Temporal;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
Editor::remove_metric_marks ()
|
|
|
|
{
|
|
|
|
/* don't delete these while handling events, just punt till the GUI is idle */
|
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
for (auto & m : tempo_marks) {
|
|
|
|
delete_when_idle (m);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2022-01-18 21:45:18 -05:00
|
|
|
for (auto & m : meter_marks) {
|
|
|
|
delete_when_idle (m);
|
2016-05-07 13:03:12 -04:00
|
|
|
}
|
2022-01-18 21:45:18 -05:00
|
|
|
for (auto & m : bbt_marks) {
|
|
|
|
delete_when_idle (m);
|
2016-12-11 10:03:19 -05:00
|
|
|
}
|
2022-01-18 21:45:18 -05:00
|
|
|
|
|
|
|
tempo_marks.clear ();
|
|
|
|
meter_marks.clear ();
|
|
|
|
bbt_marks.clear ();
|
|
|
|
}
|
2021-01-01 18:00:07 -05:00
|
|
|
|
2021-04-04 19:56:58 -04:00
|
|
|
void
|
2022-06-26 07:55:46 -04:00
|
|
|
Editor::reassociate_metric_markers (TempoMap::SharedPtr const& tmap)
|
2021-04-04 19:56:58 -04:00
|
|
|
{
|
|
|
|
TempoMap::Metrics metrics;
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & t : tempo_marks) {
|
|
|
|
reassociate_tempo_marker (tmap, tmap->tempos(), *dynamic_cast<TempoMarker*> (t));
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & m : meter_marks) {
|
|
|
|
reassociate_meter_marker (tmap, tmap->meters(), *dynamic_cast<MeterMarker*> (m));
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & b : bbt_marks) {
|
|
|
|
reassociate_bartime_marker (tmap, tmap->bartimes(), *dynamic_cast<BBTMarker*> (b));
|
2022-01-15 22:04:03 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::reassociate_tempo_marker (TempoMap::SharedPtr const & tmap, TempoMap::Tempos const & tempos, TempoMarker& marker)
|
2022-01-15 22:04:03 -05:00
|
|
|
{
|
2022-06-28 00:20:51 -04:00
|
|
|
Temporal::MusicTimePoint const * mtp;
|
|
|
|
|
|
|
|
for (auto const & tempo : tempos) {
|
|
|
|
if ((mtp = dynamic_cast<Temporal::MusicTimePoint const *>(&tempo)) != 0) {
|
|
|
|
/* do nothing .. but we had to catch
|
|
|
|
this first because MusicTimePoint
|
|
|
|
IS-A TempoPoint
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (marker.point().sclock() == tempo.sclock()) {
|
|
|
|
marker.reset_tempo (tempo);
|
|
|
|
marker.curve().reset_point (tempo);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-04-04 19:56:58 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
void
|
|
|
|
Editor::reassociate_meter_marker (TempoMap::SharedPtr const & tmap, TempoMap::Meters const & meters, MeterMarker& marker)
|
|
|
|
{
|
2022-04-08 11:23:39 -04:00
|
|
|
Temporal::MusicTimePoint const * mtp;
|
2021-04-04 19:56:58 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto const & meter : meters) {
|
|
|
|
if ((mtp = dynamic_cast<Temporal::MusicTimePoint const *>(&meter)) != 0) {
|
|
|
|
/* do nothing .. but we had to catch
|
|
|
|
this first because MusicTimePoint
|
|
|
|
IS-A MeterPoint
|
|
|
|
*/
|
|
|
|
continue;
|
2022-01-15 22:04:03 -05:00
|
|
|
}
|
2022-06-28 00:20:51 -04:00
|
|
|
if (marker.point().sclock() == meter.sclock()) {
|
|
|
|
marker.reset_meter (meter);
|
|
|
|
break;
|
2022-01-15 22:04:03 -05:00
|
|
|
}
|
2022-06-28 00:20:51 -04:00
|
|
|
}
|
|
|
|
}
|
2022-01-15 22:04:03 -05:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
void
|
|
|
|
Editor::reassociate_bartime_marker (TempoMap::SharedPtr const & tmap, TempoMap::MusicTimes const & bartimes, BBTMarker& marker)
|
|
|
|
{
|
|
|
|
for (auto const & bartime : bartimes) {
|
|
|
|
if (marker.point().sclock() == bartime.sclock()) {
|
|
|
|
marker.reset_point (bartime);
|
|
|
|
break;
|
2021-04-04 19:56:58 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2022-06-26 00:26:34 -04:00
|
|
|
Editor::make_bbt_marker (MusicTimePoint const * mtp, Marks::iterator before)
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
2022-06-26 00:26:34 -04:00
|
|
|
bbt_marks.insert (before, new BBTMarker (*this, *bbt_ruler, UIConfiguration::instance().color ("meter marker"), *mtp));
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-26 00:26:34 -04:00
|
|
|
Editor::make_meter_marker (Temporal::MeterPoint const * ms, Marks::iterator before)
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
snprintf (buf, sizeof(buf), "%d/%d", ms->divisions_per_bar(), ms->note_value ());
|
2022-06-26 00:26:34 -04:00
|
|
|
meter_marks.insert (before, new MeterMarker (*this, *meter_group, UIConfiguration::instance().color ("meter marker"), buf, *ms));
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-26 00:26:34 -04:00
|
|
|
Editor::make_tempo_marker (Temporal::TempoPoint const * ts, double& min_tempo, double& max_tempo, TempoPoint const *& prev_ts, uint32_t tc_color, samplecnt_t sr, Marks::iterator before)
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
|
|
|
max_tempo = max (max_tempo, ts->note_types_per_minute());
|
|
|
|
max_tempo = max (max_tempo, ts->end_note_types_per_minute());
|
|
|
|
min_tempo = min (min_tempo, ts->note_types_per_minute());
|
|
|
|
min_tempo = min (min_tempo, ts->end_note_types_per_minute());
|
|
|
|
|
|
|
|
const std::string tname (X_(""));
|
2022-05-23 16:24:50 -04:00
|
|
|
char const * color_name = X_("tempo marker");
|
2022-01-18 21:45:18 -05:00
|
|
|
|
2022-06-26 00:26:34 -04:00
|
|
|
tempo_marks.insert (before, new TempoMarker (*this, *tempo_group, UIConfiguration::instance().color (color_name), tname, *ts, ts->sample (sr), tc_color));
|
2022-01-18 21:45:18 -05:00
|
|
|
|
|
|
|
/* XXX the point of this code was "a jump in tempo by more than 1 ntpm results in a red
|
|
|
|
tempo mark pointer." (3a7bc1fd3f32f0)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (prev_ts && abs (prev_ts->end_note_types_per_minute() - ts->note_types_per_minute()) < 1.0) {
|
|
|
|
tempo_marks.back()->set_points_color (UIConfiguration::instance().color ("tempo marker music"));
|
|
|
|
} else {
|
|
|
|
tempo_marks.back()->set_points_color (UIConfiguration::instance().color ("tempo marker"));
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_ts = ts;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::reset_metric_marks ()
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
2022-06-28 00:20:51 -04:00
|
|
|
reset_tempo_marks ();
|
|
|
|
reset_meter_marks ();
|
|
|
|
reset_bbt_marks ();
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::reset_tempo_marks ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2021-01-01 18:00:07 -05:00
|
|
|
if (!_session) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
const uint32_t tc_color = UIConfiguration::instance().color ("tempo curve");
|
|
|
|
const samplecnt_t sr (_session->sample_rate());
|
2022-06-28 00:20:51 -04:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
Temporal::TempoMap::SharedPtr tmap (TempoMap::use());
|
|
|
|
TempoMap::Tempos const & tempi (tmap->tempos());
|
2022-06-28 00:20:51 -04:00
|
|
|
TempoPoint const * prev_ts = 0;
|
2016-05-07 13:03:12 -04:00
|
|
|
double max_tempo = 0.0;
|
|
|
|
double min_tempo = DBL_MAX;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & t : tempo_marks) {
|
|
|
|
delete t;
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
tempo_marks.clear ();
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto const & t : tempi) {
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
/* do not draw BBT position elements that are both tempo & meter points */
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
if (!dynamic_cast<Temporal::MusicTimePoint const *> (&t)) {
|
|
|
|
make_tempo_marker (&t, min_tempo, max_tempo, prev_ts, tc_color, sr, tempo_marks.end());
|
|
|
|
prev_ts = &t;
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
update_tempo_curves (min_tempo, max_tempo, sr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::reset_meter_marks ()
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
|
|
|
if (!_session) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Temporal::TempoMap::SharedPtr tmap (TempoMap::use());
|
|
|
|
TempoMap::Meters const & meters (tmap->meters());
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & m : meter_marks) {
|
|
|
|
delete m;
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
meter_marks.clear ();
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto const & m : meters) {
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
/* do not draw BBT position elements that are both tempo & meter points */
|
2022-05-29 16:42:23 -04:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
if (!dynamic_cast<Temporal::MusicTimePoint const *> (&m)) {
|
|
|
|
make_meter_marker (&m, meter_marks.end());
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::reset_bbt_marks ()
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
|
|
|
if (!_session) {
|
|
|
|
return;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2016-05-17 14:47:40 -04:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
Temporal::TempoMap::SharedPtr tmap (TempoMap::use());
|
|
|
|
TempoMap::MusicTimes const & bartimes (tmap->bartimes());
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto & b : bbt_marks) {
|
|
|
|
delete b;
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
bbt_marks.clear ();
|
2022-01-18 21:45:18 -05:00
|
|
|
|
2022-06-28 00:20:51 -04:00
|
|
|
for (auto const & b : bartimes) {
|
|
|
|
make_bbt_marker (&b, bbt_marks.end());
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Editor::update_tempo_curves (double min_tempo, double max_tempo, samplecnt_t sr)
|
|
|
|
{
|
2016-05-24 14:10:22 -04:00
|
|
|
const double min_tempo_range = 5.0;
|
|
|
|
const double tempo_delta = fabs (max_tempo - min_tempo);
|
|
|
|
|
|
|
|
if (tempo_delta < min_tempo_range) {
|
|
|
|
max_tempo += min_tempo_range - tempo_delta;
|
|
|
|
min_tempo += tempo_delta - min_tempo_range;
|
|
|
|
}
|
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
for (Marks::iterator m = tempo_marks.begin(); m != tempo_marks.end(); ++m) {
|
|
|
|
|
|
|
|
TempoMarker* tm = static_cast<TempoMarker*>(*m);
|
|
|
|
Marks::iterator tmp = m;
|
2016-05-07 13:03:12 -04:00
|
|
|
++tmp;
|
2017-01-06 11:39:24 -05:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
TempoCurve& curve (tm->curve());
|
2017-01-06 11:39:24 -05:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
curve.set_max_tempo (max_tempo);
|
|
|
|
curve.set_min_tempo (min_tempo);
|
2006-08-30 22:28:42 -04:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
if (tmp != tempo_marks.end()) {
|
|
|
|
TempoMarker* nxt = static_cast<TempoMarker*>(*tmp);
|
|
|
|
curve.set_duration (nxt->tempo().sample(sr) - tm->tempo().sample(sr));
|
|
|
|
} else {
|
|
|
|
curve.set_duration (samplecnt_t (UINT32_MAX));
|
|
|
|
}
|
2016-05-17 14:47:40 -04:00
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
if (!tm->tempo().active()) {
|
|
|
|
curve.hide();
|
|
|
|
} else {
|
|
|
|
curve.show();
|
2016-05-17 14:47:40 -04:00
|
|
|
}
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-11-16 13:19:22 -05:00
|
|
|
Editor::tempo_map_changed ()
|
2022-05-02 14:02:04 -04:00
|
|
|
{
|
2022-06-28 12:16:31 -04:00
|
|
|
if (ignore_map_change) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-06-16 14:57:39 -04:00
|
|
|
TempoMap::SharedPtr current_map = TempoMap::fetch ();
|
2022-06-26 00:26:34 -04:00
|
|
|
|
2022-06-17 00:09:53 -04:00
|
|
|
/* If the tempo map was changed by something other than the Editor, we
|
|
|
|
* will need to reassociate all visual elements used for tempo display
|
|
|
|
* with the new map.
|
|
|
|
*/
|
|
|
|
|
2022-06-28 12:16:31 -04:00
|
|
|
reset_metric_marks ();
|
|
|
|
update_tempo_based_rulers ();
|
|
|
|
maybe_draw_grid_lines ();
|
2015-12-22 13:58:49 -05:00
|
|
|
}
|
|
|
|
|
2007-04-12 19:20:37 -04:00
|
|
|
void
|
2018-02-09 10:59:39 -05:00
|
|
|
Editor::redisplay_grid (bool immediate_redraw)
|
use filechooser widget in export dialog, selected files set format combos, hide progress bar until use in export dialog, speed up 'separate regions in range' operation on larger sessions, ruler scale now calculated separately to mark generation, fix for non-stacked layering regression, try not to generate 'buried' crossfades, use playlist->freeze() to speed up copying/moving regions on large playlists (not done for undo), width dependent items now reset on regionview init, get rid of jack_port_ensure_monitor check, remove audiosourse _length (only source has a length.. i think), make overlapend differ to overlapexternal where start points coincide.
git-svn-id: svn://localhost/ardour2/trunk@2576 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-10-26 09:32:24 -04:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
if (!_session) {
|
use filechooser widget in export dialog, selected files set format combos, hide progress bar until use in export dialog, speed up 'separate regions in range' operation on larger sessions, ruler scale now calculated separately to mark generation, fix for non-stacked layering regression, try not to generate 'buried' crossfades, use playlist->freeze() to speed up copying/moving regions on large playlists (not done for undo), width dependent items now reset on regionview init, get rid of jack_port_ensure_monitor check, remove audiosourse _length (only source has a length.. i think), make overlapend differ to overlapexternal where start points coincide.
git-svn-id: svn://localhost/ardour2/trunk@2576 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-10-26 09:32:24 -04:00
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
if (immediate_redraw) {
|
2017-03-10 09:37:26 -05:00
|
|
|
|
2018-02-09 10:59:39 -05:00
|
|
|
update_tempo_based_rulers ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2018-02-09 10:59:39 -05:00
|
|
|
update_grid();
|
2020-10-15 01:09:22 -04:00
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
} else {
|
2018-02-09 10:59:39 -05:00
|
|
|
Glib::signal_idle().connect (sigc::bind_return (sigc::bind (sigc::mem_fun (*this, &Editor::redisplay_grid), true), false));
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
use filechooser widget in export dialog, selected files set format combos, hide progress bar until use in export dialog, speed up 'separate regions in range' operation on larger sessions, ruler scale now calculated separately to mark generation, fix for non-stacked layering regression, try not to generate 'buried' crossfades, use playlist->freeze() to speed up copying/moving regions on large playlists (not done for undo), width dependent items now reset on regionview init, get rid of jack_port_ensure_monitor check, remove audiosourse _length (only source has a length.. i think), make overlapend differ to overlapexternal where start points coincide.
git-svn-id: svn://localhost/ardour2/trunk@2576 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-10-26 09:32:24 -04:00
|
|
|
}
|
2017-02-25 15:03:02 -05:00
|
|
|
void
|
2021-01-26 21:30:56 -05:00
|
|
|
Editor::tempo_curve_selected (Temporal::TempoPoint const * ts, bool yn)
|
2017-02-25 15:03:02 -05:00
|
|
|
{
|
2017-03-04 13:21:56 -05:00
|
|
|
if (ts == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
for (Marks::iterator x = tempo_marks.begin(); x != tempo_marks.end(); ++x) {
|
|
|
|
TempoMarker* tm = static_cast<TempoMarker*> (*x);
|
|
|
|
if (&tm->tempo() == ts) {
|
2017-02-26 19:10:47 -05:00
|
|
|
if (yn) {
|
2022-01-18 21:45:18 -05:00
|
|
|
tm->curve().set_color_rgba (UIConfiguration::instance().color ("location marker"));
|
2017-02-26 19:10:47 -05:00
|
|
|
} else {
|
2022-01-18 21:45:18 -05:00
|
|
|
tm->curve().set_color_rgba (UIConfiguration::instance().color ("tempo curve"));
|
2017-02-26 19:10:47 -05:00
|
|
|
}
|
2017-02-25 15:03:02 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
use filechooser widget in export dialog, selected files set format combos, hide progress bar until use in export dialog, speed up 'separate regions in range' operation on larger sessions, ruler scale now calculated separately to mark generation, fix for non-stacked layering regression, try not to generate 'buried' crossfades, use playlist->freeze() to speed up copying/moving regions on large playlists (not done for undo), width dependent items now reset on regionview init, get rid of jack_port_ensure_monitor check, remove audiosourse _length (only source has a length.. i think), make overlapend differ to overlapexternal where start points coincide.
git-svn-id: svn://localhost/ardour2/trunk@2576 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-10-26 09:32:24 -04:00
|
|
|
|
2015-12-19 12:41:45 -05:00
|
|
|
/* computes a grid starting a beat before and ending a beat after leftmost and rightmost respectively */
|
use filechooser widget in export dialog, selected files set format combos, hide progress bar until use in export dialog, speed up 'separate regions in range' operation on larger sessions, ruler scale now calculated separately to mark generation, fix for non-stacked layering regression, try not to generate 'buried' crossfades, use playlist->freeze() to speed up copying/moving regions on large playlists (not done for undo), width dependent items now reset on regionview init, get rid of jack_port_ensure_monitor check, remove audiosourse _length (only source has a length.. i think), make overlapend differ to overlapexternal where start points coincide.
git-svn-id: svn://localhost/ardour2/trunk@2576 d708f5d6-7413-0410-9779-e7cbd77b26cf
2007-10-26 09:32:24 -04:00
|
|
|
void
|
2020-11-16 13:19:22 -05:00
|
|
|
Editor::compute_current_bbt_points (Temporal::TempoMapPoints& grid, samplepos_t leftmost, samplepos_t rightmost)
|
2007-04-12 19:20:37 -04:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
if (!_session) {
|
2007-04-12 19:20:37 -04:00
|
|
|
return;
|
|
|
|
}
|
2006-09-18 23:29:16 -04:00
|
|
|
|
2021-03-22 18:02:36 -04:00
|
|
|
TempoMap::SharedPtr tmap (TempoMap::use());
|
|
|
|
|
2012-01-08 11:53:11 -05:00
|
|
|
/* prevent negative values of leftmost from creeping into tempomap
|
|
|
|
*/
|
2021-03-22 18:02:36 -04:00
|
|
|
|
|
|
|
const Beats left = tmap->quarters_at_sample (leftmost).round_down_to_beat();
|
|
|
|
const Beats lower_beat = (left < Beats() ? Beats() : left);
|
2020-11-16 13:19:22 -05:00
|
|
|
const samplecnt_t sr (_session->sample_rate());
|
|
|
|
|
2016-10-18 12:56:43 -04:00
|
|
|
switch (bbt_ruler_scale) {
|
|
|
|
|
2018-07-26 15:07:45 -04:00
|
|
|
case bbt_show_quarters:
|
|
|
|
case bbt_show_eighths:
|
|
|
|
case bbt_show_sixteenths:
|
|
|
|
case bbt_show_thirtyseconds:
|
2021-02-20 20:37:56 -05:00
|
|
|
case bbt_show_sixtyfourths:
|
2021-02-21 08:14:22 -05:00
|
|
|
case bbt_show_onetwentyeighths:
|
2020-11-27 14:41:11 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 0);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case bbt_show_1:
|
2021-01-21 17:46:34 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 1);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case bbt_show_4:
|
2021-01-21 17:46:34 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 4);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case bbt_show_16:
|
2021-01-21 17:46:34 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 16);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case bbt_show_64:
|
2021-01-21 17:46:34 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 64);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* bbt_show_many */
|
2021-01-21 17:46:34 -05:00
|
|
|
tmap->get_grid (grid, max (tmap->superclock_at (lower_beat), (superclock_t) 0), samples_to_superclock (rightmost, sr), 128);
|
2016-10-18 12:56:43 -04:00
|
|
|
break;
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2018-02-09 10:59:39 -05:00
|
|
|
Editor::hide_grid_lines ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2018-02-09 10:59:39 -05:00
|
|
|
if (grid_lines) {
|
|
|
|
grid_lines->hide();
|
2013-04-24 15:42:14 -04:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2018-02-09 10:59:39 -05:00
|
|
|
Editor::maybe_draw_grid_lines ()
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2018-02-09 10:59:39 -05:00
|
|
|
if ( _session == 0 ) {
|
2005-09-25 14:42:24 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-09 10:59:39 -05:00
|
|
|
if (grid_lines == 0) {
|
|
|
|
grid_lines = new GridLines (time_line_group, ArdourCanvas::LineSet::Vertical);
|
|
|
|
}
|
|
|
|
|
|
|
|
grid_marks.clear();
|
|
|
|
samplepos_t rightmost_sample = _leftmost_sample + current_page_samples();
|
|
|
|
|
|
|
|
if ( grid_musical() ) {
|
|
|
|
metric_get_bbt (grid_marks, _leftmost_sample, rightmost_sample, 12);
|
2018-02-26 19:38:18 -05:00
|
|
|
} else if (_grid_type== GridTypeTimecode) {
|
2018-02-09 10:59:39 -05:00
|
|
|
metric_get_timecode (grid_marks, _leftmost_sample, rightmost_sample, 12);
|
2018-02-26 18:02:24 -05:00
|
|
|
} else if (_grid_type == GridTypeCDFrame) {
|
2018-02-26 19:52:28 -05:00
|
|
|
metric_get_minsec (grid_marks, _leftmost_sample, rightmost_sample, 12);
|
2018-02-09 10:59:39 -05:00
|
|
|
} else if (_grid_type == GridTypeMinSec) {
|
|
|
|
metric_get_minsec (grid_marks, _leftmost_sample, rightmost_sample, 12);
|
2008-09-10 17:27:39 -04:00
|
|
|
}
|
2015-01-07 19:05:21 -05:00
|
|
|
|
2018-02-09 10:59:39 -05:00
|
|
|
grid_lines->draw ( grid_marks );
|
|
|
|
grid_lines->show();
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-10-05 00:52:17 -04:00
|
|
|
Editor::mouse_add_new_tempo_event (timepos_t pos)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
if (_session == 0) {
|
2005-09-25 14:42:24 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:02 -05:00
|
|
|
if (pos.beats() > Beats()) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2020-12-31 00:28:02 -05:00
|
|
|
begin_reversible_command (_("add tempo mark"));
|
2020-10-05 00:52:17 -04:00
|
|
|
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr map (TempoMap::write_copy());
|
2016-04-13 16:14:51 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = map->get_state();
|
2016-04-13 16:03:20 -04:00
|
|
|
|
2020-12-31 00:28:02 -05:00
|
|
|
/* add music-locked ramped (?) tempo using the bpm/note type at sample*/
|
2020-11-27 14:41:11 -05:00
|
|
|
|
2020-12-31 00:28:02 -05:00
|
|
|
map->set_tempo (map->tempo_at (pos), pos);
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &after = map->get_state();
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("add tempo"), &before, &after));
|
2016-04-13 16:14:51 -04:00
|
|
|
commit_reversible_command ();
|
2020-12-31 00:28:02 -05:00
|
|
|
|
|
|
|
TempoMap::update (map);
|
2016-04-13 16:14:51 -04:00
|
|
|
}
|
2020-11-24 17:06:35 -05:00
|
|
|
|
2008-02-01 22:57:35 -05:00
|
|
|
//map.dump (cerr);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-10-05 00:52:17 -04:00
|
|
|
Editor::mouse_add_new_meter_event (timepos_t pos)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
if (_session == 0) {
|
2005-09-25 14:42:24 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-01-04 23:57:59 -05:00
|
|
|
MeterDialog meter_dialog (TempoMap::use(), pos, _("add"));
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
switch (meter_dialog.run ()) {
|
|
|
|
case RESPONSE_ACCEPT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2005-11-27 16:17:41 -05:00
|
|
|
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr map (TempoMap::write_copy());
|
2021-01-04 23:57:59 -05:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
double bpb = meter_dialog.get_bpb ();
|
|
|
|
bpb = max (1.0, bpb); // XXX is this a reasonable limit?
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
double note_type = meter_dialog.get_note_type ();
|
2008-02-01 22:57:35 -05:00
|
|
|
|
2020-07-23 19:46:49 -04:00
|
|
|
Temporal::BBT_Time requested;
|
2005-11-27 16:17:41 -05:00
|
|
|
meter_dialog.get_bbt_time (requested);
|
2008-02-01 22:57:35 -05:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
begin_reversible_command (_("add meter mark"));
|
2020-10-05 00:52:17 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = map->get_state();
|
2016-05-07 13:03:12 -04:00
|
|
|
|
2022-05-23 16:24:50 -04:00
|
|
|
pos = timepos_t (map->quarters_at (requested));
|
2016-05-07 13:03:12 -04:00
|
|
|
|
2020-12-07 20:56:39 -05:00
|
|
|
map->set_meter (Meter (bpb, note_type), pos);
|
|
|
|
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("add time signature"), &before, &map->get_state()));
|
2005-11-27 16:17:41 -05:00
|
|
|
commit_reversible_command ();
|
2020-12-07 20:56:39 -05:00
|
|
|
|
2020-12-31 14:05:20 -05:00
|
|
|
TempoMap::update (map);
|
|
|
|
|
2008-02-01 22:57:35 -05:00
|
|
|
//map.dump (cerr);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2022-10-03 16:16:27 -04:00
|
|
|
void
|
|
|
|
Editor::mouse_add_bbt_marker_event (timepos_t pos)
|
|
|
|
{
|
|
|
|
if (_session == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* position markers must always be positioned using audio time */
|
|
|
|
|
|
|
|
BBTMarkerDialog marker_dialog (pos);
|
|
|
|
|
|
|
|
/* run this modally since we are finishing a drag and the drag object
|
|
|
|
* will be destroyed when we return from here
|
|
|
|
*/
|
|
|
|
|
|
|
|
int result = marker_dialog.run ();
|
|
|
|
|
|
|
|
switch (result) {
|
|
|
|
case RESPONSE_ACCEPT:
|
|
|
|
case RESPONSE_OK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
BBT_Time bbt;
|
|
|
|
std::string name;
|
|
|
|
|
|
|
|
bbt = marker_dialog.bbt_value ();
|
|
|
|
name = marker_dialog.name();
|
|
|
|
|
|
|
|
begin_reversible_command (_("add BBT marker"));
|
|
|
|
|
|
|
|
TempoMap::WritableSharedPtr map (TempoMap::write_copy());
|
|
|
|
XMLNode &before = map->get_state();
|
|
|
|
|
|
|
|
map->set_bartime (bbt, marker_dialog.position(), name);
|
|
|
|
|
|
|
|
_session->add_command (new Temporal::TempoCommand (_("add BBT marker"), &before, &map->get_state()));
|
|
|
|
commit_reversible_command ();
|
|
|
|
|
|
|
|
TempoMap::update (map);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-08-17 18:27:53 -04:00
|
|
|
void
|
|
|
|
Editor::remove_bbt_marker (ArdourCanvas::Item* item)
|
|
|
|
{
|
|
|
|
ArdourMarker* marker;
|
|
|
|
BBTMarker* bbt_marker;
|
|
|
|
|
|
|
|
if ((marker = reinterpret_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
|
|
|
|
fatal << _("programming error: bbt marker canvas item has no marker object pointer!") << endmsg;
|
|
|
|
abort(); /*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((bbt_marker = dynamic_cast<BBTMarker*> (marker)) == 0) {
|
|
|
|
fatal << _("programming error: marker for bbt is not a bbt marker!") << endmsg;
|
|
|
|
abort(); /*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::real_remove_bbt_marker), &bbt_marker->mt_point()));
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2005-11-23 12:21:12 -05:00
|
|
|
Editor::remove_tempo_marker (ArdourCanvas::Item* item)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2015-07-23 07:23:47 -04:00
|
|
|
ArdourMarker* marker;
|
2005-09-25 14:42:24 -04:00
|
|
|
TempoMarker* tempo_marker;
|
|
|
|
|
2015-07-23 07:23:47 -04:00
|
|
|
if ((marker = reinterpret_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
|
2005-09-25 14:42:24 -04:00
|
|
|
fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((tempo_marker = dynamic_cast<TempoMarker*> (marker)) == 0) {
|
|
|
|
fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2017-01-06 09:12:09 -05:00
|
|
|
if (!tempo_marker->tempo().locked_to_meter() && tempo_marker->tempo().active()) {
|
2010-05-02 19:14:43 -04:00
|
|
|
Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::real_remove_tempo_marker), &tempo_marker->tempo()));
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2020-11-23 18:45:08 -05:00
|
|
|
Editor::edit_meter_section (Temporal::MeterPoint& section)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2020-11-27 14:41:11 -05:00
|
|
|
MeterDialog meter_dialog (section, _("done"));
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
switch (meter_dialog.run()) {
|
|
|
|
case RESPONSE_ACCEPT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
double bpb = meter_dialog.get_bpb ();
|
|
|
|
bpb = max (1.0, bpb); // XXX is this a reasonable limit?
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-03-01 10:07:32 -05:00
|
|
|
double const note_type = meter_dialog.get_note_type ();
|
2016-07-03 11:12:55 -04:00
|
|
|
const Meter meter (bpb, note_type);
|
|
|
|
|
2020-07-23 19:46:49 -04:00
|
|
|
Temporal::BBT_Time when;
|
2016-05-23 14:17:35 -04:00
|
|
|
meter_dialog.get_bbt_time (when);
|
2011-12-28 16:02:31 -05:00
|
|
|
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
2020-11-27 14:41:11 -05:00
|
|
|
|
2021-04-04 19:56:58 -04:00
|
|
|
reassociate_metric_markers (tmap);
|
|
|
|
|
2022-05-23 13:26:36 -04:00
|
|
|
begin_reversible_command (_("Edit Time Signature"));
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = tmap->get_state();
|
2016-05-20 11:45:37 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
tmap->set_meter (meter, when);
|
2016-05-20 11:45:37 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &after = tmap->get_state();
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("edit time signature"), &before, &after));
|
2005-11-27 16:17:41 -05:00
|
|
|
commit_reversible_command ();
|
2020-12-31 14:05:20 -05:00
|
|
|
|
|
|
|
TempoMap::update (tmap);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2022-08-17 18:27:53 -04:00
|
|
|
void
|
|
|
|
Editor::edit_bbt (MusicTimePoint& point)
|
|
|
|
{
|
|
|
|
BBTMarkerDialog dialog (point);
|
|
|
|
|
|
|
|
switch (dialog.run ()) {
|
|
|
|
case RESPONSE_OK:
|
|
|
|
case RESPONSE_ACCEPT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dialog.bbt_value() == point.bbt()) {
|
|
|
|
/* just a name change, no need to modify the map */
|
|
|
|
point.set_name (dialog.name());
|
|
|
|
/* XXX need to update marker label */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
|
|
|
reassociate_metric_markers (tmap);
|
|
|
|
|
|
|
|
begin_reversible_command (_("Edit Tempo"));
|
|
|
|
XMLNode &before = tmap->get_state();
|
|
|
|
|
|
|
|
tmap->remove_bartime (point);
|
|
|
|
tmap->set_bartime (dialog.bbt_value(), dialog.position(), dialog.name());
|
|
|
|
|
|
|
|
XMLNode &after = tmap->get_state();
|
|
|
|
_session->add_command (new Temporal::TempoCommand (_("edit tempo"), &before, &after));
|
|
|
|
commit_reversible_command ();
|
|
|
|
|
|
|
|
TempoMap::update (tmap);
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
void
|
2020-11-23 18:45:08 -05:00
|
|
|
Editor::edit_tempo_section (TempoPoint& section)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2020-11-27 14:41:11 -05:00
|
|
|
TempoDialog tempo_dialog (TempoMap::use(), section, _("done"));
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-11-27 16:17:41 -05:00
|
|
|
switch (tempo_dialog.run ()) {
|
|
|
|
case RESPONSE_ACCEPT:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
2005-11-27 16:17:41 -05:00
|
|
|
|
|
|
|
double bpm = tempo_dialog.get_bpm ();
|
2017-03-06 12:00:38 -05:00
|
|
|
double end_bpm = tempo_dialog.get_end_bpm ();
|
2021-01-01 17:59:47 -05:00
|
|
|
int nt = tempo_dialog.get_note_type ();
|
2016-07-03 11:12:55 -04:00
|
|
|
bpm = max (0.01, bpm);
|
2021-01-01 17:59:47 -05:00
|
|
|
|
|
|
|
const Tempo tempo (bpm, end_bpm, nt);
|
2016-02-27 12:59:34 -05:00
|
|
|
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
2021-04-04 19:56:58 -04:00
|
|
|
reassociate_metric_markers (tmap);
|
2020-11-27 14:41:11 -05:00
|
|
|
|
2020-07-23 19:46:49 -04:00
|
|
|
Temporal::BBT_Time when;
|
2016-04-03 13:00:40 -04:00
|
|
|
tempo_dialog.get_bbt_time (when);
|
2016-03-01 10:07:32 -05:00
|
|
|
|
2022-05-23 13:26:36 -04:00
|
|
|
begin_reversible_command (_("Edit Tempo"));
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = tmap->get_state();
|
2016-03-23 11:55:59 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
tmap->set_tempo (tempo, when);
|
2016-03-23 11:55:59 -04:00
|
|
|
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &after = tmap->get_state();
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("edit tempo"), &before, &after));
|
2005-11-27 16:17:41 -05:00
|
|
|
commit_reversible_command ();
|
2020-12-31 14:05:20 -05:00
|
|
|
|
|
|
|
TempoMap::update (tmap);
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-01-27 10:09:58 -05:00
|
|
|
Editor::edit_tempo_marker (TempoMarker& tm)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2022-01-18 21:45:18 -05:00
|
|
|
edit_tempo_section (const_cast<Temporal::TempoPoint&>(tm.tempo()));
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-01-27 10:09:58 -05:00
|
|
|
Editor::edit_meter_marker (MeterMarker& mm)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2022-01-18 21:45:18 -05:00
|
|
|
edit_meter_section (const_cast<Temporal::MeterPoint&>(mm.meter()));
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
2022-08-17 18:27:53 -04:00
|
|
|
void
|
|
|
|
Editor::edit_bbt_marker (BBTMarker& bm)
|
|
|
|
{
|
|
|
|
edit_bbt (const_cast<Temporal::MusicTimePoint&>(bm.mt_point()));
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
Editor::real_remove_bbt_marker (MusicTimePoint const * point)
|
|
|
|
{
|
|
|
|
begin_reversible_command (_("remove BBT marker"));
|
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
|
|
|
XMLNode &before = tmap->get_state();
|
|
|
|
tmap->remove_bartime (*point);
|
|
|
|
XMLNode &after = tmap->get_state();
|
|
|
|
_session->add_command (new Temporal::TempoCommand (_("remove BBT marker"), &before, &after));
|
|
|
|
commit_reversible_command ();
|
|
|
|
|
|
|
|
TempoMap::update (tmap);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
gint
|
2022-01-18 21:45:18 -05:00
|
|
|
Editor::real_remove_tempo_marker (TempoPoint const * section)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
|
|
|
begin_reversible_command (_("remove tempo mark"));
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = tmap->get_state();
|
|
|
|
tmap->remove_tempo (*section);
|
|
|
|
XMLNode &after = tmap->get_state();
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("remove tempo change"), &before, &after));
|
2005-09-25 14:42:24 -04:00
|
|
|
commit_reversible_command ();
|
|
|
|
|
2020-12-31 14:05:20 -05:00
|
|
|
TempoMap::update (tmap);
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-11-23 12:21:12 -05:00
|
|
|
Editor::remove_meter_marker (ArdourCanvas::Item* item)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2015-07-23 07:23:47 -04:00
|
|
|
ArdourMarker* marker;
|
2005-09-25 14:42:24 -04:00
|
|
|
MeterMarker* meter_marker;
|
|
|
|
|
2015-07-23 07:23:47 -04:00
|
|
|
if ((marker = reinterpret_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
|
2005-09-25 14:42:24 -04:00
|
|
|
fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((meter_marker = dynamic_cast<MeterMarker*> (marker)) == 0) {
|
|
|
|
fatal << _("programming error: marker for meter is not a meter marker!") << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2020-11-16 13:19:22 -05:00
|
|
|
if (!meter_marker->meter().map().is_initial(meter_marker->meter())) {
|
|
|
|
Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::real_remove_meter_marker), &meter_marker->meter()));
|
2005-09-25 14:42:24 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
2022-01-18 21:45:18 -05:00
|
|
|
Editor::real_remove_meter_marker (Temporal::MeterPoint const * section)
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
|
|
|
begin_reversible_command (_("remove tempo mark"));
|
2022-04-08 11:23:39 -04:00
|
|
|
TempoMap::WritableSharedPtr tmap (TempoMap::write_copy());
|
2020-11-27 14:41:11 -05:00
|
|
|
XMLNode &before = tmap->get_state();
|
|
|
|
tmap->remove_meter (*section);
|
|
|
|
XMLNode &after = tmap->get_state();
|
2022-04-08 13:57:56 -04:00
|
|
|
_session->add_command (new Temporal::TempoCommand (_("remove time signature change"), &before, &after));
|
2005-09-25 14:42:24 -04:00
|
|
|
commit_reversible_command ();
|
2006-08-30 22:28:42 -04:00
|
|
|
|
2020-12-31 14:05:20 -05:00
|
|
|
TempoMap::update (tmap);
|
|
|
|
|
2005-09-25 14:42:24 -04:00
|
|
|
return FALSE;
|
|
|
|
}
|
2022-01-16 00:53:36 -05:00
|
|
|
|
2022-05-02 14:01:12 -04:00
|
|
|
Temporal::TempoMap::WritableSharedPtr
|
2022-01-16 00:53:36 -05:00
|
|
|
Editor::begin_tempo_map_edit ()
|
|
|
|
{
|
2022-05-02 14:01:12 -04:00
|
|
|
TempoMap::WritableSharedPtr wmap = TempoMap::fetch_writable ();
|
|
|
|
reassociate_metric_markers (wmap);
|
|
|
|
return wmap;
|
2022-01-16 00:53:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Editor::abort_tempo_map_edit ()
|
|
|
|
{
|
|
|
|
/* this drops the lock held while we have a writable copy in our per-thread pointer */
|
|
|
|
TempoMap::abort_update ();
|
|
|
|
|
2022-05-10 11:37:30 -04:00
|
|
|
/* Now update our own per-thread copy of the tempo map pointer to be
|
|
|
|
the canonical one, and reconnect markers with elements of that map
|
|
|
|
*/
|
2022-01-16 00:53:36 -05:00
|
|
|
TempoMap::SharedPtr tmap (TempoMap::fetch());
|
|
|
|
reassociate_metric_markers (tmap);
|
|
|
|
}
|
|
|
|
|
2022-06-28 12:16:31 -04:00
|
|
|
void
|
2022-08-16 17:50:45 -04:00
|
|
|
Editor::commit_tempo_map_edit (TempoMap::WritableSharedPtr& new_map, bool with_update)
|
2022-06-28 12:16:31 -04:00
|
|
|
{
|
2022-08-16 17:50:45 -04:00
|
|
|
if (!with_update) {
|
|
|
|
PBD::Unwinder<bool> uw (ignore_map_change, true);
|
|
|
|
TempoMap::update (new_map);
|
|
|
|
} else {
|
|
|
|
TempoMap::update (new_map);
|
|
|
|
}
|
2022-06-28 12:16:31 -04:00
|
|
|
}
|
|
|
|
|
2022-01-18 21:45:18 -05:00
|
|
|
void
|
2022-06-28 00:20:51 -04:00
|
|
|
Editor::mid_tempo_change (MidTempoChanges what_changed)
|
2022-01-18 21:45:18 -05:00
|
|
|
{
|
2022-05-10 13:44:51 -04:00
|
|
|
// std::cerr << "============== MID TEMPO\n";
|
|
|
|
// TempoMap::SharedPtr map (TempoMap::use());
|
|
|
|
// map->dump (std::cerr);
|
2022-06-28 00:20:51 -04:00
|
|
|
|
|
|
|
if (what_changed & TempoChanged) {
|
|
|
|
double min_tempo = DBL_MAX;
|
|
|
|
double max_tempo = 0.0;
|
|
|
|
|
|
|
|
for (auto & t : tempo_marks) {
|
|
|
|
t->update ();
|
|
|
|
|
|
|
|
TempoMarker* tm (dynamic_cast<TempoMarker*> (t));
|
|
|
|
|
|
|
|
max_tempo = max (max_tempo, tm->tempo().note_types_per_minute());
|
|
|
|
max_tempo = max (max_tempo, tm->tempo().end_note_types_per_minute());
|
|
|
|
min_tempo = min (min_tempo, tm->tempo().note_types_per_minute());
|
|
|
|
min_tempo = min (min_tempo, tm->tempo().end_note_types_per_minute());
|
|
|
|
|
|
|
|
}
|
|
|
|
update_tempo_curves (min_tempo, max_tempo, _session->sample_rate());
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto & m : meter_marks) {
|
|
|
|
m->update ();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto & b : bbt_marks) {
|
|
|
|
b->update ();
|
|
|
|
}
|
|
|
|
|
|
|
|
update_tempo_based_rulers ();
|
|
|
|
maybe_draw_grid_lines ();
|
2022-06-28 13:44:25 -04:00
|
|
|
|
|
|
|
foreach_time_axis_view (sigc::mem_fun (*this, &Editor::mid_tempo_per_track_update));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Editor::mid_tempo_per_track_update (TimeAxisView& tav)
|
|
|
|
{
|
|
|
|
MidiTimeAxisView* mtav = dynamic_cast<MidiTimeAxisView*> (&tav);
|
|
|
|
|
|
|
|
if (!mtav) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
MidiStreamView* msv = mtav->midi_view();
|
|
|
|
|
|
|
|
if (!msv) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
msv->foreach_regionview (sigc::mem_fun (*this, &Editor::mid_tempo_per_region_update));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Editor::mid_tempo_per_region_update (RegionView* rv)
|
|
|
|
{
|
|
|
|
rv->redisplay (true);
|
2022-01-18 21:45:18 -05:00
|
|
|
}
|