static Book2 LoadEpub(string path)
{
try
{
EpubBook epub = EpubReader.Read(path);
var book = new Book2
{
Authors = string.Join(", ", epub.Authors.ToArray()),
Title = epub.Title,
Path = path
};
return(book);
}
catch
{
return(null);
}
}
private void ParseNavigation(EpubBook epubBook, BookContent content, List <HtmlPagingItem> pagings)
{
foreach (var navItem in epubBook.Navigation)
{
var chapter = navItem.Title;
var navKey = navItem.Link.ContentFileName.ToLower().Trim();
var htmlItem = pagings.Find(x => x.PageKey == navKey);
var newNavItem = new NavigationItem()
{
HtmlPagingItemId = htmlItem.Id,
Chapter = chapter,
HtmlPagingItem = htmlItem,
BookContent = content,
};
this.navigationItems.Add(newNavItem);
this.navigationItems.Save();
}
}
protected override void OnAppearing()
{
var assembly = typeof(epubreaderPage).GetTypeInfo().Assembly;
Stream stream = assembly.GetManifestResourceStream("epubreader.Resources.conde.epub");
EpubBook epubBook = EpubReader.ReadBook(stream);
this.titleTxt.Text = epubBook.Title;
this.authorTxt.Text = epubBook.Author;
var chaptersList = "";
foreach (EpubChapter chapter in epubBook.Chapters)
{
// Title of chapter
chaptersList += chapter.Title + " ";
}
this.chapterList.Text = chaptersList;
}
/// <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="stream">Stream of EPUB book</param>
/// <returns><seealso cref="EpubBook"/></returns>
public static async Task <EpubBook> ReadBookAsync(Stream stream)
{
var result = new EpubBook();
using (var epubBookRef = await OpenBookAsync(stream).ConfigureAwait(false))
{
result.Schema = epubBookRef.Schema;
result.Title = epubBookRef.Title;
result.AuthorList = epubBookRef.AuthorList;
result.Content = await ReadContent(epubBookRef.Content).ConfigureAwait(false);
result.CoverImage = await BookCoverReader.ReadBookCoverAsync(epubBookRef).ConfigureAwait(false);
var chapterRefs = ChapterReader.GetChapters(epubBookRef);
result.Chapters = await ReadChapters(chapterRefs).ConfigureAwait(false);
}
return(result);
}
// Use this for initialization
void Start()
{
using (var client = new WebClient())
{
//TODO: Next step - allow the user to choose what book to read (input url? search? browse?)
Stream stream = client.OpenRead("http://www.gutenberg.org/ebooks/135.epub.noimages");
book = EpubReader.Read(stream, false);
}
chapterTexts = new LinkedList <string>();
foreach (EpubTextFile chapter in book.SpecialResources.HtmlInReadingOrder)
{
string newText = chapter.TextContent + '\n';
newText = Regex.Replace(newText, "<br[^>]*>", "\n");
newText = Regex.Replace(newText, "<p[^>]*>", "\n");
newText = Regex.Replace(newText, "</p>", "");
newText = Regex.Replace(newText, "<h5[^>]*>", "<size=+1>");
newText = Regex.Replace(newText, "</h5>", "</size>");
newText = Regex.Replace(newText, "<h4[^>]*>", "<size=+2>");
newText = Regex.Replace(newText, "</h4>", "</size>");
newText = Regex.Replace(newText, "<h3[^>]*>", "<size=+3>");
newText = Regex.Replace(newText, "</h3>", "</size>");
newText = Regex.Replace(newText, "<h2[^>]*>", "<size=+4>");
newText = Regex.Replace(newText, "</h2>", "</size>");
newText = Regex.Replace(newText, "<h1[^>]*>", "<size=+5>");
newText = Regex.Replace(newText, "</h1>", "</size>");
newText = Regex.Replace(newText, "<div[^>]*>", "\n");
newText = Regex.Replace(newText, "</div>", "\n");
// Replace anything not matched above, or italics/bold/underline, with blank
newText = Regex.Replace(newText, "</?(((p|size|i|br|u|b)[^ r=>][^>]*)|((?!(p|br|size|i|b|u|/))[^>]*))>", "");
chapterTexts.AddLast(new LinkedListNode <string>(newText));
}
curText = chapterTexts.First;
pageOne.text = curText.Value;
pageTwo.text = curText.Value;
}
public string ReadBook(EpubBook book)
{
//Переменная в которую добавляется весь текст html
string chapterHtmlContent = "";
//Чтение по главам
foreach (EpubChapter chapter in book.Chapters)
{
chapterHtmlContent += chapter.HtmlContent;
//Чтение всех подглав
List <EpubChapter> subChapters = chapter.SubChapters;
foreach (EpubChapter item in subChapters)
{
chapterHtmlContent += item.HtmlContent;
htmlCon = chapter.HtmlContent;
}
}
return(chapterHtmlContent);
}
/// <summary>
/// Чтение книги с устройства
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void LoadButtonClicked(object sender, EventArgs e)
{
try
{
//Допустимые форматы
string[] types = new string[] { ".epub" };
//Открываем проводник
FileData fileData = await CrossFilePicker.Current.PickFile(allowedTypes : types);
//Если ничего не выбрано, то просто возвращаем null
if (fileData == null)
{
return;
}
//Создаем объект EpubBook
EpubBook newBook = EpubReader.ReadBook(new MemoryStream(fileData.DataArray));
//Добавляем в словарь
books.Add(newBook.Title + Environment.NewLine + newBook.Author, newBook);
//Берем путь и сохраняем его для того, чтобы после закрытия программы все книги отобразились вновь
string path = fileData.FilePath;
using (StreamWriter sw = new StreamWriter(filenameForBooks, true, System.Text.Encoding.Default))
{
sw.WriteLine(path);
}
foreach (string book in Books.books.Keys)
{
Goal.bookPicker.Items.Add(book);
}
//Создаём кнопку с книгой
LoadNewBook(newBook);
}
catch (Exception ex)
{
Console.WriteLine("Ошибка при выборе файла: " + ex.ToString());
}
}
/// <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);
}
private void AssertEpub(EpubBook expected, EpubBook actual)
{
Assert.IsNotNull(expected);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Title, actual.Title);
Assert.AreEqual(expected.Author, actual.Author);
AssertPrimitiveCollection(expected.Authors, actual.Authors, nameof(actual.Authors), "Author");
Assert.AreEqual(expected.CoverImage == null, actual.CoverImage == null, nameof(actual.CoverImage));
if (expected.CoverImage != null && actual.CoverImage != null)
{
Assert.IsTrue(expected.CoverImage.Length > 0, "Expected CoverImage.Length > 0");
Assert.IsTrue(actual.CoverImage.Length > 0, "Actual CoverImage.Length > 0");
Assert.AreEqual(expected.CoverImage.Length, actual.CoverImage.Length, "CoverImage.Length");
}
AssertContentFileCollection(expected.Resources.Css, actual.Resources.Css, nameof(actual.Resources.Css));
AssertContentFileCollection(expected.Resources.Fonts, actual.Resources.Fonts, nameof(actual.Resources.Fonts));
AssertContentFileCollection(expected.Resources.Html, actual.Resources.Html, nameof(actual.Resources.Html));
AssertContentFileCollection(expected.Resources.Images, actual.Resources.Images, nameof(actual.Resources.Images));
AssertContentFileCollection(
// Filter some format related files, because they often are not byte-by-byte the same when are generated by the writers.
expected.Resources.Other.Where(e => e.FileName != expected.Format.Opf.FindNcxPath()),
actual.Resources.Other.Where(e => e.FileName != expected.Format.Opf.FindNcxPath()),
nameof(actual.Resources.Other)
);
AssertCollection(expected.SpecialResources.HtmlInReadingOrder, actual.SpecialResources.HtmlInReadingOrder, nameof(actual.SpecialResources.HtmlInReadingOrder), (old, @new) =>
{
AssertContentFile(old, @new, nameof(actual.SpecialResources.HtmlInReadingOrder));
});
AssertCollection(expected.TableOfContents, actual.TableOfContents, nameof(actual.TableOfContents), AssertChapter);
AssertOcf(expected.Format.Ocf, actual.Format.Ocf);
AssertOpf(expected.Format.Opf, actual.Format.Opf);
AssertNcx(expected.Format.Ncx, actual.Format.Ncx);
AssertNav(expected.Format.Nav, actual.Format.Nav);
}
private void Epub()
{
nom = Path.GetFileName(ch.full_chemin_livre); //Nom fichier epub
string extention = System.IO.Path.GetFileNameWithoutExtension(nom) + ".zip";
string pathString = biblio.CurrentPath + @"\copies\";
nchemin = pathString + extention;
if (File.Exists(pathString + nom))
{
//FRM_OriginalModifier Popup = new FRM_OriginalModifier();
//Popup.ShowDialog();
//charge = Popup.Choix();
if (charge == 1)
{
epubBook = EpubReader.ReadBook(ch.full_chemin_livre);
}
else
{
epubBook = EpubReader.ReadBook(pathString + nom);
}
}
}
public static List <EpubChapter> GetAllChapters(this EpubBook book)
{
List <EpubChapter> chapters = new List <EpubChapter>();
Action <EpubChapter> ActAddSubChapters = null;
ActAddSubChapters = new Action <EpubChapter>((epChapter) =>
{
chapters.Add(epChapter);
if (epChapter.SubChapters != null && epChapter.SubChapters.Any())
{
foreach (var epSubChapter in epChapter.SubChapters)
{
ActAddSubChapters(epSubChapter);
}
}
});
foreach (var epChapter in book.Chapters)
{
ActAddSubChapters(epChapter);
}
return(chapters);
}
private List <HtmlPagingItem> ParsePages(EpubBook epubBook, BookContent content)
{
var pagings = new List <HtmlPagingItem>();
foreach (var item in epubBook.Content.Html)
{
var key = item.Key.ToLower().Trim();
string htmlContent, keyPart;
string inputHtml = item.Value.Content;
string[] bodyTags = { "<body", "/body>" };
var piecesHtml = inputHtml.Split(bodyTags, StringSplitOptions.RemoveEmptyEntries);
if (piecesHtml[1] != null)
{
keyPart = piecesHtml[1];
}
else
{
keyPart = piecesHtml[0];
}
string resultHtml = string.Format("{0}{1}{2}", "<div", keyPart, "</div>");
htmlContent = resultHtml;
var newPage = new HtmlPagingItem()
{
PageKey = key,
HtmlContent = htmlContent,
BookContent = content,
};
pagings.Add(newPage);
this.pagingItems.Add(newPage);
this.pagingItems.Save();
}
return(pagings);
}
async void Button_Clicked(System.Object sender, System.EventArgs e)
{
var fileData = await CrossFilePicker.Current.PickFile();
if (fileData == null)
{
return; // user canceled file picking
}
epubBook = EpubReader.ReadBook(fileData.FilePath);
//SaveImages();
Item.Text = epubBook.Title;
try
{
var coverFileName = "";
if (Device.RuntimePlatform == "UWP")
{
coverFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "tempCover.jpg");
}
else
{
coverFileName = Path.Combine(baseUrl, "tempCover.jpg");
}
File.WriteAllBytes(coverFileName, epubBook.CoverImage ?? epubBook.Content.Images.FirstOrDefault().Value.Content);
this.CoverImage.Source = coverFileName;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
this.OnPropertyChanged("Item");
//SaveHtmlCssFiles();
contentService.ExtractAllFilesFromEpub(epubBook, BookEnvironment.GetTempLocalPathForEpub());
renderHtml();
}
private static void SpineParser(EpubBook book, Published p)
{
var spineIds = book.PackageData.Spine.ItemRefs.Select(i => i.IdRef).ToList();
var data = book.PackageData.Manifest.Items;
// 2. Get the content elements
var content = data.Where(i => spineIds.Any(sid => sid == i.Identifier)).Select(i => new {
Data = i.Data,
Identifier = i.Href,
Name = i.Identifier
});
FrozenFragment rootFragment = new FrozenFragment {
Name = "Root",
TypeOfFragment = FragmentType.Meta,
Children = new List <FrozenFragment>()
};
int orderNr = 1;
foreach (var file in content)
{
var c = UTF8Encoding.UTF8.GetString(file.Data);
CreateTextFragment(rootFragment, ref c, data);
}
p.FrozenFragments = rootFragment.Children;
}
public EpubBook OpenBook(int bookId)
{
EpubBook epubBook = EpubReader.OpenBook(settings.Books.First(book => book.Id == bookId).FilePath);
return(epubBook);
}
/// <summary>
/// This method is looking for a books, adds books to the main page if they are not contains in the database,
/// deletes books if they don't exist on the user's device. It helps to hold actual data.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="args">An object that contains the event data.</param>
private async void OnClickSearchBooksButton(object sender, EventArgs args)
{
IFiler filer = DependencyService.Get <IFiler>();
IEnumerable <string> pathsOfFoundFiles = await filer.GetFilesPathsAsync(FileExtension.EPUB).ConfigureAwait(false);
List <EpubBook> epubBooks = new List <EpubBook>();
foreach (var path in pathsOfFoundFiles)
{
EpubBook book = await EpubReader.EpubReader.ReadBookAsync(path).ConfigureAwait(false);
epubBooks.Add(book);
}
List <string> pathsOfExistingFiles = this.bookEntities.Select(entity => entity.FilePath).ToList();
// Try to read not all book information.
// I need to read only a necessary information e.g. Title, Author, Cover.
foreach (EpubBook epubBook in epubBooks)
{
// If the book entity does not exist.
// Add a new book info to the main page.
if (pathsOfExistingFiles.Contains(epubBook.FilePath) == false)
{
BookEntity bookEntity = new BookEntity
{
Id = Guid.NewGuid().ToNonDashedString(),
Title = epubBook.Title,
Author = epubBook.Author,
// It should be changed.
// An image might be missed.
Cover = epubBook.Content.Images.FirstOrDefault().Value.Content,
FilePath = epubBook.FilePath
};
SettingsEntity settingsEntity = new SettingsEntity
{
BookId = bookEntity.Id,
LastPage = 1,
FontSize = 14
};
SQLiteResult result = this.bookRepository.Add(bookEntity);
SQLiteResult settingsInsertResult = this.settingsRepository.Add(settingsEntity);
// 0 is SQLITE_OK
// But returns 1 and entity is successfully saved into database.
//if (bookInsertStatusCode == 1)
//{
this.bookEntities.Add(bookEntity);
BookInfoViewModel model = bookEntity.ToBookInfoModelMapper();
this.books.Add(model);
//}
}
}
// Delete book info models and book entities which do not exist yet.
foreach (var pathOfExistingFile in pathsOfExistingFiles)
{
if (pathsOfFoundFiles.Contains(pathOfExistingFile) == false)
{
// Delete entity.
BookEntity deletedBookEntity = this.bookEntities.FirstOrDefault(e => e.FilePath == pathOfExistingFile);
this.bookRepository.DeleteById(deletedBookEntity.Id);
this.bookEntities.Remove(deletedBookEntity);
// Delete book info view model.
BookInfoViewModel deletedBookInfoViewModel = this.books.FirstOrDefault(m => m.FilePath == pathOfExistingFile);
this.books.Remove(deletedBookInfoViewModel);
}
}
Xamarin.Forms.Device.BeginInvokeOnMainThread(() => this.UpdateBookLibrary(this.books));
}
public List <NavigationItemViewModel> GetNavigation(EpubBook epubBook)
{
return(GetNavigation(epubBook.Navigation));
}
private void EpubToChapters(string ebookPath)
{
book = EpubReader.ReadBook(ebookPath);
contentFiles = book.ReadingOrder.ToList();
Chapters = new List <Chapter>();
for (int i = 0; i < contentFiles.Count; i++)
{
Chapter chapter = new Chapter();
bool foundBody = false;
bool firstLine = true;
bool secondLine = false;
bool inTable = false;
bool hasTableRows = false;
int tableDepth = 0;
bool inComment = false;
bool inBlockquote = false;
string imageFile;
StringBuilder currline = new StringBuilder();
Stack <string> spanStack = new Stack <string>();
// split all the items into html tags and raw text
string[] contentText = contentFiles[i].Content
.Replace("\r", "")
.Replace("</span>\n<span", "</span> <span")
.Replace("\n", " ") // fixes paragraphs across multiple lines
.Replace(">", ">\n")
.Replace("<", "\n<")
.Split('\n');
foreach (string s in contentText)
{
if (s.Length == 0)
{
continue;
}
string s2;
if (s.Trim().StartsWith("<"))
{
s2 = s.Trim();
}
else
{
s2 = s;
}
if (s2.Contains(" "))
{
s2 = s2.Replace(" ", " ");
}
if (s2.Contains(" "))
{
s2 = s2.Replace(" ", " ");
}
if (s2.Contains($"{(char)160}"))
{
s2 = s2.Replace((char)160, ' ');
}
if (s2.Length == 0)
{
continue;
}
if (s2.Contains("_"))
{
s2 = s2.Replace("_", "_");
}
if (inComment)
{
if (s2.Contains("-->"))
{
inComment = false;
int pos2 = s2.IndexOf("-->");
if (pos2 + 3 >= s2.Length)
{
continue;
}
s2 = s2.Substring(pos2 + 3);
if (s2.Length == 0)
{
continue;
}
}
else
{
continue;
}
}
if (s2.Contains("<!--"))
{
inComment = true;
int pos = s2.IndexOf("<!--");
int pos2 = s2.IndexOf("-->", pos);
if (pos2 > pos)
{
s2 = s2.Remove(pos, pos2 - pos + 3);
inComment = false;
}
else
{
s2 = s2.Substring(0, pos);
}
if (s2.Length == 0)
{
continue;
}
}
if (!s2.StartsWith("<"))
{
if (foundBody)
{
string s3 = FixText(s2);
if (currline.ToString().EndsWith("_t_") && s3.StartsWith(" "))
{
// change spaces to another _t_
currline.Append("_t_");
currline.Append(s2.TrimStart());
}
else
{
currline.Append(s3);
}
}
continue;
}
string tag = GetTag(s2);
switch (tag)
{
case "body":
foundBody = true;
break;
case "/body":
foundBody = false;
break;
case "blockquote":
if (inBlockquote)
{
// avoid nested blockquotes
continue;
}
if (inTable)
{
continue;
}
inBlockquote = true;
if (!currline.ToString().EndsWith("_t_"))
{
currline.Append("_t_");
}
break;
case "/blockquote":
if (!inBlockquote)
{
// avoid nested blockquotes
continue;
}
if (inTable)
{
continue;
}
inBlockquote = false;
if (!secondLine || currline.Length > 0)
{
chapter.Paragraphs.Add("_p_" + currline.ToString().Trim());
secondLine = false;
}
currline.Clear();
break;
case "/p":
case "/div":
case "br":
case "/li":
case "hr":
case "/ul":
case "/ol":
case "/h1":
case "/h2":
case "/h3":
case "/h4":
case "/h5":
case "/h6":
if (inTable)
{
continue;
}
if (firstLine)
{
string s4 = currline.ToString();
s4 = s4.Replace("_b1_", "");
s4 = s4.Replace("_b0_", "");
s4 = s4.Replace("_i1_", "");
s4 = s4.Replace("_i0_", "");
s4 = s4.Replace("_u1_", "");
s4 = s4.Replace("_u0_", "");
s4 = s4.Replace("_t_", "");
s4 = s4.Trim();
if (s4.Length == 0)
{
continue;
}
if (s4.StartsWith("_"))
{
chapter.Paragraphs.Add("###");
chapter.Paragraphs.Add("");
chapter.Paragraphs.Add("_p_" + s4);
secondLine = false;
}
else if (char.IsDigit(s4[0]) || s4.ToUpper().StartsWith("CHAPTER"))
{
chapter.Paragraphs.Add("###" + s4);
chapter.Paragraphs.Add("");
secondLine = true;
}
else if (s4.Length > 100) // too long for chapter
{
chapter.Paragraphs.Add("###");
chapter.Paragraphs.Add("");
chapter.Paragraphs.Add("_p_" + s4);
secondLine = false;
}
else
{
chapter.Paragraphs.Add("###" + s4);
chapter.Paragraphs.Add("");
secondLine = true;
}
firstLine = false;
}
else if (tag == "hr")
{
if (currline.Length > 0)
{
chapter.Paragraphs.Add(currline.ToString().TrimEnd());
}
chapter.Paragraphs.Add("_p_---");
secondLine = false;
}
else if (tag == "/li" && currline.Length > 0)
{
chapter.Paragraphs.Add("_p__t_" + currline.ToString().Trim());
secondLine = false;
}
else if (!secondLine || currline.Length > 0)
{
chapter.Paragraphs.Add("_p_" + currline.ToString().Trim());
secondLine = false;
}
currline.Clear();
break;
case "image":
imageFile = s2.Substring(s2.IndexOf("href=\"") + 6);
imageFile = imageFile.Substring(0, imageFile.IndexOf("\""));
if (imageFile != "cover.jpeg")
{
currline.Append("_image:");
currline.Append(imageFile);
currline.Append("_");
}
break;
case "img":
imageFile = s2.Substring(s2.IndexOf("src=\"") + 5);
imageFile = imageFile.Substring(0, imageFile.IndexOf("\""));
if (imageFile != "cover.jpeg")
{
currline.Append("_image:");
currline.Append(imageFile);
currline.Append("_");
if (s2.IndexOf("alt=\"") >= 0)
{
string altTag = s2.Substring(s2.IndexOf("alt=\"") + 5);
altTag = altTag.Substring(0, altTag.IndexOf("\"")).Trim();
if (altTag.Length > 0)
{
currline.Append("_imagealt:");
currline.Append(altTag);
currline.Append("_");
}
}
}
break;
case "span":
if (s2.Contains("\"bold\""))
{
spanStack.Push("b");
currline.Append("_b1_");
}
else if (s2.Contains("\"italic\""))
{
spanStack.Push("i");
currline.Append("_i1_");
}
else if (s2.Contains("\"underline\""))
{
spanStack.Push("u");
currline.Append("_u1_");
}
else
{
spanStack.Push("");
}
break;
case "/span":
string spanPop = spanStack.Pop();
if (spanPop == "b")
{
currline.Append("_b0_");
}
else if (spanPop == "i")
{
currline.Append("_i0_");
}
else if (spanPop == "u")
{
currline.Append("_u0_");
}
break;
case "li":
int pos = s2.IndexOf("value=\"");
if (pos >= 0)
{
pos += 7;
int pos2 = s2.IndexOf("\"", pos);
currline.Append(s2.Substring(pos, pos2 - pos));
currline.Append(": ");
}
else
{
currline.Append("* "); // no list value found
}
break;
case "table":
inTable = true;
if (tableDepth == 0)
{
hasTableRows = false;
}
tableDepth++;
if (!hasTableRows)
{
break;
}
if (currline.Length > 0)
{
chapter.Paragraphs.Add(currline.ToString());
currline.Clear();
}
chapter.Paragraphs.Add("_p__table1_");
break;
case "/table":
tableDepth--;
if (tableDepth <= 0)
{
tableDepth = 0;
inTable = false;
}
if (!hasTableRows)
{
break;
}
if (currline.Length > 0)
{
chapter.Paragraphs.Add(currline.ToString());
currline.Clear();
}
chapter.Paragraphs.Add("_p__table0_");
break;
case "tr":
if (!inTable)
{
Console.WriteLine("<tr> outside table error");
break;
}
if (!hasTableRows)
{
if (currline.Length > 0)
{
chapter.Paragraphs.Add(currline.ToString());
currline.Clear();
}
for (int trI = 0; trI < tableDepth; trI++)
{
chapter.Paragraphs.Add("_p__table1_");
}
hasTableRows = true;
}
currline.Append("_p__tr1_");
break;
case "/tr":
if (!inTable)
{
Console.WriteLine("</tr> outside table error");
break;
}
currline.Append("_tr0_");
chapter.Paragraphs.Add(currline.ToString());
currline.Clear();
break;
case "caption":
if (!inTable)
{
Console.WriteLine("<caption> outside table error");
break;
}
currline.Append("_p__caption1_");
break;
case "/caption":
if (!inTable)
{
Console.WriteLine("</caption> outside table error");
break;
}
currline.Append("_caption0_");
chapter.Paragraphs.Add(currline.ToString());
currline.Clear();
break;
case "tt":
currline.Append("_code1_");
break;
case "/tt":
currline.Append("_code0_");
break;
case "em":
currline.Append("_i1_");
break;
case "/em":
currline.Append("_i0_");
break;
case "strong":
currline.Append("_b1_");
break;
case "/strong":
currline.Append("_b0_");
break;
case "i":
case "/i":
case "b":
case "/b":
case "s":
case "/s":
case "u":
case "/u":
case "sup":
case "/sup":
case "sub":
case "/sub":
case "small":
case "/small":
// on-off tag pairs
currline.Append("_");
if (tag.StartsWith("/"))
{
currline.Append(tag.Substring(1));
currline.Append("0"); // off
}
else
{
currline.Append(tag);
currline.Append("1"); // on
}
currline.Append("_");
break;
case "th":
case "/th":
case "td":
case "/td":
if (!inTable)
{
Console.WriteLine($"<{tag}> outside table error");
break; // ignore all these if not in table
}
// on-off tag pairs
if (currline.Length == 0)
{
currline.Append("_p_");
}
currline.Append("_");
if (tag.StartsWith("/"))
{
currline.Append(tag.Substring(1));
currline.Append("0"); // off
}
else
{
currline.Append(tag);
currline.Append("1"); // on
}
currline.Append("_");
break;
case "div":
case "a":
case "/a":
case "ul":
case "ol":
case "svg":
case "/svg":
case "h1":
case "h2":
case "h3":
case "h4":
case "h5":
case "h6":
case "col":
case "colgroup":
case "/colgroup":
case "section":
case "/section":
case "big":
case "/big":
case "nav":
case "/nav":
// ignore all these
break;
case "p":
break;
default:
if (foundBody)
{
currline.Append("<");
currline.Append(tag);
currline.Append(">");
}
break;
}
}
if (currline.ToString().Trim().Length > 0)
{
if (firstLine)
{
string s4 = currline.ToString().Trim();
s4 = s4.Replace("_b1_", "");
s4 = s4.Replace("_b0_", "");
s4 = s4.Replace("_i1_", "");
s4 = s4.Replace("_i0_", "");
s4 = s4.Replace("_u1_", "");
s4 = s4.Replace("_u0_", "");
s4 = s4.Replace("_t_", "");
s4 = s4.Trim();
if (s4.StartsWith("_"))
{
chapter.Paragraphs.Add("###");
chapter.Paragraphs.Add("");
chapter.Paragraphs.Add("_p_" + s4);
}
else if (s4.Contains("_"))
{
chapter.Paragraphs.Add("###" + s4.Substring(0, s4.IndexOf("_")).Trim());
chapter.Paragraphs.Add("");
chapter.Paragraphs.Add("_p_" + s4.Substring(s4.IndexOf("_")).Trim());
}
else
{
chapter.Paragraphs.Add("###" + s4);
chapter.Paragraphs.Add("");
}
}
else
{
chapter.Paragraphs.Add(currline.ToString().Trim());
}
}
if (chapter.Paragraphs.Count > 0 &&
!chapter.Paragraphs[0].ToLower().Contains("contents"))
{
while (chapter.Paragraphs.Count >= 3 &&
chapter.Paragraphs[2] == "_p_")
{
chapter.Paragraphs.RemoveAt(2);
}
while (chapter.Paragraphs.Count > 0 &&
(chapter.Paragraphs[chapter.Paragraphs.Count - 1].Length == 0 ||
chapter.Paragraphs[chapter.Paragraphs.Count - 1] == "_p_")
)
{
chapter.Paragraphs.RemoveAt(chapter.Paragraphs.Count - 1);
}
if (chapter.Paragraphs.Count > 0)
{
if (chapter.Paragraphs[0].Contains("_b"))
{
chapter.Paragraphs[0] = chapter.Paragraphs[0].Replace("_b1_", "").Replace("_b0_", "");
}
if (chapter.Paragraphs[0].Contains("_i"))
{
// could be _image_, but will be ignored
chapter.Paragraphs[0] = chapter.Paragraphs[0].Replace("_i1_", "").Replace("_i0_", "");
}
if (chapter.Paragraphs[0].Contains("_u"))
{
chapter.Paragraphs[0] = chapter.Paragraphs[0].Replace("_u1_", "").Replace("_u0_", "");
}
for (int para = chapter.Paragraphs.Count - 1; para > 1; para--)
{
if (chapter.Paragraphs[para] == "_p_" && chapter.Paragraphs[para - 1] == "_p_")
{
chapter.Paragraphs.RemoveAt(para);
}
}
Chapters.Add(chapter);
}
}
}
}
public async Task <EpubBook> OpenBookAsync(int bookId)
{
EpubBook epubBook = await EpubReader.ReadBookAsync("C:\\Users\\edoua\\OneDrive\\Documents\\Livres\\Private Prince\\Private Prince 1.epub");
return(epubBook);
}
public static EpubContent ReadContentFiles(ZipArchive epubArchive, EpubBook book)
{
EpubContent result = new EpubContent
{
Html = new Dictionary<string, EpubTextContentFile>(),
Css = new Dictionary<string, EpubTextContentFile>(),
Images = new Dictionary<string, EpubByteContentFile>(),
Fonts = new Dictionary<string, EpubByteContentFile>(),
AllFiles = new Dictionary<string, EpubContentFile>()
};
foreach (EpubManifestItem manifestItem in book.Schema.Package.Manifest)
{
string contentFilePath = ZipPathUtils.Combine(book.Schema.ContentDirectoryPath, manifestItem.Href);
ZipArchiveEntry contentFileEntry = epubArchive.GetEntry(contentFilePath);
if (contentFileEntry == null)
throw new Exception(String.Format("EPUB parsing error: file {0} not found in archive.", contentFilePath));
if (contentFileEntry.Length > Int32.MaxValue)
throw new Exception(String.Format("EPUB parsing error: file {0} is bigger than 2 Gb.", contentFilePath));
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:
EpubTextContentFile epubTextContentFile = new EpubTextContentFile
{
FileName = fileName,
ContentMimeType = contentMimeType,
ContentType = contentType
};
using (Stream contentStream = contentFileEntry.Open())
{
if (contentStream == null)
throw new Exception(String.Format("Incorrect EPUB file: content file \"{0}\" specified in manifest is not found", fileName));
using (StreamReader streamReader = new StreamReader(contentStream))
epubTextContentFile.Content = streamReader.ReadToEnd();
}
switch (contentType)
{
case EpubContentType.XHTML_1_1:
result.Html.Add(fileName, epubTextContentFile);
break;
case EpubContentType.CSS:
result.Css.Add(fileName, epubTextContentFile);
break;
}
result.AllFiles.Add(fileName, epubTextContentFile);
break;
default:
EpubByteContentFile epubByteContentFile = new EpubByteContentFile
{
FileName = fileName,
ContentMimeType = contentMimeType,
ContentType = contentType
};
using (Stream contentStream = contentFileEntry.Open())
{
if (contentStream == null)
throw new Exception(String.Format("Incorrect EPUB file: content file \"{0}\" specified in manifest is not found", fileName));
using (MemoryStream memoryStream = new MemoryStream((int)contentFileEntry.Length))
{
contentStream.CopyTo(memoryStream);
epubByteContentFile.Content = memoryStream.ToArray();
}
}
switch (contentType)
{
case EpubContentType.IMAGE_GIF:
case EpubContentType.IMAGE_JPEG:
case EpubContentType.IMAGE_PNG:
case EpubContentType.IMAGE_SVG:
result.Images.Add(fileName, epubByteContentFile);
break;
case EpubContentType.FONT_TRUETYPE:
case EpubContentType.FONT_OPENTYPE:
result.Fonts.Add(fileName, epubByteContentFile);
break;
}
result.AllFiles.Add(fileName, epubByteContentFile);
break;
}
}
return result;
}
public async Task <EpubBook> OpenBookAsync(int bookId)
{
EpubBook epubBook = await EpubReader.ReadBookAsync(settings.Books.First(book => book.Id == bookId).FilePath);
return(epubBook);
}
/// <summary>
/// Open the selected book
/// </summary>
/// <param name="file">the selected book</param>
/// <returns></returns>
public void OpenBook(Book file)
{
//await RefreshBook(file);
Loading = true;
if (!DI.FileManager.PathExists(file.BookFilePath))
{
// TODO:
MessageBox.Show("Not Found");
Loading = false;
return;
}
// Read an epub file
EpubBook book = EpubReader.Read(file.BookFilePath);
ICollection <EpubTextFile> html = book.Resources.Html;
var bookVM = new BookViewModel()
{
Title = file.BookName,
};
var i = 0;
foreach (EpubTextFile text in html)
{
var chapter = book.TableOfContents.FirstOrDefault(tof => tof.FileName == text.FileName);
if (chapter == null)
{
continue;
}
// TODO: out of index
var pageVM = new PageViewModel()
{
Index = i,
Title = chapter.Title
};
var j = 0;
foreach (string paragraph in text.ToParagraphs())
{
var paragraphVM = new ParagraphViewModel()
{
Index = j++,
ParagraphText = paragraph,
};
pageVM.AddParagraph(paragraphVM);
}
if (pageVM.ParagraphViewModels.Count > 0)
{
bookVM.AddPage(pageVM);
i++;
}
}
file.LastOpenDate = DateTime.Now;
DI.ClientDataStore.AddBook(file);
ViewModelLocator.ApplicationViewModel.CurrentBook = file;
ViewModelLocator.ApplicationViewModel.CurrentBookViewModel = bookVM;
ViewModelLocator.ApplicationViewModel.CurrentBookViewModel.Initialize(file);
ViewModelLocator.ApplicationViewModel.GoToPage(ApplicationPage.Book);
Loading = false;
}
private static EpubBook CreateInternal(byte[] data)
{
var b = new EpubBook();
try
{
using (MemoryStream ms = new MemoryStream(data))
{
using (ZipStorer gz = ZipStorer.Open(ms, FileAccess.Read))
{
ZipStorer.ZipFileEntry metainf;
// ******************** CONTAINER.XML ********************//
metainf = gz.ReadCentralDir().FirstOrDefault(z => z.FilenameInZip == "META-INF/container.xml");
using (MemoryStream mscontainer = new MemoryStream())
{
gz.ExtractFile(metainf, mscontainer);
mscontainer.Position = 0;
XDocument containerDoc = XDocument.Load(mscontainer);
// Container
b.ContainerData = Container.CreateContainer(containerDoc.Root);
}
// OPF (Package)
using (MemoryStream msopf = new MemoryStream())
{
// opf folder
string opsFolder = Path.GetDirectoryName(b.ContainerData.Rootfiles.First().FullPath).Replace("\\", "/");
//
metainf = gz.ReadCentralDir().FirstOrDefault(z => z.FilenameInZip == b.ContainerData.Rootfiles.First().FullPath);
gz.ExtractFile(metainf, msopf);
msopf.Position = 0;
// ******************** OPF ********************//
var reader = XmlTextReader.Create(msopf);
XDocument opfDoc = XDocument.Load(reader);
string ncxHref;
b.PackageData = OpfPackage.CreatePackage(opfDoc.Root, gz, opsFolder, out ncxHref);
// metadata head
// ******************** NCX ********************//
using (MemoryStream msncx = new MemoryStream())
{
metainf = gz.ReadCentralDir().FirstOrDefault(z => z.FilenameInZip == Helper.CreatePath(opsFolder, ncxHref));
gz.ExtractFile(metainf, msncx);
msncx.Position = 0;
XDocument ncxDocument = XDocument.Load(msncx);
b.NavigationData = Navigation.CreateNavigation(b.PackageData.Manifest, ncxDocument);
}
}
// pull from regular content for faster access using Guide information
b.CoverDescription = b.PackageData.Guide.ReferenceTitle;
var coverItem = b.PackageData.Manifest.Items.FirstOrDefault(i => i.Href == b.PackageData.Guide.ReferenceHref);
if (coverItem != null)
{
b.CoverImage = coverItem.Data;
}
}
}
}
catch (System.Exception)
{
return(null);
}
return(b);
}
public List <ChapterViewModel> GetChapters(EpubBook epubBook, EpubBook epubBook1, EpubBook epubBook2)
{
return(GetChapters(epubBook.Chapters, epubBook1.Chapters, epubBook2.Chapters));
}
private async void ImportFiles()
{
string path = Application.persistentDataPath + _sourceFolder;
try
{
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
}
catch (IOException ex)
{
Debug.Log(ex.Message);
return;
}
var files = FileBrowserHelpers.GetEntriesInDirectory(path);
foreach (var file in files)
{
string fileName = string.Empty;
string filePath = string.Empty;
string imagePath = string.Empty;
string text = string.Empty;
string finalText = string.Empty;
byte[] imageData = null;
FileData newBook = null;
if (!file.IsDirectory)
{
switch (file.Extension)
{
case ".fb2":
fileName = FileBrowserHelpers.GetFilename(file.Path);
text = FileBrowserHelpers.ReadTextFromFile(file.Path);
FB2File fb2File = await new FB2Reader().ReadAsync(text);
var lines = await _fB2SampleConverter.ConvertAsync(fb2File);
finalText = _fB2SampleConverter.GetLinesAsText();
imageData = _fB2SampleConverter.GetCoverImageData();
if (imageData != null)
{
imagePath = Application.persistentDataPath + _targetFolder + fileName + ".jpg";;
try
{
File.WriteAllBytes(imagePath, imageData);
Debug.Log("Image is saved. Path: " + imagePath);
}
catch
{
Debug.LogError("Loading image is error!");
}
imagePath = imagePath.Replace("/", "\\");
}
filePath = (Application.persistentDataPath + _targetFolder + fileName).Replace("/", "\\");
newBook = new FileData(fileName, filePath, imagePath, FileData.FileType.Book);
SaveFile(newBook, finalText);
FileBrowserHelpers.DeleteFile(file.Path);
break;
case ".epub":
EpubBook epubFile = EpubReader.ReadBook(file.Path);
fileName = epubFile.Title + " (" + epubFile.Author + ")";
foreach (EpubTextContentFile textContentFile in epubFile.ReadingOrder)
{
HtmlDocument htmlDocument = new HtmlDocument();
htmlDocument.LoadHtml(textContentFile.Content);
StringBuilder sb = new StringBuilder();
foreach (HtmlNode node in htmlDocument.DocumentNode.SelectNodes("//text()"))
{
sb.AppendLine(node.InnerText.Replace("\n", "").Replace("\r", ""));
}
finalText += sb.ToString();
}
imageData = epubFile.CoverImage;
var imageName = string.Empty;
if (imageData == null)
{
imageData = epubFile.Content.Images.FirstOrDefault().Value.Content;
imageName = epubFile.Content.Images.FirstOrDefault().Key;
}
else
{
imageName = epubFile.Content.Cover.FileName;
}
if (imageData != null)
{
imagePath = Application.persistentDataPath + _targetFolder + imageName;
try
{
File.WriteAllBytes(imagePath, imageData);
Debug.Log("Image is saved. Path: " + imagePath);
}
catch
{
Debug.LogError("Loading image is error!");
}
imagePath = imagePath.Replace("/", "\\");
}
filePath = (Application.persistentDataPath + _targetFolder + fileName).Replace("/", "\\");
newBook = new FileData(fileName, filePath, imagePath, FileData.FileType.Book);
SaveFile(newBook, finalText);
FileBrowserHelpers.DeleteFile(file.Path);
break;
case ".pdf":
var document = PdfiumViewer.PdfDocument.Load(file.Path);
var title = document.GetInformation().Title;
if (FilesData.Files.Any(x => x.Name == title))
{
return;
}
fileName = FileBrowserHelpers.GetFilename(file.Path);
filePath = Application.persistentDataPath + _targetFolder + fileName;
imagePath = Application.persistentDataPath + _targetFolder + fileName.Remove(fileName.Length - 4) + ".png";
var image = document.Render(0, 72, 72, false);
image.Save(imagePath, System.Drawing.Imaging.ImageFormat.Png);
imagePath = imagePath.Replace("/", "\\");
filePath = filePath.Replace("/", "\\");
document.Dispose();
FileBrowserHelpers.MoveFile(file.Path, filePath);
newBook = new FileData(title, filePath, imagePath, FileData.FileType.PdfFile);
SaveFile(newBook);
break;
}
}
else
{
FileBrowserHelpers.DeleteDirectory(file.Path);
}
}
}
static void Main(string[] args)
{
string directory = AppDomain.CurrentDomain.BaseDirectory;
string epubDirectory = string.Format(@"{0}\{1}", Directory.GetParent(directory).Parent.Parent.FullName, "epubs");
string targetDirectory = string.Format(@"{0}\{1}", Directory.GetParent(directory).Parent.Parent.FullName, "books");
if (Directory.Exists(epubDirectory))
{
Console.WriteLine("Directorio existe");
string[] bookPaths = Directory.GetFiles(epubDirectory, "*.epub");
if (bookPaths.Length > 0)
{
List <Book> books = new List <Book>();
Console.WriteLine("Existen Libros en el directorio");
foreach (string str in bookPaths)
{
EpubBook book = EpubReader.ReadBook(str);
Book readBook = new Book()
{
Author = book.Author,
Title = book.Title,
Files = new List <Pages>()
};
foreach (KeyValuePair <string, EpubTextContentFile> file in book.Content.Html)
{
addFile(file, readBook);
}
books.Add(readBook);
}
for (int i = 0; i < books.Count; i++)
{
string name = (i + 1).ToString();
if (!Directory.Exists(targetDirectory))
{
Directory.CreateDirectory(targetDirectory);
}
string filename = string.Format(@"{0}.xml", name);
string subfolder = string.Format(@"{0}\{1}\", targetDirectory, name);
using (StreamWriter sw = File.CreateText(string.Format(@"{0}\{1}", targetDirectory, filename)))
{
sw.WriteLine("<book>");
sw.WriteLine("<title>" + books[i].Title + "</title>");
sw.WriteLine("<author>" + books[i].Author + "</author>");
sw.WriteLine("<pages>" + (books[i].Files.Count + 1).ToString() + "</pages>");
sw.Write("</book>");
};
Directory.CreateDirectory(subfolder);
for (int j = 0; j < books[i].Files.Count; j++)
{
string pagename = (j + 1).ToString();
using (StreamWriter sw = File.CreateText(string.Format("{0}{1}.txt", subfolder, pagename)))
{
sw.Write(books[i].Files[j].textcontent);
};
using (StreamWriter sw = File.CreateText(string.Format("{0}{1}.html", subfolder, pagename)))
{
sw.Write(books[i].Files[j].htmlcontent);
};
}
}
}
}
Console.WriteLine("Proceso Finalizado");
Console.ReadKey();
}
public static Stream SaveBookToStream(EpubBook book)
{
var ms = new MemoryStream(SaveBook(book));
return(ms);
}
public static byte[] SaveBook(EpubBook book)
{
byte[] data = SaveEpubToDisk(book);
//byte[] data = SaveBookInternal(book);
return(data);
}
private void ImportEPUB()
{
// clear children
foreach (var slotChild in Slot.Children)
{
slotChild.Destroy();
}
var filesToImport = new List <string>();
var fileAttributes = File.GetAttributes(EBookPath.Value);
if (fileAttributes.HasFlag(FileAttributes.Directory))
{
var files = Directory.GetFiles(EBookPath.Value, "*.epub",
Recursive.Value ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
filesToImport.AddRange(files);
}
else
{
filesToImport.Add(EBookPath.Value);
}
Message("Starting import...");
//World.AddSlot(this.Slot, "EPUB");
foreach (var file in filesToImport)
{
try
{
if (!File.Exists(file))
{
Message("File could not be found!");
Slot.AddSlot("Error message in tag").Tag = file + " could not be found!";
return;
}
EpubBook book = EpubReader.Read(file);
if (book == null)
{
Message("Book could not be loaded for an unknown reason!");
Slot.AddSlot("Error message in tag").Tag = file + " could not not be loaded for an unknown reason!";
}
var bookSlot = Slot.AddSlot(book.Title);
if (AddSimpleAvatarProtection.Value)
{
var protection = bookSlot.AttachComponent <SimpleAvatarProtection>();
protection.User.Target = this.LocalUser;
}
var grabbable = bookSlot.AttachComponent <Grabbable>();
grabbable.Scalable.Value = true;
bookSlot.AttachComponent <ObjectRoot>();
var license = bookSlot.AttachComponent <License>();
license.CreditString.Value = "Imported using the NeosVREBookImporter plugin";
bookSlot.Tag = "ebook";
var snapper = bookSlot.AttachComponent <Snapper>();
snapper.Keywords.Add("ebook");
var dynVarsSlot = bookSlot.AddSlot("Dynamic Variables");
AttachDynVar(dynVarsSlot, DynVarTitleName, book.Title);
AttachDynVar <int>(dynVarsSlot, DynVarCurrentPosition, 0);
AttachDynVar <int>(dynVarsSlot, DynVarCurrentChapter, -1);
int authorCount = book.Authors.Count();
AttachDynVar(dynVarsSlot, DynVarAuthorCountName, authorCount);
int i = 0;
foreach (var bookAuthor in book.Authors)
{
AttachDynVar(dynVarsSlot, DynVarAuthorName + i, bookAuthor);
i++;
}
// Add chapters
var chaptersSlot = bookSlot.AddSlot("Chapters");
var chapterCount = AddChapters(book, chaptersSlot, book.TableOfContents);
AttachDynVar(chaptersSlot, DynVarChapterCountName, chapterCount);
CreateVisual(bookSlot, book.Title);
Message("Yay done!");
}
catch (FileNotFoundException e)
{
LogError("EPUB could not be found!", e);
}
catch (IOException e)
{
LogError("EPUB could not be read!", e);
}
catch (XmlException e)
{
LogError("Error occurred while parsing chapter html!", e);
}
catch (Exception e)
{
LogError("An unknown error occurred while importing", e);
}
}
}
private static byte[] SaveEpubToDisk(EpubBook book)
{
string FileName = Guid.NewGuid().ToString();
string PhysicalPath = Path.Combine(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "data\\"));
MemoryStream ms = new MemoryStream();
using (FileStream epubfile = File.Open(PhysicalPath + "\\Epub_" + FileName + ".epub", FileMode.Create, FileAccess.ReadWrite))
{
using (var output = new ZipOutputStream(epubfile))
{
var e = output.PutNextEntry("mimetype");
e.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
Stream mimeType = new MemoryStream();
var mtString = "application/epub+zip";
output.Write(Encoding.ASCII.GetBytes(mtString), 0, mtString.Length);
// OPF File with three Elements: METADATA, MANIFEST, SPINE
// container
output.PutNextEntry("META-INF/container.xml");
byte[] metaInf = Helper.ReadStreamToEnd(GetContainerData(book.ContainerData));
output.Write(metaInf, 0, metaInf.Length);
// <item id="ncxtoc" media-type="application/x-dtbncx+xml" href="toc.ncx"/>
book.PackageData.Manifest.Items.Add(new ContentFile
{
Identifier = book.PackageData.Spine.Toc,
Href = "toc.ncx",
MediaType = "application/x-dtbncx+xml"
});
output.PutNextEntry("OEBPS/content.opf");
byte[] opfData = Helper.ReadStreamToEnd(GetOpfData(book.PackageData));
output.Write(opfData, 0, opfData.Length);
book.GetTableOfContent().HeadMetaData = new Head();
book.GetTableOfContent().NavMap = book.NavigationData.NavMap;
book.GetTableOfContent().HeadMetaData.Identifier = "isbn:9780735656680";// Guid.NewGuid().ToString();
book.GetTableOfContent().HeadMetaData.Creator = book.PackageData.MetaData.Creator.ToString();
book.GetTableOfContent().HeadMetaData.Depth = 2;
book.GetTableOfContent().HeadMetaData.TotalPageCount = 0;
book.GetTableOfContent().HeadMetaData.MaxPageNumber = 0;
output.PutNextEntry("OEBPS/toc.ncx");
byte[] ncxData = Helper.ReadStreamToEnd(GetNcxData(book.GetTableOfContent(), book.PackageData.MetaData.Title.Text));
output.Write(ncxData, 0, ncxData.Length);
// take manifest items and create remaining files
foreach (var item in book.GetAllFiles().Where(file => file.Href != "toc.ncx"))
{
//var msItem = new MemoryStream(item.Data);
//msItem.Position = 0;
var path = String.Format("{0}/{1}", "OEBPS", item.Href);
output.PutNextEntry(path);
output.Write(item.Data, 0, item.Data.Length);
}
}
}
using (FileStream fileStream = File.OpenRead(PhysicalPath + "\\Epub_" + FileName + ".epub"))
{
MemoryStream memStream = new MemoryStream();
memStream.SetLength(fileStream.Length);
fileStream.Read(memStream.GetBuffer(), 0, (int)fileStream.Length);
ms = memStream;
}
if (File.Exists(PhysicalPath + "\\Epub_" + FileName + ".epub"))
{
File.Delete(PhysicalPath + "\\Epub_" + FileName + ".epub");
}
ms.Position = 0;
return(ms.ToArray());
}
public List <ChapterViewModel> GetChapters(EpubBook epubBook)
{
return(GetChapters(epubBook.Chapters));
}
/// <summary>
/// Extracting all E-Book files from epub to disk using book key to creating sub-folder
/// </summary>
/// <param name="epubArchive"></param>
/// <param name="book"></param>
/// <returns></returns>
public static async Task ExtractContentFilesToDiskAsync(ZipArchive epubArchive, EpubBook book)
{
//double progress = 20;
//double increment = (double)80 / book.Schema.Package.Manifest.Count;
string bookFolder = string.Empty;
//StorageFolder destinationFolder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("GUTS");
StorageFolder destinationFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
foreach (EpubMetadataIdentifier id in book.Schema.Package.Metadata.Identifiers)
{
if (!string.IsNullOrEmpty(id.Identifier))
{
bookFolder = ZipPathUtils.verifyPathName(string.Format("{0}_{1}",id.Identifier,id.Id));
break;
}
}
//StorageApplicationPermissions.FutureAccessList.AddOrReplace("PickedFolderToken", destinationFolder);
//Creating uniq subfolder for the book
StorageFolder unzipFolder = await destinationFolder.CreateFolderAsync(bookFolder, CreationCollisionOption.GenerateUniqueName);
//Unzippin
try
{
//LogStatus("Unziping file: " + zipFile.DisplayName + "...", NotifyType.StatusMessage);
await ZipUtils.UnZipFileAsync(epubArchive, unzipFolder);
//LogStatus("Unzip file '" + zipFile.DisplayName + "' successfully!", NotifyType.StatusMessage);
}
catch (Exception ex)
{
throw new Exception(string.Format("Failed to unzip file ...{0}", ex.Message));
}
return;
}
