/[svn]/linuxsampler/trunk/src/db/InstrumentsDb.cpp

Diff of /linuxsampler/trunk/src/db/InstrumentsDb.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 1161 by iliev,
Mon Apr 16 15:51:18 2007 UTC
+revision 1781 by iliev,
Mon Sep 29 18:21:21 2008 UTC
 Line 1
  /***************************************************************************
   *                                                                         *
-  *   Copyright (C) 2007 Grigor Iliev                                       *
+  *   Copyright (C) 2007, 2008 Grigor Iliev                                 *
   *                                                                         *
   *   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  *
 Line 20
  #include "InstrumentsDb.h"
- #if HAVE_SQLITE3
+ #include "../common/File.h"
+ #include "../common/global_private.h"
  #include <iostream>
  #include <sstream>
- #include <dirent.h>
+ #include <vector>
  #include <errno.h>
- #include <ftw.h>
+ #include <fnmatch.h>
  #include "../common/Exception.h"
  namespace LinuxSampler {
-     void DbInstrument::Copy(const DbInstrument& Instr) {
+     InstrumentsDb InstrumentsDb::instance;
-         if (this == &Instr) return;
-         InstrFile = Instr.InstrFile;
-         InstrNr = Instr.InstrNr;
-         FormatFamily = Instr.FormatFamily;
-         FormatVersion = Instr.FormatVersion;
-         Size = Instr.Size;
-         Created = Instr.Created;
-         Modified = Instr.Modified;
-         Description = Instr.Description;
-         IsDrum = Instr.IsDrum;
-         Product = Instr.Product;
-         Artists = Instr.Artists;
-         Keywords = Instr.Keywords;
-     }
-     void DbDirectory::Copy(const DbDirectory& Dir) {
+     void InstrumentsDb::CreateInstrumentsDb(String FilePath) {
-         if (this == &Dir) return;
+         File f = File(FilePath);
+         if (f.Exist()) {
-         Created = Dir.Created;
+             throw Exception("File exists: " + FilePath);
-         Modified = Dir.Modified;
+         }
-         Description = Dir.Description;
+         GetInstrumentsDb()->SetDbFile(FilePath);
+         String sql =
+             "  CREATE TABLE instr_dirs (                                      "
+             "      dir_id         INTEGER PRIMARY KEY AUTOINCREMENT,          "
+             "      parent_dir_id  INTEGER DEFAULT 0,                          "
+             "      dir_name       TEXT,                                       "
+             "      created        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,        "
+             "      modified       TIMESTAMP DEFAULT CURRENT_TIMESTAMP,        "
+             "      description    TEXT,                                       "
+             "      FOREIGN KEY(parent_dir_id) REFERENCES instr_dirs(dir_id),  "
+             "      UNIQUE (parent_dir_id,dir_name)                            "
+             "  );                                                             ";
+         GetInstrumentsDb()->ExecSql(sql);
+         sql = "INSERT INTO instr_dirs (dir_id, parent_dir_id, dir_name) VALUES (0, -2, '/');";
+         GetInstrumentsDb()->ExecSql(sql);
+         sql =
+             "  CREATE TABLE instruments (                                "
+             "      instr_id        INTEGER PRIMARY KEY AUTOINCREMENT,    "
+             "      dir_id          INTEGER DEFAULT 0,                    "
+             "      instr_name      TEXT,                                 "
+             "      instr_file      TEXT,                                 "
+             "      instr_nr        INTEGER,                              "
+             "      format_family   TEXT,                                 "
+             "      format_version  TEXT,                                 "
+             "      instr_size      INTEGER,                              "
+             "      created         TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  "
+             "      modified        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  "
+             "      description     TEXT,                                 "
+             "      is_drum         INTEGER(1),                           "
+             "      product         TEXT,                                 "
+             "      artists         TEXT,                                 "
+             "      keywords        TEXT,                                 "
+             "      FOREIGN KEY(dir_id) REFERENCES instr_dirs(dir_id),    "
+             "      UNIQUE (dir_id,instr_name)                            "
+             "  );                                                        ";
+         GetInstrumentsDb()->ExecSql(sql);
      }
-     InstrumentsDb* InstrumentsDb::pInstrumentsDb = new InstrumentsDb;
      InstrumentsDb::InstrumentsDb() {
          db = NULL;
          DbInstrumentsMutex = Mutex();
+         InTransaction = false;
      }
      InstrumentsDb::~InstrumentsDb() {
          if (db != NULL) sqlite3_close(db);
      }
-     void InstrumentsDb::Destroy() {
-         if (pInstrumentsDb != NULL) {
-             delete pInstrumentsDb;
-             pInstrumentsDb = NULL;
-         }
-     }
      void InstrumentsDb::AddInstrumentsDbListener(InstrumentsDb::Listener* l) {
          llInstrumentsDbListeners.AddListener(l);
      }
-Line 85 
 namespace LinuxSampler {
+Line 103 
 namespace LinuxSampler {
      }
      InstrumentsDb* InstrumentsDb::GetInstrumentsDb() {
-         return pInstrumentsDb;
+         return &instance;
      }
      void InstrumentsDb::SetDbFile(String File) {
-Line 101 
 namespace LinuxSampler {
+Line 119 
 namespace LinuxSampler {
      sqlite3* InstrumentsDb::GetDb() {
          if ( db != NULL) return db;
-         if (DbFile.empty()) DbFile = "/var/lib/linuxsampler/instruments.db";
+         if (DbFile.empty()) DbFile = CONFIG_DEFAULT_INSTRUMENTS_DB_LOCATION;
+                 #if defined(__APPLE__)  /* 20071224 Toshi Nagata  */
+                 if (DbFile.find("~") == 0)
+                         DbFile.replace(0, 1, getenv("HOME"));
+                 #endif
          int rc = sqlite3_open(DbFile.c_str(), &db);
          if (rc) {
              sqlite3_close(db);
              db = NULL;
              throw Exception("Cannot open instruments database: " + DbFile);
          }
+         rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8, NULL, Regexp, NULL, NULL);
+         if (rc) { throw Exception("Failed to add user function for handling regular expressions."); }
+         // TODO: remove this in the next version
+         try {
+             int i = ExecSqlInt("SELECT parent_dir_id FROM instr_dirs WHERE dir_id=0");
+             // The parent ID of the root directory should be -2 now.
+             if(i != -2) ExecSql("UPDATE instr_dirs SET parent_dir_id=-2 WHERE dir_id=0");
+         } catch(Exception e) { }
+         ////////////////////////////////////////
          return db;
      }
-Line 121 
 namespace LinuxSampler {
+Line 153 
 namespace LinuxSampler {
          int count = ExecSqlInt(sql.str());
-         // While the root dir has ID 0 and parent ID 0, the directory
-         // count for the root dir will be incorrect, so we should fix it.
-         if (count != -1 && DirId == 0) count--;
          return count;
      }
-     int InstrumentsDb::GetDirectoryCount(String Dir) {
+     int InstrumentsDb::GetDirectoryCount(String Dir, bool Recursive) {
-         dmsg(2,("InstrumentsDb: GetDirectoryCount(Dir=%s)\n", Dir.c_str()));
+         dmsg(2,("InstrumentsDb: GetDirectoryCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
          int i;
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
-         try { i = GetDirectoryCount(GetDirectoryId(Dir)); }
+         try {
-         catch (Exception e) {
+             if (Recursive) {
-             DbInstrumentsMutex.Unlock();
+                 DirectoryCounter directoryCounter;
+                 DirectoryTreeWalk(Dir, &directoryCounter);
+                 i = directoryCounter.GetDirectoryCount();
+             } else {
+                 i = GetDirectoryCount(GetDirectoryId(Dir));
+             }
+         } catch (Exception e) {
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
-         if (i == -1) throw Exception("Unkown DB directory: " + Dir);
+         if (i == -1) throw Exception("Unkown DB directory: " + toEscapedPath(Dir));
          return i;
      }
-Line 151 
 namespace LinuxSampler {
+Line 187 
 namespace LinuxSampler {
          return ExecSqlIntList(sql.str());
      }
-     StringListPtr InstrumentsDb::GetDirectories(String Dir) {
+     StringListPtr InstrumentsDb::GetDirectories(String Dir, bool Recursive) {
-         dmsg(2,("InstrumentsDb: GetDirectories(Dir=%s)\n", Dir.c_str()));
+         dmsg(2,("InstrumentsDb: GetDirectories(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(Dir);
-             if(dirId == -1) throw Exception("Unknown DB directory: " + Dir);
+             if(dirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
-             std::stringstream sql;
-             sql << "SELECT dir_name FROM instr_dirs ";
-             sql << "WHERE parent_dir_id=" << dirId << " AND dir_id!=0";
-             DbInstrumentsMutex.Unlock();
+             StringListPtr pDirs;
-             return ExecSqlStringList(sql.str());
+             if (Recursive) {
+                 SearchQuery q;
+                 DirectoryFinder directoryFinder(&q);
+                 DirectoryTreeWalk(Dir, &directoryFinder);
+                 pDirs = directoryFinder.GetDirectories();
+             } else {
+                 pDirs = GetDirectories(dirId);
+             }
+             EndTransaction();
+             return pDirs;
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
      }
+     StringListPtr InstrumentsDb::GetDirectories(int DirId) {
+         std::stringstream sql;
+         sql << "SELECT dir_name FROM instr_dirs ";
+         sql << "WHERE parent_dir_id=" << DirId << " AND dir_id!=0";
+         StringListPtr dirs = ExecSqlStringList(sql.str());
+         for (int i = 0; i < dirs->size(); i++) {
+             for (int j = 0; j < dirs->at(i).length(); j++) {
+                 if (dirs->at(i).at(j) == '/') dirs->at(i).at(j) = '\0';
+             }
+         }
+         return dirs;
+     }
      int InstrumentsDb::GetDirectoryId(String Dir) {
          dmsg(2,("InstrumentsDb: GetDirectoryId(Dir=%s)\n", Dir.c_str()));
-Line 197 
 namespace LinuxSampler {
+Line 253 
 namespace LinuxSampler {
      int InstrumentsDb::GetDirectoryId(int ParentDirId, String DirName) {
          dmsg(2,("InstrumentsDb: GetDirectoryId(ParentDirId=%d, DirName=%s)\n", ParentDirId, DirName.c_str()));
+         DirName = toDbName(DirName);
          std::stringstream sql;
          sql << "SELECT dir_id FROM instr_dirs WHERE parent_dir_id=";
          sql << ParentDirId << " AND dir_name=?";
          return ExecSqlInt(sql.str(), DirName);
      }
+     int InstrumentsDb::GetDirectoryId(int InstrId) {
+         dmsg(2,("InstrumentsDb: GetDirectoryId(InstrId=%d)\n", InstrId));
+         std::stringstream sql;
+         sql << "SELECT dir_id FROM instruments WHERE instr_id=" << InstrId;
+         return ExecSqlInt(sql.str());
+     }
+     String InstrumentsDb::GetDirectoryName(int DirId) {
+         String sql = "SELECT dir_name FROM instr_dirs WHERE dir_id=" + ToString(DirId);
+         String name = ExecSqlString(sql);
+         if (name.empty()) throw Exception("Directory ID not found");
+         return name;
+     }
+     int InstrumentsDb::GetParentDirectoryId(int DirId) {
+         if (DirId == 0) throw Exception("The root directory is specified");
+         String sql = "SELECT parent_dir_id FROM instr_dirs WHERE dir_id=" + ToString(DirId);
+         int parentId = ExecSqlInt(sql);
+         if (parentId == -1) throw Exception("DB directory not found");
+         return parentId;
+     }
+     String InstrumentsDb::GetDirectoryPath(int DirId) {
+         String path = "";
+         int count = 1000; // used to prevent infinite loops
+         while(--count) {
+             if (DirId == 0) {
+                 path = "/" + path;
+                 break;
+             }
+             path = GetDirectoryName(DirId) + "/" + path;
+             DirId = GetParentDirectoryId(DirId);
+         }
+         if (!count) throw Exception("Possible infinite loop detected");
+         return path;
+     }
+     StringListPtr InstrumentsDb::GetInstrumentsByFile(String File) {
+         dmsg(2,("InstrumentsDb: GetInstrumentsByFile(File=%s)\n", File.c_str()));
+         StringListPtr instrs(new std::vector<String>);
+         BeginTransaction();
+         try {
+             File = toEscapedFsPath(File);
+             IntListPtr ids = ExecSqlIntList("SELECT instr_id FROM instruments WHERE instr_file=?", File);
+             for (int i = 0; i < ids->size(); i++) {
+                 String name = GetInstrumentName(ids->at(i));
+                 String dir = GetDirectoryPath(GetDirectoryId(ids->at(i)));
+                 instrs->push_back(dir + name);
+             }
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+         return instrs;
+     }
      void InstrumentsDb::AddDirectory(String Dir) {
          dmsg(2,("InstrumentsDb: AddDirectory(Dir=%s)\n", Dir.c_str()));
          CheckPathName(Dir);
          String ParentDir = GetParentDirectory(Dir);
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              if (Dir.length() > 1) {
                  if (Dir.at(Dir.length() - 1) == '/') Dir.erase(Dir.length() - 1);
-Line 216 
 namespace LinuxSampler {
+Line 337 
 namespace LinuxSampler {
              String dirName = GetFileName(Dir);
              if(ParentDir.empty() || dirName.empty()) {
-                 throw Exception("Failed to add DB directory: " + Dir);
+                 throw Exception("Failed to add DB directory: " + toEscapedPath(Dir));
              }
              int id = GetDirectoryId(ParentDir);
-             if (id == -1) throw Exception("DB directory doesn't exist: " + ParentDir);
+             if (id == -1) throw Exception("DB directory doesn't exist: " + toEscapedPath(ParentDir));
              int id2 = GetDirectoryId(id, dirName);
-             if (id2 != -1) throw Exception("DB directory already exist: " + Dir);
+             if (id2 != -1) throw Exception("DB directory already exist: " + toEscapedPath(Dir));
+             id2 = GetInstrumentId(id, dirName);
+             if (id2 != -1) throw Exception("Instrument with that name exist: " + toEscapedPath(Dir));
              std::stringstream sql;
              sql << "INSERT INTO instr_dirs (parent_dir_id, dir_name) VALUES (";
              sql << id << ", ?)";
-             ExecSql(sql.str(), dirName);
+             ExecSql(sql.str(), toDbName(dirName));
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireDirectoryCountChanged(ParentDir);
      }
-Line 244 
 namespace LinuxSampler {
+Line 367 
 namespace LinuxSampler {
          String ParentDir = GetParentDirectory(Dir);
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(Dir);
-             if (dirId == -1) throw Exception("Unknown DB directory: " + Dir);
+             if (dirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
              if (dirId == 0) throw Exception("Cannot delete the root directory: " + Dir);
              if(ParentDir.empty()) throw Exception("Unknown parent directory");
              if (Force) RemoveDirectoryContent(dirId);
              RemoveDirectory(dirId);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireDirectoryCountChanged(ParentDir);
      }
-Line 330 
 namespace LinuxSampler {
+Line 453 
 namespace LinuxSampler {
          dmsg(2,("InstrumentsDb: GetDirectoryInfo(Dir=%s)\n", Dir.c_str()));
          DbDirectory d;
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int id = GetDirectoryId(Dir);
-             if(id == -1) throw Exception("Unknown DB directory: " + Dir);
+             if(id == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
              sqlite3_stmt *pStmt = NULL;
              std::stringstream sql;
-Line 357 
 namespace LinuxSampler {
+Line 480 
 namespace LinuxSampler {
                  if (res != SQLITE_DONE) {
                      throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
                  } else {
-                     throw Exception("Unknown DB directory: " + Dir);
+                     throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
                  }
              }
              sqlite3_finalize(pStmt);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          return d;
      }
      void InstrumentsDb::RenameDirectory(String Dir, String Name) {
          dmsg(2,("InstrumentsDb: RenameDirectory(Dir=%s,Name=%s)\n", Dir.c_str(), Name.c_str()));
          CheckFileName(Name);
+         String dbName = toDbName(Name);
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(Dir);
-             if (dirId == -1) throw Exception("Unknown DB directory: " + Dir);
+             if (dirId == -1) throw Exception("Unknown DB directory: " + toEscapedText(Dir));
              std::stringstream sql;
              sql << "SELECT parent_dir_id FROM instr_dirs WHERE dir_id=" <<  dirId;
              int parent = ExecSqlInt(sql.str());
-             if (parent == -1) throw Exception("Unknown parent directory: " + Dir);
+             if (parent == -1) throw Exception("Unknown parent directory: " + toEscapedPath(Dir));
-             if (GetDirectoryId(parent, Name) != -1) {
-                 throw Exception("Cannot rename. Directory with that name already exists: " + Name);
+             if (GetDirectoryId(parent, dbName) != -1) {
+                 String s = toEscapedPath(Name);
+                 throw Exception("Cannot rename. Directory with that name already exists: " + s);
+             }
+             if (GetInstrumentId(parent, dbName) != -1) {
+                 throw Exception("Cannot rename. Instrument with that name exist: " + toEscapedPath(Dir));
              }
              sql.str("");
              sql << "UPDATE instr_dirs SET dir_name=? WHERE dir_id=" << dirId;
-             ExecSql(sql.str(), Name);
+             ExecSql(sql.str(), dbName);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
-         FireDirectoryNameChanged(Dir, Name);
+         FireDirectoryNameChanged(Dir, toAbstractName(Name));
      }
      void InstrumentsDb::MoveDirectory(String Dir, String Dst) {
          dmsg(2,("InstrumentsDb: MoveDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
+         if(Dir.compare("/") == 0) throw Exception("Cannot move the root directory");
          String ParentDir = GetParentDirectory(Dir);
          if(ParentDir.empty()) throw Exception("Unknown parent directory");
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(Dir);
-             if (dirId == -1) throw Exception("Unknown DB directory: " + Dir);
+             if (dirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
              int dstId = GetDirectoryId(Dst);
-             if (dstId == -1) throw Exception("Unknown DB directory: " + Dst);
+             if (dstId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dst));
              if (dirId == dstId) {
                  throw Exception("Cannot move directory to itself");
              }
-Line 423 
 namespace LinuxSampler {
+Line 554 
 namespace LinuxSampler {
                      throw Exception("Cannot move a directory to a subdirectory of itself.");
                  }
              }
+             Dir.erase(Dir.length() - 1);
+             String dirName = GetFileName(Dir);
+             int id2 = GetDirectoryId(dstId, dirName);
+             if (id2 != -1) throw Exception("DB directory already exist: " + toEscapedPath(dirName));
+             id2 = GetInstrumentId(dstId, dirName);
+             if (id2 != -1) throw Exception("Instrument with that name exist: " + toEscapedPath(dirName));
              std::stringstream sql;
              sql << "UPDATE instr_dirs SET parent_dir_id=" << dstId;
              sql << " WHERE dir_id=" << dirId;
              ExecSql(sql.str());
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireDirectoryCountChanged(ParentDir);
          FireDirectoryCountChanged(Dst);
      }
+     void InstrumentsDb::CopyDirectory(String Dir, String Dst) {
+         dmsg(2,("InstrumentsDb: CopyDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
+         if(Dir.compare("/") == 0) throw Exception("Cannot copy the root directory");
+         String ParentDir = GetParentDirectory(Dir);
+         if(ParentDir.empty()) throw Exception("Unknown parent directory");
+         BeginTransaction();
+         try {
+             int dirId = GetDirectoryId(Dir);
+             if (dirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
+             int dstId = GetDirectoryId(Dst);
+             if (dstId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dst));
+             if (dirId == dstId) {
+                 throw Exception("Cannot copy directory to itself");
+             }
+             if (Dir.at(Dir.length() - 1) != '/') Dir.append("/");
+             if (Dst.length() > Dir.length()) {
+                 if (Dir.compare(Dst.substr(0, Dir.length())) == 0) {
+                     throw Exception("Cannot copy a directory to a subdirectory of itself.");
+                 }
+             }
+             Dir.erase(Dir.length() - 1);
+             String dirName = GetFileName(Dir);
+             int id2 = GetDirectoryId(dstId, dirName);
+             if (id2 != -1) throw Exception("DB directory already exist: " + toEscapedPath(dirName));
+             id2 = GetInstrumentId(dstId, dirName);
+             if (id2 != -1) throw Exception("Instrument with that name exist: " + toEscapedPath(dirName));
+             DirectoryCopier directoryCopier(ParentDir, Dst);
+             DirectoryTreeWalk(Dir, &directoryCopier);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+     }
      void InstrumentsDb::SetDirectoryDescription(String Dir, String Desc) {
          dmsg(2,("InstrumentsDb: SetDirectoryDescription(Dir=%s,Desc=%s)\n", Dir.c_str(), Desc.c_str()));
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int id = GetDirectoryId(Dir);
-             if(id == -1) throw Exception("Unknown DB directory: " + Dir);
+             if(id == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
              std::stringstream sql;
              sql << "UPDATE instr_dirs SET description=?,modified=CURRENT_TIMESTAMP ";
-Line 452 
 namespace LinuxSampler {
+Line 633 
 namespace LinuxSampler {
              ExecSql(sql.str(), Desc);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireDirectoryInfoChanged(Dir);
      }
-     void InstrumentsDb::AddInstruments(String DbDir, String FilePath, int Index) {
+     int InstrumentsDb::AddInstruments(ScanMode Mode, String DbDir, String FsDir, bool bBackground, bool insDir) {
-         dmsg(2,("InstrumentsDb: AddInstruments(DbDir=%s,FilePath=%s,Index=%d)\n", DbDir.c_str(), FilePath.c_str(), Index));
+         dmsg(2,("InstrumentsDb: AddInstruments(Mode=%d,DbDir=%s,FsDir=%s,bBackground=%d,insDir=%d)\n", Mode, DbDir.c_str(), FsDir.c_str(), bBackground, insDir));
+         if(!bBackground) {
+             switch (Mode) {
+                 case NON_RECURSIVE:
+                     AddInstrumentsNonrecursive(DbDir, FsDir, insDir);
+                     break;
+                 case RECURSIVE:
+                     AddInstrumentsRecursive(DbDir, FsDir, false, insDir);
+                     break;
+                 case FLAT:
+                     AddInstrumentsRecursive(DbDir, FsDir, true, insDir);
+                     break;
+                 default:
+                     throw Exception("Unknown scan mode");
+             }
+             return -1;
+         }
+         ScanJob job;
+         int jobId = Jobs.AddJob(job);
+         InstrumentsDbThread.Execute(new AddInstrumentsJob(jobId, Mode, DbDir, FsDir, insDir));
+         return jobId;
+     }
+     int InstrumentsDb::AddInstruments(String DbDir, String FilePath, int Index, bool bBackground) {
+         dmsg(2,("InstrumentsDb: AddInstruments(DbDir=%s,FilePath=%s,Index=%d,bBackground=%d)\n", DbDir.c_str(), FilePath.c_str(), Index, bBackground));
+         if(!bBackground) {
+             AddInstruments(DbDir, false, FilePath, Index);
+             return -1;
+         }
+         ScanJob job;
+         int jobId = Jobs.AddJob(job);
+         InstrumentsDbThread.Execute(new AddInstrumentsFromFileJob(jobId, DbDir, FilePath, Index, false));
+         return jobId;
+     }
+     void InstrumentsDb::AddInstruments(String DbDir, bool insDir, String FilePath, int Index, ScanProgress* pProgress) {
+         dmsg(2,("InstrumentsDb: AddInstruments(DbDir=%s,insDir=%d,FilePath=%s,Index=%d)\n", DbDir.c_str(), insDir, FilePath.c_str(), Index));
          if (DbDir.empty() || FilePath.empty()) return;
          DbInstrumentsMutex.Lock();
          try {
              int dirId = GetDirectoryId(DbDir);
-             if (dirId == -1) throw Exception("Invalid DB directory: " + DbDir);
+             if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedText(DbDir));
-             struct stat statBuf;
+             File f = File(FilePath);
-             int res = stat(FilePath.c_str(), &statBuf);
+             if (!f.Exist()) {
-             if (res) {
                  std::stringstream ss;
-                 ss << "Fail to stat `" << FilePath << "`: " << strerror(errno);
+                 ss << "Fail to stat `" << FilePath << "`: " << f.GetErrorMsg();
                  throw Exception(ss.str());
              }
-             if (S_ISREG(statBuf.st_mode)) {
+             if (!f.IsFile()) {
-                 AddInstrumentsFromFile(DbDir, FilePath, Index);
-                 DbInstrumentsMutex.Unlock();
-                 return;
-             }
-             if (!S_ISDIR(statBuf.st_mode)) {
-                 DbInstrumentsMutex.Unlock();
-                 return;
-             }
-             if (Index != -1) {
                  std::stringstream ss;
-                 ss << "`" << FilePath << "` is directory, not an instrument file";
+                 ss << "`" << FilePath << "` is not an instrument file";
                  throw Exception(ss.str());
              }
-             AddInstrumentsRecursive(DbDir, FilePath, false);
+                         if(insDir) {
+                                 std::string tmp = f.basename(FilePath, ".");
+                                 String gigDir;
+                                 if(DbDir.length() == 1 && DbDir.at(0) == '/') //DbDir is /
+                                         gigDir = DbDir + (String)tmp + "/";
+                                 else
+                                         gigDir = DbDir +"/"+ (String)tmp + "/";
+                                 dmsg(2,("InstrumentsDb: AddInstrumentsNonrecursive(Dir from file mode=%d, Created SubDir=%s)\n",insDir, gigDir.c_str()));
+                 DbInstrumentsMutex.Unlock();
+                                 AddDirectory(gigDir);//TODO: Add some error checking here to make sure the dir is created
+                 DbInstrumentsMutex.Lock();
+                 AddInstrumentsFromFile(gigDir, FilePath, Index, pProgress);
+                         } else {
+                 AddInstrumentsFromFile(DbDir, FilePath, Index, pProgress);
+                         }
          } catch (Exception e) {
              DbInstrumentsMutex.Unlock();
              throw e;
-Line 503 
 namespace LinuxSampler {
+Line 727 
 namespace LinuxSampler {
          DbInstrumentsMutex.Unlock();
      }
-     void InstrumentsDb::AddInstrumentsNonrecursive(String DbDir, String FsDir) {
+     void InstrumentsDb::AddInstrumentsNonrecursive(String DbDir, String FsDir, bool insDir, ScanProgress* pProgress) {
-         dmsg(2,("InstrumentsDb: AddInstrumentsNonrecursive(DbDir=%s,FsDir=%s)\n", DbDir.c_str(), FsDir.c_str()));
+         dmsg(2,("InstrumentsDb: AddInstrumentsNonrecursive(DbDir=%s,FsDir=%s,insDir=%d)\n", DbDir.c_str(), FsDir.c_str(), insDir));
          if (DbDir.empty() || FsDir.empty()) return;
          DbInstrumentsMutex.Lock();
          try {
              int dirId = GetDirectoryId(DbDir);
-             if (dirId == -1) throw Exception("Invalid DB directory: " + DbDir);
+             if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));
-             struct stat statBuf;
+             File f = File(FsDir);
-             int res = stat(FsDir.c_str(), &statBuf);
+             if (!f.Exist()) {
-             if (res) {
                  std::stringstream ss;
-                 ss << "Fail to stat `" << FsDir << "`: " << strerror(errno);
+                 ss << "Fail to stat `" << FsDir << "`: " << f.GetErrorMsg();
                  throw Exception(ss.str());
              }
-             if (!S_ISDIR(statBuf.st_mode)) {
+             if (!f.IsDirectory()) {
-                 throw Exception("Directory expected");
+                 throw Exception("Directory expected: " + FsDir);
              }
-             if (FsDir.at(FsDir.length() - 1) != '/') FsDir.append("/");
+             if (FsDir.at(FsDir.length() - 1) != File::DirSeparator) {
+                 FsDir.push_back(File::DirSeparator);
-             DIR* pDir = opendir(FsDir.c_str());
-             if (pDir == NULL) {
-                 std::stringstream ss;
-                 ss << "The scanning of directory `" << FsDir << "` failed: ";
-                 ss << strerror(errno);
-                 std::cout << ss.str();
-                 DbInstrumentsMutex.Unlock();
-                 return;
              }
-             struct dirent* pEnt = readdir(pDir);
+             try {
-             while (pEnt != NULL) {
+                 FileListPtr fileList = File::GetFiles(FsDir);
-                 if (pEnt->d_type != DT_REG) {
+                 for (int i = 0; i < fileList->size(); i++) {
-                     pEnt = readdir(pDir);
+                                         if(insDir)
-                     continue;
+                                         {
+                                                 //File gFile = File(fileList->at(i));
+                                                 String gigDir;
+                                                 if(DbDir.length() == 1 && DbDir.at(0) == '/') //DbDir is /
+                                                         gigDir  = DbDir + f.basename(fileList->at(i),".") + "/";
+                                                 else
+                                                         gigDir  = DbDir +"/"+ f.basename(fileList->at(i),".") + "/";
+                                                 dmsg(2,("InstrumentsDb: AddInstrumentsNonrecursive(Dir from file mode=%d, Created SubDir=%s)\n",insDir, gigDir.c_str()));
+                                 DbInstrumentsMutex.Unlock(); // UnLock the db so we can add our extra directory
+                                                 AddDirectory(gigDir);//TODO: Add some error checking here to make sure the dir is created
+                                         DbInstrumentsMutex.Lock(); //Lock and carry on
+                         AddInstrumentsFromFile(gigDir, FsDir + fileList->at(i), -1, pProgress);
+                                         }
+                                         else
+                                         {
+                         AddInstrumentsFromFile(DbDir, FsDir + fileList->at(i), -1, pProgress);
+                                         }
                  }
+             } catch(Exception e) {
-                 AddInstrumentsFromFile(DbDir, FsDir + String(pEnt->d_name));
+                 e.PrintMessage();
-                 pEnt = readdir(pDir);
+                 DbInstrumentsMutex.Unlock();
-             }
+                 return;
-             if (closedir(pDir)) {
-                 std::stringstream ss;
-                 ss << "Failed to close directory `" << FsDir << "`: ";
-                 ss << strerror(errno);
-                 std::cout << ss.str();
              }
          } catch (Exception e) {
              DbInstrumentsMutex.Unlock();
-Line 561 
 namespace LinuxSampler {
+Line 786 
 namespace LinuxSampler {
          DbInstrumentsMutex.Unlock();
      }
-     void InstrumentsDb::AddInstrumentsRecursive(String DbDir, String FsDir, bool Flat) {
+     void InstrumentsDb::AddInstrumentsRecursive(String DbDir, String FsDir, bool Flat, bool insDir, ScanProgress* pProgress) {
-         dmsg(2,("InstrumentsDb: AddInstrumentsRecursive(DbDir=%s,FsDir=%s,Flat=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat));
+         dmsg(2,("InstrumentsDb: AddInstrumentsRecursive(DbDir=%s,FsDir=%s,Flat=%d,insDir=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat, insDir));
-         DirectoryScanner::Scan(DbDir, FsDir, Flat);
+         if (pProgress != NULL) {
+             InstrumentFileCounter c;
+             pProgress->SetTotalFileCount(c.Count(FsDir));
+         }
+         DirectoryScanner d;
+         d.Scan(DbDir, FsDir, Flat, insDir, pProgress);
      }
      int InstrumentsDb::GetInstrumentCount(int DirId) {
-Line 576 
 namespace LinuxSampler {
+Line 807 
 namespace LinuxSampler {
          return ExecSqlInt(sql.str());
      }
-     int InstrumentsDb::GetInstrumentCount(String Dir) {
+     int InstrumentsDb::GetInstrumentCount(String Dir, bool Recursive) {
-         dmsg(2,("InstrumentsDb: GetInstrumentCount(Dir=%s)\n", Dir.c_str()));
+         dmsg(2,("InstrumentsDb: GetInstrumentCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
          int i;
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
-         try { i = GetInstrumentCount(GetDirectoryId(Dir)); }
+         try {
-         catch (Exception e) {
+             if (Recursive) {
-             DbInstrumentsMutex.Unlock();
+                 InstrumentCounter instrumentCounter;
+                 DirectoryTreeWalk(Dir, &instrumentCounter);
+                 i = instrumentCounter.GetInstrumentCount();
+             } else {
+                 i = GetInstrumentCount(GetDirectoryId(Dir));
+             }
+         } catch (Exception e) {
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
-         if (i == -1) throw Exception("Unknown Db directory: " + Dir);
+         if (i == -1) throw Exception("Unknown Db directory: " + toEscapedPath(Dir));
          return i;
      }
-Line 599 
 namespace LinuxSampler {
+Line 837 
 namespace LinuxSampler {
          return ExecSqlIntList(sql.str());
      }
-     StringListPtr InstrumentsDb::GetInstruments(String Dir) {
+     StringListPtr InstrumentsDb::GetInstruments(String Dir, bool Recursive) {
-         dmsg(2,("InstrumentsDb: GetInstruments(Dir=%s)\n", Dir.c_str()));
+         dmsg(2,("InstrumentsDb: GetInstruments(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(Dir);
-             if(dirId == -1) throw Exception("Unknown DB directory: " + Dir);
+             if(dirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
-             std::stringstream sql;
+             StringListPtr pInstrs;
-             sql << "SELECT instr_name FROM instruments WHERE dir_id=" << dirId;
-             StringListPtr instrs = ExecSqlStringList(sql.str());
+             if(Recursive) {
-             DbInstrumentsMutex.Unlock();
+                 SearchQuery q;
-             return instrs;
+                 InstrumentFinder instrumentFinder(&q);
+                 DirectoryTreeWalk(Dir, &instrumentFinder);
+                 pInstrs = instrumentFinder.GetInstruments();
+             } else {
+                 std::stringstream sql;
+                 sql << "SELECT instr_name FROM instruments WHERE dir_id=" << dirId;
+                 pInstrs = ExecSqlStringList(sql.str());
+                 // Converting to abstract names
+                 for (int i = 0; i < pInstrs->size(); i++) {
+                     for (int j = 0; j < pInstrs->at(i).length(); j++) {
+                         if (pInstrs->at(i).at(j) == '/') pInstrs->at(i).at(j) = '\0';
+                     }
+                 }
+             }
+             EndTransaction();
+             return pInstrs;
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
      }
-Line 633 
 namespace LinuxSampler {
+Line 886 
 namespace LinuxSampler {
          std::stringstream sql;
          sql << "SELECT instr_id FROM instruments WHERE dir_id=";
          sql << DirId << " AND instr_name=?";
-         return ExecSqlInt(sql.str(), InstrName);
+         return ExecSqlInt(sql.str(), toDbName(InstrName));
+     }
+     String InstrumentsDb::GetInstrumentName(int InstrId) {
+         dmsg(2,("InstrumentsDb: GetInstrumentName(InstrId=%d)\n", InstrId));
+         std::stringstream sql;
+         sql << "SELECT instr_name FROM instruments WHERE instr_id=" << InstrId;
+         return toAbstractName(ExecSqlString(sql.str()));
      }
      void InstrumentsDb::RemoveInstrument(String Instr) {
-Line 641 
 namespace LinuxSampler {
+Line 901 
 namespace LinuxSampler {
          String ParentDir = GetDirectoryPath(Instr);
          if(ParentDir.empty()) throw Exception("Unknown parent directory");
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int instrId = GetInstrumentId(Instr);
              if(instrId == -1) {
-                 throw Exception("The specified instrument does not exist: " + Instr);
+                 throw Exception("The specified instrument does not exist: " + toEscapedPath(Instr));
              }
              RemoveInstrument(instrId);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireInstrumentCountChanged(ParentDir);
      }
-Line 677 
 namespace LinuxSampler {
+Line 937 
 namespace LinuxSampler {
          dmsg(2,("InstrumentsDb: GetInstrumentInfo(Instr=%s)\n", Instr.c_str()));
          DbInstrument i;
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int id = GetInstrumentId(Instr);
-             if(id == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if(id == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
+             i = GetInstrumentInfo(id);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
-             sqlite3_stmt *pStmt = NULL;
+         return i;
-             std::stringstream sql;
+     }
-             sql << "SELECT instr_file,instr_nr,format_family,format_version,";
-             sql << "instr_size,created,modified,description,is_drum,product,";
-             sql << "artists,keywords FROM instruments WHERE instr_id=" << id;
-             int res = sqlite3_prepare(GetDb(), sql.str().c_str(), -1, &pStmt, NULL);
+     DbInstrument InstrumentsDb::GetInstrumentInfo(int InstrId) {
-             if (res != SQLITE_OK) {
+         sqlite3_stmt *pStmt = NULL;
-                 throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+         std::stringstream sql;
-             }
+         sql << "SELECT instr_file,instr_nr,format_family,format_version,";
+         sql << "instr_size,created,modified,description,is_drum,product,";
+         sql << "artists,keywords FROM instruments WHERE instr_id=" << InstrId;
-             res = sqlite3_step(pStmt);
+         int res = sqlite3_prepare(GetDb(), sql.str().c_str(), -1, &pStmt, NULL);
-             if(res == SQLITE_ROW) {
+         if (res != SQLITE_OK) {
-                 i.InstrFile = ToString(sqlite3_column_text(pStmt, 0));
+             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
-                 i.InstrNr = sqlite3_column_int(pStmt, 1);
+         }
-                 i.FormatFamily = ToString(sqlite3_column_text(pStmt, 2));
-                 i.FormatVersion = ToString(sqlite3_column_text(pStmt, 3));
-                 i.Size = sqlite3_column_int64(pStmt, 4);
-                 i.Created = ToString(sqlite3_column_text(pStmt, 5));
-                 i.Modified = ToString(sqlite3_column_text(pStmt, 6));
-                 i.Description = ToString(sqlite3_column_text(pStmt, 7));
-                 i.IsDrum = sqlite3_column_int(pStmt, 8);
-                 i.Product = ToString(sqlite3_column_text(pStmt, 9));
-                 i.Artists = ToString(sqlite3_column_text(pStmt, 10));
-                 i.Keywords = ToString(sqlite3_column_text(pStmt, 11));
-             } else {
-                 sqlite3_finalize(pStmt);
-                 if (res != SQLITE_DONE) {
-                     throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
-                 } else {
-                     throw Exception("Unknown DB instrument: " + Instr);
-                 }
-             }
+         DbInstrument i;
+         res = sqlite3_step(pStmt);
+         if(res == SQLITE_ROW) {
+             i.InstrFile = ToString(sqlite3_column_text(pStmt, 0));
+             i.InstrNr = sqlite3_column_int(pStmt, 1);
+             i.FormatFamily = ToString(sqlite3_column_text(pStmt, 2));
+             i.FormatVersion = ToString(sqlite3_column_text(pStmt, 3));
+             i.Size = sqlite3_column_int64(pStmt, 4);
+             i.Created = ToString(sqlite3_column_text(pStmt, 5));
+             i.Modified = ToString(sqlite3_column_text(pStmt, 6));
+             i.Description = ToString(sqlite3_column_text(pStmt, 7));
+             i.IsDrum = sqlite3_column_int(pStmt, 8);
+             i.Product = ToString(sqlite3_column_text(pStmt, 9));
+             i.Artists = ToString(sqlite3_column_text(pStmt, 10));
+             i.Keywords = ToString(sqlite3_column_text(pStmt, 11));
+         } else {
              sqlite3_finalize(pStmt);
-         } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             if (res != SQLITE_DONE) {
-             throw e;
+                 throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+             } else {
+                 throw Exception("Unknown DB instrument");
+             }
          }
-         DbInstrumentsMutex.Unlock();
+         sqlite3_finalize(pStmt);
          return i;
      }
-Line 731 
 namespace LinuxSampler {
+Line 996 
 namespace LinuxSampler {
          dmsg(2,("InstrumentsDb: RenameInstrument(Instr=%s,Name=%s)\n", Instr.c_str(), Name.c_str()));
          CheckFileName(Name);
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int dirId = GetDirectoryId(GetDirectoryPath(Instr));
-             if (dirId == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if (dirId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
              int instrId = GetInstrumentId(dirId, GetFileName(Instr));
-             if (instrId == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if (instrId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
              if (GetInstrumentId(dirId, Name) != -1) {
-                 throw Exception("Cannot rename. Instrument with that name already exists: " + Name);
+                 String s = toEscapedPath(Name);
+                 throw Exception("Cannot rename. Instrument with that name already exists: " + s);
+             }
+             if (GetDirectoryId(dirId, Name) != -1) {
+                 String s = toEscapedPath(Name);
+                 throw Exception("Cannot rename. Directory with that name already exists: " + s);
              }
              std::stringstream sql;
              sql << "UPDATE instruments SET instr_name=? WHERE instr_id=" << instrId;
-             ExecSql(sql.str(), Name);
+             ExecSql(sql.str(), toDbName(Name));
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
-         FireInstrumentNameChanged(Instr, Name);
+         FireInstrumentNameChanged(Instr, toAbstractName(Name));
      }
      void InstrumentsDb::MoveInstrument(String Instr, String Dst) {
-Line 759 
 namespace LinuxSampler {
+Line 1030 
 namespace LinuxSampler {
          String ParentDir = GetDirectoryPath(Instr);
          if(ParentDir.empty()) throw Exception("Unknown parent directory");
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
-             int dirId = GetDirectoryId(GetDirectoryPath(Instr));
+             int dirId = GetDirectoryId(ParentDir);
-             if (dirId == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if (dirId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
              String instrName = GetFileName(Instr);
              int instrId = GetInstrumentId(dirId, instrName);
-             if (instrId == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if (instrId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
              int dstId = GetDirectoryId(Dst);
-             if (dstId == -1) throw Exception("Unknown DB directory: " + Dst);
+             if (dstId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dst));
              if (dirId == dstId) {
-                 DbInstrumentsMutex.Unlock();
+                 EndTransaction();
                  return;
              }
              if (GetInstrumentId(dstId, instrName) != -1) {
-                 throw Exception("Cannot move. Instrument with that name already exists: " + instrName);
+                 String s = toEscapedPath(instrName);
+                 throw Exception("Cannot move. Instrument with that name already exists: " + s);
+             }
+             if (GetDirectoryId(dstId, instrName) != -1) {
+                 String s = toEscapedPath(instrName);
+                 throw Exception("Cannot move. Directory with that name already exists: " + s);
              }
              std::stringstream sql;
-Line 784 
 namespace LinuxSampler {
+Line 1061 
 namespace LinuxSampler {
              sql << " WHERE instr_id=" << instrId;
              ExecSql(sql.str());
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireInstrumentCountChanged(ParentDir);
          FireInstrumentCountChanged(Dst);
      }
+     void InstrumentsDb::CopyInstrument(String Instr, String Dst) {
+         dmsg(2,("InstrumentsDb: CopyInstrument(Instr=%s,Dst=%s)\n", Instr.c_str(), Dst.c_str()));
+         String ParentDir = GetDirectoryPath(Instr);
+         if(ParentDir.empty()) throw Exception("Unknown parent directory");
+         BeginTransaction();
+         try {
+             int dirId = GetDirectoryId(GetDirectoryPath(Instr));
+             if (dirId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
+             String instrName = GetFileName(Instr);
+             int instrId = GetInstrumentId(dirId, instrName);
+             if (instrId == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
+             int dstId = GetDirectoryId(Dst);
+             if (dstId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dst));
+             if (dirId == dstId) {
+                 EndTransaction();
+                 return;
+             }
+             CopyInstrument(instrId, instrName, dstId, Dst);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+     }
+     void InstrumentsDb::CopyInstrument(int InstrId, String InstrName, int DstDirId, String DstDir) {
+         if (GetInstrumentId(DstDirId, InstrName) != -1) {
+             String s = toEscapedPath(InstrName);
+             throw Exception("Cannot copy. Instrument with that name already exists: " + s);
+         }
+         if (GetDirectoryId(DstDirId, InstrName) != -1) {
+             String s = toEscapedPath(InstrName);
+             throw Exception("Cannot copy. Directory with that name already exists: " + s);
+         }
+         DbInstrument i = GetInstrumentInfo(InstrId);
+         sqlite3_stmt *pStmt = NULL;
+         std::stringstream sql;
+         sql << "INSERT INTO instruments (dir_id,instr_name,instr_file,instr_nr,format_family,";
+         sql << "format_version,instr_size,description,is_drum,product,artists,keywords) ";
+         sql << "VALUES (" << DstDirId << ",?,?," << i.InstrNr << ",?,?," << i.Size << ",?,";
+         sql << i.IsDrum << ",?,?,?)";
+         int res = sqlite3_prepare(GetDb(), sql.str().c_str(), -1, &pStmt, NULL);
+         if (res != SQLITE_OK) {
+             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+         }
+         String s = toDbName(InstrName);
+         BindTextParam(pStmt, 1, s);
+         BindTextParam(pStmt, 2, i.InstrFile);
+         BindTextParam(pStmt, 3, i.FormatFamily);
+         BindTextParam(pStmt, 4, i.FormatVersion);
+         BindTextParam(pStmt, 5, i.Description);
+         BindTextParam(pStmt, 6, i.Product);
+         BindTextParam(pStmt, 7, i.Artists);
+         BindTextParam(pStmt, 8, i.Keywords);
+         res = sqlite3_step(pStmt);
+         if(res != SQLITE_DONE) {
+             sqlite3_finalize(pStmt);
+             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+         }
+         sqlite3_finalize(pStmt);
+         FireInstrumentCountChanged(DstDir);
+     }
      void InstrumentsDb::SetInstrumentDescription(String Instr, String Desc) {
          dmsg(2,("InstrumentsDb: SetInstrumentDescription(Instr=%s,Desc=%s)\n", Instr.c_str(), Desc.c_str()));
-         DbInstrumentsMutex.Lock();
+         BeginTransaction();
          try {
              int id = GetInstrumentId(Instr);
-             if(id == -1) throw Exception("Unknown DB instrument: " + Instr);
+             if(id == -1) throw Exception("Unknown DB instrument: " + toEscapedPath(Instr));
              std::stringstream sql;
              sql << "UPDATE instruments SET description=?,modified=CURRENT_TIMESTAMP ";
-Line 806 
 namespace LinuxSampler {
+Line 1157 
 namespace LinuxSampler {
              ExecSql(sql.str(), Desc);
          } catch (Exception e) {
-             DbInstrumentsMutex.Unlock();
+             EndTransaction();
              throw e;
          }
-         DbInstrumentsMutex.Unlock();
+         EndTransaction();
          FireInstrumentInfoChanged(Instr);
      }
-     void InstrumentsDb::AddInstrumentsFromFile(String DbDir, String File, int Index) {
+     void InstrumentsDb::AddInstrumentsFromFile(String DbDir, String File, int Index, ScanProgress* pProgress) {
          dmsg(2,("InstrumentsDb: AddInstrumentsFromFile(DbDir=%s,File=%s,Index=%d)\n", DbDir.c_str(), File.c_str(), Index));
          if(File.length() < 4) return;
          try {
              if(!strcasecmp(".gig", File.substr(File.length() - 4).c_str())) {
-                 AddGigInstruments(DbDir, File, Index);
+                 if (pProgress != NULL) {
+                     pProgress->SetStatus(0);
+                     pProgress->CurrentFile = File;
+                 }
+                 AddGigInstruments(DbDir, File, Index, pProgress);
+                 if (pProgress != NULL) {
+                     pProgress->SetScannedFileCount(pProgress->GetScannedFileCount() + 1);
+                 }
              }
          } catch(Exception e) {
-             std::cout << e.Message() << std::endl;
+             e.PrintMessage();
          }
      }
-     void InstrumentsDb::AddGigInstruments(String DbDir, String File, int Index) {
+     void InstrumentsDb::AddGigInstruments(String DbDir, String FilePath, int Index, ScanProgress* pProgress) {
-         dmsg(2,("InstrumentsDb: AddGigInstruments(DbDir=%s,File=%s,Index=%d)\n", DbDir.c_str(), File.c_str(), Index));
+         dmsg(2,("InstrumentsDb: AddGigInstruments(DbDir=%s,FilePath=%s,Index=%d)\n", DbDir.c_str(), FilePath.c_str(), Index));
          int dirId = GetDirectoryId(DbDir);
-         if (dirId == -1) throw Exception("Invalid DB directory: " + DbDir);
+         if (dirId == -1) throw Exception("Invalid DB directory: " + toEscapedPath(DbDir));
-         struct stat statBuf;
+         File f = File(FilePath);
-         int res = stat(File.c_str(), &statBuf);
+         if (!f.Exist()) {
-         if (res) {
              std::stringstream ss;
-             ss << "Fail to stat `" << File << "`: " << strerror(errno);
+             ss << "Fail to stat `" << FilePath << "`: " << f.GetErrorMsg();
              throw Exception(ss.str());
          }
-         if (!S_ISREG(statBuf.st_mode)) {
+         if (!f.IsFile()) {
              std::stringstream ss;
-             ss << "`" << File << "` is not a regular file";
+             ss << "`" << FilePath << "` is not a regular file";
              throw Exception(ss.str());
          }
          RIFF::File* riff = NULL;
          gig::File* gig = NULL;
          try {
-             riff = new RIFF::File(File);
+             riff = new RIFF::File(FilePath);
              gig::File* gig = new gig::File(riff);
+             gig->SetAutoLoad(false); // avoid time consuming samples scanning
              std::stringstream sql;
              sql << "INSERT INTO instruments (dir_id,instr_name,instr_file,";
              sql << "instr_nr,format_family,format_version,instr_size,";
              sql << "description,is_drum,product,artists,keywords) VALUES (";
-             sql << dirId << ",?,?,?,'GIG',?," << statBuf.st_size << ",?,?,?,?,?)";
+             sql << dirId << ",?,?,?,'GIG',?," << f.GetSize() << ",?,?,?,?,?)";
              sqlite3_stmt* pStmt = NULL;
-Line 865 
 namespace LinuxSampler {
+Line 1225 
 namespace LinuxSampler {
                  throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
              }
-             BindTextParam(pStmt, 2, File);
+             String s = toEscapedFsPath(FilePath);
+             BindTextParam(pStmt, 2, s);
              String ver = "";
              if (gig->pVersion != NULL) ver = ToString(gig->pVersion->major);
              BindTextParam(pStmt, 4, ver);
              if (Index == -1) {
                  int instrIndex = 0;
+                 if (pProgress != NULL) gig->GetInstrument(0, &(pProgress->GigFileProgress)); // TODO: this workaround should be fixed
                  gig::Instrument* pInstrument = gig->GetFirstInstrument();
                  while (pInstrument) {
                      BindTextParam(pStmt, 7, gig->pInfo->Product);
                      BindTextParam(pStmt, 8, gig->pInfo->Artists);
                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);
-                     AddGigInstrument(pStmt, DbDir, dirId, File, pInstrument, instrIndex);
+                     AddGigInstrument(pStmt, DbDir, dirId, FilePath, pInstrument, instrIndex);
                      instrIndex++;
                      pInstrument = gig->GetNextInstrument();
                  }
              } else {
-                 gig::Instrument* pInstrument = gig->GetInstrument(Index);
+                 gig::Instrument* pInstrument;
+                 if (pProgress == NULL) pInstrument = gig->GetInstrument(Index);
+                 else pInstrument = gig->GetInstrument(Index, &(pProgress->GigFileProgress));
                  if (pInstrument != NULL) {
                      BindTextParam(pStmt, 7, gig->pInfo->Product);
                      BindTextParam(pStmt, 8, gig->pInfo->Artists);
                      BindTextParam(pStmt, 9, gig->pInfo->Keywords);
-                     AddGigInstrument(pStmt, DbDir, dirId, File, pInstrument, Index);
+                     AddGigInstrument(pStmt, DbDir, dirId, FilePath, pInstrument, Index);
                  }
              }
+             sqlite3_finalize(pStmt);
              delete gig;
              delete riff;
          } catch (RIFF::Exception e) {
              if (gig != NULL) delete gig;
              if (riff != NULL) delete riff;
              std::stringstream ss;
-             ss << "Failed to scan `" << File << "`: " << e.Message;
+             ss << "Failed to scan `" << FilePath << "`: " << e.Message;
              throw Exception(ss.str());
          } catch (Exception e) {
-Line 908 
 namespace LinuxSampler {
+Line 1273 
 namespace LinuxSampler {
          } catch (...) {
              if (gig != NULL) delete gig;
              if (riff != NULL) delete riff;
-             throw Exception("Failed to scan `" + File + "`");
+             throw Exception("Failed to scan `" + FilePath + "`");
          }
      }
-     void InstrumentsDb::AddGigInstrument (sqlite3_stmt* pStmt, String DbDir, int DirId, String File, gig::Instrument* pInstrument, int Index) {
+     void InstrumentsDb::AddGigInstrument(sqlite3_stmt* pStmt, String DbDir, int DirId, String File, gig::Instrument* pInstrument, int Index) {
+         dmsg(2,("InstrumentsDb: AddGigInstrument(DbDir=%s,DirId=%d,File=%s,Index=%d)\n", DbDir.c_str(), DirId, File.c_str(), Index));
          String name = pInstrument->pInfo->Name;
          if (name == "") return;
          name = GetUniqueInstrumentName(DirId, name);
-Line 920 
 namespace LinuxSampler {
+Line 1286 
 namespace LinuxSampler {
          std::stringstream sql2;
          sql2 << "SELECT COUNT(*) FROM instruments WHERE instr_file=? AND ";
          sql2 << "instr_nr=" << Index;
-         if (ExecSqlInt(sql2.str(), File) > 0) return;
+         String s = toEscapedFsPath(File);
+         if (ExecSqlInt(sql2.str(), s) > 0) return;
          BindTextParam(pStmt, 1, name);
          BindIntParam(pStmt, 3, Index);
-Line 949 
 namespace LinuxSampler {
+Line 1316 
 namespace LinuxSampler {
          FireInstrumentCountChanged(DbDir);
      }
-     void InstrumentsDb::ExecSql(String Sql) {
+     void InstrumentsDb::DirectoryTreeWalk(String AbstractPath, DirectoryHandler* pHandler) {
-         dmsg(2,("InstrumentsDb: ExecSql(Sql=%s)\n", Sql.c_str()));
+         int DirId = GetDirectoryId(AbstractPath);
+         if(DirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(AbstractPath));
+         DirectoryTreeWalk(pHandler, AbstractPath, DirId, 0);
+     }
+     void InstrumentsDb::DirectoryTreeWalk(DirectoryHandler* pHandler, String AbstractPath, int DirId, int Level) {
+         if(Level == 1000) throw Exception("Possible infinite loop detected");
+         pHandler->ProcessDirectory(AbstractPath, DirId);
+         String s;
+         StringListPtr pDirs = GetDirectories(DirId);
+         for(int i = 0; i < pDirs->size(); i++) {
+             if (AbstractPath.length() == 1 && AbstractPath.at(0) == '/') {
+                 s = "/" + pDirs->at(i);
+             } else {
+                 s = AbstractPath + "/" + pDirs->at(i);
+             }
+             DirectoryTreeWalk(pHandler, s, GetDirectoryId(DirId, pDirs->at(i)), Level + 1);
+         }
+     }
+     StringListPtr InstrumentsDb::FindDirectories(String Dir, SearchQuery* pQuery, bool Recursive) {
+         dmsg(2,("InstrumentsDb: FindDirectories(Dir=%s)\n", Dir.c_str()));
+         DirectoryFinder directoryFinder(pQuery);
+         BeginTransaction();
+         try {
+             int DirId = GetDirectoryId(Dir);
+             if(DirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
+             if (Recursive) DirectoryTreeWalk(Dir, &directoryFinder);
+             else directoryFinder.ProcessDirectory(Dir, DirId);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+         return directoryFinder.GetDirectories();
+     }
+     StringListPtr InstrumentsDb::FindInstruments(String Dir, SearchQuery* pQuery, bool Recursive) {
+         dmsg(2,("InstrumentsDb: FindInstruments(Dir=%s)\n", Dir.c_str()));
+         InstrumentFinder instrumentFinder(pQuery);
+         BeginTransaction();
+         try {
+             int DirId = GetDirectoryId(Dir);
+             if(DirId == -1) throw Exception("Unknown DB directory: " + toEscapedPath(Dir));
+             if (Recursive) DirectoryTreeWalk(Dir, &instrumentFinder);
+             else instrumentFinder.ProcessDirectory(Dir, DirId);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+         return instrumentFinder.GetInstruments();
+     }
+     StringListPtr InstrumentsDb::FindLostInstrumentFiles() {
+         dmsg(2,("InstrumentsDb: FindLostInstrumentFiles()\n"));
+         BeginTransaction();
+         try {
+             StringListPtr files = ExecSqlStringList("SELECT DISTINCT instr_file FROM instruments");
+             StringListPtr result(new std::vector<String>);
+             for (int i = 0; i < files->size(); i++) {
+                 File f(toNonEscapedFsPath(files->at(i)));
+                 if (!f.Exist()) result->push_back(files->at(i));
+             }
+             return result;
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+     }
+     void InstrumentsDb::SetInstrumentFilePath(String OldPath, String NewPath) {
+         if (OldPath == NewPath) return;
+         StringListPtr instrs;
+         BeginTransaction();
+         try {
+             std::vector<String> params(2);
+             params[0] = toEscapedFsPath(NewPath);
+             params[1] = toEscapedFsPath(OldPath);
+             instrs = GetInstrumentsByFile(OldPath);
+             ExecSql("UPDATE instruments SET instr_file=? WHERE instr_file=?", params);
+         } catch (Exception e) {
+             EndTransaction();
+             throw e;
+         }
+         EndTransaction();
+         for (int i = 0; i < instrs->size(); i++) {
+             FireInstrumentInfoChanged(instrs->at(i));
+         }
+     }
+     void InstrumentsDb::BeginTransaction() {
+         dmsg(2,("InstrumentsDb: BeginTransaction(InTransaction=%d)\n", InTransaction));
+         DbInstrumentsMutex.Lock();
+         if (InTransaction) return;
+         if(db == NULL) return;
          sqlite3_stmt *pStmt = NULL;
-         int res = sqlite3_prepare(GetDb(), Sql.c_str(), -1, &pStmt, NULL);
+         InTransaction = true;
+         int res = sqlite3_prepare(db, "BEGIN TRANSACTION", -1, &pStmt, NULL);
          if (res != SQLITE_OK) {
-             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+             std::cerr << ToString(sqlite3_errmsg(db)) << std::endl;
+             return;
          }
          res = sqlite3_step(pStmt);
          if(res != SQLITE_DONE) {
              sqlite3_finalize(pStmt);
-             throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
+             std::cerr << ToString(sqlite3_errmsg(db)) << std::endl;
+             return;
          }
          sqlite3_finalize(pStmt);
      }
+     void InstrumentsDb::EndTransaction() {
+         dmsg(2,("InstrumentsDb: EndTransaction(InTransaction=%d)\n", InTransaction));
+         if (!InTransaction) {
+             DbInstrumentsMutex.Unlock();
+             return;
+         }
+         InTransaction = false;
+         if(db == NULL) {
+             DbInstrumentsMutex.Unlock();
+             return;
+         }
+         sqlite3_stmt *pStmt = NULL;
+         int res = sqlite3_prepare(db, "END TRANSACTION", -1, &pStmt, NULL);
+         if (res != SQLITE_OK) {
+             std::cerr << ToString(sqlite3_errmsg(db)) << std::endl;
+             DbInstrumentsMutex.Unlock();
+             return;
+         }
+         res = sqlite3_step(pStmt);
+         if(res != SQLITE_DONE) {
+             sqlite3_finalize(pStmt);
+             std::cerr << ToString(sqlite3_errmsg(db)) << std::endl;
+             DbInstrumentsMutex.Unlock();
+             return;
+         }
+         sqlite3_finalize(pStmt);
+         DbInstrumentsMutex.Unlock();
+     }
+     void InstrumentsDb::ExecSql(String Sql) {
+         dmsg(2,("InstrumentsDb: ExecSql(Sql=%s)\n", Sql.c_str()));
+         std::vector<String> Params;
+         ExecSql(Sql, Params);
+     }
      void InstrumentsDb::ExecSql(String Sql, String Param) {
          dmsg(2,("InstrumentsDb: ExecSql(Sql=%s,Param=%s)\n", Sql.c_str(), Param.c_str()));
+         std::vector<String> Params;
+         Params.push_back(Param);
+         ExecSql(Sql, Params);
+     }
+     void InstrumentsDb::ExecSql(String Sql, std::vector<String>& Params) {
+         dmsg(2,("InstrumentsDb: ExecSql(Sql=%s,Params)\n", Sql.c_str()));
          sqlite3_stmt *pStmt = NULL;
          int res = sqlite3_prepare(GetDb(), Sql.c_str(), -1, &pStmt, NULL);
-Line 977 
 namespace LinuxSampler {
+Line 1499 
 namespace LinuxSampler {
              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
          }
-         BindTextParam(pStmt, 1, Param);
+         for(int i = 0; i < Params.size(); i++) {
+             BindTextParam(pStmt, i + 1, Params[i]);
+         }
          res = sqlite3_step(pStmt);
          if (res != SQLITE_DONE) {
-Line 1059 
 namespace LinuxSampler {
+Line 1583 
 namespace LinuxSampler {
      }
      IntListPtr InstrumentsDb::ExecSqlIntList(String Sql) {
+         dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s)\n", Sql.c_str()));
+         std::vector<String> Params;
+         return ExecSqlIntList(Sql, Params);
+     }
+     IntListPtr InstrumentsDb::ExecSqlIntList(String Sql, String Param) {
+         dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s,Param=%s)\n", Sql.c_str(), Param.c_str()));
+         std::vector<String> Params;
+         Params.push_back(Param);
+         return ExecSqlIntList(Sql, Params);
+     }
+     IntListPtr InstrumentsDb::ExecSqlIntList(String Sql, std::vector<String>& Params) {
+         dmsg(2,("InstrumentsDb: ExecSqlIntList(Sql=%s)\n", Sql.c_str()));
          IntListPtr intList(new std::vector<int>);
          sqlite3_stmt *pStmt = NULL;
-Line 1068 
 namespace LinuxSampler {
+Line 1606 
 namespace LinuxSampler {
              throw Exception("DB error: " + ToString(sqlite3_errmsg(db)));
          }
+         for(int i = 0; i < Params.size(); i++) {
+             BindTextParam(pStmt, i + 1, Params[i]);
+         }
          res = sqlite3_step(pStmt);
          while(res == SQLITE_ROW) {
              intList->push_back(sqlite3_column_int(pStmt, 0));
-Line 1085 
 namespace LinuxSampler {
+Line 1627 
 namespace LinuxSampler {
      }
      StringListPtr InstrumentsDb::ExecSqlStringList(String Sql) {
+         dmsg(2,("InstrumentsDb: ExecSqlStringList(Sql=%s)\n", Sql.c_str()));
          StringListPtr stringList(new std::vector<String>);
          sqlite3_stmt *pStmt = NULL;
-Line 1128 
 namespace LinuxSampler {
+Line 1671 
 namespace LinuxSampler {
          }
      }
+     void InstrumentsDb::Regexp(sqlite3_context* pContext, int argc, sqlite3_value** ppValue) {
+         if (argc != 2) return;
+         String pattern = ToString(sqlite3_value_text(ppValue[0]));
+         String str = ToString(sqlite3_value_text(ppValue[1]));
+         if(!fnmatch(pattern.c_str(), str.c_str(), FNM_CASEFOLD)) {
+             sqlite3_result_int(pContext, 1);
+         }
+     }
      String InstrumentsDb::GetDirectoryPath(String File) {
          if (File.empty()) return String("");
          if (File.at(0) != '/') String("");
-Line 1169 
 namespace LinuxSampler {
+Line 1723 
 namespace LinuxSampler {
          return Dir.substr(0, i);
      }
+     void InstrumentsDb::Format() {
+         DbInstrumentsMutex.Lock();
+         if (db != NULL) {
+             sqlite3_close(db);
+             db = NULL;
+         }
+         if (DbFile.empty()) DbFile = CONFIG_DEFAULT_INSTRUMENTS_DB_LOCATION;
+         String bkp = DbFile + ".bkp";
+         remove(bkp.c_str());
+         if (rename(DbFile.c_str(), bkp.c_str()) && errno != ENOENT) {
+             DbInstrumentsMutex.Unlock();
+             throw Exception(String("Failed to backup database: ") + strerror(errno));
+         }
+         String f = DbFile;
+         DbFile = "";
+         try { CreateInstrumentsDb(f); }
+         catch(Exception e) {
+             DbInstrumentsMutex.Unlock();
+             throw e;
+         }
+         DbInstrumentsMutex.Unlock();
+         FireDirectoryCountChanged("/");
+         FireInstrumentCountChanged("/");
+     }
      void InstrumentsDb::CheckFileName(String File) {
          if (File.empty()) throw Exception("Invalid file name: " + File);
-         if (File.find('/') != std::string::npos) {
-             throw Exception("Invalid file name: " + File);
-         }
      }
      String InstrumentsDb::GetUniqueInstrumentName(int DirId, String Name) {
          dmsg(2,("InstrumentsDb: GetUniqueInstrumentName(DirId=%d,Name=%s)\n", DirId, Name.c_str()));
-         std::stringstream sql;
-         sql << "SELECT COUNT(*) FROM instruments WHERE dir_id=" << DirId;
-         sql << " AND instr_name=?";
-         if (ExecSqlInt(sql.str(), Name) == 0) return Name;
+         if (GetInstrumentId(DirId, Name) == -1 && GetDirectoryId(DirId, Name) == -1) return Name;
          std::stringstream ss;
          for(int i = 2; i < 1001; i++) {
              ss.str("");
              ss << Name << '[' << i << ']';
-             if (ExecSqlInt(sql.str(), ss.str()) == 0) return ss.str();
+             if (GetInstrumentId(DirId, ss.str()) == -1 && GetInstrumentId(DirId, ss.str()) == -1) {
+                 return ss.str();
+             }
          }
          throw Exception("Unable to find an unique name: " + Name);
      }
+     String InstrumentsDb::toDbName(String AbstractName) {
+         for (int i = 0; i < AbstractName.length(); i++) {
+             if (AbstractName.at(i) == '\0') AbstractName.at(i) = '/';
+         }
+         return AbstractName;
+     }
+     String InstrumentsDb::toEscapedPath(String AbstractName) {
+         for (int i = 0; i < AbstractName.length(); i++) {
+             if (AbstractName.at(i) == '\0')      AbstractName.replace(i++, 1, "\\x2f");
+             else if (AbstractName.at(i) == '\\') AbstractName.replace(i++, 1, "\\\\");
+             else if (AbstractName.at(i) == '\'') AbstractName.replace(i++, 1, "\\'");
+             else if (AbstractName.at(i) == '"')  AbstractName.replace(i++, 1, "\\\"");
+             else if (AbstractName.at(i) == '\r') AbstractName.replace(i++, 1, "\\r");
+             else if (AbstractName.at(i) == '\n') AbstractName.replace(i++, 1, "\\n");
+         }
+         return AbstractName;
+     }
+     String InstrumentsDb::toEscapedText(String text) {
+         for (int i = 0; i < text.length(); i++) {
+             if (text.at(i) == '\\')      text.replace(i++, 1, "\\\\");
+             else if (text.at(i) == '\'') text.replace(i++, 1, "\\'");
+             else if (text.at(i) == '"')  text.replace(i++, 1, "\\\"");
+             else if (text.at(i) == '\r') text.replace(i++, 1, "\\r");
+             else if (text.at(i) == '\n') text.replace(i++, 1, "\\n");
+         }
+         return text;
+     }
+     String InstrumentsDb::toNonEscapedText(String text) {
+         String sb;
+         for (int i = 0; i < text.length(); i++) {
+             char c = text.at(i);
+                         if(c == '\\') {
+                                 if(i >= text.length()) {
+                                         std::cerr << "Broken escape sequence!" << std::endl;
+                                         break;
+                                 }
+                                 char c2 = text.at(++i);
+                                 if(c2 == '\'')      sb.push_back('\'');
+                                 else if(c2 == '"')  sb.push_back('"');
+                                 else if(c2 == '\\') sb.push_back('\\');
+                                 else if(c2 == 'r')  sb.push_back('\r');
+                                 else if(c2 == 'n')  sb.push_back('\n');
+                                 else std::cerr << "Unknown escape sequence \\" << c2 << std::endl;
+                         } else {
+                                 sb.push_back(c);
+                         }
+         }
+         return sb;
+     }
+     String InstrumentsDb::toEscapedFsPath(String FsPath) {
+         return toEscapedText(FsPath);
+     }
+     String InstrumentsDb::toNonEscapedFsPath(String FsPath) {
+         return toNonEscapedText(FsPath);
+     }
+     String InstrumentsDb::toAbstractName(String DbName) {
+         for (int i = 0; i < DbName.length(); i++) {
+             if (DbName.at(i) == '/') DbName.at(i) = '\0';
+         }
+         return DbName;
+     }
      void InstrumentsDb::FireDirectoryCountChanged(String Dir) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->DirectoryCountChanged(Dir);
          }
      }
      void InstrumentsDb::FireDirectoryInfoChanged(String Dir) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->DirectoryInfoChanged(Dir);
          }
      }
      void InstrumentsDb::FireDirectoryNameChanged(String Dir, String NewName) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->DirectoryNameChanged(Dir, NewName);
          }
      }
      void InstrumentsDb::FireInstrumentCountChanged(String Dir) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->InstrumentCountChanged(Dir);
          }
      }
      void InstrumentsDb::FireInstrumentInfoChanged(String Instr) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->InstrumentInfoChanged(Instr);
          }
      }
      void InstrumentsDb::FireInstrumentNameChanged(String Instr, String NewName) {
          for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
              llInstrumentsDbListeners.GetListener(i)->InstrumentNameChanged(Instr, NewName);
          }
      }
-     String DirectoryScanner::DbDir;
-     String DirectoryScanner::FsDir;
-     bool DirectoryScanner::Flat;
-     void DirectoryScanner::Scan(String DbDir, String FsDir, bool Flat) {
-         dmsg(2,("DirectoryScanner: Scan(DbDir=%s,FsDir=%s,Flat=%d)\n", DbDir.c_str(), FsDir.c_str(), Flat));
-         if (DbDir.empty() || FsDir.empty()) throw Exception("Directory expected");
-         struct stat statBuf;
-         int res = stat(FsDir.c_str(), &statBuf);
-         if (res) {
-             std::stringstream ss;
-             ss << "Fail to stat `" << FsDir << "`: " << strerror(errno);
-             throw Exception(ss.str());
-         }
-         if (!S_ISDIR(statBuf.st_mode)) {
+     void InstrumentsDb::FireJobStatusChanged(int JobId) {
-             throw Exception("Directory expected");
+         for (int i = 0; i < llInstrumentsDbListeners.GetListenerCount(); i++) {
-         }
+             llInstrumentsDbListeners.GetListener(i)->JobStatusChanged(JobId);
-         DirectoryScanner::DbDir = DbDir;
-         DirectoryScanner::FsDir = FsDir;
-         if (DbDir.at(DbDir.length() - 1) != '/') {
-             DirectoryScanner::DbDir.append("/");
-         }
-         if (FsDir.at(FsDir.length() - 1) != '/') {
-             DirectoryScanner::FsDir.append("/");
          }
-         DirectoryScanner::Flat = Flat;
-         ftw(FsDir.c_str(), FtwCallback, 10);
      }
-     int DirectoryScanner::FtwCallback(const char* fpath, const struct stat* sb, int typeflag) {
-         dmsg(2,("DirectoryScanner: FtwCallback(fpath=%s)\n", fpath));
-         if (typeflag != FTW_D) return 0;
-         String dir = DbDir;
-         if (!Flat) {
-             String subdir = fpath;
-             if(subdir.length() > FsDir.length()) {
-                 subdir = subdir.substr(FsDir.length());
-                 dir += subdir;
-             }
-         }
-         InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
-         if (!db->DirectoryExist(dir)) db->AddDirectory(dir);
-         db->AddInstrumentsNonrecursive(dir, String(fpath));
-         return 0;
-     };
  } // namespace LinuxSampler
- #endif // HAVE_SQLITE3

 Legend:



Removed from v.1161
 


changed lines


 
Added in v.1781
 Legend:



Removed from v.1161
 


changed lines


 
Added in v.1781
-Removed from v.1161
+Added in v.1781

	ViewVC Help
Powered by ViewVC