13
0
livetrax/gtk2_ardour/duplicate_routes_dialog.cc

231 lines
5.9 KiB
C++
Raw Normal View History

/*
* Copyright (C) 2015-2019 Paul Davis <paul@linuxaudiosystems.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.
*/
#include "gtkmm/stock.h"
#include "ardour/route.h"
#include "ardour/session.h"
#include "ardour_ui.h"
#include "editor.h"
#include "duplicate_routes_dialog.h"
#include "selection.h"
#include "pbd/i18n.h"
using namespace ARDOUR;
using namespace Gtk;
DuplicateRouteDialog::DuplicateRouteDialog ()
: ArdourDialog (_("Duplicate Tracks/Busses"), false, false)
, playlist_option_label (_("For each Track:"))
, copy_playlists_button (playlist_button_group, _("Copy playlist"))
, new_playlists_button (playlist_button_group, _("New playlist"))
, share_playlists_button (playlist_button_group, _("Share playlist"))
, count_adjustment (1.0, 1.0, 999, 1.0, 10.0)
, count_spinner (count_adjustment)
, count_label (_("Duplicate each track/bus this number of times:"))
{
count_box.pack_start (count_label, false, false);
count_box.pack_start (count_spinner, false, false, 5);
get_vbox()->pack_start (count_box, false, false, 10);
Gtk::HBox* hb = manage (new HBox);
hb->pack_start (playlist_option_label, false, false);
get_vbox()->pack_start (*hb, false, false, 10);
playlist_button_box.pack_start (copy_playlists_button, false, false);
playlist_button_box.pack_start (new_playlists_button, false, false);
playlist_button_box.pack_start (share_playlists_button, false, false);
playlist_button_box.show_all ();
insert_at_combo.append (_("First"));
insert_at_combo.append (_("Before Selection"));
insert_at_combo.append (_("After Selection"));
insert_at_combo.append (_("Last"));
insert_at_combo.set_active (3);
Gtk::Label* l = manage (new Label (_("Insert duplicates at: ")));
Gtk::HBox* b = manage (new HBox);
b->pack_start (*l, false, false, 10);
b->pack_start (insert_at_combo, true, true);
get_vbox()->pack_end (*b, false, false, 10);
get_vbox()->show_all ();
add_button (Stock::CANCEL, RESPONSE_CANCEL);
add_button (Stock::OK, RESPONSE_OK);
}
int
DuplicateRouteDialog::restart (Session* s)
{
if (!s) {
return -1;
}
set_session (s);
TrackSelection& tracks (PublicEditor::instance().get_selection().tracks);
uint32_t ntracks = 0;
uint32_t nbusses = 0;
for (TrackSelection::iterator t = tracks.begin(); t != tracks.end(); ++t) {
RouteUI* rui = dynamic_cast<RouteUI*> (*t);
if (!rui) {
/* some other type of timeaxis view, not a route */
continue;
}
std::shared_ptr<Route> r (rui->route());
if (std::dynamic_pointer_cast<Track> (r)) {
ntracks++;
2023-11-26 22:26:46 -05:00
} else if (!r->is_main_bus()) {
nbusses++;
}
}
if (ntracks == 0 && nbusses == 0) {
std::cerr << "You can't do this\n";
return -1;
}
/* XXX grrr. Gtk Boxes do not shrink when children are removed,
which is what we really want to happen here.
*/
if (playlist_button_box.get_parent()) {
get_vbox()->remove (playlist_button_box);
}
if (ntracks > 0) {
get_vbox()->pack_end (playlist_button_box, false, false);
}
return 0;
}
uint32_t
DuplicateRouteDialog::count() const
{
return count_adjustment.get_value ();
}
ARDOUR::PlaylistDisposition
DuplicateRouteDialog::playlist_disposition() const
{
if (new_playlists_button.get_active()) {
return ARDOUR::NewPlaylist;
} else if (copy_playlists_button.get_active()) {
return ARDOUR::CopyPlaylist;
}
return ARDOUR::SharePlaylist;
}
void
DuplicateRouteDialog::on_response (int response)
{
hide ();
if (response != RESPONSE_OK) {
return;
}
ARDOUR::PlaylistDisposition playlist_action = playlist_disposition ();
uint32_t cnt = count ();
/* Copy the track selection because it will/may change as we add new ones */
TrackSelection tracks (PublicEditor::instance().get_selection().tracks);
int err = 0;
/* Track Selection should be sorted into presentation order before
* duplicating, so that new tracks appear in same order as the
* originals.
*/
StripableList sl;
for (TrackSelection::iterator t = tracks.begin(); t != tracks.end(); ++t) {
RouteUI* rui = dynamic_cast<RouteUI*> (*t);
if (rui) {
sl.push_back (rui->route());
}
}
sl.sort (Stripable::Sorter());
for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
std::shared_ptr<Route> r;
if ((r = std::dynamic_pointer_cast<Route> (*s)) == 0) {
/* some other type of Stripable, not a route */
continue;
}
2023-11-26 22:26:46 -05:00
if ((*s)->is_main_bus ()) {
/* no option to duplicate these */
continue;
}
XMLNode& state (r->get_state());
RouteList rl = _session->new_route_from_template (cnt, ARDOUR_UI::instance()->translate_order (insert_at()), state, std::string(), playlist_action);
/* normally the state node would be added to a parent, and
* ownership would transfer. Because we don't do that here,
* we need to delete the node ourselves.
*/
delete &state;
if (rl.empty()) {
err++;
break;
}
}
if (err) {
MessageDialog msg (_("1 or more tracks/busses could not be duplicated"),
true, MESSAGE_ERROR, BUTTONS_OK, true);
msg.set_position (WIN_POS_MOUSE);
msg.run ();
}
}
RouteDialogs::InsertAt
DuplicateRouteDialog::insert_at ()
{
using namespace RouteDialogs;
std::string str = insert_at_combo.get_active_text();
if (str == _("First")) {
return First;
} else if (str == _("After Selection")) {
return AfterSelection;
} else if (str == _("Before Selection")){
return BeforeSelection;
}
return Last;
}