/[svn]/linuxsampler/trunk/src/plugins/InstrumentEditorFactory.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/plugins/InstrumentEditorFactory.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1601 by schoenebeck, Sat Dec 29 20:27:53 2007 UTC revision 1653 by schoenebeck, Wed Jan 30 01:51:46 2008 UTC
# Line 1  Line 1 
1  /***************************************************************************  /***************************************************************************
2   *                                                                         *   *                                                                         *
3   *   Copyright (C) 2007 Christian Schoenebeck                              *   *   Copyright (C) 2007, 2008 Christian Schoenebeck                        *
4   *                                                                         *   *                                                                         *
5   *   This program is free software; you can redistribute it and/or modify  *   *   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  *   *   it under the terms of the GNU General Public License as published by  *
# Line 105  namespace LinuxSampler { Line 105  namespace LinuxSampler {
105          if (!bPluginsLoaded) {          if (!bPluginsLoaded) {
106              dmsg(1,("Loading instrument editor plugins..."));              dmsg(1,("Loading instrument editor plugins..."));
107              #if defined(WIN32)              #if defined(WIN32)
             bool firstFileFound = true;  
108              WIN32_FIND_DATA win32FindData;              WIN32_FIND_DATA win32FindData;
109              String plugindir = (String)CONFIG_PLUGIN_DIR + (String)("\\*.DLL");              const String plugindir = (String)CONFIG_PLUGIN_DIR + (String)("\\*.DLL");
110              HANDLE hDir = FindFirstFile(plugindir.c_str(), &win32FindData);              HANDLE hDir = FindFirstFile(plugindir.c_str(), &win32FindData);
111              if (hDir == INVALID_HANDLE_VALUE) {              if (hDir == INVALID_HANDLE_VALUE) {
112                  if(GetLastError() != ERROR_FILE_NOT_FOUND) {                  if (GetLastError() != ERROR_FILE_NOT_FOUND) {
113                      std::cerr << "Could not open instrument editor plugins directory "                      std::cerr << "Could not open instrument editor plugins "
114                          << "(" << CONFIG_PLUGIN_DIR << "): Error "                                << "directory (" << CONFIG_PLUGIN_DIR << "), "
115                          << GetLastError() << std::endl;                                << "Error: " << GetLastError() << std::endl;
116                      return;                  } else {
117                  }                      dmsg(1,("None"));
                 else {  
                     firstFileFound = false;              
118                  }                  }
119                    // either dir doesn't exist or is empty
120                    return;
121              }              }
122    
123              while(GetLastError() != ERROR_NO_MORE_FILES && firstFileFound) {              do {
124                  if(!(win32FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {                  // skip directory entries
125                      String sPath = (String)CONFIG_PLUGIN_DIR + ((String)"\\" + (String)win32FindData.cFileName);                  if (win32FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
126                      // load the DLL (the plugins should register themselfes automatically)                      continue;
127                      HINSTANCE hinstLib;                  // dir entry name as full qualified path
128                      void* pDLL = hinstLib = LoadLibrary( sPath.c_str() );                  const String sPath = (String)CONFIG_PLUGIN_DIR + ((String)"\\" + (String)win32FindData.cFileName);
129                      if (!pDLL) {                  // load the DLL
130                          std::cerr << "Failed to load instrument editor plugin: "                  HINSTANCE hinstLib;
131                                    << sPath << std::endl;                  void* pDLL = hinstLib = LoadLibrary(sPath.c_str());
132                          continue;                  if (!pDLL) {
133                      }                      std::cerr << "Failed to load instrument editor plugin: "
134                                                      << sPath << std::endl;
135                      //(InnerFactory*) (*fn)(void);                      continue;
136                      InnerFactoryRegisterFunction fn;                  }
137                      fn = (InnerFactoryRegisterFunction)  
138                    //(InnerFactory*) (*fn)(void);
139                    InnerFactoryRegisterFunction fn =
140                        (InnerFactoryRegisterFunction)
141                          GetProcAddress(                          GetProcAddress(
142                              hinstLib,                              hinstLib,
143                              "createInstrumentEditorInnerFactory"                              "createInstrumentEditorInnerFactory"
144                          );                          );
145                      if (fn == NULL) {                  if (fn == NULL) {
146                          std::cerr << "ERROR: unable to find "                      std::cerr << "ERROR: unable to find "
147                                       "createInstrumentEditorInnerFactory() "                                   "createInstrumentEditorInnerFactory() "
148                                       "in DLL\n" << std::flush;                                   "in DLL\n" << std::flush;
149                          FreeLibrary(hinstLib);                      FreeLibrary(hinstLib);
150                          continue;                      continue;
                     }  
                       
                     // get the plugin instance and register it to the factory  
                       
                     InnerFactory* pInnerFactory = (InnerFactory*)fn();  
                     if (!pInnerFactory) {  
                         std::cerr << "ERROR: !pInnerFactory\n" << std::flush;  
                         FreeLibrary(hinstLib);  
                         continue;  
                     }  
                     InstrumentEditor* pEditor = pInnerFactory->Create();  
                     if (InnerFactories.count(pEditor->Name())) {  
                         std::cerr << "ERROR: a plugin with name '"  
                                   << pEditor->Name()  
                                   << "' already loaded (skipping)\n"  
                                   << std::flush;  
                         pInnerFactory->Destroy(pEditor);  
                         FreeLibrary(hinstLib);  
                         continue;  
                     }  
                     InnerFactories[pEditor->Name()] = pInnerFactory;  
                     pInnerFactory->Destroy(pEditor);  
                       
                     LoadedDLLs.push_back(pDLL);  
151                  }                  }
152                  int res = FindNextFile(hDir, &win32FindData);  
153                  if(res == 0 && GetLastError() != ERROR_NO_MORE_FILES) {                  // get the plugin instance and register it to the factory
154                      std::cerr << "Error while reading plugins directory FindNextFile Error "  
155                                << GetLastError() << std::endl;                  InnerFactory* pInnerFactory = (InnerFactory*)fn();
156                      return;                                if (!pInnerFactory) {
157                        std::cerr << "ERROR: !pInnerFactory\n" << std::flush;
158                        FreeLibrary(hinstLib);
159                        continue;
160                  }                  }
161              }                  InstrumentEditor* pEditor = pInnerFactory->Create();
162              FindClose(hDir);                  if (InnerFactories.count(pEditor->Name())) {
163                        std::cerr << "ERROR: a plugin with name '"
164                                  << pEditor->Name()
165                                  << "' already loaded (skipping)\n"
166                                  << std::flush;
167                        pInnerFactory->Destroy(pEditor);
168                        FreeLibrary(hinstLib);
169                        continue;
170                    }
171                    InnerFactories[pEditor->Name()] = pInnerFactory;
172                    pInnerFactory->Destroy(pEditor);
173    
174                    LoadedDLLs.push_back(pDLL);
175                } while (FindNextFile(hDir, &win32FindData));
176                if (hDir != INVALID_HANDLE_VALUE) FindClose(hDir);
177              #else // POSIX              #else // POSIX
178                            #if defined(__APPLE__)  /*  20071224 Toshi Nagata  */
179                            String Config_plugin_dir = (String)CONFIG_PLUGIN_DIR;
180                            if (Config_plugin_dir.find("~") == 0)
181                                       Config_plugin_dir.replace(0, 1, getenv("HOME"));
182                            DIR* hDir = opendir(Config_plugin_dir.c_str());
183                            #else
184              DIR* hDir = opendir(CONFIG_PLUGIN_DIR);              DIR* hDir = opendir(CONFIG_PLUGIN_DIR);
185                            #endif
186              if (!hDir) {              if (!hDir) {
187                  std::cerr << "Could not open instrument editor plugins directory "                  std::cerr << "Could not open instrument editor plugins directory "
188                            << "(" << CONFIG_PLUGIN_DIR << "): "                            << "(" << CONFIG_PLUGIN_DIR << "): "
# Line 189  namespace LinuxSampler { Line 191  namespace LinuxSampler {
191              }              }
192              for (dirent* pEntry = readdir(hDir); pEntry; pEntry = readdir(hDir)) {              for (dirent* pEntry = readdir(hDir); pEntry; pEntry = readdir(hDir)) {
193                  // dir entry name as full qualified path                  // dir entry name as full qualified path
194                            #if defined(__APPLE__)  /*  20080110 Toshi Nagata  */
195                    const String sPath = Config_plugin_dir + ("/" + String(pEntry->d_name));
196                            #else
197                  const String sPath = CONFIG_PLUGIN_DIR + ("/" + String(pEntry->d_name));                  const String sPath = CONFIG_PLUGIN_DIR + ("/" + String(pEntry->d_name));
198                            #endif
199                  // skip entries that are not regular files                  // skip entries that are not regular files
200                  struct stat entry_stat;                  struct stat entry_stat;
201                  if (lstat(sPath.c_str(), &entry_stat) != 0 ||                  if (lstat(sPath.c_str(), &entry_stat) != 0 ||
# Line 204  namespace LinuxSampler { Line 210  namespace LinuxSampler {
210                  void* pDLL = dlopen(sPath.c_str(), RTLD_NOW);                  void* pDLL = dlopen(sPath.c_str(), RTLD_NOW);
211                  if (pDLL) LoadedDLLs.push_back(pDLL);                  if (pDLL) LoadedDLLs.push_back(pDLL);
212                  else {                  else {
213                      std::cerr << "Failed to load instrument editor plugin: "                      std::cerr << "Failed to load instrument editor plugin: '"
214                                << sPath << std::endl;                                << sPath << "', cause: " << dlerror() << std::endl;
215                  }                  }
216              }              }
217              closedir(hDir);              closedir(hDir);
Legend:
Removed from v.1601  
changed lines
  Added in v.1653
  ViewVC Help
Powered by ViewVC