formatting changes only.
authorCampbell Barton <ideasman42@gmail.com>
Thu, 19 May 2011 13:50:53 +0000 (13:50 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 19 May 2011 13:50:53 +0000 (13:50 +0000)
source/blender/blenlib/intern/bpath.c

index 63a8df3f73a1e9e0f3d65849e24808f564c6bd01..654ade8955f800325babc610b1a7c3c4f5c54649 100644 (file)
 #include "BKE_utildefines.h"
 #include "BKE_report.h"
 
-//XXX #include "BIF_screen.h" /* only for wait cursor */
-//
-/* for sequence */
-//XXX #include "BSE_sequence.h"
-//XXX define below from BSE_sequence.h - otherwise potentially odd behaviour
-
-
-typedef struct BPathIteratorSeqData {
+typedef struct BPathIteratorSeqData
+{
        int totseq;
        int seq;
-       struct Sequence **seqar; /* Sequence */
-       struct Scene *scene;                    /* Current scene */
+       struct Sequence **seqar;        /* Sequence */
+       struct Scene *scene;            /* Current scene */
 } BPathIteratorSeqData;
 
-typedef struct BPathIterator {
+typedef struct BPathIterator
+{
        char*   _path; /* never access directly, use BLI_bpathIterator_getPath */
        const char*     _lib;
        const char*     _name;
@@ -94,7 +89,7 @@ typedef struct BPathIterator {
        void (*setpath_callback)(struct BPathIterator *, const char *);
        void (*getpath_callback)(struct BPathIterator *, char *);
 
-       const char*     base_path; /* base path, the directry the blend file is in - normally bmain->name */
+       const char*     base_path; /* base path, the directory the blend file is in - normally bmain->name */
 
        Main *bmain;
 
@@ -116,7 +111,7 @@ enum BPathTypes {
        BPATH_SEQ,
        BPATH_CDATA,
 
-        BPATH_DONE
+       BPATH_DONE
 };
 
 void BLI_bpathIterator_init(struct BPathIterator **bpi_pt, Main *bmain, const char *basedir, const int flag)
@@ -128,10 +123,10 @@ void BLI_bpathIterator_init(struct BPathIterator **bpi_pt, Main *bmain, const ch
 
        bpi->type= BPATH_IMAGE;
        bpi->data= NULL;
-       
+
        bpi->getpath_callback= NULL;
        bpi->setpath_callback= NULL;
-       
+
        /* Sequencer specific */
        bpi->seqdata.totseq= 0;
        bpi->seqdata.seq= 0;
@@ -147,62 +142,75 @@ void BLI_bpathIterator_init(struct BPathIterator **bpi_pt, Main *bmain, const ch
 }
 
 #if 0
-static void BLI_bpathIterator_alloc(struct BPathIterator **bpi) {
+static void BLI_bpathIterator_alloc(struct BPathIterator **bpi)
+{
        *bpi= MEM_mallocN(sizeof(BPathIterator), "BLI_bpathIterator_alloc");
 }
 #endif
 
-void BLI_bpathIterator_free(struct BPathIterator *bpi) {
+void BLI_bpathIterator_free(struct BPathIterator *bpi)
+{
        if (bpi->seqdata.seqar)
                MEM_freeN((void *)bpi->seqdata.seqar);
        bpi->seqdata.seqar= NULL;
        bpi->seqdata.scene= NULL;
-       
+
        MEM_freeN(bpi);
 }
 
-void BLI_bpathIterator_getPath(struct BPathIterator *bpi, char *path) {
+void BLI_bpathIterator_getPath(struct BPathIterator *bpi, char *path)
+{
        if (bpi->getpath_callback) {
                bpi->getpath_callback(bpi, path);
-       } else {
+       }
+       else {
                strcpy(path, bpi->_path); /* warning, we assume 'path' are long enough */
        }
 }
 
-void BLI_bpathIterator_setPath(struct BPathIterator *bpi, const char *path) {
+void BLI_bpathIterator_setPath(struct BPathIterator *bpi, const char *path)
+{
        if (bpi->setpath_callback) {
                bpi->setpath_callback(bpi, path);
-       } else {
+       }
+       else {
                strcpy(bpi->_path, path); /* warning, we assume 'path' are long enough */
        }
 }
 
-void BLI_bpathIterator_getPathExpanded(struct BPathIterator *bpi, char *path_expanded) {
+void BLI_bpathIterator_getPathExpanded(struct BPathIterator *bpi, char *path_expanded)
+{
        const char *libpath;
-       
+
        BLI_bpathIterator_getPath(bpi, path_expanded);
        libpath= BLI_bpathIterator_getLib(bpi);
-       
+
        if (libpath) { /* check the files location relative to its library path */
                BLI_path_abs(path_expanded, libpath);
-       } else { /* local data, use the blend files path */
+       }
+       else { /* local data, use the blend files path */
                BLI_path_abs(path_expanded, bpi->base_path);
        }
        BLI_cleanup_file(NULL, path_expanded);
 }
-const char* BLI_bpathIterator_getLib(struct BPathIterator *bpi) {
+const char* BLI_bpathIterator_getLib(struct BPathIterator *bpi)
+{
        return bpi->_lib;
 }
-const char* BLI_bpathIterator_getName(struct BPathIterator *bpi) {
+const char* BLI_bpathIterator_getName(struct BPathIterator *bpi)
+{
        return bpi->_name;
 }
-int    BLI_bpathIterator_getType(struct BPathIterator *bpi) {
+int    BLI_bpathIterator_getType(struct BPathIterator *bpi)
+{
        return bpi->type;
 }
-unsigned int   BLI_bpathIterator_getPathMaxLen(struct BPathIterator *bpi) {
+unsigned int   BLI_bpathIterator_getPathMaxLen(struct BPathIterator *bpi)
+{
        return bpi->len;
 }
-const char* BLI_bpathIterator_getBasePath(struct BPathIterator *bpi) {
+const char* BLI_bpathIterator_getBasePath(struct BPathIterator *bpi)
+{
        return bpi->base_path;
 }
 
@@ -211,10 +219,10 @@ static struct Image *ima_stepdata__internal(struct Image *ima, const int step_ne
 {
        if (ima==NULL)
                return NULL;
-       
+
        if (step_next)
                ima= ima->id.next;
-       
+
        while (ima) {
                if (ELEM3(ima->source, IMA_SRC_FILE, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
                        if(ima->packedfile==NULL || (flag & BPATH_USE_PACKED)) {
@@ -223,7 +231,7 @@ static struct Image *ima_stepdata__internal(struct Image *ima, const int step_ne
                }
                /* image is not a image with a path, skip it */
                ima= ima->id.next;
-       }       
+       }
        return ima;
 }
 
@@ -240,7 +248,7 @@ static struct Tex *tex_stepdata__internal(struct Tex *tex, const int step_next,
                        break;
                /* image is not a image with a path, skip it */
                tex= tex->id.next;
-       }       
+       }
        return tex;
 }
 
@@ -257,7 +265,7 @@ static struct Text *text_stepdata__internal(struct Text *text, const int step_ne
                        break;
                /* image is not a image with a path, skip it */
                text= text->id.next;
-       }       
+       }
        return text;
 }
 
@@ -265,20 +273,20 @@ static struct VFont *vf_stepdata__internal(struct VFont *vf, const int step_next
 {
        if (vf==NULL)
                return NULL;
-       
+
        if (step_next)
                vf= vf->id.next;
-       
+
        while (vf) {
                if (strcmp(vf->name, FO_BUILTIN_NAME)!=0) {
                        if(vf->packedfile==NULL || (flag & BPATH_USE_PACKED)) {
                                break;
                        }
                }
-               
+
                /* font with no path, skip it */
                vf= vf->id.next;
-       }       
+       }
        return vf;
 }
 
@@ -286,10 +294,10 @@ static struct bSound *snd_stepdata__internal(struct bSound *snd, int step_next,
 {
        if (snd==NULL)
                return NULL;
-       
+
        if (step_next)
                snd= snd->id.next;
-       
+
        while (snd) {
                if(snd->packedfile==NULL || (flag & BPATH_USE_PACKED)) {
                        break;
@@ -297,7 +305,7 @@ static struct bSound *snd_stepdata__internal(struct bSound *snd, int step_next,
 
                /* font with no path, skip it */
                snd= snd->id.next;
-       }       
+       }
        return snd;
 }
 
@@ -305,16 +313,16 @@ static struct Sequence *seq_stepdata__internal(struct BPathIterator *bpi, int st
 {
        Editing *ed;
        Sequence *seq;
-       
+
        /* Initializing */
        if (bpi->seqdata.scene==NULL) {
                bpi->seqdata.scene= bpi->bmain->scene.first;
        }
-       
+
        if (step_next) {
                bpi->seqdata.seq++;
        }
-       
+
        while (bpi->seqdata.scene) {
                ed= seq_give_editing(bpi->seqdata.scene, 0);
                if (ed) {
@@ -323,10 +331,11 @@ static struct Sequence *seq_stepdata__internal(struct BPathIterator *bpi, int st
                                seq_array(ed, &bpi->seqdata.seqar, &bpi->seqdata.totseq, 0);
                                bpi->seqdata.seq= 0;
                        }
-                       
+
                        if (bpi->seqdata.seq >= bpi->seqdata.totseq) {
                                seq= NULL;
-                       } else {
+                       }
+                       else {
                                seq= bpi->seqdata.seqar[bpi->seqdata.seq];
                                while (!SEQ_HAS_PATH(seq) && seq->plugin==NULL) {
                                        bpi->seqdata.seq++;
@@ -339,7 +348,8 @@ static struct Sequence *seq_stepdata__internal(struct BPathIterator *bpi, int st
                        }
                        if (seq) {
                                return seq;
-                       } else {
+                       }
+                       else {
                                /* keep looking through the next scene, reallocate seq array */
                                if (bpi->seqdata.seqar) {
                                        MEM_freeN((void *)bpi->seqdata.seqar);
@@ -347,19 +357,21 @@ static struct Sequence *seq_stepdata__internal(struct BPathIterator *bpi, int st
                                }
                                bpi->seqdata.scene= bpi->seqdata.scene->id.next;
                        }
-               } else {
+               }
+               else {
                        /* no seq data in this scene, next */
                        bpi->seqdata.scene= bpi->seqdata.scene->id.next;
                }
        }
-       
+
        return NULL;
 }
 
-static void seq_getpath(struct BPathIterator *bpi, char *path) {
+static void seq_getpath(struct BPathIterator *bpi, char *path)
+{
        Sequence *seq= (Sequence *)bpi->data;
 
-       
+
        path[0]= '\0'; /* incase we cant get the path */
        if (seq==NULL) return;
        if (SEQ_HAS_PATH(seq)) {
@@ -369,7 +381,7 @@ static void seq_getpath(struct BPathIterator *bpi, char *path) {
                        if (seq->strip->stripdata) { /* should always be true! */
                                /* Using the first image is weak for image sequences */
                                strcat(path, seq->strip->stripdata->name);
-                       } 
+                       }
                }
                else {
                        /* simple case */
@@ -381,10 +393,11 @@ static void seq_getpath(struct BPathIterator *bpi, char *path) {
        }
 }
 
-static void seq_setpath(struct BPathIterator *bpi, const char *path) {
+static void seq_setpath(struct BPathIterator *bpi, const char *path)
+{
        Sequence *seq= (Sequence *)bpi->data;
-       if (seq==NULL) return; 
-       
+       if (seq==NULL) return;
+
        if (SEQ_HAS_PATH(seq)) {
                if (ELEM3(seq->type, SEQ_IMAGE, SEQ_MOVIE, SEQ_SOUND)) {
                        BLI_split_dirfile(path, seq->strip->dir, seq->strip->stripdata->name);
@@ -399,7 +412,8 @@ static void seq_setpath(struct BPathIterator *bpi, const char *path) {
        }
 }
 
-static void text_getpath(struct BPathIterator *bpi, char *path) {
+static void text_getpath(struct BPathIterator *bpi, char *path)
+{
        Text *text= (Text *)bpi->data;
        path[0]= '\0'; /* incase we cant get the path */
        if(text->name) {
@@ -407,9 +421,10 @@ static void text_getpath(struct BPathIterator *bpi, char *path) {
        }
 }
 
-static void text_setpath(struct BPathIterator *bpi, const char *path) {
+static void text_setpath(struct BPathIterator *bpi, const char *path)
+{
        Text *text= (Text *)bpi->data;
-       if (text==NULL) return; 
+       if (text==NULL) return;
 
        if(text->name) {
                MEM_freeN(text->name);
@@ -418,27 +433,29 @@ static void text_setpath(struct BPathIterator *bpi, const char *path) {
        text->name= BLI_strdup(path);
 }
 
-static struct Mesh *cdata_stepdata__internal(struct Mesh *me, int step_next) {
+static struct Mesh *cdata_stepdata__internal(struct Mesh *me, int step_next)
+{
        if (me==NULL)
                return NULL;
-       
+
        if (step_next)
                me= me->id.next;
-       
+
        while (me) {
                if (me->fdata.external) {
                        break;
                }
-               
+
                me= me->id.next;
-       }       
+       }
        return me;
 }
 
-static void bpi_type_step__internal(struct BPathIterator *bpi) {
+static void bpi_type_step__internal(struct BPathIterator *bpi)
+{
        bpi->type++; /* advance to the next type */
        bpi->data= NULL;
-       
+
        switch (bpi->type) {
        case BPATH_SEQ:
                bpi->getpath_callback= seq_getpath;
@@ -455,27 +472,29 @@ static void bpi_type_step__internal(struct BPathIterator *bpi) {
        }
 }
 
-void BLI_bpathIterator_step(struct BPathIterator *bpi) {
+void BLI_bpathIterator_step(struct BPathIterator *bpi)
+{
        while (bpi->type != BPATH_DONE) {
-               
+
                if  ((bpi->type) == BPATH_IMAGE) {
                        /*if (bpi->data)        bpi->data= ((ID *)bpi->data)->next;*/
                        if (bpi->data)  bpi->data= ima_stepdata__internal((Image *)bpi->data, 1, bpi->flag); /* must skip images that have no path */
                        else                    bpi->data= ima_stepdata__internal(bpi->bmain->image.first, 0, bpi->flag);
-                       
+
                        if (bpi->data) {
                                /* get the path info from this datatype */
                                Image *ima= (Image *)bpi->data;
-                               
+
                                bpi->_lib= ima->id.lib ? ima->id.lib->filepath : NULL;
                                bpi->_path= ima->name;
                                bpi->_name= ima->id.name+2;
                                bpi->len= sizeof(ima->name);
-                               
+
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
 
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
                }
@@ -502,7 +521,8 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
 
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
                }
@@ -524,11 +544,11 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
 
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
                }
-
                else if  ((bpi->type) == BPATH_SOUND) {
                        if (bpi->data)  bpi->data= snd_stepdata__internal((bSound *)bpi->data, 1, bpi->flag); /* must skip images that have no path */
                        else                    bpi->data= snd_stepdata__internal(bpi->bmain->sound.first, 0, bpi->flag);
@@ -544,16 +564,16 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
 
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
-                       
-                       
-               } else if  ((bpi->type) == BPATH_FONT) {
-                       
+               }
+               else if  ((bpi->type) == BPATH_FONT) {
+
                        if (bpi->data)  bpi->data= vf_stepdata__internal((VFont *)bpi->data, 1, bpi->flag);
                        else                    bpi->data= vf_stepdata__internal(bpi->bmain->vfont.first, 0, bpi->flag);
-                       
+
                        if (bpi->data) {
                                /* get the path info from this datatype */
                                VFont *vf= (VFont *)bpi->data;
@@ -565,29 +585,33 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
 
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
 
-               } else if  ((bpi->type) == BPATH_LIB) {
+               }
+               else if  ((bpi->type) == BPATH_LIB) {
                        if (bpi->data)  bpi->data= ((ID *)bpi->data)->next;
                        else                    bpi->data= bpi->bmain->library.first;
-                       
+
                        if (bpi->data) {
                                /* get the path info from this datatype */
                                Library *lib= (Library *)bpi->data;
-                               
+
                                bpi->_lib= NULL;
                                bpi->_path= lib->name;
                                bpi->_name= NULL;
                                bpi->len= sizeof(lib->name);
-                               
+
                                /* we are done, advancing to the next item, this type worked fine */
                                break;
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
-               } else if  ((bpi->type) == BPATH_SEQ) {
+               }
+               else if  ((bpi->type) == BPATH_SEQ) {
                        if (bpi->data)  bpi->data= seq_stepdata__internal( bpi, 1 );
                        else                    bpi->data= seq_stepdata__internal( bpi, 0 );
                        if (bpi->data) {
@@ -596,10 +620,12 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
                                bpi->_name= seq->name+2;
                                bpi->len= seq->plugin ? sizeof(seq->plugin->name) : sizeof(seq->strip->dir) + sizeof(seq->strip->stripdata->name);
                                break;
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
-               } else if  ((bpi->type) == BPATH_CDATA) {
+               }
+               else if  ((bpi->type) == BPATH_CDATA) {
                        if (bpi->data)  bpi->data= cdata_stepdata__internal( bpi->data, 1 );
                        else                    bpi->data= cdata_stepdata__internal( bpi->bmain->mesh.first, 0 );
 
@@ -610,7 +636,8 @@ void BLI_bpathIterator_step(struct BPathIterator *bpi) {
                                bpi->_name= me->id.name+2;
                                bpi->len= sizeof(me->fdata.external->filename);
                                break;
-                       } else {
+                       }
+                       else {
                                bpi_type_step__internal(bpi);
                        }
                }
@@ -627,7 +654,7 @@ static void bpath_as_report(struct BPathIterator *bpi, const char *message, Repo
        const char *prefix;
        const char *name;
        char path_expanded[FILE_MAXDIR*2];
-       
+
        if(reports==NULL)
                return;
 
@@ -660,7 +687,7 @@ static void bpath_as_report(struct BPathIterator *bpi, const char *message, Repo
                prefix= "Unknown";
                break;
        }
-       
+
        name= BLI_bpathIterator_getName(bpi);
        BLI_bpathIterator_getPathExpanded(bpi, path_expanded);
 
@@ -674,14 +701,14 @@ static void bpath_as_report(struct BPathIterator *bpi, const char *message, Repo
 /* high level function */
 void checkMissingFiles(Main *bmain, ReportList *reports) {
        struct BPathIterator *bpi;
-       
+
        /* be sure there is low chance of the path being too short */
-       char filepath_expanded[FILE_MAXDIR*2]; 
-       
+       char filepath_expanded[FILE_MAXDIR*2];
+
        BLI_bpathIterator_init(&bpi, bmain, bmain->name, 0);
        while (!BLI_bpathIterator_isDone(bpi)) {
                BLI_bpathIterator_getPathExpanded(bpi, filepath_expanded);
-               
+
                if (!BLI_exists(filepath_expanded))
                        bpath_as_report(bpi, "file not found", reports);
 
@@ -696,7 +723,7 @@ void makeFilesRelative(Main *bmain, const char *basedir, ReportList *reports) {
        struct BPathIterator *bpi;
        char filepath[FILE_MAX];
        const char *libpath;
-       
+
        /* be sure there is low chance of the path being too short */
        char filepath_relative[(FILE_MAXDIR * 2) + FILE_MAXFILE];
 
@@ -709,25 +736,28 @@ void makeFilesRelative(Main *bmain, const char *basedir, ReportList *reports) {
        while (!BLI_bpathIterator_isDone(bpi)) {
                BLI_bpathIterator_getPath(bpi, filepath);
                libpath= BLI_bpathIterator_getLib(bpi);
-               
+
                if(strncmp(filepath, "//", 2)) {
                        if (libpath) { /* cant make relative if we are library - TODO, LOG THIS */
                                linked++;
-                       } else { /* local data, use the blend files path */
+                       }
+                       else { /* local data, use the blend files path */
                                BLI_strncpy(filepath_relative, filepath, sizeof(filepath_relative));
                                /* Important BLI_cleanup_dir runs before the path is made relative
-                                * because it wont work for paths that start with "//../" */ 
+                                * because it wont work for paths that start with "//../" */
                                BLI_cleanup_file(bpi->base_path, filepath_relative); /* fix any /foo/../foo/ */
                                BLI_path_rel(filepath_relative, bpi->base_path);
                                /* be safe and check the length */
                                if (BLI_bpathIterator_getPathMaxLen(bpi) <= strlen(filepath_relative)) {
                                        bpath_as_report(bpi, "couldn't make path relative (too long)", reports);
                                        failed++;
-                               } else {
+                               }
+                               else {
                                        if(strncmp(filepath_relative, "//", 2)==0) {
                                                BLI_bpathIterator_setPath(bpi, filepath_relative);
                                                changed++;
-                                       } else {
+                                       }
+                                       else {
                                                bpath_as_report(bpi, "couldn't make path relative", reports);
                                                failed++;
                                        }
@@ -752,7 +782,7 @@ void makeFilesAbsolute(Main *bmain, const char *basedir, ReportList *reports)
        struct BPathIterator *bpi;
        char filepath[FILE_MAX];
        const char *libpath;
-       
+
        /* be sure there is low chance of the path being too short */
        char filepath_absolute[(FILE_MAXDIR * 2) + FILE_MAXFILE];
 
@@ -765,22 +795,25 @@ void makeFilesAbsolute(Main *bmain, const char *basedir, ReportList *reports)
        while (!BLI_bpathIterator_isDone(bpi)) {
                BLI_bpathIterator_getPath(bpi, filepath);
                libpath= BLI_bpathIterator_getLib(bpi);
-               
+
                if(strncmp(filepath, "//", 2)==0) {
                        if (libpath) { /* cant make absolute if we are library - TODO, LOG THIS */
                                linked++;
-                       } else { /* get the expanded path and check it is relative or too long */
+                       }
+                       else { /* get the expanded path and check it is relative or too long */
                                BLI_bpathIterator_getPathExpanded(bpi, filepath_absolute);
                                BLI_cleanup_file(bpi->base_path, filepath_absolute); /* fix any /foo/../foo/ */
                                /* to be safe, check the length */
                                if (BLI_bpathIterator_getPathMaxLen(bpi) <= strlen(filepath_absolute)) {
                                        bpath_as_report(bpi, "couldn't make absolute (too long)", reports);
                                        failed++;
-                               } else {
+                               }
+                               else {
                                        if(strncmp(filepath_absolute, "//", 2)) {
                                                BLI_bpathIterator_setPath(bpi, filepath_absolute);
                                                changed++;
-                                       } else {
+                                       }
+                                       else {
                                                bpath_as_report(bpi, "couldn't make absolute", reports);
                                                failed++;
                                        }
@@ -811,25 +844,25 @@ static int findFileRecursive(char *filename_new, const char *dirname, const char
        struct stat status;
        char path[FILE_MAX];
        int size;
-       
+
        dir= opendir(dirname);
-       
+
        if (dir==NULL)
                return 0;
-       
+
        if (*filesize == -1)
                *filesize= 0; /* dir opened fine */
-       
+
        while ((de= readdir(dir)) != NULL) {
-               
+
                if (strcmp(".", de->d_name)==0 || strcmp("..", de->d_name)==0)
                        continue;
-               
+
                BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
-               
+
                if (stat(path, &status) != 0)
                        continue; /* cant stat, dont bother with this file, could print debug info here */
-               
+
                if (S_ISREG(status.st_mode)) { /* is file */
                        if (strncmp(filename, de->d_name, FILE_MAX)==0) { /* name matches */
                                /* open the file to read its size */
@@ -839,7 +872,8 @@ static int findFileRecursive(char *filename_new, const char *dirname, const char
                                        BLI_strncpy(filename_new, path, FILE_MAX);
                                }
                        }
-               } else if (S_ISDIR(status.st_mode)) { /* is subdir */
+               }
+               else if (S_ISDIR(status.st_mode)) { /* is subdir */
                        if (*recur_depth <= MAX_RECUR) {
                                (*recur_depth)++;
                                findFileRecursive(filename_new, path, filename, filesize, recur_depth);
@@ -854,54 +888,55 @@ static int findFileRecursive(char *filename_new, const char *dirname, const char
 /* high level function - call from fileselector */
 void findMissingFiles(Main *bmain, const char *str) {
        struct BPathIterator *bpi;
-       
+
        /* be sure there is low chance of the path being too short */
-       char filepath_expanded[FILE_MAXDIR*2]; 
+       char filepath_expanded[FILE_MAXDIR*2];
        char filepath[FILE_MAX];
        const char *libpath;
        int filesize, recur_depth;
-       
+
        char dirname[FILE_MAX], filename_new[FILE_MAX];
-       
+
        //XXX waitcursor( 1 );
-       
+
        BLI_split_dirfile(str, dirname, NULL);
-       
+
        BLI_bpathIterator_init(&bpi, bmain, bmain->name, 0);
-       
+
        while (!BLI_bpathIterator_isDone(bpi)) {
                BLI_bpathIterator_getPath(bpi, filepath);
                libpath= BLI_bpathIterator_getLib(bpi);
-               
+
                /* Check if esc was pressed because searching files can be slow */
                /*XXX if (blender_test_break()) {
                        break;
                }*/
-               
+
                if (libpath==NULL) {
-                       
+
                        BLI_bpathIterator_getPathExpanded(bpi, filepath_expanded);
-                       
+
                        if (!BLI_exists(filepath_expanded)) {
                                /* can the dir be opened? */
                                filesize= -1;
                                recur_depth= 0;
-                               
+
                                findFileRecursive(filename_new, dirname, BLI_path_basename(filepath), &filesize, &recur_depth);
                                if (filesize == -1) { /* could not open dir */
                                        printf("Could not open dir \"%s\"\n", dirname);
                                        return;
                                }
-                               
+
                                if (filesize > 0) {
-                                       
-                                       if (BLI_bpathIterator_getPathMaxLen(bpi) < strlen(filename_new)) { 
+
+                                       if (BLI_bpathIterator_getPathMaxLen(bpi) < strlen(filename_new)) {
                                                printf("cannot set path \"%s\" too long!", filename_new);
-                                       } else {
+                                       }
+                                       else {
                                                /* copy the found path into the old one */
                                                if (G.relbase_valid)
                                                        BLI_path_rel(filename_new, bpi->base_path);
-                                               
+
                                                BLI_bpathIterator_setPath(bpi, filename_new);
                                        }
                                }
@@ -910,6 +945,6 @@ void findMissingFiles(Main *bmain, const char *str) {
                BLI_bpathIterator_step(bpi);
        }
        BLI_bpathIterator_free(bpi);
-       
+
        //XXX waitcursor( 0 );
 }