private void ChapterObjectArchiveWatcher_Event(object sender, FileSystemEventArgs e) { RunOnUiThread(() => { switch (e.ChangeType) { case WatcherChangeTypes.Created: case WatcherChangeTypes.Deleted: MangaCacheObject ExistingMangaCacheObject = MangaCacheObjects.FirstOrDefault( _ => Equals( _.MangaObject.MangaFileName(), Path.GetDirectoryName(e.Name))); if (!Equals(ExistingMangaCacheObject, null)) { Int32 ExistingMangaCacheObjectIndex = ExistingMangaCacheObject.ChapterCacheObjects.FindIndex(_ => Equals(_.ArchiveFileName, Path.GetFileName(e.Name))); if (ExistingMangaCacheObjectIndex >= 0) { ExistingMangaCacheObject.ChapterCacheObjects[ExistingMangaCacheObjectIndex].IsLocal = File.Exists(e.FullPath); } } break; } Messenger.Instance.Send(e, "ChapterObjectArchiveWatcher"); }); }
private Boolean CanShowMangaCacheObjectDialog(MangaCacheObject MangaCacheObject) { if (Equals(MangaCacheObject, null)) { return(false); } return(true); }
private Boolean CanDeleteAsync(MangaCacheObject MangaCacheObject) { if (Equals(MangaCacheObject, null)) { return(false); } return(true); }
private Boolean CanRefresh(MangaCacheObject MangaCacheObject) { if (Equals(MangaCacheObject, null)) { return(false); } return(true); }
private Boolean CanEditAsync(MangaCacheObject MangaCacheObject) { if (Equals(MangaCacheObject, null)) { return(false); } return(false); //return true; }
private Boolean FilterMangaCacheObject(object item) { MangaCacheObject MangaCacheObject = item as MangaCacheObject; if (String.IsNullOrWhiteSpace(SearchTerm)) { return(true); } return(MangaCacheObject.MangaObject.IsNameMatch(SearchTerm)); }
private void DeleteAsync(MangaCacheObject MangaCacheObject) { String SavePath = Path.Combine(App.CORE.MANGA_ARCHIVE_DIRECTORY, MangaCacheObject.MangaObject.MangaArchiveName(App.CORE.MANGA_ARCHIVE_EXTENSION)); MessageBoxResult msgboxResult = MessageBox.Show(String.Format("Are you sure you wish to delete \"{0}\"?", MangaCacheObject.MangaObject.Name), "Delete Manga?", MessageBoxButton.YesNo); if (Equals(msgboxResult, MessageBoxResult.Yes)) { File.Delete(SavePath); } }
/// <summary> /// Warning, this will completely reload the cache. /// </summary> /// <returns>Time taken to load cache.</returns> private async Task <TimeSpan> FullMangaCacheObject() { Boolean ErrorOccured = false; Stopwatch loadWatch = Stopwatch.StartNew(); await RenameSchema(); String[] MangaArchivePaths = Directory.GetFiles(CORE.MANGA_ARCHIVE_DIRECTORY, CORE.MANGA_ARCHIVE_FILTER, SearchOption.TopDirectoryOnly); IEnumerable <Task <MangaCacheObject> > MangaCacheObjectTasksQuery = from MangaArchivePath in MangaArchivePaths // select UnsafeDispatcherLoadMangaCacheObjectAsync(MangaArchivePath); select DispatcherReloadMangaCacheObjectAsync(MangaArchivePath, true); List <Task <MangaCacheObject> > MangaCacheObjectTasks = MangaCacheObjectTasksQuery.ToList(); await Current.Dispatcher.InvokeAsync(MangaCacheObjects.Clear); while (MangaCacheObjectTasks.Count > 0) { Task <MangaCacheObject> completedTask = await Task.WhenAny(MangaCacheObjectTasks); MangaCacheObjectTasks.Remove(completedTask); MangaCacheObject LoadedMangaCacheObject = await completedTask; if (!Equals(LoadedMangaCacheObject, null)) { await Current.Dispatcher.InvokeAsync(() => MangaCacheObjects.Add(LoadedMangaCacheObject)); } else { ErrorOccured = true; } } TimeSpan loadTime = loadWatch.Elapsed; loadWatch.Stop(); if (ErrorOccured) { String[] ErrorMessageArray = { "There was an error when attempting to load a manga on startup.", "Please check the most recent log file for the full error." }; String ErrorMessage = String.Join(Environment.NewLine, ErrorMessageArray); MessageBox.Show( ErrorMessage, "Error During Loading Manga!", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK); } return(loadTime); }
private void PreloadChapterObject(MangaObject MangaObject, ChapterObject ChapterObject) { if (!App.ContentDownloadManager.IsCacheKeyActive(App.ContentDownloadManager.CacheKey(MangaObject, ChapterObject))) { // Lookup MangaCacheObject and ChapterCacheObject MangaCacheObject MangaCacheObject = App.MangaCacheObjects.FirstOrDefault(mco => Equals( mco.MangaObject.Name, MangaObject.Name)); ChapterCacheObject ChapterCacheObject = Equals(MangaCacheObject, null) ? null : MangaCacheObject.ChapterCacheObjects.FirstOrDefault(cco => Equals( cco.ArchiveFileName, ChapterObject.ChapterArchiveName(App.CORE.CHAPTER_ARCHIVE_EXTENSION))); // Start Download App.ContentDownloadManager.Download( MangaObject, ChapterObject, Equals(ChapterCacheObject, null) ? null : ChapterCacheObject.DownloadProgressReporter); } }
public MangaCacheObjectDetailViewModel(MangaCacheObject MangaCacheObject) : base(false) { this.MangaCacheObject = MangaCacheObject; }
private void ShowMangaCacheObjectDialog(MangaCacheObject MangaCacheObject) { MangaCacheObjectDialog.MangaCacheObjectDetail.MangaCacheObject = MangaCacheObject; MangaCacheObjectDialog.ShowDialog(); }
private async Task <MangaCacheObject> UnsafeLoadMangaCacheObjectAsync(String ArchivePath) { try { MangaCacheObject MangaCacheObject = new MangaCacheObject(); MangaCacheObject.ArchiveFileName = Path.GetFileName(ArchivePath); // Load BookmarkObject Data Stream BookmarkObjectStream = CORE.ZipManager.UnsafeRead(ArchivePath, typeof(BookmarkObject).Name); if (!Equals(BookmarkObjectStream, null)) { using (BookmarkObjectStream) { MangaCacheObject.BookmarkObject = BookmarkObjectStream.Deserialize <BookmarkObject>(SerializeType); } } // Load MangaObject Data Stream MangaObjectStream = CORE.ZipManager.UnsafeRead(ArchivePath, typeof(MangaObject).Name); if (!Equals(MangaObjectStream, null)) { using (MangaObjectStream) { MangaCacheObject.MangaObject = MangaObjectStream.Deserialize <MangaObject>(SerializeType); } } // Move archive to correct location if needed String CorrectArchivePath = Path.Combine(Path.GetDirectoryName(ArchivePath), MangaCacheObject.ArchiveFileName); if (!Equals(ArchivePath, CorrectArchivePath)) { File.Move(ArchivePath, CorrectArchivePath); logger.Info(String.Format("MangaObject archive file was moved/renamed to '{0}'.", MangaCacheObject.ArchiveFileName)); } // MangaObject update check Boolean VersionUpdated = false; if (!Equals(MangaCacheObject.MangaObject, null)) { UpdateMangaObjectVersion(MangaCacheObject.MangaObject, ref VersionUpdated); } if (VersionUpdated) { logger.Info(String.Format("MangaObject version was updated for '{0}'.", MangaCacheObject.MangaObject.Name)); await CORE.ZipManager.WriteAsync( CorrectArchivePath, typeof(MangaObject).Name, MangaCacheObject.MangaObject.Serialize(SerializeType)).Retry(TimeSpan.FromMinutes(1)); } // Load Cover Image IEnumerable <String> Entries = CORE.ZipManager.UnsafeGetEntries(CorrectArchivePath); LocationObject SelectedCoverLocationObject = MangaCacheObject.MangaObject.SelectedCover(); String CoverImageFileName = Path.GetFileName(SelectedCoverLocationObject.Url); if (!Entries.Contains(CoverImageFileName)) { // Try to download the missing cover; ContentDownloadManager.DownloadCover(MangaCacheObject.MangaObject, SelectedCoverLocationObject); // If the SelectedCover is not in the archive file select a new cover. String Url = (from CoverLocation in MangaCacheObject.MangaObject.CoverLocations where Entries.Contains(Path.GetFileName(CoverLocation.Url)) select CoverLocation.Url).FirstOrDefault(); if (!Equals(Url, null)) { CoverImageFileName = Path.GetFileName(Url); } } Stream CoverImageStream = CORE.ZipManager.UnsafeRead(CorrectArchivePath, CoverImageFileName); if (!Equals(CoverImageStream, null)) { using (CoverImageStream) { if (Equals(MangaCacheObject.CoverImage, null)) { MangaCacheObject.CoverImage = new BitmapImage(); } if (!Equals(MangaCacheObject.CoverImage.StreamSource, null)) { MangaCacheObject.CoverImage.StreamSource.Close(); MangaCacheObject.CoverImage.StreamSource.Dispose(); MangaCacheObject.CoverImage.StreamSource = null; } MangaCacheObject.CoverImage.BeginInit(); MangaCacheObject.CoverImage.DecodePixelWidth = 300; MangaCacheObject.CoverImage.CacheOption = BitmapCacheOption.OnLoad; MangaCacheObject.CoverImage.CreateOptions = BitmapCreateOptions.PreservePixelFormat; using (MangaCacheObject.CoverImage.StreamSource = CoverImageStream) { MangaCacheObject.CoverImage.EndInit(); MangaCacheObject.CoverImage.Freeze(); } CoverImageStream.Close(); } } return(MangaCacheObject); } catch (Exception ex) { logger.Error(String.Format("Unable to read Manga Archive.\nFile: {0}", ArchivePath), ex); return(null); } }
private async void MangaObjectArchiveWatcher_Event(object sender, FileSystemEventArgs e) { if (Dispatcher.Thread == Thread.CurrentThread) { MangaCacheObject ExistingMangaCacheObject = MangaCacheObjects.FirstOrDefault(_ => Equals(_.ArchiveFileName, e.Name)); switch (e.ChangeType) { case WatcherChangeTypes.Created: if (Equals(ExistingMangaCacheObject, null)) { MangaCacheObjects.Add(ExistingMangaCacheObject = new MangaCacheObject() { ArchiveFileName = e.Name }); } goto case WatcherChangeTypes.Changed; case WatcherChangeTypes.Changed: // (Re)Cache if creaded or changed if (!Equals(ExistingMangaCacheObject, null)) { // If ExistingMangaCacheObject is null we are probably still loading. MangaCacheObject ReloadedMangaCacheObject = await DispatcherReloadMangaCacheObjectAsync(e.FullPath, Equals(ExistingMangaCacheObject.CoverImage, null)); if (!Equals(ReloadedMangaCacheObject, null)) { if (Equals(ExistingMangaCacheObject, null)) { MangaCacheObjects.Add(ReloadedMangaCacheObject); } else { ExistingMangaCacheObject.Update(ReloadedMangaCacheObject); } } } break; case WatcherChangeTypes.Deleted: // Reselect nearest neighbor after delete Int32 ExistingIndex = MangaCacheObjects.IndexOf(ExistingMangaCacheObject); if (ExistingIndex >= 0) { MangaCacheObjects.RemoveAt(ExistingIndex); } // If delete was the last item subtract from index if (ExistingIndex >= MangaCacheObjects.Count) { --ExistingIndex; } Messenger.Instance.Send((ExistingIndex >= 0) ? MangaCacheObjects[ExistingIndex] : null, "SelectMangaCacheObject"); break; default: break; } Messenger.Instance.Send(e, "MangaObjectArchiveWatcher"); } else { Dispatcher.Invoke(DispatcherPriority.Send, new Action(() => MangaObjectArchiveWatcher_Event(sender, e))); } }
private void Refresh(MangaCacheObject MangaCacheObject) { App.ContentDownloadManager.Download(MangaCacheObject.MangaObject, true, MangaCacheObject.DownloadProgressReporter); }
private void EditAsync(MangaCacheObject MangaCacheObject) { }