mirror of
https://github.com/noDRM/DeDRM_tools.git
synced 2024-11-05 05:26:09 +06:00
afa4ac5716
THIS IS ON THE MASTER BRANCH. The Master branch will be Python 3.0 from now on. While Python 2.7 support will not be deliberately broken, all efforts should now focus on Python 3.0 compatibility. I can see a lot of work has been done. There's more to do. I've bumped the version number of everything I came across to the next major number for Python 3.0 compatibility indication. Thanks everyone. I hope to update here at least once a week until we have a stable 7.0 release for calibre 5.0
232 lines
7.5 KiB
Python
232 lines
7.5 KiB
Python
# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
|
|
from __future__ import (unicode_literals, division, absolute_import,
|
|
print_function)
|
|
|
|
__license__ = 'GPL v3'
|
|
__docformat__ = 'restructuredtext en'
|
|
|
|
|
|
import os, struct, time
|
|
try:
|
|
from StringIO import StringIO
|
|
except ImportError:
|
|
from io import StringIO
|
|
from traceback import print_exc
|
|
|
|
try:
|
|
from PyQt5.Qt import (Qt, QDialog, QPixmap, QIcon, QLabel, QHBoxLayout, QFont, QTableWidgetItem)
|
|
except ImportError:
|
|
from PyQt4.Qt import (Qt, QDialog, QPixmap, QIcon, QLabel, QHBoxLayout, QFont, QTableWidgetItem)
|
|
|
|
from calibre.utils.config import config_dir
|
|
from calibre.constants import iswindows, DEBUG
|
|
from calibre import prints
|
|
from calibre.gui2 import (error_dialog, gprefs)
|
|
from calibre.gui2.actions import menu_action_unique_name
|
|
|
|
from calibre_plugins.obok_dedrm.__init__ import (PLUGIN_NAME,
|
|
PLUGIN_SAFE_NAME, PLUGIN_VERSION, PLUGIN_DESCRIPTION)
|
|
|
|
plugin_ID = None
|
|
plugin_icon_resources = {}
|
|
|
|
try:
|
|
from calibre.gui2 import QVariant
|
|
del QVariant
|
|
except ImportError:
|
|
is_qt4 = False
|
|
convert_qvariant = lambda x: x
|
|
else:
|
|
is_qt4 = True
|
|
|
|
def convert_qvariant(x):
|
|
vt = x.type()
|
|
if vt == x.String:
|
|
return x.toString()
|
|
if vt == x.List:
|
|
return [convert_qvariant(i) for i in x.toList()]
|
|
return x.toPyObject()
|
|
|
|
BASE_TIME = None
|
|
def debug_print(*args):
|
|
global BASE_TIME
|
|
if BASE_TIME is None:
|
|
BASE_TIME = time.time()
|
|
if DEBUG:
|
|
prints('DEBUG: %6.1f'%(time.time()-BASE_TIME), *args)
|
|
|
|
try:
|
|
debug_print("obok::utilities.py - loading translations")
|
|
load_translations()
|
|
except NameError:
|
|
debug_print("obok::utilities.py - exception when loading translations")
|
|
pass # load_translations() added in calibre 1.9
|
|
|
|
def format_plural(number, possessive=False):
|
|
'''
|
|
Cosmetic ditty to provide the proper string formatting variable to handle singular/plural situations
|
|
|
|
:param: number: variable that represents the count/len of something
|
|
'''
|
|
if not possessive:
|
|
return '' if number == 1 else 's'
|
|
return '\'s' if number == 1 else 's\''
|
|
|
|
|
|
def set_plugin_icon_resources(name, resources):
|
|
'''
|
|
Set our global store of plugin name and icon resources for sharing between
|
|
the InterfaceAction class which reads them and the ConfigWidget
|
|
if needed for use on the customization dialog for this plugin.
|
|
'''
|
|
global plugin_icon_resources, plugin_ID
|
|
plugin_ID = name
|
|
plugin_icon_resources = resources
|
|
|
|
def get_icon(icon_name):
|
|
'''
|
|
Retrieve a QIcon for the named image from the zip file if it exists,
|
|
or if not then from Calibre's image cache.
|
|
'''
|
|
if icon_name:
|
|
pixmap = get_pixmap(icon_name)
|
|
if pixmap is None:
|
|
# Look in Calibre's cache for the icon
|
|
return QIcon(I(icon_name))
|
|
else:
|
|
return QIcon(pixmap)
|
|
return QIcon()
|
|
|
|
def get_pixmap(icon_name):
|
|
'''
|
|
Retrieve a QPixmap for the named image
|
|
Any icons belonging to the plugin must be prefixed with 'images/'
|
|
'''
|
|
if not icon_name.startswith('images/'):
|
|
# We know this is definitely not an icon belonging to this plugin
|
|
pixmap = QPixmap()
|
|
pixmap.load(I(icon_name))
|
|
return pixmap
|
|
|
|
# Check to see whether the icon exists as a Calibre resource
|
|
# This will enable skinning if the user stores icons within a folder like:
|
|
# ...\AppData\Roaming\calibre\resources\images\Plugin Name\
|
|
if plugin_ID:
|
|
local_images_dir = get_local_images_dir(plugin_ID)
|
|
local_image_path = os.path.join(local_images_dir, icon_name.replace('images/', ''))
|
|
if os.path.exists(local_image_path):
|
|
pixmap = QPixmap()
|
|
pixmap.load(local_image_path)
|
|
return pixmap
|
|
|
|
# As we did not find an icon elsewhere, look within our zip resources
|
|
if icon_name in plugin_icon_resources:
|
|
pixmap = QPixmap()
|
|
pixmap.loadFromData(plugin_icon_resources[icon_name])
|
|
return pixmap
|
|
return None
|
|
|
|
def get_local_images_dir(subfolder=None):
|
|
'''
|
|
Returns a path to the user's local resources/images folder
|
|
If a subfolder name parameter is specified, appends this to the path
|
|
'''
|
|
images_dir = os.path.join(config_dir, 'resources/images')
|
|
if subfolder:
|
|
images_dir = os.path.join(images_dir, subfolder)
|
|
if iswindows:
|
|
images_dir = os.path.normpath(images_dir)
|
|
return images_dir
|
|
|
|
def showErrorDlg(errmsg, parent, trcbk=False):
|
|
'''
|
|
Wrapper method for calibre's error_dialog
|
|
'''
|
|
if trcbk:
|
|
error= ''
|
|
f=StringIO()
|
|
print_exc(file=f)
|
|
error_mess = f.getvalue().splitlines()
|
|
for line in error_mess:
|
|
error = error + str(line) + '\n'
|
|
errmsg = errmsg + '\n\n' + error
|
|
return error_dialog(parent, _(PLUGIN_NAME + ' v' + PLUGIN_VERSION),
|
|
_(errmsg), show=True)
|
|
|
|
class SizePersistedDialog(QDialog):
|
|
'''
|
|
This dialog is a base class for any dialogs that want their size/position
|
|
restored when they are next opened.
|
|
'''
|
|
def __init__(self, parent, unique_pref_name):
|
|
QDialog.__init__(self, parent)
|
|
self.unique_pref_name = unique_pref_name
|
|
self.geom = gprefs.get(unique_pref_name, None)
|
|
self.finished.connect(self.dialog_closing)
|
|
|
|
def resize_dialog(self):
|
|
if self.geom is None:
|
|
self.resize(self.sizeHint())
|
|
else:
|
|
self.restoreGeometry(self.geom)
|
|
|
|
def dialog_closing(self, result):
|
|
geom = bytearray(self.saveGeometry())
|
|
gprefs[self.unique_pref_name] = geom
|
|
self.persist_custom_prefs()
|
|
|
|
def persist_custom_prefs(self):
|
|
'''
|
|
Invoked when the dialog is closing. Override this function to call
|
|
save_custom_pref() if you have a setting you want persisted that you can
|
|
retrieve in your __init__() using load_custom_pref() when next opened
|
|
'''
|
|
pass
|
|
|
|
def load_custom_pref(self, name, default=None):
|
|
return gprefs.get(self.unique_pref_name+':'+name, default)
|
|
|
|
def save_custom_pref(self, name, value):
|
|
gprefs[self.unique_pref_name+':'+name] = value
|
|
|
|
class ImageTitleLayout(QHBoxLayout):
|
|
'''
|
|
A reusable layout widget displaying an image followed by a title
|
|
'''
|
|
def __init__(self, parent, icon_name, title):
|
|
'''
|
|
:param parent: Parent gui
|
|
:param icon_name: Path to plugin image resource
|
|
:param title: String to be displayed beside the image
|
|
'''
|
|
QHBoxLayout.__init__(self)
|
|
self.title_image_label = QLabel(parent)
|
|
self.update_title_icon(icon_name)
|
|
self.addWidget(self.title_image_label)
|
|
|
|
title_font = QFont()
|
|
title_font.setPointSize(16)
|
|
shelf_label = QLabel(title, parent)
|
|
shelf_label.setFont(title_font)
|
|
self.addWidget(shelf_label)
|
|
self.insertStretch(-1)
|
|
|
|
def update_title_icon(self, icon_name):
|
|
pixmap = get_pixmap(icon_name)
|
|
if pixmap is None:
|
|
error_dialog(self.parent(), _('Restart required'),
|
|
_('Title image not found - you must restart Calibre before using this plugin!'), show=True)
|
|
else:
|
|
self.title_image_label.setPixmap(pixmap)
|
|
self.title_image_label.setMaximumSize(32, 32)
|
|
self.title_image_label.setScaledContents(True)
|
|
|
|
|
|
class ReadOnlyTableWidgetItem(QTableWidgetItem):
|
|
|
|
def __init__(self, text):
|
|
if text is None:
|
|
text = ''
|
|
QTableWidgetItem.__init__(self, text, QTableWidgetItem.UserType)
|
|
self.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
|