public static void AddSource(GallerySource source)
{
if (!Sources.Contains(source))
{
Sources.Add(source);
Sources.Sort();
}
}
private static void SerializeSource(StreamWriter writer, GallerySource source)
{
writer.WriteLine(source.Serialize());
foreach (MediaCodec mediaCodec in source.Codecs)
{
writer.WriteLine(mediaCodec.Serialize());
}
SerializeSubFolders(writer, source.RootFolder);
}
private void StartScan(bool reScan)
{
if (toolStripComboBoxSource.SelectedIndex > -1)
{
EnableControls(true, false);
GallerySource source = (GallerySource)((ComboBoxItem)toolStripComboBoxSource.SelectedItem).Tag;
RemoveTreeNodes(source.RootFolder);
_worker.ScanSource(source, reScan);
}
}
public static Stream GetMetaDatabaseStream(GallerySource source)
{
MemoryStream memoryStream = new MemoryStream();
StreamWriter writer = new StreamWriter(memoryStream);
writer.WriteLine(GalleryVersion.Instance.Serialize());
SerializeSource(writer, source);
writer.Flush();
memoryStream.Position = 0;
return(memoryStream);
}
private static void GetFolders(MediaFolder parent, GallerySource source)
{
List <string> directories = Directory.GetDirectories(Path.Combine(source.Path, parent.RelativePathName)).ToList();
directories.Sort();
foreach (string directory in directories)
{
string path = directory.TrimEnd(Path.PathSeparator);
string folderName = Path.GetFileName(path);
string relativePath = RemoveAbsolutePath(Path.GetDirectoryName(path), source.Path);
parent.SubFolders.Add(new MediaFolder(folderName, relativePath, parent, source));
}
}
public static void ScanFolders(GalleryDatabase galleryDatabase, GallerySource source, bool reScan)
{
try
{
ClearWorkingDirectory();
int folderCount = 0, fileCount = 0;
ScanSubFolder(galleryDatabase, source, source.RootFolder, reScan, ref folderCount, ref fileCount, 0);
}
finally
{
ClearWorkingDirectory();
}
}
public void RemoveSource(GallerySource source)
{
try
{
ObjectPool.RemoveSource(source);
RegistryHandler.SaveSettings(SettingsType.GallerySource);
RaiseSourceListUpdatedEvent(ObjectPool.Sources);
}
catch (Exception ex)
{
CommonWorker.ShowError(ex);
}
}
private static void DeserializeSource(StreamReader reader, GallerySource source)
{
string objectPrefix;
string[] deserializedObject = ObjectSerializer.Deserialize(reader.ReadLine(), out objectPrefix);
if (objectPrefix != "GS")
{
throw new Exception("Failed to deserialize source database; gallery source missing");
}
string rootFolderID = source.LoadFromDeserialized(deserializedObject);
IDictionary <string, FileSystemEntry> fileSystemEntries = new Dictionary <string, FileSystemEntry>();
string serializedObject = reader.ReadLine();
while (serializedObject != null)
{
try
{
deserializedObject = ObjectSerializer.Deserialize(serializedObject, out objectPrefix);
switch (objectPrefix)
{
case "MC":
MediaCodec mediaCodec = new MediaCodec();
mediaCodec.LoadFromDeserialized(deserializedObject);
source.Codecs.Add(mediaCodec);
break;
default:
DeserializeSubFolders(fileSystemEntries, objectPrefix, deserializedObject, source);
break;
}
}
catch { }
if (fileSystemEntries.Count % 100 == 0)
{
RaiseStatusUpdatedEvent("Loading source (" + source.Path + ")... " + (100 * (double)fileSystemEntries.Count / (source.ImageCount + source.VideoCount)).ToString("0.0") + "%");
}
serializedObject = reader.ReadLine();
}
if (!fileSystemEntries.ContainsKey(rootFolderID))
{
throw new Exception("Failed to deserialize source database; root object does not exist");
}
MediaFolder rootFolder = fileSystemEntries[rootFolderID] as MediaFolder;
if (rootFolder == null)
{
throw new Exception("Failed to deserialize source database; parent root object is not a folder");
}
source.RootFolder = rootFolder;
}
private static void GetFolders(GallerySource source, MediaFolder parent)
{
List <string> directories = Directory.GetDirectories(Path.Combine(source.RootedPath, parent.RelativePathName)).ToList();
directories.Sort();
foreach (string directory in directories)
{
string path = directory.TrimEnd(Path.PathSeparator);
string folderName = Path.GetFileName(path);
string relativePath = RemoveAbsolutePath(Path.GetDirectoryName(path), source.RootedPath);
int existingIndex = parent.SubFolders.FindIndex(mediaFile => mediaFile.Name == folderName);
if (existingIndex != -1)
{
parent.SubFolders.RemoveAt(existingIndex);
}
parent.SubFolders.Add(new MediaFolder(folderName, relativePath, parent, source));
}
}
private void ScanSourceThread(GallerySource source, bool reScan)
{
try
{
using (GalleryDatabase database = GalleryDatabase.Open(Gallery.FilePath, Gallery.EncryptionAlgorithm, Gallery.Password, true))
{
database.RegisterStreamProvider <Gallery>(GalleryMetadataStreamProvider);
database.RegisterStreamProvider <MediaFile>(MediaFileStreamProvider);
FileSystemHandler.ScanFolders(database, source, reScan);
source.ScanDate = DateTime.Now;
source.UpdateMediaCount();
database.UpdateEntry(GALLERY_FILE_NAME, string.Empty, Gallery, true);
database.Save();
}
RaiseDatabaseOperationCompletedEvent(OperationType.ScanSource);
}
catch (Exception ex)
{
CommonWorker.ShowError(ex);
}
}
private static bool ScanSubFolder(GalleryDatabase galleryDatabase, GallerySource source, MediaFolder folder,
bool reScan, ref int folderCount, ref int fileCount, int depth)
{
try
{
folderCount++;
RaiseStatusUpdatedEvent("Scanning folder #" + folderCount + " at depth " + depth + ", found " + fileCount + " files...");
GetFolders(source, folder);
GetFiles(galleryDatabase, source, folder, reScan);
if (folder.SubFolders.Count == 0 && folder.Files.Count == 0)
{
return(false);
}
RaiseMediaFolderAddedEvent(folder);
depth++;
fileCount += folder.Files.Count;
List <MediaFolder> emptyFolders = new List <MediaFolder>();
foreach (MediaFolder subFolder in folder.SubFolders)
{
if (!ScanSubFolder(galleryDatabase, source, subFolder, reScan, ref folderCount, ref fileCount, depth))
{
emptyFolders.Add(subFolder);
}
}
foreach (MediaFolder emptyFolder in emptyFolders)
{
folder.SubFolders.Remove(emptyFolder);
}
if (folder.SubFolders.Count == 0 && folder.Files.Count == 0)
{
RaiseMediaFolderRemovedEvent(folder);
return(false);
}
}
catch { }
return(true);
}
public void AddSource()
{
FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog()
{
Description = "Please select a source root folder..."
};
if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
{
GallerySource source = new GallerySource(folderBrowserDialog.SelectedPath, Gallery);
if (Gallery.AddSource(source))
{
using (GalleryDatabase database = GalleryDatabase.Open(Gallery.FilePath, Gallery.EncryptionAlgorithm, Gallery.Password, true))
{
database.RegisterStreamProvider <Gallery>(GalleryMetadataStreamProvider);
database.UpdateEntry(GALLERY_FILE_NAME, string.Empty, Gallery, true);
database.Save();
}
FolderAdded(source.RootFolder);
}
}
}
private void ScanSourceThread(object data)
{
try
{
object[] parameters = data as object[];
if (parameters != null && parameters.Length == 2)
{
GallerySource source = (parameters[0] as GallerySource);
if (source != null && parameters[1] is bool)
{
FileSystemHandler.PrepareDirectories();
FileSystemHandler.InitializeImageProcessor(90L);
FileSystemHandler.ScanFolders(source, (bool)parameters[1]);
}
}
RaiseDatabaseOperationCompletedEvent(OperationType.ScanSource);
}
catch (Exception ex)
{
CommonWorker.ShowError(ex);
}
}
private static void GetFiles(GalleryDatabase galleryDatabase, GallerySource source, MediaFolder parentFolder, bool reScan)
{
List <string> files = Directory.GetFiles(Path.Combine(source.RootedPath, parentFolder.RelativePathName)).ToList();
files.Sort();
foreach (string file in files)
{
try
{
string extension = Path.GetExtension(file).ToLower();
string fileName = Path.GetFileName(file);
string relativePath = RemoveAbsolutePath(Path.GetDirectoryName(file), source.RootedPath);
FileInfo fileInfo = new FileInfo(file);
if (MediaFile.IMAGE_FILE_EXTENSIONS.Contains(extension))
{
if (!files.Any(filePath => (Path.GetFileName(filePath) == Path.GetFileNameWithoutExtension(file))))
{
ImageFile imageFile = new ImageFile(fileName, relativePath, parentFolder, source)
{
FileSize = fileInfo.Length
};
try
{
imageFile.Size = ImageFileHelper.GetDimensions(file);
}
catch {}
int existingIndex = parentFolder.Files.FindIndex(mediaFile => mediaFile.Name == fileName);
if (existingIndex != -1)
{
parentFolder.Files.RemoveAt(existingIndex);
}
parentFolder.Files.Add(imageFile);
AddDatabaseImageEntry(galleryDatabase, imageFile, reScan);
}
}
else if (MediaFile.VIDEO_FILE_EXTENSIONS.Contains(extension))
{
VideoFile videoFile = new VideoFile(fileName, relativePath, parentFolder, source)
{
FileSize = fileInfo.Length
};
try
{
TagLib.File tagFile = TagLib.File.Create(file);
videoFile.Duration = tagFile.Properties.Duration;
videoFile.Size = new Size(tagFile.Properties.VideoWidth, tagFile.Properties.VideoHeight);
foreach (TagLib.ICodec codec in tagFile.Properties.Codecs)
{
MediaCodec mediaCodec = new MediaCodec(MediaCodec.TranslateCodecType(codec.MediaTypes), codec.Description);
if (source.Gallery.Codecs.Contains(mediaCodec))
{
mediaCodec = source.Gallery.Codecs.First(x => x.Equals(mediaCodec));
}
else
{
source.Gallery.Codecs.Add(mediaCodec);
}
videoFile.Codecs.Add(mediaCodec);
}
}
catch {}
int existingIndex = parentFolder.Files.FindIndex(mediaFile => mediaFile.Name == fileName);
if (existingIndex != -1)
{
parentFolder.Files.RemoveAt(existingIndex);
}
parentFolder.Files.Add(videoFile);
AddDatabaseImageEntry(galleryDatabase, videoFile, reScan);
}
}
catch {}
}
}
public void ScanSource(GallerySource source, bool reScan)
{
new Thread(ScanSourceThread).Start(new object[] { source, reScan });
}
public void ScanSource(GallerySource source, bool reScan)
{
new Thread(() => ScanSourceThread(source, reScan)).Start();
}
private static void DeserializeSubFolders(IDictionary <string, FileSystemEntry> fileSystemEntries, string objectPrefix, string[] deserializedObject, GallerySource source)
{
FileSystemEntry fileSystemEntry = null;
switch (objectPrefix)
{
case "FO":
fileSystemEntry = new MediaFolder(source);
break;
case "IF":
fileSystemEntry = new ImageFile(source);
break;
case "VF":
fileSystemEntry = new VideoFile(source);
break;
}
if (fileSystemEntry == null)
{
throw new Exception("Failed to deserialize file system entry of source database; invalid object type");
}
string parentID = fileSystemEntry.LoadFromDeserialized(deserializedObject);
if (!string.IsNullOrEmpty(parentID))
{
if (!fileSystemEntries.ContainsKey(parentID))
{
throw new Exception("Failed to deserialize file system entry of source database; parent object does not exist");
}
MediaFolder parentFolder = fileSystemEntries[parentID] as MediaFolder;
if (parentFolder == null)
{
throw new Exception("Failed to deserialize file system entry of source database; parent object is not a folder");
}
fileSystemEntry.SetParent(parentFolder);
if (fileSystemEntry is MediaFolder)
{
parentFolder.SubFolders.Add((MediaFolder)fileSystemEntry);
}
else
{
parentFolder.Files.Add((MediaFile)fileSystemEntry);
}
}
fileSystemEntries.Add(fileSystemEntry.ID, fileSystemEntry);
if (fileSystemEntry is MediaFolder)
{
RaiseMediaFolderAddedEvent((MediaFolder)fileSystemEntry);
}
}
public static void RemoveSource(GallerySource source)
{
Sources.Remove(source);
}
public static void ScanFolders(GallerySource source, bool reScan)
{
ZipFile sourceDatabase = null;
string sourceDatabasePath = null;
string sourceDatabaseBackupPath = null;
bool deleteBackup = true;
try
{
ClearWorkingDirectory();
_scanState.Source = source;
_scanState.DatabaseImageEntries.Clear();
int folderCount = 0, fileCount = 0;
sourceDatabasePath = Path.Combine(ObjectPool.CompleteDatabaseLocation, Path.ChangeExtension(source.ID, DATABASE_FILE_EXTENSION));
if (File.Exists(sourceDatabasePath))
{
RaiseStatusUpdatedEvent("Backing up existing source database...");
sourceDatabaseBackupPath = sourceDatabasePath + ".backup";
if (File.Exists(sourceDatabaseBackupPath))
{
File.Delete(sourceDatabaseBackupPath);
}
if (reScan)
{
File.Move(sourceDatabasePath, sourceDatabaseBackupPath);
}
else
{
File.Copy(sourceDatabasePath, sourceDatabaseBackupPath);
}
}
sourceDatabase = new ZipFile(sourceDatabasePath);
source.RootFolder = new MediaFolder(source.Path, string.Empty, null, source);
ScanSubFolder(source.RootFolder, source, sourceDatabase, reScan, ref folderCount, ref fileCount, 0);
source.ScanDate = DateTime.Now;
sourceDatabase.UpdateEntry(Path.ChangeExtension(source.ID, METAFILE_FILE_EXTENSION), string.Empty, Stream.Null);
sourceDatabase.SaveProgress += SourceDatabase_SaveProgress;
sourceDatabase.Save();
sourceDatabase.SaveProgress -= SourceDatabase_SaveProgress;
sourceDatabase.Dispose();
RegistryHandler.SaveSettings(SettingsType.GallerySource);
}
catch
{
try
{
if (sourceDatabasePath != null && sourceDatabaseBackupPath != null && File.Exists(sourceDatabaseBackupPath))
{
deleteBackup = false;
if (sourceDatabase != null)
{
sourceDatabase.Dispose();
}
if (File.Exists(sourceDatabasePath))
{
File.Delete(sourceDatabasePath);
}
File.Move(sourceDatabaseBackupPath, sourceDatabasePath);
deleteBackup = true;
}
}
catch {}
throw;
}
finally
{
try
{
if (deleteBackup && sourceDatabaseBackupPath != null && File.Exists(sourceDatabaseBackupPath))
{
File.Delete(sourceDatabaseBackupPath);
}
ClearWorkingDirectory();
_scanState.DatabaseImageEntries.Clear();
}
catch {}
}
}
