bool BookTextView::onStylusMove(int x, int y) {
const ZLTextElementArea *area = elementByCoordinates(x, y);
std::string id;
bool isExternal;
fbreader().setHyperlinkCursor((area != 0) && getHyperlinkId(*area, id, isExternal));
return true;
}
bool BookTextView::_onStylusMove(int x, int y) {
const ZLTextElementArea *area = elementByCoordinates(x, y);
std::string id;
std::string type;
fbreader().setHyperlinkCursor((area != 0) && getHyperlinkInfo(*area, id, type));
return true;
}
std::string BookTextView::getFirstInternalHyperlinkId(int x0, int y0, int x1, int y1) {
std::string id;
std::string type;
const ZLTextElementArea * area = elementByCoordinates(x0, y0);
const ZLTextElementArea * stop_area = elementByCoordinates(x1, y1);
if ( !area || ((area->Kind != ZLTextElement::WORD_ELEMENT) &&
(area->Kind != ZLTextElement::IMAGE_ELEMENT))) {
return id;
}
ZLTextWordCursor cursor = startCursor();
cursor.moveToParagraph(area->ParagraphIndex);
int paragraphs = area->ParagraphIndex;
int end_paragraphs = stop_area ? stop_area->ParagraphIndex : 0;
do
{
cursor.moveToParagraphStart();
ZLTextKind hyperlinkKind = REGULAR;
for ( ; !cursor.isEndOfParagraph();) {
const ZLTextElement &element = cursor.element();
if (element.kind() == ZLTextElement::CONTROL_ELEMENT) {
const ZLTextControlEntry &control = ((const ZLTextControlElement&)element).entry();
if (control.isHyperlink()) {
hyperlinkKind = control.kind();
id = ((const ZLTextHyperlinkControlEntry&)control).label();
type = ((const ZLTextHyperlinkControlEntry&)control).hyperlinkType();
if (type == "internal")
{
return id;
}
} else if (!control.isStart() && (control.kind() == hyperlinkKind)) {
hyperlinkKind = REGULAR;
}
}
cursor.nextWord();
}
} while( ++paragraphs <= end_paragraphs && cursor.nextParagraph());
return std::string();
}
bool NetLibraryView::_onStylusMove(int x, int y) {
if (!model().isNull()) {
const ZLTextElementArea *imageArea = elementByCoordinates(x, y);
if ((imageArea != 0) && (imageArea->Kind == ZLTextElement::IMAGE_ELEMENT)) {
fbreader().setHyperlinkCursor(true);
return true;
}
}
fbreader().setHyperlinkCursor(false);
return false;
}
bool BookTextView::onStylusMove(int x, int y) {
const ZLTextElementArea *area = elementByCoordinates(x, y);
std::string id;
std::string type;
if ((area != 0) && getHyperlinkInfo(*area, id, type))
{
fbreader().setHyperlinkCursor(true);
return (type == "internal" ? true : false);
}
fbreader().setHyperlinkCursor(false);
return false;
}
std::string BookTextView::getInternalHyperlinkId(int x, int y) {
const ZLTextElementArea *area = elementByCoordinates(x, y);
std::string id;
std::string type;
if ((area != 0) && getHyperlinkInfo(*area, id, type))
{
if (type == "internal")
{
return id;
}
}
return std::string();
}
bool CollectionView::_onStylusPress(int x, int y) {
fbreader().setHyperlinkCursor(false);
const ZLTextElementArea *imageArea = elementByCoordinates(x, y);
if ((imageArea != 0) && (imageArea->Kind == ZLTextElement::IMAGE_ELEMENT)) {
ZLTextWordCursor cursor = startCursor();
cursor.moveToParagraph(imageArea->ParagraphIndex);
cursor.moveTo(imageArea->ElementIndex, 0);
const ZLTextElement &element = cursor.element();
if (element.kind() != ZLTextElement::IMAGE_ELEMENT) {
return false;
}
const ZLTextImageElement &imageElement = (ZLTextImageElement&)element;
const std::string &id = imageElement.id();
if (id == CollectionModel::BookInfoImageId) {
editBookInfo(collectionModel().bookByParagraphIndex(imageArea->ParagraphIndex));
return true;
} else if (id == CollectionModel::RemoveBookImageId) {
removeBook(collectionModel().bookByParagraphIndex(imageArea->ParagraphIndex));
return true;
} else if (id == CollectionModel::RemoveTagImageId) {
removeTag(collectionModel().tagByParagraphIndex(imageArea->ParagraphIndex));
return true;
} else if (id == CollectionModel::TagInfoImageId) {
editTagInfo(collectionModel().tagByParagraphIndex(imageArea->ParagraphIndex));
return true;
} else {
return false;
}
}
int index = paragraphIndexByCoordinates(x, y);
if (index == -1) {
return false;
}
BookDescriptionPtr book = collectionModel().bookByParagraphIndex(index);
if (!book.isNull()) {
fbreader().openBook(book);
fbreader().showBookTextView();
return true;
}
return false;
}
bool CollectionView::_onStylusMove(int x, int y) {
const ZLTextElementArea *imageArea = elementByCoordinates(x, y);
if ((imageArea != 0) && (imageArea->Kind == ZLTextElement::IMAGE_ELEMENT)) {
fbreader().setHyperlinkCursor(true);
return true;
}
int index = paragraphIndexByCoordinates(x, y);
if (index != -1) {
BookDescriptionPtr book = collectionModel().bookByParagraphIndex(index);
if (!book.isNull()) {
fbreader().setHyperlinkCursor(true);
return true;
}
}
fbreader().setHyperlinkCursor(false);
return false;
}
bool BookTextView::_onStylusPress(int x, int y) {
const ZLTextElementArea *area = elementByCoordinates(x, y);
if (area != 0) {
std::string id;
bool isExternal;
if (getHyperlinkId(*area, id, isExternal)) {
fbreader().tryShowFootnoteView(id, isExternal);
return true;
}
if (fbreader().isDictionarySupported() &&
fbreader().EnableSingleClickDictionaryOption.value()) {
const std::string txt = word(*area);
if (!txt.empty()) {
fbreader().openInDictionary(txt);
return true;
}
}
}
return false;
}
bool NetLibraryView::_onStylusPress(int x, int y) {
fbreader().setHyperlinkCursor(false);
if (model().isNull()) {
return false;
}
const ZLTextElementArea *imageArea = elementByCoordinates(x, y);
if ((imageArea == 0) || (imageArea->Kind != ZLTextElement::IMAGE_ELEMENT)) {
return false;
}
ZLTextWordCursor cursor = startCursor();
cursor.moveToParagraph(imageArea->ParagraphIndex);
cursor.moveTo(imageArea->ElementIndex, 0);
const ZLTextElement &element = cursor.element();
if (element.kind() != ZLTextElement::IMAGE_ELEMENT) {
return false;
}
const ZLTextImageElement &imageElement = (ZLTextImageElement&)element;
const std::string &id = imageElement.id();
shared_ptr<NetworkBookInfo> book = myParagraphToBookMap[imageArea->ParagraphIndex];
if (book.isNull()) {
return false;
}
if ((id == DownloadEpub) || (id == DownloadMobi)) {
if (!ZLNetworkManager::instance().connect()) {
NetworkOperationRunnable::showErrorMessage(
ZLResource::resource("dialog")
["networkError"]
["couldntConnectToNetworkMessage"].value()
);
return false;
}
NetworkBookInfo::URLType format = (id == DownloadEpub) ? NetworkBookInfo::BOOK_EPUB : NetworkBookInfo::BOOK_MOBIPOCKET;
DownloadBookRunnable downloader(*book, format);
downloader.executeWithUI();
if (downloader.hasErrors()) {
downloader.showErrorMessage();
} else {
BookDescriptionPtr description = BookDescription::getDescription(downloader.fileName());
WritableBookDescription wDescription(*description);
wDescription.clearAuthor();
wDescription.addAuthor(book->Author.DisplayName, book->Author.SortKey);
wDescription.title() = book->Title;
wDescription.language() = book->Language;
for (std::vector<std::string>::const_iterator it = book->Tags.begin(); it != book->Tags.end(); ++it) {
wDescription.addTag(*it);
}
wDescription.saveInfo();
fbreader().openBook(description);
fbreader().setMode(FBReader::BOOK_TEXT_MODE);
rebuildModel();
}
return true;
} else if ((id == ReadLocalEpub) || (id == ReadLocalMobi)) {
NetworkBookInfo::URLType format = (id == DownloadEpub) ? NetworkBookInfo::BOOK_EPUB : NetworkBookInfo::BOOK_MOBIPOCKET;
fbreader().openFile(NetworkLinkCollection::instance().bookFileName(book->URLByType[format]));
fbreader().setMode(FBReader::BOOK_TEXT_MODE);
return true;
} else if (id == OpenInBrowser) {
std::string url = book->URLByType[NetworkBookInfo::LINK_HTTP];
shared_ptr<ProgramCollection> collection = fbreader().webBrowserCollection();
if (!url.empty() && !collection.isNull()) {
shared_ptr<Program> program = collection->currentProgram();
if (!program.isNull()) {
program->run("openLink", url);
}
}
return true;
}
return false;
}
