ifndef OFX_DIRLIST
  define OFX_DIRLIST
  
  

**********************************************************

  OpenFrameworks Library
  
  File:                         ofxDirList.h
  Description:         List the contents of a directory
  Notes:                        Now takes string arguements and starts at the data/ folder level
                  Now all C++ strings! No more arrays.
  
  Last Modified: 2009.03.01
  Creator: Theodore Watson
  
  ************************************************************/
  
  include <ofMain.h>
  
  ifdef TARGET_WIN32
          #include <stdio.h>
          #include <iostream>
          #include <string.h>
  else
          #include <dirent.h>
  endif
  
  class ofxDirList{
  
          public:
                  ofxDirList();
                  void setVerbose(bool _verbose);
                  string getName(int pos);
                  string getPath(int pos);
          void reset();                                                                                                // resets extension list
                  bool allowExt(string ext);                                                                        // returns true if ext is accepted
                  int listDir(string directory);                                                                // returns number of files found
  
          private:
          vector <string> allowedFileExt;
          vector <string> nameArray;
          vector <string> pathArray;
  
  };
  
  // this is WIN32 dirent included in here for ease of usage
  // since windows doesn't have dirent by default.  this is just a wrapper....
  // because we haven't written win32 version of the same code
  
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  
  /*
   * dirent.h - dirent API for Microsoft Visual Studio
   *
   * Copyright (C) 2006 Toni Ronkko
   *
   * Permission is hereby granted, free of charge, to any person obtaining
   * a copy of this software and associated documentation files (the
   * ``Software''), to deal in the Software without restriction, including
   * without limitation the rights to use, copy, modify, merge, publish,
   * distribute, sublicense, and/or sell copies of the Software, and to
   * permit persons to whom the Software is furnished to do so, subject to
   * the following conditions:
   *
   * The above copyright notice and this permission notice shall be included
   * in all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
   * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   * IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
   * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
   * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
   * OTHER DEALINGS IN THE SOFTWARE.
   */
  
  ifdef TARGET_WIN32
  
          #include <windows.h>
          #include <tchar.h>
          #include <string.h>
          #include <assert.h>
  
          typedef struct dirent {
            /* name of current directory entry (a multi-byte character string) */
            char d_name[MAX_PATH + 1];
  
            /* file attributes */
            WIN32_FIND_DATA data;
          } dirent;
  
          typedef struct DIR {
            /* current directory entry */
            dirent current;
  
            /* is there an un-processed entry in current? */
            int cached;
  
            /* file search handle */
            HANDLE search_handle;
  
            /* search pattern (3 = zero terminator + pattern "\\*") */
            TCHAR patt[MAX_PATH + 3];
          } DIR;
  
          static DIR *opendir (const char *dirname);
          static struct dirent *readdir (DIR *dirp);
          static int closedir (DIR *dirp);
  
          /* use the new safe string functions introduced in Visual Studio 2005 */
          #if defined(_MSC_VER) && _MSC_VER >= 1400
          # define STRNCPY(dest,src,size) strncpy_s((dest),(size),(src),_TRUNCATE)
          #else
          # define STRNCPY(dest,src,size) strncpy((dest),(src),(size))
          #endif
  
          /*
  	 * Open directory stream DIRNAME for read and return a pointer to the
  	 * internal working area that is used to retrieve individual directory
  	 * entries.
  	 */
          static DIR*
          opendir(
              const char *dirname)
          {
            DIR *dirp;
            assert (dirname != NULL);
            assert (strlen (dirname) < MAX_PATH);
  
            /* construct new DIR structure */
            dirp = (DIR*) malloc (sizeof (struct DIR));
            if (dirp != NULL) {
              TCHAR *p;
  
              /* prepare search pattern */
          #ifdef _UNICODE
  
              /* convert directory name to wide character string */
              MultiByteToWideChar(
                  CP_ACP,                                /* code page */
                  0,                                     /* conversion flags */
                  dirname,                               /* mb-string to convert */
                  -1,                                    /* length of mb-string */
                  dirp->patt,                            /* wc-string to produce */
                  MAX_PATH);                             /* max length of wc-string */
              dirp->patt[MAX_PATH] = '\0';
  
              /* append search pattern to directory name */
              p = wcschr (dirp->patt, '\0');
              if (dirp->patt < p  &&  *(p-1) != '\\'  &&  *(p-1) != ':') {
  	      *p++ = '\\';
              }
  	    *p++ = '*';
  	    *p = '\0';
  
          #else /* !_UNICODE */
  
              /* take directory name... */
              STRNCPY (dirp->patt, dirname, sizeof(dirp->patt));
              dirp->patt[MAX_PATH] = '\0';
  
              /* ... and append search pattern to it */
              p = strchr (dirp->patt, '\0');
              if (dirp->patt < p  &&  *(p-1) != '\\'  &&  *(p-1) != ':') {
  	      *p++ = '\\';
              }
  	    *p++ = '*';
  	    *p = '\0';
  
          #endif /* !_UNICODE */
  
              /* open stream and retrieve first file */
              dirp->search_handle = FindFirstFile (dirp->patt, &dirp->current.data);
              if (dirp->search_handle == INVALID_HANDLE_VALUE) {
                /* invalid search pattern? */
                free (dirp);
                return NULL;
              }
  
              /* there is an un-processed directory entry in memory now */
              dirp->cached = 1;
  
            }
            return dirp;
          }
  
          /*
  	 * Read a directory entry, and return a pointer to a dirent structure
  	 * containing the name of the entry in d_name field.  Individual directory
  	 * entries returned by this very function include regular files,
  	 * sub-directories, pseudo-directories "." and "..", but also volume labels,
  	 * hidden files and system files may be returned.
  	 */
          static struct dirent *
          readdir(
              DIR *dirp)
          {
            assert (dirp != NULL);
  
            if (dirp->search_handle == INVALID_HANDLE_VALUE) {
              /* directory stream was opened/rewound incorrectly or it ended normally */
              return NULL;
            }
  
            /* get next directory entry */
            if (dirp->cached != 0) {
              /* a valid directory entry already in memory */
              dirp->cached = 0;
            } else {
              /* read next directory entry from disk */
              if (FindNextFile (dirp->search_handle, &dirp->current.data) == FALSE) {
                /* the very last file has been processed or an error occured */
                FindClose (dirp->search_handle);
                dirp->search_handle = INVALID_HANDLE_VALUE;
                return NULL;
              }
            }
  
            /* copy directory entry to d_name */
          #ifdef _UNICODE
  
            /* convert entry name to multibyte */
            WideCharToMultiByte(
                CP_ACP,                                  /* code page */
                0,                                       /* conversion flags */
                dirp->current.data.cFileName,            /* wc-string to convert */
                -1,                                      /* length of wc-string */
                dirp->current.d_name,                    /* mb-string to produce */
                MAX_PATH,                                /* max length of mb-string */
                NULL,                                    /* use sys default character */
                NULL);                                   /* don't care  */
            dirp->current.d_name[MAX_PATH] = '\0';
  
          #else /* !_UNICODE */
  
            /* copy as a multibyte character string */
            STRNCPY (dirp->current.d_name, dirp->current.data.cFileName, sizeof(dirp->current.d_name));
            dirp->current.d_name[MAX_PATH] = '\0';
  
          #endif /* !_UNICODE */
  
            return &dirp->current;
          }
  
          /*
  	 * Close directory stream opened by opendir() function.  Close of the
  	 * directory stream invalidates the DIR structure as well as any previously
  	 * read directory entry.
  	 */
          static int
          closedir(
              DIR *dirp)
          {
            assert (dirp != NULL);
  
            /* release search handle */
            if (dirp->search_handle != INVALID_HANDLE_VALUE) {
              FindClose (dirp->search_handle);
              dirp->search_handle = INVALID_HANDLE_VALUE;
            }
  
            /* release directory handle */
            free (dirp);
            return 0;
          }
  
  endif
  
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  
  endif
  

---

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

---

(C) Æliens 04/09/2009

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.