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 EpubMetadataMeta ReadMetadataMetaVersion3(XmlNode metadataMetaNode)
{
EpubMetadataMeta result = new EpubMetadataMeta();
foreach (XmlAttribute metadataMetaNodeAttribute in metadataMetaNode.Attributes)
{
string attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.Name.ToLowerInvariant())
{
case "id":
result.Id = attributeValue;
break;
case "refines":
result.Refines = attributeValue;
break;
case "property":
result.Property = attributeValue;
break;
case "scheme":
result.Scheme = attributeValue;
break;
}
}
result.Content = metadataMetaNode.InnerText;
return(result);
}
public static EpubByteContentFileRef ReadBookCover(EpubSchema epubSchema, Dictionary <string, EpubByteContentFileRef> imageContentRefs)
{
List <EpubMetadataMeta> metaItems = epubSchema.Package.Metadata.MetaItems;
if (metaItems == null || !metaItems.Any())
{
return(null);
}
EpubMetadataMeta coverMetaItem = metaItems.FirstOrDefault(metaItem => metaItem.Name.CompareOrdinalIgnoreCase("cover"));
if (coverMetaItem == null)
{
return(null);
}
if (String.IsNullOrEmpty(coverMetaItem.Content))
{
throw new Exception("Incorrect EPUB metadata: cover item content is missing.");
}
EpubManifestItem coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (coverManifestItem == null)
{
throw new Exception($"Incorrect EPUB manifest: item with ID = \"{coverMetaItem.Content}\" is missing.");
}
if (!imageContentRefs.TryGetValue(coverManifestItem.Href, out EpubByteContentFileRef coverImageContentFileRef))
{
throw new Exception($"Incorrect EPUB manifest: item with href = \"{coverManifestItem.Href}\" is missing.");
}
return(coverImageContentFileRef);
}
private static Image LoadCoverImage(EpubBook book)
{
List <EpubMetadataMeta> metaItems = book.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 = book.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));
}
EpubByteContentFile coverImageContentFile;
if (!book.Content.Images.TryGetValue(coverManifestItem.Href, out coverImageContentFile))
{
throw new Exception(String.Format("Incorrect EPUB manifest: item with href = \"{0}\" is missing", coverManifestItem.Href));
}
using (MemoryStream coverImageStream = new MemoryStream(coverImageContentFile.Content))
return(Image.FromStream(coverImageStream));
}
private static EpubMetadataMeta ReadMetadataMetaVersion3(XElement metadataMetaNode)
{
var result = new EpubMetadataMeta();
foreach (var metadataMetaNodeAttribute in metadataMetaNode.Attributes())
{
var attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.GetLowerCaseLocalName())
{
case "id":
result.Id = attributeValue;
break;
case "refines":
result.Refines = attributeValue;
break;
case "property":
result.Property = attributeValue;
break;
case "scheme":
result.Scheme = attributeValue;
break;
}
}
result.Content = metadataMetaNode.Value;
return(result);
}
public static EpubByteContentFileRef ReadBookCover(EpubSchema epubSchema, Dictionary <string, EpubByteContentFileRef> imageContentRefs)
{
List <EpubMetadataMeta> metaItems = epubSchema.Package.Metadata.MetaItems;
if (metaItems == null || !metaItems.Any())
{
return(null);
}
EpubMetadataMeta coverMetaItem = metaItems.FirstOrDefault(metaItem => metaItem.Name.CompareOrdinalIgnoreCase("cover"));
if (coverMetaItem == null)
{
return(null);
}
if (String.IsNullOrEmpty(coverMetaItem.Content))
{
throw new Exception("Incorrect EPUB metadata: cover item content is missing.");
}
EpubManifestItem coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (coverManifestItem == null)
{
// 2019-08-20 Hotfix: if coverManifestItem is not found by its Id, then try it with its Href - some ebooks refer to the image directly!
coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Href.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (null == coverManifestItem)
{
throw new Exception($"Incorrect EPUB manifest: item with ID = \"{coverMetaItem.Content}\" is missing.");
}
}
if (imageContentRefs.TryGetValue(coverManifestItem.Href, out EpubByteContentFileRef coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
// 2019-08-21 Fix some ebooks seem to contain more than one item with Id="cover"
// thus we test if there is a second item....
coverManifestItem = epubSchema.Package.Manifest.Where(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Content)).Skip(1).FirstOrDefault();;
if (coverManifestItem == null)
{
// 2019-08-20 Hotfix: if coverManifestItem is not found by its Id, then try it with its Href - some ebooks refer to the image directly!
coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Href.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (null == coverManifestItem)
{
throw new Exception($"Incorrect EPUB manifest: item with ID = \"{coverMetaItem.Content}\" is missing.");
}
}
if (imageContentRefs.TryGetValue(coverManifestItem.Href, out EpubByteContentFileRef coverImageContentFileRef2))
{
return(coverImageContentFileRef2);
}
throw new Exception($"Incorrect EPUB manifest: item with href = \"{coverManifestItem.Href}\" is missing.");
}
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 async Task <BitmapImage> LoadCoverImageAsync(EpubBook book)
{
//TO-DO Currently this function only accepts covers as a image file. If cover is wrapped in.xhtml file - nothing happen.
List <EpubMetadataMeta> metaItems = book.Schema.Package.Metadata.MetaItems;
BitmapImage result = new BitmapImage();
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 = book.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));
}
EpubByteContentFile coverImageContentFile;
// ---------------------------------------------------------------------------------------------------------------------
//TO-DO: Currently this function only accepts covers as a image file. If cover is wrapped in.xhtml file - nothing happen.
// Have to check how people using wrapped cover - do they point <meta content> directly to xhtml or just placing it in the manifest
// ---------------------------------------------------------------------------------------------------------------------
if (!book.Content.Images.TryGetValue(coverManifestItem.Href, out coverImageContentFile))
{
throw new Exception(String.Format("Incorrect EPUB manifest: item with href = \"{0}\" is missing", coverManifestItem.Href));
}
// Old code is not working as SystemDrawings is deprecated
//using (MemoryStream coverImageStream = new MemoryStream(coverImageContentFile.Content))
result = await ConvertToBitmapImageAsync(coverImageContentFile.Content);
return(result);
}
private static EpubMetadataMeta ReadMetadataMetaVersion2(XmlNode metadataMetaNode)
{
EpubMetadataMeta result = new EpubMetadataMeta();
foreach (XmlAttribute metadataMetaNodeAttribute in metadataMetaNode.Attributes)
{
string attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.Name.ToLowerInvariant())
{
case "name":
result.Name = attributeValue;
break;
case "content":
result.Content = attributeValue;
break;
}
}
return(result);
}
private static EpubMetadataMeta ReadMetadataMetaVersion2(XElement metadataMetaNode)
{
EpubMetadataMeta result = new EpubMetadataMeta();
foreach (XAttribute metadataMetaNodeAttribute in metadataMetaNode.Attributes())
{
string attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.GetLowerCaseLocalName())
{
case "name":
result.Name = attributeValue;
break;
case "content":
result.Content = attributeValue;
break;
}
}
return(result);
}
private static EpubMetadataMeta ReadMetadataMetaVersion2(XElement metadataMetaNode)
{
var result = new EpubMetadataMeta();
foreach (var metadataMetaNodeAttribute in metadataMetaNode.Attributes())
{
var attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.Name.LocalName.ToLowerInvariant())
{
case "name":
result.Name = attributeValue;
break;
case "content":
result.Content = attributeValue;
break;
}
}
return(result);
}
private static EpubMetadataMeta ReadMetadataMetaVersion3(XElement metadataMetaNode)
{
EpubMetadataMeta result = new EpubMetadataMeta();
foreach (XAttribute metadataMetaNodeAttribute in metadataMetaNode.Attributes())
{
string attributeValue = metadataMetaNodeAttribute.Value;
switch (metadataMetaNodeAttribute.GetLowerCaseLocalName())
{
case "id":
result.Id = attributeValue;
break;
case "refines":
result.Refines = attributeValue;
break;
case "property":
result.Property = attributeValue;
break;
case "scheme":
result.Scheme = attributeValue;
break;
case "name":
result.Name = attributeValue;
break;
case "content":
result.Content = attributeValue;
break;
}
}
if (string.IsNullOrEmpty(result.Content))
{
result.Content = metadataMetaNode.Value;
}
return(result);
}
private static EpubMetadata ReadMetadata(XmlNode metadataNode, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List <string>();
result.Creators = new List <EpubMetadataCreator>();
result.Subjects = new List <string>();
result.Publishers = new List <string>();
result.Contributors = new List <EpubMetadataContributor>();
result.Dates = new List <EpubMetadataDate>();
result.Types = new List <string>();
result.Formats = new List <string>();
result.Identifiers = new List <EpubMetadataIdentifier>();
result.Sources = new List <string>();
result.Languages = new List <string>();
result.Relations = new List <string>();
result.Coverages = new List <string>();
result.Rights = new List <string>();
result.MetaItems = new List <EpubMetadataMeta>();
foreach (XmlNode metadataItemNode in metadataNode.ChildNodes)
{
string innerText = metadataItemNode.InnerText;
switch (metadataItemNode.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(innerText);
break;
case "creator":
EpubMetadataCreator creator = ReadMetadataCreator(metadataItemNode);
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(innerText);
break;
case "description":
result.Description = innerText;
break;
case "publisher":
result.Publishers.Add(innerText);
break;
case "contributor":
EpubMetadataContributor contributor = ReadMetadataContributor(metadataItemNode);
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = ReadMetadataDate(metadataItemNode);
result.Dates.Add(date);
break;
case "type":
result.Types.Add(innerText);
break;
case "format":
result.Formats.Add(innerText);
break;
case "identifier":
EpubMetadataIdentifier identifier = ReadMetadataIdentifier(metadataItemNode);
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(innerText);
break;
case "language":
result.Languages.Add(innerText);
break;
case "relation":
result.Relations.Add(innerText);
break;
case "coverage":
result.Coverages.Add(innerText);
break;
case "rights":
result.Rights.Add(innerText);
break;
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion2(metadataItemNode);
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion3(metadataItemNode);
result.MetaItems.Add(meta);
}
break;
}
}
return(result);
}
public static EpubByteContentFileRef ReadBookCover(EpubSchema epubSchema, Dictionary <string, EpubByteContentFileRef> imageContentRefs)
{
List <EpubMetadataMeta> metaItems = epubSchema.Package.Metadata.MetaItems;
if (metaItems == null || !metaItems.Any())
{
return(null);
}
EpubMetadataMeta coverMetaItem = metaItems.FirstOrDefault(metaItem => metaItem.Name.CompareOrdinalIgnoreCase("cover"));
if (coverMetaItem == null)
{
return(null);
}
if (String.IsNullOrEmpty(coverMetaItem.Content))
{
throw new Exception("Incorrect EPUB metadata: cover item content is missing.");
}
EpubByteContentFileRef coverImageContentFileRef;
EpubManifestItem coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (null != coverManifestItem?.Href && imageContentRefs.TryGetValue(coverManifestItem.Href, out coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
// For non-standard ebooks, we try several other ways...
if (null != coverManifestItem) // we have found the item but there was no corresponding image ...
{
// some ebooks seem to contain more than one item with Id="cover"
// thus we test if there is a second item, and whether that is an image....
coverManifestItem = epubSchema.Package.Manifest.Where(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Content)).Skip(1).FirstOrDefault();;
if (null != coverManifestItem?.Href && imageContentRefs.TryGetValue(coverManifestItem.Href, out coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
}
// we have still not found the item
// 2019-08-20 Hotfix: if coverManifestItem is not found by its Id, then try it with its Href - some ebooks refer to the image directly!
coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Href.CompareOrdinalIgnoreCase(coverMetaItem.Content));
if (null != coverManifestItem?.Href && imageContentRefs.TryGetValue(coverManifestItem.Href, out coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
// 2019-08-24 if it is still not found, then try to find an Id named cover
coverManifestItem = epubSchema.Package.Manifest.FirstOrDefault(manifestItem => manifestItem.Id.CompareOrdinalIgnoreCase(coverMetaItem.Name));
if (null != coverManifestItem?.Href && imageContentRefs.TryGetValue(coverManifestItem.Href, out coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
// 2019-08-24 if it is still not found, then try to find it in the guide
var guideItem = epubSchema.Package.Guide.FirstOrDefault(reference => reference.Title.CompareOrdinalIgnoreCase(coverMetaItem.Name));
if (null != guideItem?.Href && imageContentRefs.TryGetValue(guideItem.Href, out coverImageContentFileRef))
{
return(coverImageContentFileRef);
}
throw new Exception($"Incorrect EPUB manifest: item with ID = \"{coverMetaItem.Content}\" is missing or no corresponding image was found.");
}
private static EpubMetadata ReadMetadata(XElement metadataNode, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata
{
Titles = new List <string>(),
Creators = new List <EpubMetadataCreator>(),
Subjects = new List <string>(),
Publishers = new List <string>(),
Contributors = new List <EpubMetadataContributor>(),
Dates = new List <EpubMetadataDate>(),
Types = new List <string>(),
Formats = new List <string>(),
Identifiers = new List <EpubMetadataIdentifier>(),
Sources = new List <string>(),
Languages = new List <string>(),
Relations = new List <string>(),
Coverages = new List <string>(),
Rights = new List <string>(),
MetaItems = new List <EpubMetadataMeta>()
};
foreach (XElement metadataItemNode in metadataNode.Elements())
{
string innerText = metadataItemNode.Value;
switch (metadataItemNode.GetLowerCaseLocalName())
{
case "title":
result.Titles.Add(innerText);
break;
case "creator":
EpubMetadataCreator creator = ReadMetadataCreator(metadataItemNode);
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(innerText);
break;
case "description":
result.Description = innerText;
break;
case "publisher":
result.Publishers.Add(innerText);
break;
case "contributor":
EpubMetadataContributor contributor = ReadMetadataContributor(metadataItemNode);
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = ReadMetadataDate(metadataItemNode);
result.Dates.Add(date);
break;
case "type":
result.Types.Add(innerText);
break;
case "format":
result.Formats.Add(innerText);
break;
case "identifier":
EpubMetadataIdentifier identifier = ReadMetadataIdentifier(metadataItemNode);
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(innerText);
break;
case "language":
result.Languages.Add(innerText);
break;
case "relation":
result.Relations.Add(innerText);
break;
case "coverage":
result.Coverages.Add(innerText);
break;
case "rights":
result.Rights.Add(innerText);
break;
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion2(metadataItemNode);
result.MetaItems.Add(meta);
}
else if (epubVersion == EpubVersion.EPUB_3_0 || epubVersion == EpubVersion.EPUB_3_1)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion3(metadataItemNode);
result.MetaItems.Add(meta);
}
break;
}
}
return(result);
}
private static async System.Threading.Tasks.Task <EpubMetadata> ReadMetadataAsync(XmlReader reader, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List <string>();
result.Creators = new List <EpubMetadataCreator>();
result.Subjects = new List <string>();
result.Publishers = new List <string>();
result.Contributors = new List <EpubMetadataContributor>();
result.Dates = new List <EpubMetadataDate>();
result.Types = new List <string>();
result.Formats = new List <string>();
result.Identifiers = new List <EpubMetadataIdentifier>();
result.Sources = new List <string>();
result.Languages = new List <string>();
result.Relations = new List <string>();
result.Coverages = new List <string>();
result.Rights = new List <string>();
result.MetaItems = new List <EpubMetadataMeta>();
//Parsing all metadata insides and saving it in EpubMetadata instance
//
//Мне нужно пройтись по всем нодам внутри метадаты последовательно, извлечь ноды указанные в массиве metadataNodesNames...
//... и сохранить их в структуре EpubMetadata
//В каждой итерации нам нужно извлечь имя нода, сделать маленькими буквами и,
// в зависимости от того есть ли он в массиве - выполнить запись в структуру
//ИЛИ мы можем тупо искать по заданным в массиве именам, с опасностью, что какая-то сука написала капсами и это ебнет весь ридер
//
bool isMetadataAvailable = await reader.ReadToFollowingAsync("metadata", "http://www.idpf.org/2007/opf");
if (!isMetadataAvailable)
{
throw new Exception("EPUB parsing error: metadata not found in the package.");
}
while (await reader.ReadAsync() && !(reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "metadata"))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(reader.ReadElementContentAsString());
break;
case "creator":
EpubMetadataCreator creator = new EpubMetadataCreator();
creator.Role = reader.GetAttribute("opf:role");
creator.FileAs = reader.GetAttribute("opf:file-as");
creator.Creator = reader.ReadElementContentAsString();
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(reader.ReadElementContentAsString());
break;
case "description":
result.Description = reader.ReadElementContentAsString();
break;
case "publisher":
result.Publishers.Add(reader.ReadElementContentAsString());
break;
case "contributor":
EpubMetadataContributor contributor = new EpubMetadataContributor();
contributor.Role = reader.GetAttribute("opf:role");
contributor.FileAs = reader.GetAttribute("opf:file-as");
contributor.Contributor = reader.ReadElementContentAsString();
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = new EpubMetadataDate();
date.Event = reader.GetAttribute("opf:event");
date.Date = reader.ReadElementContentAsString();
result.Dates.Add(date);
break;
case "type":
result.Types.Add(reader.ReadElementContentAsString());
break;
case "format":
result.Formats.Add(reader.ReadElementContentAsString());
break;
case "identifier":
EpubMetadataIdentifier identifier = new EpubMetadataIdentifier();
identifier.Id = reader.GetAttribute("id");
identifier.Scheme = reader.GetAttribute("opf:scheme");
identifier.Identifier = reader.ReadElementContentAsString();
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(reader.ReadElementContentAsString());
break;
case "language":
result.Languages.Add(reader.ReadElementContentAsString());
break;
case "relation":
result.Relations.Add(reader.ReadElementContentAsString());
break;
case "coverage":
result.Coverages.Add(reader.ReadElementContentAsString());
break;
case "rights":
result.Rights.Add(reader.ReadElementContentAsString());
break;
//looks like there is an optional refining node "meta" and it is present in EPUB3
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Name = reader.GetAttribute("name");
meta.Content = reader.GetAttribute("content");
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Id = reader.GetAttribute("id");
meta.Refines = reader.GetAttribute("refines");
meta.Property = reader.GetAttribute("property");
meta.Scheme = reader.GetAttribute("scheme");
meta.Content = reader.ReadElementContentAsString();
result.MetaItems.Add(meta);
}
break;
}
break;
}
}
return(result);
}
