public static List <EpubTextContentFileRef> GetReadingOrder(EpubBookRef bookRef) { List <EpubTextContentFileRef> result = new List <EpubTextContentFileRef>(); foreach (EpubSpineItemRef spineItemRef in bookRef.Schema.Package.Spine) { EpubManifestItem manifestItem = bookRef.Schema.Package.Manifest.FirstOrDefault(item => item.Id == spineItemRef.IdRef); if (manifestItem == null) { throw new Exception($"Incorrect EPUB spine: item with IdRef = \"{spineItemRef.IdRef}\" is missing in the manifest."); } if (bookRef.Content.Html.TryGetValue(manifestItem.Href, out EpubTextContentFileRef htmlContentFileRef)) { result.Add(htmlContentFileRef); continue; } // 2019-08-21 Fix: some ebooks seem to contain two items with id="cover", one of them is an image, and the other an XHTML file // thus, if the first attempt to get the HTML item fails, we try for a second item with the same Id manifestItem = bookRef.Schema.Package.Manifest.Where(item => item.Id == spineItemRef.IdRef).Skip(1).FirstOrDefault(); if (manifestItem == null) { throw new Exception($"Incorrect EPUB spine: item with IdRef = \"{spineItemRef.IdRef}\" is not HTML content"); } if (bookRef.Content.Html.TryGetValue(manifestItem.Href, out EpubTextContentFileRef htmlContentFileRef2)) { result.Add(htmlContentFileRef2); continue; } throw new Exception($"Incorrect EPUB manifest: item with href = \"{spineItemRef.IdRef}\" is missing in the book."); } return(result); }
private static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef, Epub3NavOl epub3NavOl) { List <EpubNavigationItemRef> result = new List <EpubNavigationItemRef>(); if (epub3NavOl != null && epub3NavOl.Lis != null) { foreach (Epub3NavLi epub3NavLi in epub3NavOl.Lis) { if (epub3NavLi != null && (epub3NavLi.Anchor != null || epub3NavLi.Span != null)) { if (epub3NavLi.Anchor != null) { Epub3NavAnchor navAnchor = epub3NavLi.Anchor; EpubNavigationItemRef navigationItemRef = EpubNavigationItemRef.CreateAsLink(); navigationItemRef.Title = GetFirstNonEmptyHeader(navAnchor.Text, navAnchor.Title, navAnchor.Alt); navigationItemRef.Link = new EpubNavigationItemLink(navAnchor.Href); navigationItemRef.HtmlContentFileRef = GetHtmlContentFileRef(bookRef, navigationItemRef.Link.ContentFileName); navigationItemRef.NestedItems = GetNavigationItems(bookRef, epub3NavLi.ChildOl); result.Add(navigationItemRef); } else if (epub3NavLi.Span != null) { Epub3NavSpan navSpan = epub3NavLi.Span; EpubNavigationItemRef navigationItemRef = EpubNavigationItemRef.CreateAsHeader(); navigationItemRef.Title = GetFirstNonEmptyHeader(navSpan.Text, navSpan.Title, navSpan.Alt); navigationItemRef.NestedItems = GetNavigationItems(bookRef, epub3NavLi.ChildOl); result.Add(navigationItemRef); } } } } return(result); }
private static void TestEpubFile(string epubFilePath, Dictionary <string, int> filesByVersion, List <string> filesWithErrors) { Console.WriteLine($"File: {epubFilePath}"); Console.WriteLine("-----------------------------------"); try { using (EpubBookRef bookRef = EpubReader.OpenBook(epubFilePath)) { string epubVersionString = bookRef.Schema.Package.GetVersionString(); if (filesByVersion.ContainsKey(epubVersionString)) { filesByVersion[epubVersionString]++; } else { filesByVersion[epubVersionString] = 1; } Console.WriteLine($"EPUB version: {epubVersionString}"); Console.WriteLine($"Total files: {bookRef.Content.AllFiles.Count}, HTML files: {bookRef.Content.Html.Count}," + $" CSS files: {bookRef.Content.Css.Count}, image files: {bookRef.Content.Images.Count}, font files: {bookRef.Content.Fonts.Count}."); Console.WriteLine($"Reading order: {bookRef.GetReadingOrder().Count} file(s)."); Console.WriteLine("Navigation:"); foreach (EpubNavigationItemRef navigationItemRef in bookRef.GetNavigation()) { PrintNavigationItem(navigationItemRef, 0); } } } catch (Exception exception) { Console.WriteLine(exception.ToString()); filesWithErrors.Add(epubFilePath); } Console.WriteLine(); }
public static List <EpubChapterRef> GetChapters(EpubBookRef bookRef, List <EpubNavigationPoint> navigationPoints) { List <EpubChapterRef> result = new List <EpubChapterRef>(); foreach (EpubNavigationPoint navigationPoint in navigationPoints) { string contentFileName; string anchor; int contentSourceAnchorCharIndex = navigationPoint.Content.Source.IndexOf('#'); if (contentSourceAnchorCharIndex == -1) { contentFileName = navigationPoint.Content.Source; anchor = null; } else { contentFileName = navigationPoint.Content.Source.Substring(0, contentSourceAnchorCharIndex); anchor = navigationPoint.Content.Source.Substring(contentSourceAnchorCharIndex + 1); } EpubTextContentFileRef htmlContentFileRef; if (!bookRef.Content.Html.TryGetValue(contentFileName, out htmlContentFileRef)) { throw new Exception(String.Format("Incorrect EPUB manifest: item with href = \"{0}\" is missing.", contentFileName)); } EpubChapterRef chapterRef = new EpubChapterRef(htmlContentFileRef); chapterRef.ContentFileName = contentFileName; chapterRef.Anchor = anchor; chapterRef.Title = navigationPoint.NavigationLabels.First().Text; chapterRef.SubChapters = GetChapters(bookRef, navigationPoint.ChildNavigationPoints); result.Add(chapterRef); } return(result); }
public static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef) { if (bookRef.Schema.Package.EpubVersion == EpubVersion.EPUB_2) { if (null != bookRef.Schema.Epub2Ncx) { return(GetNavigationItems(bookRef, bookRef.Schema.Epub2Ncx)); } else { return(new List <EpubNavigationItemRef>()); // if Ncx is missing, return an empty list } } else { if (bookRef.Schema.Epub3NavDocument != null) { return(GetNavigationItems(bookRef, bookRef.Schema.Epub3NavDocument)); } // otherwise fallback to Epub2Ncx if (null != bookRef.Schema.Epub2Ncx) { return(GetNavigationItems(bookRef, bookRef.Schema.Epub2Ncx)); } else { return(new List <EpubNavigationItemRef>()); // if Ncx is missing, return an empty list } } }
public void AddBookToLibrary(string bookFilePath) { int bookId; if (settings.Books.Any()) { bookId = settings.Books.Max(bookItem => bookItem.Id) + 1; } else { bookId = 1; } EpubBookRef epubBookRef = EpubReader.OpenBook(bookFilePath); Image coverImage = epubBookRef.ReadCover(); if (coverImage != null) { if (!Directory.Exists(Constants.COVER_IMAGES_FOLDER)) { Directory.CreateDirectory(Constants.COVER_IMAGES_FOLDER); } using (Image resizedCoverImage = ResizeCover(coverImage)) resizedCoverImage.Save(GetBookCoverImageFilePath(bookId), ImageFormat.Png); } Book book = new Book { Id = bookId, FilePath = bookFilePath, Title = epubBookRef.Title, HasCover = coverImage != null }; settings.Books.Add(book); applicationContext.SaveSettings(); }
public static async Task <byte[]> ReadBookCoverAsync(EpubBookRef bookRef) { List <EpubMetadataMeta> metaItems = bookRef.Schema.Package.Metadata.MetaItems; if (metaItems == null || !metaItems.Any()) { return(null); } EpubMetadataMeta coverMetaItem = metaItems.FirstOrDefault(metaItem => String.Compare(metaItem.Name, "cover", StringComparison.OrdinalIgnoreCase) == 0); if (coverMetaItem == null) { return(null); } if (String.IsNullOrEmpty(coverMetaItem.Content)) { throw new Exception("Incorrect EPUB metadata: cover item content is missing."); } EpubManifestItem coverManifestItem = bookRef.Schema.Package.Manifest.FirstOrDefault(manifestItem => String.Compare(manifestItem.Id, coverMetaItem.Content, StringComparison.OrdinalIgnoreCase) == 0); if (coverManifestItem == null) { throw new Exception(String.Format("Incorrect EPUB manifest: item with ID = \"{0}\" is missing.", coverMetaItem.Content)); } if (!bookRef.Content.Images.TryGetValue(coverManifestItem.Href, out EpubByteContentFileRef coverImageContentFileRef)) { throw new Exception(String.Format("Incorrect EPUB manifest: item with href = \"{0}\" is missing.", coverManifestItem.Href)); } byte[] coverImageContent = await coverImageContentFileRef.ReadContentAsBytesAsync().ConfigureAwait(false); return(coverImageContent); }
private static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef, Epub3Nav epub3Nav) { List <EpubNavigationItemRef> result; if (epub3Nav != null) { if (epub3Nav.Head != null) { result = new List <EpubNavigationItemRef>(); EpubNavigationItemRef navigationItemRef = EpubNavigationItemRef.CreateAsHeader(); navigationItemRef.Title = epub3Nav.Head; navigationItemRef.NestedItems = GetNavigationItems(bookRef, epub3Nav.Ol); result.Add(navigationItemRef); } else { result = GetNavigationItems(bookRef, epub3Nav.Ol); } } else { result = new List <EpubNavigationItemRef>(); } return(result); }
internal void SetContent(EpubBookRef epubBook) { _epubBook = epubBook; _chapterRefs = Flatten(epubBook.GetChapters()); _currChapter = -1; pagePanel.EpubBook = epubBook; UpdateChapter(); }
public static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef) { if (bookRef.Schema.Package.EpubVersion == EpubVersion.EPUB_2) { return(GetNavigationItems(bookRef, bookRef.Schema.Epub2Ncx)); } else { return(GetNavigationItems(bookRef, bookRef.Schema.Epub3NavDocument)); } }
private static EpubTextContentFileRef GetHtmlContentFileRef(EpubBookRef bookRef, string contentFileName) { if (contentFileName == null) { return(null); } if (!bookRef.Content.Html.TryGetValue(contentFileName, out EpubTextContentFileRef htmlContentFileRef)) { return(null); } return(htmlContentFileRef); }
public static void Run(string filePath) { using (EpubBookRef bookRef = EpubReader.OpenBook(filePath)) { Console.WriteLine("Navigation:"); foreach (EpubNavigationItemRef navigationItemRef in bookRef.GetNavigation()) { PrintNavigationItem(navigationItemRef, 0); } } Console.WriteLine(); }
/// <summary> /// Opens the book asynchronously without reading its content. Holds the handle to the EPUB file. /// </summary> /// <param name="stream">Stream of file to be parsed</param> /// <returns></returns> private static async Task <EpubBookRef> OpenBookAsync(Stream stream) { var epubArchive = new ZipArchive(stream); var bookRef = new EpubBookRef(epubArchive) { Schema = await SchemaReader.ReadSchemaAsync(epubArchive).ConfigureAwait(false) }; bookRef.Title = bookRef.Schema.Package.Metadata.Titles.FirstOrDefault() ?? string.Empty; bookRef.AuthorList = bookRef.Schema.Package.Metadata.Creators.Select(creator => creator.Creator).ToList(); bookRef.Content = ContentReader.ParseContentMap(bookRef); return(bookRef); }
private static List <EpubChapterRef> GetChapters(EpubBookRef bookRef, IEnumerable <EpubNavigationPoint> navigationPoints) { var result = new List <EpubChapterRef>(); foreach (var navigationPoint in navigationPoints) { string contentFileName; string anchor; var contentSourceAnchorCharIndex = navigationPoint.Content.Source.IndexOf('#'); if (contentSourceAnchorCharIndex is - 1) { contentFileName = navigationPoint.Content.Source; anchor = null; }
public static string Run(string filePath) { StringBuilder result = new StringBuilder(); using (EpubBookRef bookRef = EpubReader.OpenBook(filePath)) { result.AppendLine("Navigation:"); foreach (EpubNavigationItemRef navigationItemRef in bookRef.GetNavigation()) { result.Append(PrintNavigationItem(navigationItemRef, 0)); } } result.AppendLine(); return(result.ToString()); }
public static async Task <Image> ReadBookCoverAsync(EpubBookRef bookRef) { List <EpubMetadataMeta> metaItems = bookRef.Schema.Package.Metadata.MetaItems; if (metaItems == null || !metaItems.Any()) { return(null); } EpubMetadataMeta coverMetaItem = metaItems.FirstOrDefault(metaItem => string.Compare(metaItem.Name, "cover", StringComparison.OrdinalIgnoreCase) == 0); if (coverMetaItem == null) { return(null); } if (String.IsNullOrEmpty(coverMetaItem.Content)) { throw new Exception("Incorrect EPUB metadata: cover item content is missing."); } EpubManifestItem coverManifestItem = bookRef.Schema.Package.Manifest.FirstOrDefault(manifestItem => String.Compare(manifestItem.Id, coverMetaItem.Content, StringComparison.OrdinalIgnoreCase) == 0); if (coverManifestItem == null) { throw new Exception(string.Format(CultureInfo.InvariantCulture, "Incorrect EPUB manifest: item with ID = \"{0}\" is missing.", coverMetaItem.Content)); } EpubByteContentFileRef coverImageContentFileRef; if (!bookRef.Content.Images.TryGetValue(coverManifestItem.Href, out coverImageContentFileRef)) { throw new Exception(string.Format(CultureInfo.InvariantCulture, "Incorrect EPUB manifest: item with href = \"{0}\" is missing.", coverManifestItem.Href)); } byte[] coverImageContent = await coverImageContentFileRef.ReadContentAsBytesAsync().ConfigureAwait(false); using (MemoryStream coverImageStream = new MemoryStream(coverImageContent)) { Image image = new Image(); //return await Task.Run(() => Image.FromStream(coverImageStream)).ConfigureAwait(false); Func <Stream> stream = () => coverImageStream; image.Source = ImageSource.FromStream(stream); return(await Task.Run(() => image).ConfigureAwait(false)); } }
private static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef, List <Epub2NcxNavigationPoint> navigationPoints) { List <EpubNavigationItemRef> result = new List <EpubNavigationItemRef>(); if (navigationPoints != null) { foreach (Epub2NcxNavigationPoint navigationPoint in navigationPoints) { EpubNavigationItemRef navigationItemRef = EpubNavigationItemRef.CreateAsLink(); navigationItemRef.Title = navigationPoint.NavigationLabels.First().Text; navigationItemRef.Link = new EpubNavigationItemLink(navigationPoint.Content.Source); navigationItemRef.HtmlContentFileRef = GetHtmlContentFileRef(bookRef, navigationItemRef.Link.ContentFileName); navigationItemRef.NestedItems = GetNavigationItems(bookRef, navigationPoint.ChildNavigationPoints); result.Add(navigationItemRef); } } return(result); }
public static List <EpubTextContentFileRef> GetReadingOrder(EpubBookRef bookRef) { List <EpubTextContentFileRef> result = new List <EpubTextContentFileRef>(); foreach (EpubSpineItemRef spineItemRef in bookRef.Schema.Package.Spine) { EpubManifestItem manifestItem = bookRef.Schema.Package.Manifest.FirstOrDefault(item => item.Id == spineItemRef.IdRef); if (manifestItem == null) { throw new Exception($"Incorrect EPUB spine: item with IdRef = \"{spineItemRef.IdRef}\" is missing in the manifest."); } if (!bookRef.Content.Html.TryGetValue(manifestItem.Href, out EpubTextContentFileRef htmlContentFileRef)) { throw new Exception($"Incorrect EPUB manifest: item with href = \"{spineItemRef.IdRef}\" is missing in the book."); } result.Add(htmlContentFileRef); } return(result); }
/// <summary> /// Opens the book asynchronously and reads all of its content into the memory. Does not hold the handle to the EPUB file. /// </summary> /// <param name="filePath">path to the EPUB file</param> /// <returns></returns> public static async Task <EpubBook> ReadBookAsync(string filePath) { EpubBook result = new EpubBook(); using (EpubBookRef epubBookRef = await OpenBookAsync(filePath).ConfigureAwait(false)) { result.FilePath = epubBookRef.FilePath; result.Schema = epubBookRef.Schema; result.Title = epubBookRef.Title; result.AuthorList = epubBookRef.AuthorList; result.Author = epubBookRef.Author; result.Content = await ReadContent(epubBookRef.Content).ConfigureAwait(false); result.CoverImage = await epubBookRef.ReadCoverAsync().ConfigureAwait(false); List <EpubChapterRef> chapterRefs = await epubBookRef.GetChaptersAsync().ConfigureAwait(false); result.Chapters = await ReadChapters(chapterRefs).ConfigureAwait(false); } return(result); }
public static List <EpubChapterRef> GetChapters(EpubBookRef bookRef, EpubSpine spine, List <EpubNavigationPoint> navigationPoints) { var result = new List <EpubChapterRef>(); for (var s = 0; s < spine.Count; s++) { var itemRef = spine[s]; string contentFileName; string anchor; contentFileName = WebUtility.UrlDecode(bookRef.Schema.Package.Manifest .FirstOrDefault(e => e.Id == itemRef.IdRef)?.Href); anchor = null; if (!bookRef.Content.Html.TryGetValue(contentFileName, out var htmlContentFileRef)) { throw new Exception(string.Format("Incorrect EPUB manifest: item with href = \"{0}\" is missing.", contentFileName)); } var chapterRef = new EpubChapterRef(htmlContentFileRef); chapterRef.ContentFileName = contentFileName; chapterRef.Anchor = anchor; chapterRef.Parent = null; var navPoint = navigationPoints.LastOrDefault(nav => spine.Take(s + 1) .Select(sp => bookRef.Schema.Package.Manifest.FirstOrDefault(e => e.Id == sp.IdRef)?.Href) .Contains(nav.Content.Source.Split('#')[0])); if (navPoint != null) { chapterRef.Title = navPoint.NavigationLabels.First().Text; } else { chapterRef.Title = $"Chapter {s + 1}"; } chapterRef.SubChapters = new List <EpubChapterRef>(); result.Add(chapterRef); } return(result); }
/// <summary> /// Opens the book asynchronously without reading its content. Holds the handle to the EPUB file. /// </summary> /// <param name="filePath">path to the EPUB file</param> /// <returns></returns> public static async Task <EpubBookRef> OpenBookAsync(string filePath) { IFiler filer = DependencyService.Get <IFiler>(); IZipFile zipFile = DependencyService.Get <IZipFile>(); if (!await filer.DoesFileExistAsync(filePath).ConfigureAwait(false)) { throw new FileNotFoundException("Specified epub file not found.", filePath); } IZipArchive epubArchive = await zipFile.OpenReadAsync(filePath).ConfigureAwait(false); EpubBookRef bookRef = new EpubBookRef(epubArchive); bookRef.FilePath = filePath; bookRef.Schema = await SchemaReader.ReadSchemaAsync(epubArchive).ConfigureAwait(false); bookRef.Title = bookRef.Schema.Package.Metadata.Titles.FirstOrDefault() ?? String.Empty; bookRef.AuthorList = bookRef.Schema.Package.Metadata.Creators.Select(creator => creator.Creator).ToList(); bookRef.Author = string.Join(", ", bookRef.AuthorList); bookRef.Content = await Task.Run(() => ContentReader.ParseContentMap(bookRef)).ConfigureAwait(false); return(bookRef); }
/// <summary> /// Display the whole XHTML file (actually just the body innerhtml). This is generally needed to display the whole chapter/book if hyperlinks link to a targets in another chapter - in this case we display the whole book (if the whole book is in one xhtml file) /// </summary> /// <param name="ePubDisplayModel"></param> /// <param name="epubBookRef"></param> public void FindAndProcessXHTML(ref EpubDisplayModel ePubDisplayModel, EpubBookRef epubBookRef) { // build TOC foreach (var item in epubBookRef.GetNavigation())//.GetChapters()) { ePubDisplayModel.TOC_Items.Add(new EpubLink() { LinkTitle = item.Title }); // add TOC to display model } var foundContent = epubBookRef.Content.Html.Where(x => x.Key.EndsWith(_processAction, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); if (!string.IsNullOrEmpty(foundContent.Key)) { var foundHtml = foundContent.Value.ReadContentAsText(); var doc = new HtmlDocument(); doc.LoadHtml(foundHtml ?? ""); var bodyNodes = doc.DocumentNode.SelectSingleNode("//body"); // select everything inside the <body> tag ePubDisplayModel.ChapterHtml = bodyNodes.OuterHtml; } }
public static EpubContentRef ParseContentMap(EpubBookRef bookRef) { var result = new EpubContentRef { Html = new Dictionary <string, EpubTextContentFileRef>(), Css = new Dictionary <string, EpubTextContentFileRef>(), Images = new Dictionary <string, EpubByteContentFileRef>(), Fonts = new Dictionary <string, EpubByteContentFileRef>(), AllFiles = new Dictionary <string, EpubContentFileRef>() }; foreach (var manifestItem in bookRef.Schema.Package.Manifest) { var fileName = manifestItem.Href; var contentMimeType = manifestItem.MediaType; var contentType = GetContentTypeByContentMimeType(contentMimeType); switch (contentType) { case EpubContentType.XHTML_1_1: case EpubContentType.CSS: case EpubContentType.OEB1_DOCUMENT: case EpubContentType.OEB1_CSS: case EpubContentType.XML: case EpubContentType.DTBOOK: case EpubContentType.DTBOOK_NCX: var epubTextContentFile = new EpubTextContentFileRef(bookRef) { FileName = fileName, ContentMimeType = contentMimeType, ContentType = contentType }; switch (contentType) { case EpubContentType.XHTML_1_1: result.Html[fileName] = epubTextContentFile; break; case EpubContentType.CSS: result.Css[fileName] = epubTextContentFile; break; } result.AllFiles[fileName] = epubTextContentFile; break; default: var epubByteContentFile = new EpubByteContentFileRef(bookRef) { FileName = fileName, ContentMimeType = contentMimeType, ContentType = contentType }; switch (contentType) { case EpubContentType.IMAGE_GIF: case EpubContentType.IMAGE_JPEG: case EpubContentType.IMAGE_PNG: case EpubContentType.IMAGE_SVG: result.Images[fileName] = epubByteContentFile; break; case EpubContentType.FONT_TRUETYPE: case EpubContentType.FONT_OPENTYPE: result.Fonts[fileName] = epubByteContentFile; break; } result.AllFiles[fileName] = epubByteContentFile; break; } } return(result); }
public static List <EpubChapterRef> GetChapters(EpubBookRef bookRef) { return(GetChapters(bookRef, bookRef.Schema.Package.Spine, bookRef.Schema.Navigation.NavMap)); }
public EpubTextContentFileRef(EpubBookRef epubBookRef) : base(epubBookRef) { }
public static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef, Epub2Ncx epub2Ncx) { return(GetNavigationItems(bookRef, epub2Ncx.NavMap)); }
public static List <EpubNavigationItemRef> GetNavigationItems(EpubBookRef bookRef, Epub3NavDocument epub3NavDocument) { return(GetNavigationItems(bookRef, epub3NavDocument.Navs.FirstOrDefault(nav => nav.Type == StructuralSemanticsProperty.TOC))); }
public void Dispose() { _chapterRefs.Clear(); _epubBook?.Dispose(); _epubBook = null; }
/// <summary> /// Display the chapter. This might be a whole xhtml file or a section of an xhtml file between 2 'chapter' id's (or epub navnodes) /// </summary> /// <param name="ePubDisplayModel"></param> /// <param name="epubBookRef"></param> public void FindAndProcessChapter(ref EpubDisplayModel ePubDisplayModel, EpubBookRef epubBookRef) { EpubChapterHolder cHolder = new EpubChapterHolder(); // Enumerating chapters var allChapters = epubBookRef.GetNavigation();//.GetChapters(); for (int i = 0; i < allChapters.Count(); i++) { var _chapter = allChapters[i]; string encTitle = EpubHelpers.EncodeChapterTitleForUrl(_chapter.Title); if (encTitle == _processAction && !cHolder.CurrentChapter.IsValid()) // chapter found! select this chapter to display { cHolder.CurrentChapter.ChapterIndex = i; cHolder.CurrentChapter.EpubChapter = _chapter; cHolder.CurrentChapter.TitleAndLinkUrl.LinkTitle = _chapter.Title; } ePubDisplayModel.TOC_Items.Add(new EpubLink() { LinkTitle = _chapter.Title }); // add TOC to display model } if (!cHolder.CurrentChapter.IsValid()) // chapter not found - so get the default chapter and redirect to that { if (_startAtIndex < 0 || _startAtIndex >= allChapters.Count()) // check if the _startAtIndex property is within valid limits - if not then set the index to 0 { _startAtIndex = 0; } var _chapter = allChapters[_startAtIndex]; cHolder.CurrentChapter.TitleAndLinkUrl.LinkTitle = _chapter.Title; ePubDisplayModel.RedirectToChapter = cHolder.CurrentChapter.TitleAndLinkUrl.LinkUrl; return; // exit this method as we need to perform a redirect in the calling controller rather than } ePubDisplayModel.TOC_Items[cHolder.CurrentChapter.ChapterIndex].IsCurrent = true; // try and find the previous chapter details int previousChapterIndex = cHolder.CurrentChapter.ChapterIndex - 1; if (previousChapterIndex >= 0) // check index is valid { var _chapter = allChapters[previousChapterIndex]; cHolder.PreviousChapter.ChapterIndex = previousChapterIndex; cHolder.PreviousChapter.EpubChapter = _chapter; cHolder.PreviousChapter.TitleAndLinkUrl.LinkTitle = _chapter.Title; ePubDisplayModel.Nav_PreviousChapterLink.LinkTitle = _chapter.Title; } // try and find the next chapter details int nextChapterIndex = cHolder.CurrentChapter.ChapterIndex + 1; if (nextChapterIndex < allChapters.Count()) // check index is valid { var _chapter = allChapters[nextChapterIndex]; cHolder.NextChapter.ChapterIndex = nextChapterIndex; cHolder.NextChapter.EpubChapter = _chapter; cHolder.NextChapter.TitleAndLinkUrl.LinkTitle = _chapter.Title; ePubDisplayModel.Nav_NextChapterLink.LinkTitle = _chapter.Title; } ePubDisplayModel.ChapterHtml = BuildChapterHtml(cHolder); }
public static EpubContentRef ParseContentMap(EpubBookRef bookRef) { EpubContentRef result = new EpubContentRef { Html = new Dictionary <string, EpubTextContentFileRef>(), Css = new Dictionary <string, EpubTextContentFileRef>(), Images = new Dictionary <string, EpubByteContentFileRef>(System.StringComparer.OrdinalIgnoreCase), Fonts = new Dictionary <string, EpubByteContentFileRef>(), AllFiles = new Dictionary <string, EpubContentFileRef>() }; foreach (EpubManifestItem manifestItem in bookRef.Schema.Package.Manifest) { string fileName = manifestItem.Href; string contentMimeType = manifestItem.MediaType; EpubContentType contentType = GetContentTypeByContentMimeType(contentMimeType); switch (contentType) { case EpubContentType.XHTML_1_1: case EpubContentType.CSS: case EpubContentType.OEB1_DOCUMENT: case EpubContentType.OEB1_CSS: case EpubContentType.XML: case EpubContentType.DTBOOK: case EpubContentType.DTBOOK_NCX: EpubTextContentFileRef epubTextContentFile = new EpubTextContentFileRef(bookRef) { FileName = fileName, ContentMimeType = contentMimeType, ContentType = contentType }; switch (contentType) { case EpubContentType.XHTML_1_1: result.Html[fileName] = epubTextContentFile; break; case EpubContentType.CSS: result.Css[fileName] = epubTextContentFile; break; } result.AllFiles[fileName] = epubTextContentFile; break; default: EpubByteContentFileRef epubByteContentFile = new EpubByteContentFileRef(bookRef) { FileName = fileName, ContentMimeType = contentMimeType, ContentType = contentType }; switch (contentType) { case EpubContentType.IMAGE_GIF: case EpubContentType.IMAGE_JPEG: case EpubContentType.IMAGE_PNG: case EpubContentType.IMAGE_SVG: result.Images[fileName] = epubByteContentFile; break; case EpubContentType.FONT_TRUETYPE: case EpubContentType.FONT_OPENTYPE: result.Fonts[fileName] = epubByteContentFile; break; } result.AllFiles[fileName] = epubByteContentFile; break; } } result.Cover = BookCoverReader.ReadBookCover(bookRef.Schema, result.Images); return(result); }