def _readBookmarks(self, list_, parent):
'''
@param: list_ QVariantList const
@param: parent BookmarkItem
'''
assert (parent)
for map_ in list_:
# BookmarkItem::Type
type_ = BookmarkItem.typeFromString(map_['type'])
if type_ == BookmarkItem.Invalid:
continue
item = BookmarkItem(type_, parent)
if type_ == BookmarkItem.Url:
item.setUrl(QUrl.fromEncoded(map_['url'].encode()))
item.setTitle(map_['name'])
item.setDescription(map_['description'])
item.setKeyword(map_['keyword'])
item.setVisitCount(map_['visit_count'])
elif type_ == BookmarkItem.Folder:
item.setTitle(map_['name'])
item.setDescription(map_['description'])
item.setExpanded(map_['expanded'])
item.setSidebarExpanded(map_['expanded_sidebar'])
if 'children' in map_:
self._readBookmarks(map_['children'], item)
def __setstate__(self, state):
print('__setstate__')
for key, val in state.items():
if key == 'test1':
self.test1 = QUrl.fromEncoded(val)
else:
setattr(self, key, val)
def _sendTextByMail(self):
action = self.sender()
if isinstance(action, QAction):
data = action.data()
if isinstance(data, QByteArray):
data = data.data().decode()
body = QUrl.toPercentEncoding(data)
mailUrl = QUrl.fromEncoded(b'mailto:%%20?body=%s' % body)
QDesktopServices.openUrl(mailUrl)
def __setstate__(self, state):
for key, val in state.items():
if key == 'url':
self.__dict__[key] = QUrl.fromEncoded(val)
elif key == 'icon':
ds = QDataStream(QByteArray(val))
self.__dict__[key] = ds.readQVariant()
else:
self.__dict__[key] = val
def _bookmarkEdited(self):
assert(len(self._ui.tree.selectedBookmarks()) == 1)
item = self._ui.tree.selectedBookmarks()[0]
item.setTitle(self._ui.title.text())
item.setUrl(QUrl.fromEncoded(self._ui.address.text().encode()))
item.setKeyword(self._ui.keyword.text())
item.setDescription(self._ui.description.toPlainText())
self._bookmarks.changeBookmark(item)
def loadThumbnail(self, url, loadTitle):
'''
@param: url QString
@param: loadTitle bool
'''
thumbnailer = PageThumbnailer(self)
thumbnailer.setUrl(QUrl.fromEncoded(url.encode()))
thumbnailer.setLoadTitle(loadTitle)
thumbnailer.thumbnailCreated.connect(self._thumbnailCreated)
thumbnailer.start()
def urlForShortcut(self, key):
'''
@param: key int
@return: QUrl
'''
if not self._loaded:
self.loadSettings()
if key < 0 or len(self._pages) <= key:
return QUrl()
return QUrl.fromEncoded(self._pages[key].url.encode())
def editBookmarkDialog(cls, parent, item):
'''
@param: parent QWidget
@param: item BookmarkItem
'''
dialog = QDialog(parent)
layout = QFormLayout(dialog)
title = QLineEdit()
address = QLineEdit()
keyword = QLineEdit()
description = QPlainTextEdit()
box = QDialogButtonBox(dialog)
box.addButton(QDialogButtonBox.Ok)
box.addButton(QDialogButtonBox.Cancel)
box.rejected.connect(dialog.reject)
box.accepted.connect(dialog.accept)
layout.addRow(_('Title:'), title)
title.setText(item.title())
if not item.isFolder():
layout.addRow(_('Address:'), address)
address.setText(item.urlString())
layout.addRow(_('Keyword:'), keyword)
keyword.setText(item.keyword())
layout.addRow(_('Description:'), description)
description.document().setPlainText(item.description())
layout.addWidget(box)
dialog.setWindowIcon(item.icon())
dialog.setWindowTitle(_('Edit Bookmark'))
dialog.exec_()
if dialog.result() == QDialog.Rejected:
del dialog
return False
item.setTitle(title.text())
if not item.isFolder():
item.setUrl(QUrl.fromEncoded(address.text().encode()))
item.setKeyword(keyword.text())
item.setDescription(description.toPlainText())
del dialog
return True
def search_web(self, name):
URLS = {
'FantasticFiction':
'http://www.fantasticfiction.co.uk/search/?searchfor=author&keywords={author}',
'Goodreads':
'http://www.goodreads.com/search/search?q={author}&search_type=books',
'Google':
'http://www.google.com/#sclient=psy&q=%22{author}%22+%22{title}%22',
'Wikipedia':
'http://en.wikipedia.org/w/index.php?title=Special%3ASearch&search={author}'
}
for row in self.series_table.selectionModel().selectedRows():
book = self.books[row.row()]
safe_title = self.convert_to_search_text(book.title())
safe_author = self.convert_author_to_search_text(book.authors()[0])
url = URLS[name].replace('{title}', safe_title).replace(
'{author}', safe_author)
open_url(QUrl.fromEncoded(url))
def _showImagePreview(self, item):
'''
@param: item QTreeWidgetItem
'''
if not item:
return
imageUrl = QUrl.fromEncoded(item.text(1).encode())
if imageUrl.isRelative():
imageUrl = self._baseUrl.resolved(imageUrl)
pixmap = QPixmap()
loading = False
if imageUrl.scheme() == 'data':
# QByteArray
encodedUrl = item.text(1)
# QByteArray
imageData = encodedUrl[encodedUrl.find(',') + 1:]
pixmap = gVar.appTools.pixmapFromByteArray(imageData)
elif imageUrl.scheme() == 'file':
pixmap = QPixmap(imageUrl.toLocalFile())
elif imageUrl.scheme() == 'qrc':
pixmap = QPixmap(imageUrl.toString()[:3]) # Remove qrc from url
else:
self._imageReply = gVar.app.networkManager().get(QNetworkRequest(imageUrl))
def imageReplyCb():
if self._imageReply.error() != QNetworkReply.NoError:
return
# QByteArray
data = self._imageReply.readAll()
self._showPixmap(QPixmap.fromImage(QImage.fromData(data)))
self._imageReply.finished.connect(imageReplyCb)
loading = True
self._showLoadingText()
if not loading:
self._showPixmap(pixmap)
def _readBookmarks(self, list_, parent):
'''
@param: list_ QVariantList
@param: parent BookmarkItem
'''
assert (parent)
for entry in list_:
typeString = entry['type']
if typeString == 'url':
type_ = BookmarkItem.Url
elif typeString == 'folder':
type_ = BookmarkItem.Folder
else:
continue
item = BookmarkItem(type_, parent)
item.setTitle(entry['name'])
if item.isUrl():
item.setUrl(QUrl.fromEncoded(entry['url']))
if 'children' in entry:
self._readBookmarks(entry['children'], item)
def _sendLink(self):
url = self._window.weView().url().toEncoded().toPercentEncoding()
title = QUrl.toPercentEncoding(self._window.weView().title()).data()
mainUrl = QUrl.fromEncoded(b'mailto:%20?body=' + url + b'&subject=' + title)
QDesktopServices.openUrl(mainUrl)
def sendPageByEmail(self):
body = QUrl.toPercentEncoding(self.url().toEncoded().data().decode())
subject = QUrl.toPercentEncoding(self.title())
mailUrl = QUrl.fromEncoded(b'mailto:%%20?body=%s&subject=%s' % (body, subject))
QDesktopServices.openUrl(mailUrl)
def importBookmarks(self):
'''
@brief: Import bookmarks (it must return root folder)
'''
c = self._content
c = c.replace("<DL", "<dl")
c = c.replace("</DL", "</dl")
c = c.replace("<DT", "<dt")
c = c.replace("</DT", "</dt")
c = c.replace("<P", "<p")
c = c.replace("</P", "</p")
c = c.replace("<A", "<a")
c = c.replace("</A", "</a")
c = c.replace("HREF=", "href=")
c = c.replace("<H3", "<h3")
c = c.replace("</H3", "</h3")
c = c[:c.rfind('</dl><p>')]
start = c.find("<dl><p>")
root = BookmarkItem(BookmarkItem.Folder)
root.setTitle("HTML Import")
folders = [] # QList<BookmarkItem*>
folders.append(root)
while start > 0:
string = bookmarks[start:]
posOfFolder = string.find("<dt><h3")
posOfEndFolder = string.find("</dl><p>")
posOfLink = string.find("<dt><a")
nearest = _min(posOfLink, _min(posOfFolder, posOfEndFolder))
if nearest == -1:
break
if nearest == posOfFolder:
# Next is folder
rx = re.compile(r"<dt><h3(.*)>(.*)</h3>")
match = rx.search(string)
folderName = match.group(2).strip()
folder = BookmarkItem(BookmarkItem.Folder, not folders and root
or folders[-1])
folder.setTitle(folderName)
folders.append(folder)
start += posOfFolder + len(match.group(0))
elif nearest == posOfEndFolder:
# Next is end of folder
if folders:
folders.pop(-1)
start += posOfEndFolder + 8
else:
# Next is link
rx = re.compile(r"<dt><a(.*)>(.*)</a>")
match = rx.search(string)
arguments = match.group(1)
linkName = match.group(2).strip()
rx2 = re.compile(r"href=\"(.*)\"")
match2 = rx2.search(arguments)
url = QUrl.fromEncoded(match2.group(1).strip())
start += posOfLink + len(match.group(0))
if not url or url.scheme() == "place" or url.scheme(
) == "about":
continue
b = BookmarkItem(BookmarkItem.Url, not folders and root
or folders[-1])
b.setTitle(not linkName and url.toString() or linkName)
b.setUrl(url)
return root
