gtk2_ardour/template_dialog.cc

   1 /*
   2     Copyright (C) 2010 Paul Davis
   3     Author: Johannes Mueller
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <map>
  22 #include <vector>
  23 #include <cerrno>
  24
  25 #include <glib/gstdio.h>
  26
  27 #include <gtkmm/filechooserdialog.h>
  28 #include <gtkmm/frame.h>
  29 #include <gtkmm/liststore.h>
  30 #include <gtkmm/notebook.h>
  31 #include <gtkmm/progressbar.h>
  32 #include <gtkmm/separator.h>
  33 #include <gtkmm/scrolledwindow.h>
  34 #include <gtkmm/stock.h>
  35 #include <gtkmm/textview.h>
  36 #include <gtkmm/treeiter.h>
  37 #include <gtkmm/treeview.h>
  38
  39 #include "pbd/basename.h"
  40 #include "pbd/error.h"
  41 #include "pbd/file_archive.h"
  42 #include "pbd/file_utils.h"
  43 #include "pbd/i18n.h"
  44 #include "pbd/xml++.h"
  45
  46 #include "gtkmm2ext/gui_thread.h"
  47
  48 #include "ardour/filesystem_paths.h"
  49 #include "ardour/template_utils.h"
  50
  51 #include "progress_reporter.h"
  52
  53 #include "template_dialog.h"
  54
  55 using namespace std;
  56 using namespace Gtk;
  57 using namespace PBD;
  58 using namespace ARDOUR;
  59
  60 class TemplateManager : public Gtk::HBox,
  61                         public ProgressReporter
  62 {
  63 public:
  64         virtual ~TemplateManager () {}
  65
  66         virtual void init () = 0;
  67         void handle_dirty_description ();
  68
  69         PBD::Signal0<void> TemplatesImported;
  70
  71 protected:
  72         TemplateManager ();
  73
  74         Gtk::TextView _description_editor;
  75         Gtk::Button _save_desc;
  76
  77         void setup_model (const std::vector<ARDOUR::TemplateInfo>& templates);
  78
  79         void row_selection_changed ();
  80
  81         virtual void delete_selected_template () = 0;
  82         bool adjust_plugin_paths (XMLNode* node, const std::string& name, const std::string& new_name) const;
  83
  84         struct SessionTemplateColumns : public Gtk::TreeModel::ColumnRecord {
  85                 SessionTemplateColumns () {
  86                         add (name);
  87                         add (path);
  88                         add (description);
  89                 }
  90
  91                 Gtk::TreeModelColumn<std::string> name;
  92                 Gtk::TreeModelColumn<std::string> path;
  93                 Gtk::TreeModelColumn<std::string> description;
  94         };
  95
  96         Glib::RefPtr<Gtk::ListStore>  _template_model;
  97         SessionTemplateColumns _template_columns;
  98
  99         Gtk::TreeModel::const_iterator _current_selection;
 100
 101         Gtk::ProgressBar _progress_bar;
 102         std::string _current_action;
 103
 104 private:
 105         void render_template_names (Gtk::CellRenderer* rnd, const Gtk::TreeModel::iterator& it);
 106         void validate_edit (const Glib::ustring& path_string, const Glib::ustring& new_name);
 107         void start_edit ();
 108
 109         void set_desc_dirty ();
 110
 111         bool key_event (GdkEventKey* ev);
 112
 113         virtual void get_templates (vector<TemplateInfo>& templates) const = 0;
 114
 115         virtual void rename_template (Gtk::TreeModel::iterator& item, const Glib::ustring& new_name) = 0;
 116
 117         virtual void save_template_desc ();
 118
 119         void export_all_templates ();
 120         void import_template_set ();
 121
 122         virtual std::string templates_dir () const = 0;
 123         virtual std::string template_file (const Gtk::TreeModel::const_iterator& item) const = 0;
 124
 125         virtual bool adjust_xml_tree (XMLTree& tree, const std::string& old_name, const std::string& new_name) const = 0;
 126
 127         Gtk::TreeView _template_treeview;
 128         Gtk::CellRendererText _validating_cellrenderer;
 129         Gtk::TreeView::Column _validated_column;
 130
 131         bool _desc_dirty;
 132
 133         Gtk::Button _remove_button;
 134         Gtk::Button _rename_button;
 135
 136         Gtk::Button _export_all_templates_button;
 137         Gtk::Button _import_template_set_button;
 138
 139         sigc::connection _cursor_changed_connection;
 140
 141         void update_progress_gui (float p);
 142 };
 143
 144 class SessionTemplateManager : public TemplateManager
 145 {
 146 public:
 147         SessionTemplateManager () : TemplateManager () {}
 148         ~SessionTemplateManager () {}
 149
 150         void init ();
 151
 152         void get_templates (vector<TemplateInfo>& templates) const;
 153
 154 private:
 155         void rename_template (Gtk::TreeModel::iterator& item, const Glib::ustring& new_name);
 156         void delete_selected_template ();
 157
 158         std::string templates_dir () const;
 159         std::string template_file (const Gtk::TreeModel::const_iterator& item) const;
 160
 161         bool adjust_xml_tree (XMLTree& tree, const std::string& old_name, const std::string& new_name) const;
 162 };
 163
 164
 165 class RouteTemplateManager : public TemplateManager
 166 {
 167 public:
 168         RouteTemplateManager () : TemplateManager () {}
 169         ~RouteTemplateManager () {}
 170
 171         void init ();
 172
 173         void get_templates (vector<TemplateInfo>& templates) const;
 174
 175 private:
 176         void rename_template (Gtk::TreeModel::iterator& item, const Glib::ustring& new_name);
 177         void delete_selected_template ();
 178
 179         std::string templates_dir () const;
 180         std::string template_file (const Gtk::TreeModel::const_iterator& item) const;
 181
 182         bool adjust_xml_tree (XMLTree& tree, const std::string& old_name, const std::string& new_name) const;
 183 };
 184
 185
 186
 187 TemplateDialog::TemplateDialog ()
 188         : ArdourDialog ("Manage Templates")
 189 {
 190         Notebook* nb = manage (new Notebook);
 191
 192         SessionTemplateManager* session_tm = manage (new SessionTemplateManager);
 193         nb->append_page (*session_tm, _("Session Templates"));
 194
 195         RouteTemplateManager* route_tm = manage (new RouteTemplateManager);
 196         nb->append_page (*route_tm, _("Track Templates"));
 197
 198         get_vbox()->pack_start (*nb);
 199         add_button (_("Done"), Gtk::RESPONSE_OK);
 200
 201         get_vbox()->show_all();
 202
 203         session_tm->init ();
 204         route_tm->init ();
 205
 206         session_tm->TemplatesImported.connect (*this, invalidator (*this), boost::bind (&RouteTemplateManager::init, route_tm), gui_context ());
 207         route_tm->TemplatesImported.connect (*this, invalidator (*this), boost::bind (&SessionTemplateManager::init, session_tm), gui_context ());
 208
 209         signal_hide().connect (sigc::mem_fun (session_tm, &TemplateManager::handle_dirty_description));
 210         signal_hide().connect (sigc::mem_fun (route_tm, &TemplateManager::handle_dirty_description));
 211         nb->signal_switch_page().connect (sigc::hide (sigc::hide (sigc::mem_fun (session_tm, &TemplateManager::handle_dirty_description))));
 212         nb->signal_switch_page().connect (sigc::hide (sigc::hide (sigc::mem_fun (route_tm, &TemplateManager::handle_dirty_description))));
 213 }
 214
 215 TemplateManager::TemplateManager ()
 216         : HBox ()
 217         , ProgressReporter ()
 218         , _save_desc (_("Save Description"))
 219         , _desc_dirty (false)
 220         , _remove_button (_("Remove"))
 221         , _rename_button (_("Rename"))
 222         , _export_all_templates_button (_("Export all"))
 223         , _import_template_set_button (_("Import"))
 224 {
 225         _template_model = ListStore::create (_template_columns);
 226         _template_treeview.set_model (_template_model);
 227
 228         _validated_column.set_title (_("Template Name"));
 229         _validated_column.pack_start (_validating_cellrenderer);
 230         _template_treeview.append_column (_validated_column);
 231         _validating_cellrenderer.property_editable() = true;
 232
 233         _validated_column.set_cell_data_func (_validating_cellrenderer, sigc::mem_fun (*this, &TemplateManager::render_template_names));
 234         _validating_cellrenderer.signal_edited().connect (sigc::mem_fun (*this, &TemplateManager::validate_edit));
 235         _cursor_changed_connection = _template_treeview.signal_cursor_changed().connect (sigc::mem_fun (*this, &TemplateManager::row_selection_changed));
 236         _template_treeview.signal_key_press_event().connect (sigc::mem_fun (*this, &TemplateManager::key_event));
 237
 238         ScrolledWindow* sw = manage (new ScrolledWindow);
 239         sw->property_hscrollbar_policy() = POLICY_AUTOMATIC;
 240         sw->add (_template_treeview);
 241         sw->set_size_request (300, 200);
 242
 243         VBox* vb_btns = manage (new VBox);
 244         vb_btns->set_spacing (4);
 245         vb_btns->pack_start (_rename_button, false, false);
 246         vb_btns->pack_start (_remove_button, false, false);
 247         vb_btns->pack_start (_save_desc, false, false);
 248
 249         _rename_button.set_sensitive (false);
 250         _rename_button.signal_clicked().connect (sigc::mem_fun (*this, &TemplateManager::start_edit));
 251         _remove_button.set_sensitive (false);
 252         _remove_button.signal_clicked().connect (sigc::mem_fun (*this, &TemplateManager::delete_selected_template));
 253
 254         vb_btns->pack_start (*(manage (new VSeparator ())));
 255
 256         vb_btns->pack_start (_export_all_templates_button, false, false);
 257         vb_btns->pack_start (_import_template_set_button, false, false);
 258
 259         _export_all_templates_button.set_sensitive (false);
 260         _export_all_templates_button.signal_clicked().connect (sigc::mem_fun (*this, &TemplateManager::export_all_templates));
 261
 262         _import_template_set_button.set_sensitive (true);
 263         _import_template_set_button.signal_clicked().connect (sigc::mem_fun (*this, &TemplateManager::import_template_set));
 264
 265         set_spacing (6);
 266
 267         VBox* vb = manage (new VBox);
 268         vb->pack_start (*sw);
 269         vb->pack_start (_progress_bar);
 270
 271         Frame* desc_frame = manage (new Frame (_("Description")));
 272
 273         _description_editor.set_wrap_mode (Gtk::WRAP_WORD);
 274         _description_editor.set_size_request (300,400);
 275         _description_editor.set_border_width (6);
 276
 277         _save_desc.set_sensitive (false);
 278         _save_desc.signal_clicked().connect (sigc::mem_fun (*this, &TemplateManager::save_template_desc));
 279
 280         _description_editor.get_buffer()->signal_changed().connect (sigc::mem_fun (*this, &TemplateManager::set_desc_dirty));
 281
 282         desc_frame->add (_description_editor);
 283
 284         pack_start (*vb);
 285         pack_start (*desc_frame);
 286         pack_start (*vb_btns);
 287
 288         show_all_children ();
 289         _progress_bar.hide ();
 290 }
 291
 292 void
 293 TemplateManager::setup_model (const vector<TemplateInfo>& templates)
 294 {
 295         _template_model->clear ();
 296
 297         for (vector<TemplateInfo>::const_iterator it = templates.begin(); it != templates.end(); ++it) {
 298                 TreeModel::Row row;
 299                 row = *(_template_model->append ());
 300
 301                 row[_template_columns.name] = it->name;
 302                 row[_template_columns.path] = it->path;
 303                 row[_template_columns.description] = it->description;
 304         }
 305
 306         _export_all_templates_button.set_sensitive (!templates.empty ());
 307 }
 308
 309 void
 310 TemplateManager::handle_dirty_description ()
 311 {
 312         if (_desc_dirty && _current_selection) {
 313                 ArdourDialog dlg (_("Description not saved"), true);
 314                 const string name = _current_selection->get_value (_template_columns.name);
 315                 Label msg (string_compose (_("The discription of template \"%1\" has been modfied but has not been saved yet.\n"
 316                                              "Do you want to save it?"), name));
 317                 dlg.get_vbox()->pack_start (msg);
 318                 msg.show ();
 319                 dlg.add_button (_("Save"), RESPONSE_ACCEPT);
 320                 dlg.add_button (_("Discard"), RESPONSE_REJECT);
 321                 dlg.set_default_response (RESPONSE_REJECT);
 322
 323                 int response = dlg.run ();
 324
 325                 if (response == RESPONSE_ACCEPT) {
 326                         save_template_desc ();
 327                 } else {
 328                         _description_editor.get_buffer()->set_text (_current_selection->get_value (_template_columns.description));
 329                 }
 330         }
 331 }
 332
 333 void
 334 TemplateManager::row_selection_changed ()
 335 {
 336         if (_current_selection) {
 337                 handle_dirty_description ();
 338         } else {
 339                 _description_editor.get_buffer()->set_text ("");
 340         }
 341
 342         _current_selection = _template_treeview.get_selection()->get_selected ();
 343         if (_current_selection) {
 344                 const string desc = _current_selection->get_value (_template_columns.description);
 345                 _description_editor.get_buffer()->set_text (desc);
 346         }
 347
 348         _desc_dirty = false;
 349         _save_desc.set_sensitive (false);
 350
 351         _description_editor.set_sensitive (_current_selection);
 352         _rename_button.set_sensitive (_current_selection);
 353         _remove_button.set_sensitive (_current_selection);
 354 }
 355
 356 void
 357 TemplateManager::render_template_names (Gtk::CellRenderer*, const Gtk::TreeModel::iterator& it)
 358 {
 359         if (it) {
 360                 _validating_cellrenderer.property_text () = it->get_value (_template_columns.name);
 361         }
 362 }
 363
 364 void
 365 TemplateManager::validate_edit (const Glib::ustring& path_string, const Glib::ustring& new_name)
 366 {
 367         const TreePath path (path_string);
 368         TreeModel::iterator current = _template_model->get_iter (path);
 369
 370         if (current->get_value (_template_columns.name) == new_name) {
 371                 return;
 372         }
 373
 374         TreeModel::Children rows = _template_model->children ();
 375
 376         bool found = false;
 377         for (TreeModel::Children::const_iterator it = rows.begin(); it != rows.end(); ++it) {
 378                 if (it->get_value (_template_columns.name) == new_name) {
 379                         found = true;
 380                         break;
 381                 }
 382         }
 383
 384         if (found) {
 385                 error << string_compose (_("Template of name \"%1\" already exists"), new_name) << endmsg;
 386                 return;
 387         }
 388
 389
 390         rename_template (current, new_name);
 391 }
 392
 393 void
 394 TemplateManager::start_edit ()
 395 {
 396         TreeModel::Path path;
 397         TreeViewColumn* col;
 398         _template_treeview.get_cursor (path, col);
 399         _cursor_changed_connection.block ();
 400         _template_treeview.set_cursor (path, *col, /*set_editing =*/ true);
 401         _cursor_changed_connection.unblock ();
 402 }
 403
 404 void
 405 TemplateManager::set_desc_dirty ()
 406 {
 407         _desc_dirty = true;
 408         _save_desc.set_sensitive (true);
 409 }
 410
 411 void
 412 TemplateManager::save_template_desc ()
 413 {
 414         const string file_path = template_file (_current_selection);
 415
 416         string desc_txt = _description_editor.get_buffer()->get_text ();
 417         string::reverse_iterator wss = desc_txt.rbegin();
 418         while (wss != desc_txt.rend() && isspace (*wss)) {
 419                 desc_txt.erase (--(wss++).base());
 420         }
 421
 422         _current_selection->set_value (_template_columns.description, desc_txt);
 423
 424         XMLTree tree;
 425
 426         if (!tree.read(file_path)) {
 427                 error << string_compose (_("Could not parse template file \"%1\"."), file_path) << endmsg;
 428                 return;
 429         }
 430
 431         tree.root()->remove_nodes_and_delete (X_("description"));
 432
 433         if (!desc_txt.empty ()) {
 434                 XMLNode* desc = new XMLNode (X_("description"));
 435                 XMLNode* dn = new XMLNode (X_("content"), desc_txt);
 436                 desc->add_child_nocopy (*dn);
 437                 tree.root()->add_child_nocopy (*desc);
 438         }
 439
 440         if (!tree.write ()) {
 441                 error << string_compose(X_("Could not write to template file \"%1\"."), file_path) << endmsg;
 442                 return;
 443         }
 444
 445         _save_desc.set_sensitive (false);
 446         _desc_dirty = false;
 447 }
 448
 449 bool
 450 TemplateManager::key_event (GdkEventKey* ev)
 451 {
 452         if (ev->keyval == GDK_KEY_F2) {
 453                 start_edit ();
 454                 return true;
 455         }
 456         if (ev->keyval == GDK_KEY_Delete) {
 457                 delete_selected_template ();
 458                 return true;
 459         }
 460
 461         return false;
 462 }
 463
 464 static bool
 465 accept_all_files (string const &, void *)
 466 {
 467         return true;
 468 }
 469
 470 static void
 471 _set_progress (Progress* p, size_t n, size_t t)
 472 {
 473         p->set_progress (float (n) / float(t));
 474 }
 475
 476
 477 void
 478 TemplateManager::export_all_templates ()
 479 {
 480         GError* err = NULL;
 481         char* td = g_dir_make_tmp ("ardour-templates-XXXXXX", &err);
 482
 483         if (!td) {
 484                 error << string_compose(_("Could not make tmpdir: %1"), err->message) << endmsg;
 485                 return;
 486         }
 487         const string tmpdir (td);
 488         g_free (td);
 489         g_clear_error (&err);
 490
 491         FileChooserDialog dialog(_("Save Exported Template Archive"), FILE_CHOOSER_ACTION_SAVE);
 492         dialog.set_filename (X_("templates.tar.xz"));
 493
 494         dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 495         dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
 496
 497         FileFilter archive_filter;
 498         archive_filter.add_pattern (X_("*.tar.xz"));
 499         archive_filter.set_name (_("Template archives"));
 500         dialog.add_filter (archive_filter);
 501
 502         int result = dialog.run ();
 503
 504         if (result != RESPONSE_OK || !dialog.get_filename().length()) {
 505                 PBD::remove_directory (tmpdir);
 506                 return;
 507         }
 508
 509         string filename = dialog.get_filename ();
 510         if (filename.compare (filename.size () - 7, 7, ".tar.xz")) {
 511                 filename += ".tar.xz";
 512         }
 513
 514         if (g_file_test (filename.c_str(), G_FILE_TEST_EXISTS)) {
 515                 ArdourDialog dlg (_("File exists"), true);
 516                 Label msg (string_compose (_("The file %1 already exists."), filename));
 517                 dlg.get_vbox()->pack_start (msg);
 518                 msg.show ();
 519                 dlg.add_button (_("Overwrite"), RESPONSE_ACCEPT);
 520                 dlg.add_button (_("Cancel"), RESPONSE_REJECT);
 521                 dlg.set_default_response (RESPONSE_REJECT);
 522
 523                 result = dlg.run ();
 524
 525                 if (result == RESPONSE_REJECT) {
 526                         PBD::remove_directory (tmpdir);
 527                         return;
 528                 }
 529         }
 530
 531         PBD::copy_recurse (templates_dir (), Glib::build_filename (tmpdir, Glib::path_get_basename (templates_dir ())));
 532
 533         vector<string> files;
 534         PBD::find_files_matching_regex (files, tmpdir, string ("\\.template$"), /* recurse = */ true);
 535
 536         vector<string>::const_iterator it;
 537         for (it = files.begin(); it != files.end(); ++it) {
 538                 const string bn = PBD::basename_nosuffix (*it);
 539                 const string old_path = Glib::build_filename (templates_dir (), bn);
 540                 const string new_path = Glib::build_filename ("$TEMPLATEDIR", bn);
 541
 542                 XMLTree tree;
 543                 if (!tree.read (*it)) {
 544                         continue;
 545                 }
 546                 if (adjust_xml_tree (tree, old_path, new_path)) {
 547                         tree.write (*it);
 548                 }
 549         }
 550
 551         find_files_matching_filter (files, tmpdir, accept_all_files, 0, false, true, true);
 552
 553         std::map<std::string, std::string> filemap;
 554         for (it = files.begin(); it != files.end(); ++it) {
 555                 filemap[*it] = it->substr (tmpdir.size()+1, it->size() - tmpdir.size() - 1);
 556         }
 557
 558         _current_action = _("Exporting templates");
 559
 560         PBD::FileArchive ar (filename);
 561         PBD::ScopedConnectionList progress_connection;
 562         ar.progress.connect_same_thread (progress_connection, boost::bind (&_set_progress, this, _1, _2));
 563         ar.create (filemap);
 564
 565         PBD::remove_directory (tmpdir);
 566 }
 567
 568 void
 569 TemplateManager::import_template_set ()
 570 {
 571         FileChooserDialog dialog (_("Import template archives"));
 572         dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 573         dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
 574
 575         FileFilter archive_filter;
 576         archive_filter.add_pattern (X_("*.tar.xz"));
 577         archive_filter.set_name (_("Template archives"));
 578         dialog.add_filter (archive_filter);
 579
 580         int result = dialog.run ();
 581
 582         if (result != RESPONSE_OK || !dialog.get_filename().length()) {
 583                 return;
 584         }
 585
 586         _current_action = _("Importing templates");
 587
 588         FileArchive ar (dialog.get_filename ());
 589         PBD::ScopedConnectionList progress_connection;
 590         ar.progress.connect_same_thread (progress_connection, boost::bind (&_set_progress, this, _1, _2));
 591         ar.inflate (user_config_directory ());
 592
 593         vector<string> files;
 594         PBD::find_files_matching_regex (files, templates_dir (), string ("\\.template$"), /* recurse = */ true);
 595
 596         vector<string>::const_iterator it;
 597         for (it = files.begin(); it != files.end(); ++it) {
 598                 const string bn = PBD::basename_nosuffix (*it);
 599                 const string old_path = Glib::build_filename ("$TEMPLATEDIR", bn);
 600                 const string new_path = Glib::build_filename (templates_dir (), bn);
 601
 602                 XMLTree tree;
 603                 if (!tree.read (*it)) {
 604                         continue;
 605                 }
 606                 if (adjust_xml_tree (tree, old_path, new_path)) {
 607                         tree.write (*it);
 608                 }
 609         }
 610
 611         init ();
 612         TemplatesImported (); /* emit signal */
 613 }
 614
 615 bool
 616 TemplateManager::adjust_plugin_paths (XMLNode* node, const string& name, const string& new_name) const
 617 {
 618         bool adjusted = false;
 619
 620         const XMLNodeList& procs = node->children (X_("Processor"));
 621         XMLNodeConstIterator pit;
 622         for (pit = procs.begin(); pit != procs.end(); ++pit) {
 623                 XMLNode* lv2_node = (*pit)->child (X_("lv2"));
 624                 if (!lv2_node) {
 625                         continue;
 626                 }
 627                 string template_dir;
 628
 629                 if (!lv2_node->get_property (X_("template-dir"), template_dir)) {
 630                         continue;
 631                 }
 632
 633                 const int suffix_pos = template_dir.size() - name.size();
 634                 if (suffix_pos < 0) {
 635                         cerr << "Template name\"" << name << "\" longer than template-dir \"" << template_dir << "\", WTH?" << endl;
 636                         continue;
 637                 }
 638
 639                 if (template_dir.compare (suffix_pos, template_dir.size(), name)) {
 640                         cerr << "Template name \"" << name << "\" no suffix of template-dir \"" << template_dir << "\"" << endl;
 641                         continue;
 642                 }
 643
 644                 const string new_template_dir = template_dir.substr (0, suffix_pos) + new_name;
 645                 lv2_node->set_property (X_("template-dir"), new_template_dir);
 646
 647                 adjusted = true;
 648         }
 649
 650         return adjusted;
 651 }
 652
 653 void
 654 TemplateManager::update_progress_gui (float p)
 655 {
 656         if (p >= 1.0) {
 657                 _progress_bar.hide ();
 658                 return;
 659         }
 660
 661         _progress_bar.show ();
 662         _progress_bar.set_text (_current_action);
 663         _progress_bar.set_fraction (p);
 664 }
 665
 666 void
 667 SessionTemplateManager::init ()
 668 {
 669         vector<TemplateInfo> templates;
 670         get_templates (templates);
 671         setup_model (templates);
 672
 673         _progress_bar.hide ();
 674         _description_editor.set_sensitive (false);
 675         _save_desc.set_sensitive (false);
 676 }
 677
 678 void
 679 RouteTemplateManager::init ()
 680 {
 681         vector<TemplateInfo> templates;
 682         get_templates (templates);
 683         setup_model (templates);
 684
 685         _progress_bar.hide ();
 686         _description_editor.set_sensitive (false);
 687         _save_desc.set_sensitive (false);
 688 }
 689
 690 void
 691 SessionTemplateManager::get_templates (vector<TemplateInfo>& templates) const
 692 {
 693         find_session_templates (templates, /* read_xml = */ true);
 694 }
 695
 696 void
 697 RouteTemplateManager::get_templates (vector<TemplateInfo>& templates) const
 698 {
 699         find_route_templates (templates);
 700 }
 701
 702 #include <cerrno>
 703
 704 void
 705 SessionTemplateManager::rename_template (TreeModel::iterator& item, const Glib::ustring& new_name_)
 706 {
 707         const string old_path = item->get_value (_template_columns.path);
 708         const string old_name = item->get_value (_template_columns.name);
 709         const string new_name = string (new_name_);
 710
 711         const string old_file_old_path = Glib::build_filename (old_path, old_name+".template");
 712
 713         XMLTree tree;
 714
 715         if (!tree.read(old_file_old_path)) {
 716                 error << string_compose (_("Could not parse template file \"%1\"."), old_file_old_path) << endmsg;
 717                 return;
 718         }
 719         XMLNode* root = tree.root();
 720
 721         const XMLNode* const routes_node = root->child (X_("Routes"));
 722         if (routes_node) {
 723                 const XMLNodeList& routes = routes_node->children (X_("Route"));
 724                 XMLNodeConstIterator rit;
 725                 for (rit = routes.begin(); rit != routes.end(); ++rit) {
 726                         adjust_plugin_paths (*rit, old_name, new_name);
 727                 }
 728         }
 729
 730         const string new_file_old_path = Glib::build_filename (old_path, new_name+".template");
 731
 732         tree.set_filename (new_file_old_path);
 733
 734         if (!tree.write ()) {
 735                 error << string_compose(_("Could not write to new template file \"%1\"."), new_file_old_path);
 736                 return;
 737         }
 738
 739         const string new_path = Glib::build_filename (user_template_directory (), new_name);
 740
 741         if (g_rename (old_path.c_str(), new_path.c_str()) != 0) {
 742                 error << string_compose (_("Could not rename template directory from \"%1\" to \"%2\": %3"),
 743                                          old_path, new_path, strerror (errno)) << endmsg;
 744                 g_unlink (new_file_old_path.c_str());
 745                 return;
 746         }
 747
 748         const string old_file_new_path = Glib::build_filename (new_path, old_name+".template");
 749         if (g_unlink (old_file_new_path.c_str())) {
 750                 error << string_compose (X_("Could not delete old template file \"%1\": %2"),
 751                                          old_file_new_path, strerror (errno)) << endmsg;
 752         }
 753
 754         item->set_value (_template_columns.name, new_name);
 755         item->set_value (_template_columns.path, new_path);
 756 }
 757
 758 void
 759 SessionTemplateManager::delete_selected_template ()
 760 {
 761         if (!_current_selection) {
 762                 return;
 763         }
 764
 765         PBD::remove_directory (_current_selection->get_value (_template_columns.path));
 766
 767         _template_model->erase (_current_selection);
 768         _current_selection = TreeIter ();
 769         row_selection_changed ();
 770 }
 771
 772 string
 773 SessionTemplateManager::templates_dir () const
 774 {
 775         return user_template_directory ();
 776 }
 777
 778
 779 string
 780 SessionTemplateManager::template_file (const TreeModel::const_iterator& item) const
 781 {
 782         const string path = item->get_value (_template_columns.path);
 783         const string name = item->get_value (_template_columns.name);
 784         return Glib::build_filename (path, name+".template");
 785 }
 786
 787 bool
 788 SessionTemplateManager::adjust_xml_tree (XMLTree& tree, const std::string& old_name, const std::string& new_name) const
 789 {
 790         bool adjusted = false;
 791         XMLNode* root = tree.root();
 792
 793         const XMLNode* const routes_node = root->child (X_("Routes"));
 794         if (routes_node) {
 795                 const XMLNodeList& routes = routes_node->children (X_("Route"));
 796                 XMLNodeConstIterator rit;
 797                 for (rit = routes.begin(); rit != routes.end(); ++rit) {
 798                         if (adjust_plugin_paths (*rit, old_name, new_name)) {
 799                                 adjusted = true;
 800                         }
 801                 }
 802         }
 803
 804         return adjusted;
 805 }
 806
 807
 808 void
 809 RouteTemplateManager::rename_template (TreeModel::iterator& item, const Glib::ustring& new_name)
 810 {
 811         const string old_name = item->get_value (_template_columns.name);
 812         const string old_filepath = item->get_value (_template_columns.path);
 813         const string new_filepath = Glib::build_filename (user_route_template_directory(), new_name+".template");
 814
 815         XMLTree tree;
 816         if (!tree.read (old_filepath)) {
 817                 error << string_compose (_("Could not parse template file \"%1\"."), old_filepath) << endmsg;
 818                 return;
 819         }
 820         tree.root()->set_property (X_("name"), new_name);
 821         tree.root()->children().front()->set_property (X_("name"), new_name);
 822
 823         const bool adjusted = adjust_plugin_paths (tree.root(), old_name, string (new_name));
 824
 825         const string old_state_dir = Glib::build_filename (user_route_template_directory(), old_name);
 826         const string new_state_dir = Glib::build_filename (user_route_template_directory(), new_name);
 827
 828         if (adjusted) {
 829                 if (g_file_test (old_state_dir.c_str(), G_FILE_TEST_EXISTS)) {
 830                         if (g_rename (old_state_dir.c_str(), new_state_dir.c_str()) != 0) {
 831                                 error << string_compose (_("Could not rename state dir \"%1\" to \"%22\": %3"), old_state_dir, new_state_dir, strerror (errno)) << endmsg;
 832                                 return;
 833                         }
 834                 }
 835         }
 836
 837         tree.set_filename (new_filepath);
 838
 839         if (!tree.write ()) {
 840                 error << string_compose(_("Could not write new template file \"%1\"."), new_filepath) << endmsg;
 841                 if (adjusted) {
 842                         g_rename (new_state_dir.c_str(), old_state_dir.c_str());
 843                 }
 844                 return;
 845         }
 846
 847         if (g_unlink (old_filepath.c_str()) != 0) {
 848                 error << string_compose (_("Could not remove old template file \"%1\": %2"), old_filepath, strerror (errno)) << endmsg;
 849         }
 850
 851         item->set_value (_template_columns.name, string (new_name));
 852         item->set_value (_template_columns.path, new_filepath);
 853 }
 854
 855 void
 856 RouteTemplateManager::delete_selected_template ()
 857 {
 858         if (!_current_selection) {
 859                 return;
 860         }
 861
 862         const string file_path = _current_selection->get_value (_template_columns.path);
 863
 864         if (g_unlink (file_path.c_str()) != 0) {
 865                 error << string_compose(_("Could not delete template file \"%1\": %2"), file_path, strerror (errno)) << endmsg;
 866                 return;
 867         }
 868         PBD::remove_directory (Glib::build_filename (user_route_template_directory (),
 869                                                      _current_selection->get_value (_template_columns.name)));
 870
 871         _template_model->erase (_current_selection);
 872         row_selection_changed ();
 873 }
 874
 875 string
 876 RouteTemplateManager::templates_dir () const
 877 {
 878         return user_route_template_directory ();
 879 }
 880
 881
 882 string
 883 RouteTemplateManager::template_file (const TreeModel::const_iterator& item) const
 884 {
 885         return item->get_value (_template_columns.path);
 886 }
 887
 888 bool
 889 RouteTemplateManager::adjust_xml_tree (XMLTree& tree, const std::string& old_name, const std::string& new_name) const
 890 {
 891         return adjust_plugin_paths (tree.root(), old_name, string (new_name));
 892 }