libs/ardour/template_utils.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <algorithm>
  21 #include <cstring>
  22
  23 #include <glibmm.h>
  24
  25 #include "pbd/file_utils.h"
  26 #include "pbd/stl_delete.h"
  27 #include "pbd/xml++.h"
  28
  29 #include "ardour/template_utils.h"
  30 #include "ardour/directory_names.h"
  31 #include "ardour/filesystem_paths.h"
  32 #include "ardour/filename_extensions.h"
  33 #include "ardour/search_paths.h"
  34 #include "ardour/io.h"
  35
  36 #include "pbd/i18n.h"
  37
  38 using namespace std;
  39 using namespace PBD;
  40
  41 namespace ARDOUR {
  42
  43 std::string
  44 user_template_directory ()
  45 {
  46         return Glib::build_filename (user_config_directory(), templates_dir_name);
  47 }
  48
  49 std::string
  50 user_route_template_directory ()
  51 {
  52         return Glib::build_filename (user_config_directory(), route_templates_dir_name);
  53 }
  54
  55 static bool
  56 template_filter (const string &str, void* /*arg*/)
  57 {
  58         if (!Glib::file_test (str, Glib::FILE_TEST_IS_DIR)) {
  59                 return false;
  60         }
  61
  62         return true;
  63 }
  64
  65 static bool
  66 route_template_filter (const string &str, void* /*arg*/)
  67 {
  68         if (str.find (template_suffix) == str.length() - strlen (template_suffix)) {
  69                 return true;
  70         }
  71
  72         return false;
  73 }
  74
  75 string
  76 session_template_dir_to_file (string const & dir)
  77 {
  78         return Glib::build_filename (dir, Glib::path_get_basename(dir) + template_suffix);
  79 }
  80
  81
  82 void
  83 find_session_templates (vector<TemplateInfo>& template_names, bool read_xml)
  84 {
  85         vector<string> templates;
  86
  87         find_paths_matching_filter (templates, template_search_path(), template_filter, 0, true, true);
  88
  89         if (templates.empty()) {
  90                 cerr << "Found nothing along " << template_search_path().to_string() << endl;
  91                 return;
  92         }
  93
  94         cerr << "Found " << templates.size() << " along " << template_search_path().to_string() << endl;
  95
  96         for (vector<string>::iterator i = templates.begin(); i != templates.end(); ++i) {
  97                 string file = session_template_dir_to_file (*i);
  98
  99                 TemplateInfo rti;
 100                 rti.name = Glib::path_get_basename (*i);
 101                 rti.path = *i;
 102
 103                 if (read_xml) {
 104
 105                         XMLTree tree;
 106                         if (!tree.read (file.c_str())) {
 107                                 cerr << "Failed to parse Route-template XML file: " << file;
 108                                 continue;
 109                         }
 110
 111                         XMLNode* root = tree.root();
 112
 113                         rti.created_with = _("(unknown)");
 114                         try {
 115                                 XMLNode *pv = root->child("ProgramVersion");
 116                                 string created_with;
 117                                 if (pv != 0) {
 118                                         pv->get_property (X_("created-with"), created_with);
 119                                 }
 120                                 rti.created_with = created_with;
 121                         } catch ( LIBPBD_API::XMLException &e) {}
 122
 123                         rti.description = _("No Description");
 124                         try {
 125                                 XMLNode *desc = root->child("description");
 126                                 if (desc != 0) {
 127                                         rti.description = desc->attribute_value();
 128                                 }
 129                         } catch ( LIBPBD_API::XMLException &e) {}
 130                 }
 131
 132                 template_names.push_back (rti);
 133         }
 134 }
 135
 136 void
 137 find_route_templates (vector<TemplateInfo>& template_names)
 138 {
 139         vector<string> templates;
 140
 141         find_files_matching_filter (templates, route_template_search_path(), route_template_filter, 0, false, true);
 142
 143         if (templates.empty()) {
 144                 return;
 145         }
 146
 147         for (vector<string>::iterator i = templates.begin(); i != templates.end(); ++i) {
 148                 string fullpath = *i;
 149
 150                 XMLTree tree;
 151
 152                 if (!tree.read (fullpath.c_str())) {
 153                         cerr << "Failed to parse Route-template XML file: " << fullpath;
 154                         continue;
 155                 }
 156
 157                 XMLNode* root = tree.root();
 158
 159                 TemplateInfo rti;
 160
 161                 rti.created_with = _("(unknown)");
 162                 try {
 163                         XMLNode *pv = root->child("ProgramVersion");
 164                         string created_with;
 165                         if (pv != 0) {
 166                                 pv->get_property (X_("created-with"), created_with);
 167                         }
 168                         rti.created_with = created_with;
 169                 } catch ( LIBPBD_API::XMLException &e) {}
 170
 171                 rti.description = _("No Description");
 172                 try {
 173                         XMLNode *desc = root->child("description");
 174                         if (desc != 0) {
 175                                 rti.description = desc->attribute_value();
 176                         }
 177                 } catch ( LIBPBD_API::XMLException &e) {}
 178
 179                 rti.name = IO::name_from_state (*root->children().front());
 180                 rti.path = fullpath;
 181
 182                 template_names.push_back (rti);
 183         }
 184 }
 185
 186 }