Пример #1
0
        public static int CleanUpOriginalWallpaper()
        {
            var count            = 0;
            var originalFileList = OriginalWallpaperDirectory.GetFiles("*", SearchOption.AllDirectories);

            foreach (var currentOriginalFile in originalFileList)
            {
                if (WallpaperFileHelper.IsImage(currentOriginalFile))
                {
                    bool fileFound = false;

                    foreach (var currentWallpaper in Wallpapers)
                    {
                        if (WallpaperFileHelper.ImageFilesMatch(currentWallpaper.File, currentOriginalFile))
                        {
                            fileFound = true;
                            break;
                        }
                    }

                    if (!fileFound)
                    {
                        currentOriginalFile.MoveTo(Path.Combine(TrashDirectory.FullName, currentOriginalFile.Name));
                        count++;
                    }
                }
            }
            return(count);
        }
Пример #2
0
        internal static List <FileInfo> SortOutOrignals()
        {
            var movedFiles = new List <FileInfo>();
            //Go through all original files and see if they are not listed in the other folder. (O(n))

            var allOriginalFiles = OriginalWallpaperDirectory.GetFiles("*", SearchOption.AllDirectories);

            foreach (var currentFile in allOriginalFiles)
            {
                if (WallpaperFileHelper.IsImage(currentFile))
                {
                    if (currentFile.Name.Contains("#o"))
                    {
                        //Check if there is a corresponding wallpaper file
                        var correspondingFileName = Path.GetFileNameWithoutExtension(currentFile.FullName).Replace("#o", "#");
                        var files = new[]
                        {
                            $"{correspondingFileName}.png",                                                                                                               //Test for png
                            $"{correspondingFileName}.jpg",                                                                                                               //Test for jpg
                        };
                        var foundFile = files.FirstOrDefault(file => System.IO.File.Exists(Path.Combine(WallpaperDirectory.FullName, currentFile.Directory.Name, file))); //Find the first path that exits

                        if (foundFile is null)
                        {
                            //Move file, it does not belong here
                            currentFile.MoveTo(Path.Combine(TrashDirectory.FullName, currentFile.Name));
                            movedFiles.Add(currentFile);
                        }
                    }
                }
            }
            return(movedFiles);
        }
Пример #3
0
 public void SetIndexAndCorrectFiles(int newIndex)
 {
     Index = newIndex;
     WallpaperFileHelper.RenameFile(File, $"{Franchise.Name}#{Index}");
     if (!(OriginalFile is null))
     {
         WallpaperFileHelper.RenameFile(OriginalFile, $"{Franchise.Name}#o{Index}");
     }
 }
Пример #4
0
        public static void FullScan()
        {
            var allFiles = WallpaperDirectory.GetFiles("*", SearchOption.AllDirectories);

            foreach (var currentFile in allFiles)
            {
                if (WallpaperFileHelper.IsImage(currentFile))
                {
                    if (!currentFile.Name.Contains("#o"))
                    {
                        _ = new Wallpaper(currentFile, WallpaperCreationMode.Scan);
                    }
                }
            }
            Wallpapers.Sort();
        }
Пример #5
0
        public static Tuple <int, int> Merge()
        {
            int countDeleted = 0;
            int countCopied  = 0;

            if (false) //Environment.OSVersion.Platform == PlatformID.Win32NT
            {
                throw new NotImplementedException();
                //Implement faster method of coping files here
            }
            else
            {
                //Delete all old files
                foreach (var currentFile in MergedWallpaperDirectory.GetFiles())
                {
                    if (WallpaperFileHelper.IsImage(currentFile))
                    {
                        currentFile.Delete();
                        countDeleted++;
                    }
                }

                //Get excluded types
                WallpaperType excludedType;
                if (WallpaperType.TryGet("X-MAS", out WallpaperType? type))
                {
                    excludedType = type;
                }
                else
                {
                    throw new ArgumentNullException("Franchise not found.", nameof(excludedType));
                }

                //Copy all wallpapers that are not excluded
                foreach (var currentWallpaper in Wallpapers)
                {
                    if (currentWallpaper.Franchise.Type != excludedType)
                    {
                        currentWallpaper.File.CopyTo(Path.Combine(MergedWallpaperDirectory.FullName, currentWallpaper.File.Name));
                        countCopied++;
                    }
                }
            }

            return(new Tuple <int, int>(countDeleted, countCopied));
        }
Пример #6
0
        public static List <Wallpaper> SortInNamedWorkingWallpapers()
        {
            var newWallpapers = new List <Wallpaper>();

            var typeDirectories = WorkingDirectoryNamed.GetDirectories();

            foreach (var currentTypeDirectory in typeDirectories)
            {
                var currentFiles = currentTypeDirectory.GetFiles("*", SearchOption.TopDirectoryOnly);
                foreach (var currentFile in currentFiles)         //Go through the current type images
                {
                    if (WallpaperFileHelper.IsImage(currentFile)) //Make sure they are an image
                    {
                        WallpaperFileHelper.FixImageExtension(currentFile);
                        //not an original file
                        if (!currentFile.Name.Contains("#o"))
                        {
                            Wallpaper newWallpaper;

                            try
                            {
                                newWallpaper = new Wallpaper(currentFile, WallpaperCreationMode.New);
                            }
                            catch (WallpaperBuildExeption e)
                            {
                                if (e.UserAbortion)
                                {
                                    continue;
                                }
                                else
                                {
                                    throw e;
                                }
                            }

                            //Move it to the right location
                            newWallpaper.File.MoveTo(Path.Combine(WallpaperDirectory.FullName, newWallpaper.Franchise.Type.Name, $"{newWallpaper.Franchise.Name}#{newWallpaper.Index}{newWallpaper.File.Extension}"));
                            if (!(newWallpaper.OriginalFile is null))
                            {
                                newWallpaper.OriginalFile !.MoveTo(Path.Combine(OriginalWallpaperDirectory.FullName, newWallpaper.Franchise.Type.Name, $"{newWallpaper.Franchise.Name}#o{newWallpaper.Index}{newWallpaper.File.Extension}"));
                            }

                            newWallpapers.Add(newWallpaper);
                        }
                    }
                }

                //Now look for grouped images in franchise folders
                var currentTypeSubDirectories = currentTypeDirectory.GetDirectories();
                foreach (var currentTypeSubDiretory in currentTypeSubDirectories)
                {
                    var files = currentTypeSubDiretory.GetFiles("*", SearchOption.TopDirectoryOnly);

                    foreach (var currentFile in files)
                    {
                        if (WallpaperFileHelper.IsImage(currentFile))
                        {
                            WallpaperFileHelper.FixImageExtension(currentFile);

                            //Check if this file is not an original.
                            if (Regex.IsMatch(currentFile.Name, WallpaperManager.EditedFilesRegexString))
                            {
                                Wallpaper newWallpaper;

                                try
                                {
                                    newWallpaper = new Wallpaper(currentFile, WallpaperCreationMode.NewInSubFolder);
                                }
                                catch (WallpaperBuildExeption e)
                                {
                                    if (e.UserAbortion)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        throw e;
                                    }
                                }

                                //Move it to the right location
                                newWallpaper.File.MoveTo(Path.Combine(WallpaperDirectory.FullName, newWallpaper.Franchise.Type.Name, $"{newWallpaper.Franchise.Name}#{newWallpaper.Index}{newWallpaper.File.Extension}"));
                                if (!(newWallpaper.OriginalFile is null))
                                {
                                    newWallpaper.OriginalFile !.MoveTo(Path.Combine(OriginalWallpaperDirectory.FullName, newWallpaper.Franchise.Type.Name, $"{newWallpaper.Franchise.Name}#o{newWallpaper.Index}{newWallpaper.File.Extension}"));
                                }

                                newWallpapers.Add(newWallpaper);
                            }
                        }
                    }
                }
            }
            return(newWallpapers);
        }
Пример #7
0
        //New Powerfull C'tor
        public Wallpaper(FileInfo file, WallpaperCreationMode mode)
        {
            WallpaperDataContainer container;

            if (!file.Exists)
            {
                throw new FileNotFoundException("File was not found.");
            }
            if (!WallpaperFileHelper.IsImage(file))
            {
                throw new ArgumentException("Is not an image file.", nameof(file));
            }

            //All parameters that have to be set.
            string        typeName;
            string        franchiseName;
            bool          ignoreMissing;
            int?          index;
            DirectoryInfo originalLookUpDirectory;

            string[] possibleOriginalFileNames;

            //Helpers

            //Setting the parameters.
            switch (mode)
            {
            case WallpaperCreationMode.Scan:     // --------------------------------------------------------------------------------------------
                if (file.Name.Contains("#o"))
                {
                    throw new ArgumentException("Is an original file.", nameof(file));
                }
                if (!Regex.IsMatch(file.Name, "\\S+#\\d+"))
                {
                    throw new FileLoadException("Image file was not in the correct normalized format.", file.Name);
                }

                typeName = file.Directory.Name;
                var shortFileName1      = Path.GetFileNameWithoutExtension(file.Name);
                var splitShortFileName1 = shortFileName1.Split('#');     //The '#' separates franchise and index.
                franchiseName             = splitShortFileName1[0];
                ignoreMissing             = true;
                index                     = Convert.ToInt32(splitShortFileName1[1]);
                originalLookUpDirectory   = new DirectoryInfo(Path.Combine(WallpaperManager.OriginalWallpaperDirectory.FullName, typeName));
                possibleOriginalFileNames = new[]
                {
                    $"{franchiseName}#o{index}.png",     //Test for png
                    $"{franchiseName}#o{index}.jpg",     //Test for jpg
                };
                break;

            case WallpaperCreationMode.New:     // --------------------------------------------------------------------------------------------
                typeName = file.Directory.Name;
                var shortFileName2      = Path.GetFileNameWithoutExtension(file.Name);
                var splitShortFileName2 = shortFileName2.Split('#'); //The '#' separates franchise and index.
                if (splitShortFileName2.Length > 2)                  //Check if something has gone wrong while splitting
                {
                    throw new ArgumentException("Is not in the correct format.", nameof(file));
                }
                franchiseName           = splitShortFileName2[0];
                ignoreMissing           = false;
                index                   = null; //Set a new index, the current one is just temporary
                originalLookUpDirectory = file.Directory;

                //Determine if there is a temp index given. In a not normalized format, an temp index is not mandatory.
                string fileNameIndex;
                if (splitShortFileName2.Length == 2)
                {
                    if (Int32.TryParse(splitShortFileName2[1], out var _))
                    {
                        fileNameIndex = splitShortFileName2[1];
                    }
                    else
                    {
                        throw new ArgumentException("Could not parse index number.", nameof(file));
                    }
                }
                else     //splitShortFileName2.Length == 1
                {
                    fileNameIndex = String.Empty;
                }

                possibleOriginalFileNames = new[]
                {
                    $"{franchiseName}#o{fileNameIndex}.png",     //Test for png
                    $"{franchiseName}#o{fileNameIndex}.jpg",     //Test for jpg
                };
                break;

            case WallpaperCreationMode.NewInSubFolder:     // --------------------------------------------------------------------------------------------
                typeName                = file.Directory.Parent.Name;
                franchiseName           = file.Directory.Name;
                ignoreMissing           = false;
                index                   = null;
                originalLookUpDirectory = file.Directory;
                var matchLength = Regex.Match(file.Name, WallpaperManager.EditedFilesRegexString).Value.Length;
                var originalFileNameWithoutExtension = file.Name.Substring(0, file.Name.Length - matchLength);
                possibleOriginalFileNames = new[]
                {
                    $"{originalFileNameWithoutExtension}.png",     //Test for png
                    $"{originalFileNameWithoutExtension}.jpg",     //Test for jpg
                };
                break;

            default:
                throw new WallpaperBuildExeption($"Unknown {nameof(WallpaperCreationMode)}.");
            }

            try
            {
                container = ContructorHelper(file, typeName, franchiseName, ignoreMissing, index, originalLookUpDirectory, possibleOriginalFileNames);
            }
            catch (WallpaperBuildExeption e)
            {
                if (e.UserAbortion && !(e.ObjectsToDelte is null)) //Handle objects that need to be removed, when the process was aborted.
                {
                    foreach (var currentObject in e.ObjectsToDelte)
                    {
                        if (currentObject is WallpaperType)
                        {
                            WallpaperManager.Types.Remove((WallpaperType)currentObject);
                        }
                        else
                        {
                            throw new ArgumentException($"Object {nameof(currentObject)} is an unexpected type.");
                        }
                    }
                }
                throw e;
            }

            File         = file;
            OriginalFile = container.OriginalFile;
            Franchise    = container.Franchise;
            Index        = container.Index;
            WallpaperManager.Wallpapers.Add(this); //Add this instance to the list of all wallpapers.
        }