class FileLoader
        {
            public Int64 ID;
            public Int64 ImageID;
            public String Filename;
            public String Folder;
        }

        class ImageCache
        {
            private List<FileLoader> aFiles;
            public ICollection<FileLoader> Files
            {
                get { return aFiles; }
            }

            public ImageCache()
            {
                aFiles = new List<FileLoader>();
            }

            public void Add(FileLoader entry)
            {
                aFiles.Add(entry);
            }
        }

        public class Folder
        {
            private Int64 iImageID;
            public Int64 ImageID
            {
                get { return iImageID; }
            }

            private String sFolderName;
            public String FolderName
            {
                get { return sFolderName; }
            }

            private String sFolderPath;
            public String FolderPath
            {
                get { return sFolderPath; }
                set { sFolderPath = value; }
            }

            private int iLevel;
            public int Level
            {
                get { return iLevel; }
            }

            private List<Int64> aFiles;
            public ICollection<Int64> Files
            {
                get { return aFiles; }
            }

            private Hashtable aSubFolders;
            public ICollection SubFolders
            {
                get { return aSubFolders.Values; }
            }

            public Folder(Int64 imgId, String folderName, int level, String folderPath)
            {
                iImageID = imgId;
                aFiles = new List<Int64>();
                sFolderName = folderName;
                iLevel = level;
                aSubFolders = new Hashtable();
                sFolderPath = folderPath;
            }

            public void Add(Int64 id)
            {
                aFiles.Add(id);
            }

            public void AddSubFolder(String key, Folder subfolder)
            {
                aSubFolders.Add(key, subfolder);
            }

            public Folder GetSubFolder(String key)
            {
                if (aSubFolders.ContainsKey(key))
                    return (Folder)aSubFolders[key];
                else
                    return null;
            }

            public void Clear()
            {
                aFiles.Clear();
                sFolderName = String.Empty;
                iLevel = 0;
                aSubFolders.Clear();
                sFolderName = String.Empty;
            }
        }

        private Hashtable cFolderCache;
        private void UpdateFolderCache(Int64 imageId, bool doNotClear)
        {
            // Clear folder cache
            if (!doNotClear)
                cFolderCache.Clear();

            // Generate image cache
            Hashtable imageCache = new Hashtable();
            using (SpeedcatDBQuery query = cDBManager.QueryFiles(imageId))
            {
                int queryCount = query.Execute(DBTables.Files, SpeedcatDBQuery.ModeQuery.Select);
                for (int i = 0; i < queryCount; i++)
                {
                    SpeedcatDBRow row = query.GetRow(i);
                    FileLoader fl = new FileLoader();
                    fl.ID = row.GetInt64(DBFieldNames.FileID);
                    fl.ImageID = row.GetInt64(DBFieldNames.FileImgID);
                    fl.Filename = row.GetString(DBFieldNames.FileFilename);
                    fl.Folder = row.GetString(DBFieldNames.FileFolder);
                    ImageCache imgCache;
                    if (!imageCache.ContainsKey(fl.ImageID))
                    {
                        imgCache = new ImageCache();
                        imageCache.Add(fl.ImageID, imgCache);
                    }
                    else
                        imgCache = (ImageCache)imageCache[fl.ImageID];
                    imgCache.Add(fl);
                }
            }

            // Loop through all images
            // Build also the real folder cache
            foreach (DictionaryEntry entry in imageCache)
            {
                Int64 imgid = (Int64)entry.Key;
                ImageCache imgCache = (ImageCache)entry.Value;

                Folder imageFolder;
                if (cFolderCache.ContainsKey(imgid))
                {
                    imageFolder = (Folder)cFolderCache[imgid];
                    imageFolder.Clear();
                }
                else
                {
                    imageFolder = new Folder(imgid, String.Empty, 0, String.Empty);
                    cFolderCache.Add(imgid, imageFolder);
                }

                String shortestPath = String.Empty;
                foreach (FileLoader fl in imgCache.Files)
                {
                    if (fl.Folder.Length < shortestPath.Length || shortestPath == String.Empty)
                        shortestPath = fl.Folder;
                }
                if (shortestPath != String.Empty)
                {
                    // Now cut of path from the file entries in the image
                    foreach (FileLoader fl in imgCache.Files)
                    {
                        String changedFolderPath = fl.Folder.Remove(0, shortestPath.Length);
                        String rootFolderPath = fl.Folder.Remove(fl.Folder.Length - changedFolderPath.Length, changedFolderPath.Length);
                        String folderName = String.Empty;
                        String[] split = changedFolderPath.Split(new char[] { '\' }, StringSplitOptions.RemoveEmptyEntries);

                        int level = split.Length;

                        if (split.Length == 0)
                        {
                            // Add root files to image folder
                            imageFolder.FolderPath = rootFolderPath;
                            imageFolder.Add(fl.ID);
                        }
                        else
                        {
                            Folder curFolder = imageFolder;
                            String curPath = rootFolderPath;
                            for (int i = 0; i < split.Length; i++)
                            {
                                String fname = split[i];
                                curPath += "\\" + fname;
                                Folder subFolder = curFolder.GetSubFolder(fname);
                                if (subFolder == null)
                                {
                                    subFolder = new Folder(imgid, fname, level, curPath);
                                    curFolder.AddSubFolder(fname, subFolder);
                                }
                                curFolder = subFolder;
                                if (i == split.Length - 1)
                                    curFolder.Add(fl.ID);
                            }
                        }
                    }
                }
            }
        }