void XHTMLTagParagraphWithControlAction::doAtStart(XHTMLReader &reader, const char**) {
if ((myControl == TITLE) && (bookReader(reader).model().bookTextModel()->paragraphsNumber() > 1)) {
bookReader(reader).insertEndOfSectionParagraph();
}
bookReader(reader).pushKind(myControl);
beginParagraph(reader);
}
void XHTMLTagImageAction::doAtStart(XHTMLReader &reader, const char **xmlattributes) {
const char *fileName = reader.attributeValue(xmlattributes, *myPredicate);
if (fileName == 0) {
return;
}
const std::string fullfileName = pathPrefix(reader) + MiscUtil::decodeHtmlURL(fileName);
ZLFile imageFile(fullfileName);
if (!imageFile.exists()) {
return;
}
bool flag = bookReader(reader).paragraphIsOpen();
if (flag) {
endParagraph(reader);
}
if (std::strlen(fileName) > 2 && std::strncmp(fileName, "./", 2) == 0) {
fileName +=2;
}
bookReader(reader).addImageReference(fullfileName);
bookReader(reader).addImage(fullfileName, new ZLFileImage(ZLFile(fullfileName), 0));
if (flag) {
beginParagraph(reader);
}
}
void HtmlSectionHrefTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
HtmlSectionReader &reader = (HtmlSectionReader&)myReader;
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "NAME") {
bookReader().addHyperlinkLabel(ZLUnicodeUtil::toLower(reader.myCurrentSectionName + '#' + tag.Attributes[i].Value));
} else if ((hyperlinkType() == REGULAR) && (tag.Attributes[i].Name == "HREF")) {
const std::string &value = tag.Attributes[i].Value;
if (!value.empty()) {
FBTextKind referenceType = MiscUtil::referenceType(value);
if (referenceType != INTERNAL_HYPERLINK) {
bookReader().addHyperlinkControl(referenceType, value);
setHyperlinkType(referenceType);
} else {
const int index = value.find('#');
std::string sectionName = (index == -1) ? value : value.substr(0, index);
sectionName = ZLUnicodeUtil::toLower(MiscUtil::decodeHtmlURL(sectionName));
if (sectionName.empty()) {
sectionName = reader.myCurrentSectionName;
} else {
sectionName = reader.myReferenceCollection.addReference(sectionName, true);
}
bookReader().addHyperlinkControl(
INTERNAL_HYPERLINK, ZLUnicodeUtil::toLower((index == -1) ? sectionName : (sectionName + value.substr(index)))
);
setHyperlinkType(INTERNAL_HYPERLINK);
}
}
}
}
} else if (hyperlinkType() != REGULAR) {
bookReader().addControl(hyperlinkType(), false);
setHyperlinkType(REGULAR);
}
}
void HtmlHrefTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "NAME") {
bookReader().addHyperlinkLabel(tag.Attributes[i].Value);
} else if ((hyperlinkType() == REGULAR) && (tag.Attributes[i].Name == "HREF")) {
std::string value = tag.Attributes[i].Value;
if (!myReader.myFileName.empty() &&
(value.length() > myReader.myFileName.length()) &&
(value.substr(0, myReader.myFileName.length()) == myReader.myFileName)) {
value = value.substr(myReader.myFileName.length());
}
if (!value.empty()) {
if (value[0] == '#') {
setHyperlinkType(INTERNAL_HYPERLINK);
bookReader().addHyperlinkControl(INTERNAL_HYPERLINK, value.substr(1));
} else {
FBTextKind hyperlinkType = MiscUtil::referenceType(value);
if (hyperlinkType != INTERNAL_HYPERLINK) {
setHyperlinkType(hyperlinkType);
bookReader().addHyperlinkControl(hyperlinkType, value);
}
}
}
}
}
} else if (hyperlinkType() != REGULAR) {
bookReader().addControl(hyperlinkType(), false);
setHyperlinkType(REGULAR);
}
}
void XHTMLTagImageAction::doAtStart(XHTMLReader &reader, const char **xmlattributes) {
const char *fileName = reader.attributeValue(xmlattributes, *myPredicate);
if (fileName == 0) {
return;
}
const std::string fullfileName = pathPrefix(reader) + MiscUtil::decodeHtmlURL(fileName);
ZLFile imageFile(fullfileName);
if (!imageFile.exists()) {
return;
}
const bool flagParagraphIsOpen = bookReader(reader).paragraphIsOpen();
if (flagParagraphIsOpen) {
if (reader.myCurrentParagraphIsEmpty) {
bookReader(reader).addControl(IMAGE, true);
} else {
endParagraph(reader);
}
}
const std::string imageName = imageFile.name(false);
bookReader(reader).addImageReference(imageName, 0, reader.myMarkNextImageAsCover);
bookReader(reader).addImage(imageName, new ZLFileImage(imageFile, "", 0, 0, reader.myEncryptionMap->info(imageFile.path())));
reader.myMarkNextImageAsCover = false;
if (flagParagraphIsOpen && reader.myCurrentParagraphIsEmpty) {
bookReader(reader).addControl(IMAGE, false);
endParagraph(reader);
}
}
void XHTMLTagItemAction::doAtStart(XHTMLReader &reader, const char**) {
bookReader(reader).endParagraph();
// TODO: increase left indent
bookReader(reader).beginParagraph();
// TODO: replace bullet sign by number inside OL tag
const std::string bullet = "\xE2\x80\xA2\xC0\xA0";
bookReader(reader).addData(bullet);
}
void MobipocketHtmlHrTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
if (bookReader().contentsParagraphIsOpen()) {
bookReader().endContentsParagraph();
bookReader().exitTitle();
}
bookReader().insertEndOfSectionParagraph();
}
}
void HtmlPreTagAction::run(const HtmlReader::HtmlTag &tag) {
bookReader().endParagraph();
myReader.myIsPreformatted = tag.Start;
myReader.mySpaceCounter = -1;
myReader.myBreakCounter = 0;
if (myReader.myFormat.breakType() == PlainTextFormat::BREAK_PARAGRAPH_AT_NEW_LINE) {
if (tag.Start) {
bookReader().pushKind(PREFORMATTED);
} else {
bookReader().popKind();
}
}
bookReader().beginParagraph();
}
void XHTMLTagHyperlinkAction::doAtStart(XHTMLReader &reader, const char **xmlattributes) {
const char *href = reader.attributeValue(xmlattributes, "href");
if (href != 0) {
const std::string link = (*href == '#') ? (reader.myReferenceName + href) : href;
FBTextKind hyperlinkType = MiscUtil::isReference(link) ? EXTERNAL_HYPERLINK : INTERNAL_HYPERLINK;
myHyperlinkStack.push(hyperlinkType);
bookReader(reader).addHyperlinkControl(hyperlinkType, link);
} else {
myHyperlinkStack.push(REGULAR);
}
const char *name = reader.attributeValue(xmlattributes, "name");
if (name != 0) {
bookReader(reader).addHyperlinkLabel(reader.myReferenceName + "#" + name);
}
}
void HtmlImageTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
bookReader().endParagraph();
const std::string *ptr = tag.find("src");
if (ptr != 0) {
const std::string fileName = MiscUtil::decodeHtmlURL(*ptr);
const ZLFile file(myReader.myBaseDirPath + fileName);
if (file.exists()) {
bookReader().addImageReference(fileName, 0, false);
bookReader().addImage(fileName, new ZLFileImage(file, "", 0));
}
}
bookReader().beginParagraph();
}
}
void HtmlBreakTagAction::run(const HtmlReader::HtmlTag &tag) {
if (myReader.myDontBreakParagraph) {
myReader.myDontBreakParagraph = false;
return;
}
if ((tag.Start && (myBreakType & BREAK_AT_START)) ||
(!tag.Start && (myBreakType & BREAK_AT_END))) {
bookReader().endParagraph();
if (bookReader().isKindStackEmpty()) {
bookReader().pushKind(REGULAR);
}
bookReader().beginParagraph();
}
}
void XHTMLTagVideoAction::doAtEnd(XHTMLReader &reader) {
if (reader.myReadState == XHTML_READ_VIDEO) {
bookReader(reader).addVideoEntry(*reader.myVideoEntry);
reader.myVideoEntry.reset();
reader.myReadState = XHTML_READ_BODY;
}
}
void XHTMLTagItemAction::doAtStart(XHTMLReader &reader, const char**) {
endParagraph(reader);
beginParagraph(reader);
if (!reader.myListNumStack.empty()) {
bookReader(reader).addFixedHSpace(3 * reader.myListNumStack.size());
int &index = reader.myListNumStack.top();
if (index == 0) {
static const std::string bullet = "\xE2\x80\xA2\xC0\xA0";
bookReader(reader).addData(bullet);
} else {
bookReader(reader).addData(ZLStringUtil::numberToString(index++) + ".");
}
bookReader(reader).addFixedHSpace(1);
}
reader.myNewParagraphInProgress = true;
}
void XHTMLTagHyperlinkAction::doAtEnd(XHTMLReader &reader) {
FBTextKind kind = myHyperlinkStack.top();
if (kind != REGULAR) {
bookReader(reader).addControl(kind, false);
}
myHyperlinkStack.pop();
}
void EReaderPlugin::readDocumentInternal(const ZLFile &file, BookModel &model, const PlainTextFormat &format, const std::string &encoding, ZLInputStream &stream) const {
if (!stream.open()) {
//TODO maybe anything else opens stream
return;
}
BookReader bookReader(model);
PmlBookReader pmlBookReader(bookReader, format, encoding);
bookReader.setMainTextModel();
pmlBookReader.readDocument(stream);
EReaderStream &estream = (EReaderStream&)stream;
const std::map<std::string, EReaderStream::ImageInfo>& imageIds = estream.images();
for(std::map<std::string, EReaderStream::ImageInfo>::const_iterator it = imageIds.begin(); it != imageIds.end(); ++it) {
const std::string id = it->first;
bookReader.addImage(id, new ZLFileImage(ZLFile(file.path(), it->second.Type), it->second.Offset, it->second.Size));
}
const std::map<std::string, unsigned short>& footnoteIds = estream.footnotes();
for(std::map<std::string, unsigned short>::const_iterator it = footnoteIds.begin(); it != footnoteIds.end(); ++it) {
const std::string id = it->first;
if (estream.switchStreamDestination(EReaderStream::FOOTNOTE, id)) {
bookReader.setFootnoteTextModel(id);
bookReader.addHyperlinkLabel(id);
pmlBookReader.readDocument(estream);
}
}
stream.close();
}
void MobipocketHtmlHrefTagAction::run(const HtmlReader::HtmlTag &tag) {
MobipocketHtmlBookReader &reader = (MobipocketHtmlBookReader&)myReader;
if (tag.Start) {
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "FILEPOS") {
const std::string &value = tag.Attributes[i].Value;
if (!value.empty()) {
std::string label = "&";
int intValue = atoi(value.c_str());
if (intValue > 0) {
if (reader.myTocReader.rangeContainsPosition(tag.Offset)) {
reader.myTocReader.startReadEntry(intValue);
if (reader.myTocReader.rangeContainsPosition(intValue)) {
reader.myTocReader.setEndOffset(intValue);
}
}
reader.myFileposReferences.insert(intValue);
ZLStringUtil::appendNumber(label, intValue);
setHyperlinkType(INTERNAL_HYPERLINK);
bookReader().addHyperlinkControl(INTERNAL_HYPERLINK, label);
return;
}
}
}
}
} else {
reader.myTocReader.endReadEntry();
}
HtmlHrefTagAction::run(tag);
}
void XHTMLTagRestartParagraphAction::doAtStart(XHTMLReader &reader, const char**) {
if (reader.myCurrentParagraphIsEmpty) {
bookReader(reader).addData(" ");
}
endParagraph(reader);
beginParagraph(reader);
}
void HtmlSectionImageTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
//bookReader().endParagraph();
HtmlSectionReader &reader = (HtmlSectionReader&)myReader;
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "SRC") {
std::string fileName = MiscUtil::decodeHtmlURL(tag.Attributes[i].Value);
fileName = CHMReferenceCollection::fullReference(reader.myReferenceCollection.prefix(), fileName);
fileName = ZLUnicodeUtil::toLower(fileName);
bookReader().addImageReference(fileName);
bookReader().addImage(fileName, new CHMFileImage(reader.myInfo, fileName));
break;
}
}
//bookReader().beginParagraph();
}
}
void HtmlImageTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
bookReader().endParagraph();
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "SRC") {
const std::string fileName = MiscUtil::decodeHtmlURL(tag.Attributes[i].Value);
const ZLFile file(myReader.myBaseDirPath + fileName);
if (file.exists()) {
bookReader().addImageReference(fileName, 0, false);
bookReader().addImage(fileName, new ZLFileImage(file, "", 0));
}
break;
}
}
bookReader().beginParagraph();
}
}
void XHTMLTagImageAction::doAtStart(XHTMLReader &reader, const char **xmlattributes) {
const char *fileName = reader.attributeValue(xmlattributes, myNameAttribute.c_str());
if (fileName != 0) {
bool flag = bookReader(reader).paragraphIsOpen();
if (flag) {
bookReader(reader).endParagraph();
}
if ((strlen(fileName) > 2) && strncmp(fileName, "./", 2) == 0) {
fileName +=2;
}
const std::string fullfileName = pathPrefix(reader) + fileName;
bookReader(reader).addImageReference(fullfileName);
bookReader(reader).addImage(fullfileName, new ZLFileImage("image/auto", fullfileName, 0));
if (flag) {
bookReader(reader).beginParagraph();
}
}
}
void XHTMLTagLineBreakAction::doAtEnd(XHTMLReader& reader) {
BookReader &br = bookReader(reader);
if (br.paragraphIsOpen()) {
br.addLineBreak();
} else {
beginParagraph(reader);
br.addLineBreak();
endParagraph(reader);
}
}
void HtmlListItemTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
bookReader().endParagraph();
bookReader().beginParagraph();
if (!myReader.myListNumStack.empty()) {
bookReader().addFixedHSpace(3 * myReader.myListNumStack.size());
int &index = myReader.myListNumStack.top();
if (index == 0) {
myReader.addConvertedDataToBuffer("\342\200\242", 3, false);
} else {
const std::string number = ZLStringUtil::numberToString(index++) + ".";
myReader.addConvertedDataToBuffer(number.data(), number.length(), false);
}
bookReader().addFixedHSpace(1);
myReader.myDontBreakParagraph = true;
}
} else {
myReader.myDontBreakParagraph = false;
}
}
void HtmlControlTagAction::run(const HtmlReader::HtmlTag &tag) {
std::vector<FBTextKind> &list = myReader.myKindList;
int index;
for (index = list.size() - 1; index >= 0; --index) {
if (list[index] == myKind) {
break;
}
}
if (tag.Start) {
if (index == -1) {
bookReader().pushKind(myKind);
myReader.myKindList.push_back(myKind);
bookReader().addControl(myKind, true);
}
} else {
if (index >= 0) {
for (int i = list.size() - 1; i >= index; --i) {
bookReader().addControl(list[i], false);
bookReader().popKind();
}
for (unsigned int j = index + 1; j < list.size(); ++j) {
bookReader().addControl(list[j], true);
bookReader().pushKind(list[j]);
}
list.erase(list.begin() + index);
}
}
}
void XHTMLTagHyperlinkAction::doAtStart(XHTMLReader &reader, const char **xmlattributes) {
const char *href = reader.attributeValue(xmlattributes, "href");
if (href != 0 && href[0] != '\0') {
const FBTextKind hyperlinkType = MiscUtil::referenceType(href);
std::string link = MiscUtil::decodeHtmlURL(href);
if (hyperlinkType == INTERNAL_HYPERLINK) {
link = (link[0] == '#') ?
reader.myReferenceName + link :
reader.myReferenceDirName + link;
link = ZLFileUtil::normalizeUnixPath(link);
}
myHyperlinkStack.push(hyperlinkType);
bookReader(reader).addHyperlinkControl(hyperlinkType, link);
} else {
myHyperlinkStack.push(REGULAR);
}
const char *name = reader.attributeValue(xmlattributes, "name");
if (name != 0) {
bookReader(reader).addHyperlinkLabel(
reader.myReferenceName + "#" + MiscUtil::decodeHtmlURL(name)
);
}
}
void HtmlHeaderTagAction::run(const HtmlReader::HtmlTag &tag) {
myReader.myIsStarted = false;
if (tag.Start) {
if (myReader.myBuildTableOfContent && !myReader.myIgnoreTitles) {
if (!bookReader().contentsParagraphIsOpen()) {
bookReader().insertEndOfSectionParagraph();
bookReader().enterTitle();
bookReader().beginContentsParagraph();
}
}
bookReader().pushKind(myKind);
} else {
bookReader().popKind();
if (myReader.myBuildTableOfContent && !myReader.myIgnoreTitles) {
bookReader().endContentsParagraph();
bookReader().exitTitle();
}
}
bookReader().beginParagraph();
}
void MobipocketHtmlImageTagAction::run(const HtmlReader::HtmlTag &tag) {
if (tag.Start) {
for (unsigned int i = 0; i < tag.Attributes.size(); ++i) {
if (tag.Attributes[i].Name == "RECINDEX") {
int index = atoi(tag.Attributes[i].Value.c_str());
if (index > 0) {
int &imageCounter = ((MobipocketHtmlBookReader&)myReader).myImageCounter;
imageCounter = std::max(imageCounter, index);
bool stopParagraph = bookReader().paragraphIsOpen();
if (stopParagraph) {
bookReader().endParagraph();
}
std::string id;
ZLStringUtil::appendNumber(id, index);
bookReader().addImageReference(id);
if (stopParagraph) {
bookReader().beginParagraph();
}
}
break;
}
}
}
}
void XHTMLTagPreAction::doAtEnd(XHTMLReader &reader) {
bookReader(reader).addControl(CODE, false);
endParagraph(reader);
reader.myPreformatted = false;
}
void XHTMLTagPreAction::doAtStart(XHTMLReader &reader, const char**) {
reader.myPreformatted = true;
beginParagraph(reader);
bookReader(reader).addControl(CODE, true);
}
void XHTMLTagParagraphWithControlAction::doAtEnd(XHTMLReader &reader) {
endParagraph(reader);
bookReader(reader).popKind();
}
void XHTMLTagControlAction::doAtEnd(XHTMLReader &reader) {
bookReader(reader).addControl(myControl, false);
bookReader(reader).popKind();
}
