def main():
app = QtWidgets.QApplication(sys.argv)
fontDB = QFontDatabase()
fontDB.applicationFontFamilies(
fontDB.addApplicationFont(":/res/Harmattan.ttf"))
application = AppWindowByHaies()
application.show()
app.exec_()
def load_fonts(self, lrf, load_substitutions=True):
font_map = {}
for font in lrf.font_map:
fdata = QByteArray(lrf.font_map[font].data)
id = QFontDatabase.addApplicationFontFromData(fdata)
if id != -1:
font_map[font] = [str(i) for i in QFontDatabase.applicationFontFamilies(id)][0]
if load_substitutions:
base = P('fonts/liberation/*.ttf')
for f in glob.glob(base):
QFontDatabase.addApplicationFont(f)
self.font_loader = FontLoader(font_map, self.dpi)
def load_fonts(self, lrf, load_substitutions=True):
font_map = {}
for font in lrf.font_map:
fdata = QByteArray(lrf.font_map[font].data)
id = QFontDatabase.addApplicationFontFromData(fdata)
if id != -1:
font_map[font] = [str(i) for i in QFontDatabase.applicationFontFamilies(id)][0]
if load_substitutions:
base = P('fonts/liberation/*.ttf')
for f in glob.glob(base):
QFontDatabase.addApplicationFont(f)
self.font_loader = FontLoader(font_map, self.dpi)
def load_builtin_fonts():
global _rating_font
# Load the builtin fonts and any fonts added to calibre by the user to
# Qt
for ff in glob.glob(P('fonts/liberation/*.?tf')) + \
[P('fonts/calibreSymbols.otf')] + \
glob.glob(os.path.join(config_dir, 'fonts', '*.?tf')):
if ff.rpartition('.')[-1].lower() in {'ttf', 'otf'}:
with open(ff, 'rb') as s:
# Windows requires font files to be executable for them to be
# loaded successfully, so we use the in memory loader
fid = QFontDatabase.addApplicationFontFromData(s.read())
if fid > -1:
fam = QFontDatabase.applicationFontFamilies(fid)
fam = set(map(unicode, fam))
if u'calibre Symbols' in fam:
_rating_font = u'calibre Symbols'
def load_builtin_fonts():
global _rating_font
# Load the builtin fonts and any fonts added to calibre by the user to
# Qt
for ff in glob.glob(P('fonts/liberation/*.?tf')) + \
[P('fonts/calibreSymbols.otf')] + \
glob.glob(os.path.join(config_dir, 'fonts', '*.?tf')):
if ff.rpartition('.')[-1].lower() in {'ttf', 'otf'}:
with open(ff, 'rb') as s:
# Windows requires font files to be executable for them to be
# loaded successfully, so we use the in memory loader
fid = QFontDatabase.addApplicationFontFromData(s.read())
if fid > -1:
fam = QFontDatabase.applicationFontFamilies(fid)
fam = set(map(unicode, fam))
if u'calibre Symbols' in fam:
_rating_font = u'calibre Symbols'
def __init__(self,
str,
owner: LabeledObject,
owner_widget: GraphItem,
parent=None,
flags=Qt.WindowFlags()):
super().__init__(str, parent=parent, flags=flags)
self.__owner = owner
self.__owner_widget = owner_widget
font_database = QFontDatabase()
# Build absolute path to prevent problems on macOS
path = os.path.join(os.path.dirname(__file__),
"../ressources/fonts/lmroman8-regular.otf")
font_id = font_database.addApplicationFont(path)
if (font_id == -1):
raise IOError("Font could not be loaded")
font_name = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_name, 16)
self.setFont(font)
self.adjustSize()
self.__reposition()
def handle_embedded_fonts(self):
'''
Because of QtWebKit's inability to handle embedded fonts correctly, we
remove the embedded fonts and make them available system wide instead.
If you ever move to Qt WebKit 2.3+ then this will be unnecessary.
'''
from calibre.ebooks.oeb.base import urlnormalize
from calibre.utils.fonts.utils import remove_embed_restriction
from PyQt5.Qt import QFontDatabase, QByteArray, QRawFont, QFont
# First find all @font-face rules and remove them, adding the embedded
# fonts to Qt
family_map = {}
for item in list(self.oeb.manifest):
if not hasattr(item.data, 'cssRules'):
continue
remove = set()
for i, rule in enumerate(item.data.cssRules):
if rule.type == rule.FONT_FACE_RULE:
remove.add(i)
try:
s = rule.style
src = s.getProperty('src').propertyValue[0].uri
font_family = s.getProperty('font-family').propertyValue[0].value
except:
continue
path = item.abshref(src)
ff = self.oeb.manifest.hrefs.get(urlnormalize(path), None)
if ff is None:
continue
raw = ff.data
self.oeb.manifest.remove(ff)
try:
raw = remove_embed_restriction(raw)
except:
continue
fid = QFontDatabase.addApplicationFontFromData(QByteArray(raw))
family_name = None
if fid > -1:
try:
family_name = unicode(QFontDatabase.applicationFontFamilies(fid)[0])
except (IndexError, KeyError):
pass
if family_name:
family_map[icu_lower(font_family)] = family_name
for i in sorted(remove, reverse=True):
item.data.cssRules.pop(i)
# Now map the font family name specified in the css to the actual
# family name of the embedded font (they may be different in general).
font_warnings = set()
for item in self.oeb.manifest:
if not hasattr(item.data, 'cssRules'):
continue
for i, rule in enumerate(item.data.cssRules):
if rule.type != rule.STYLE_RULE:
continue
ff = rule.style.getProperty('font-family')
if ff is None:
continue
val = ff.propertyValue
for i in xrange(val.length):
try:
k = icu_lower(val[i].value)
except (AttributeError, TypeError):
val[i].value = k = 'times'
if k in family_map:
val[i].value = family_map[k]
if iswindows:
# On windows, Qt uses GDI which does not support OpenType
# (CFF) fonts, so we need to nuke references to OpenType
# fonts. Note that you could compile QT with configure
# -directwrite, but that requires atleast Vista SP2
for i in xrange(val.length):
family = val[i].value
if family:
f = QRawFont.fromFont(QFont(family))
if len(f.fontTable('head')) == 0:
if family not in font_warnings:
self.log.warn('Ignoring unsupported font: %s'
%family)
font_warnings.add(family)
# Either a bitmap or (more likely) a CFF font
val[i].value = 'times'
def resolve_font(path):
new_path = Storage.__resolve__("data/fonts", path)
id = Storage.DATABASE.addApplicationFont(new_path)
return QFontDatabase.applicationFontFamilies(id)[0]
def handle_embedded_fonts(self):
'''
Because of QtWebKit's inability to handle embedded fonts correctly, we
remove the embedded fonts and make them available system wide instead.
If you ever move to Qt WebKit 2.3+ then this will be unnecessary.
'''
from calibre.ebooks.oeb.base import urlnormalize
from calibre.utils.fonts.utils import remove_embed_restriction
from PyQt5.Qt import QFontDatabase, QByteArray, QRawFont, QFont
# First find all @font-face rules and remove them, adding the embedded
# fonts to Qt
family_map = {}
for item in list(self.oeb.manifest):
if not hasattr(item.data, 'cssRules'):
continue
remove = set()
for i, rule in enumerate(item.data.cssRules):
if rule.type == rule.FONT_FACE_RULE:
remove.add(i)
try:
s = rule.style
src = s.getProperty('src').propertyValue[0].uri
font_family = s.getProperty(
'font-family').propertyValue[0].value
except:
continue
path = item.abshref(src)
ff = self.oeb.manifest.hrefs.get(urlnormalize(path), None)
if ff is None:
continue
raw = ff.data
self.oeb.manifest.remove(ff)
try:
raw = remove_embed_restriction(raw)
except:
continue
fid = QFontDatabase.addApplicationFontFromData(
QByteArray(raw))
family_name = None
if fid > -1:
try:
family_name = unicode(
QFontDatabase.applicationFontFamilies(fid)[0])
except (IndexError, KeyError):
pass
if family_name:
family_map[icu_lower(font_family)] = family_name
for i in sorted(remove, reverse=True):
item.data.cssRules.pop(i)
# Now map the font family name specified in the css to the actual
# family name of the embedded font (they may be different in general).
font_warnings = set()
for item in self.oeb.manifest:
if not hasattr(item.data, 'cssRules'):
continue
for i, rule in enumerate(item.data.cssRules):
if rule.type != rule.STYLE_RULE:
continue
ff = rule.style.getProperty('font-family')
if ff is None:
continue
val = ff.propertyValue
for i in xrange(val.length):
try:
k = icu_lower(val[i].value)
except (AttributeError, TypeError):
val[i].value = k = 'times'
if k in family_map:
val[i].value = family_map[k]
if iswindows:
# On windows, Qt uses GDI which does not support OpenType
# (CFF) fonts, so we need to nuke references to OpenType
# fonts. Note that you could compile QT with configure
# -directwrite, but that requires atleast Vista SP2
for i in xrange(val.length):
family = val[i].value
if family:
f = QRawFont.fromFont(QFont(family))
if len(f.fontTable('head')) == 0:
if family not in font_warnings:
self.log.warn(
'Ignoring unsupported font: %s' %
family)
font_warnings.add(family)
# Either a bitmap or (more likely) a CFF font
val[i].value = 'times'
def __init__(self, argv): # noqa 901
super(MainApplication, self).__init__(argv)
self._isPrivate = False
self._isPortable = True
self._isClosing = False
self._isStartingAfterCrash = False
self._history = None # History
self._bookmarks = None # Bookmarks
self._autoFill = None # AutoFill
self._cookieJar = None # CookieJar
self._plugins = None # PluginProxy
self._browsingLibrary = None # BrowsingLibrary
self._networkManager = None
self._restoreManager = None
self._sessionManager = None
self._downloadManager = None
self._userAgentManager = None
self._searchEnginesManager = None
self._closedWindowsManager = None
self._protocolHandlerManager = None
self._html5PermissionsManager = None
self._desktopNotifications = None # DesktopNotificationsFactory
self._webProfile = None # QWebEngineProfile
self._autoSaver = None
self._proxyStyle = None
self._wmClass = QByteArray()
self._windows = []
self._lastActiveWindow = None
self._postLaunchActions = []
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.setAttribute(Qt.AA_DontCreateNativeWidgetSiblings)
self.setApplicationName('demo')
self.setOrganizationDomain('org.autowin')
self.setWindowIcon(QIcon.fromTheme('demo', QIcon(':/icons/demo.svg')))
self.setDesktopFileName('orig.autowin.demo')
self.setApplicationVersion('1.0')
# Set fallback icon theme (eg. on Windows/Mac)
if QIcon.fromTheme('view-refresh').isNull():
QIcon.setThemeName('breeze-fallback')
# QSQLITE database plugin is required
if not QSqlDatabase.isDriverAvailable('QSQLITE'):
QMessageBox.Critical(
None, 'Error', 'Qt SQLite database plugin is not available.'
' Please install it and restart the application.')
self._isClosing = True
return
if const.OS_WIN:
# Set default app font (needed for N'ko)
fontId = QFontDatabase.addApplicationFont('font.ttf')
if fontId != -1:
families = QFontDatabase.applicationFontFamilies(fontId)
if not families.empty():
self.setFont(QFont(families.at(0)))
startUrl = QUrl()
startProfile = ''
messages = []
noAddons = False
newInstance = False
if len(argv) > 1:
cmd = CommandLineOptions()
for pair in cmd.getActions():
action = pair.action
text = pair.text
if action == const.CL_StartWithoutAddons:
noAddons = True
elif action == const.CL_StartWithProfile:
startProfile = text
elif action == const.CL_StartPortable:
self._isPortable = True
elif action == const.CL_NewTab:
messages.append("ACTION:NewTab")
self._postLaunchActions.append(self.OpenNewTab)
elif action == const.CL_NewWindow:
messages.append("ACTION:NewWindow")
elif action == const.CL_ToggleFullScreen:
messages.append("ACTION:ToggleFullScreen")
self._postLaunchActions.append(self.ToggleFullScreen)
elif action == const.CL_ShowDownloadManager:
messages.append("ACTION:ShowDownloadManager")
self._postLaunchActions.append(self.OpenDownloadManager)
elif action == const.CL_StartPrivateBrowsing:
self._isPrivate = True
elif action == const.CL_StartNewInstance:
newInstance = True
elif action == const.CL_OpenUrlInCurrentTab:
startUrl = QUrl.fromUserInput(text)
messages.append("ACTION:OpenUrlInCurrentTab" + text)
elif action == const.CL_OpenUrlInNewWindow:
startUrl = QUrl.fromUserInput(text)
messages.append("ACTION:OpenUrlInNewWindow" + text)
elif action == const.CL_OpenUrl:
startUrl = QUrl.fromUserInput(text)
messages.append("URL:" + text)
elif action == const.CL_ExitAction:
self._isClosing = True
return
elif action == const.CL_WMClass:
self._wmClass = text
if not self.isPortable():
appConf = QSettings(
pathjoin(self.applicationDirPath(), '%s.conf' % const.APPNAME),
QSettings.IniFormat)
appConf.value('Config/Portable')
if self.isPortable():
print('%s: Running in Portable Mode.' % const.APPNAME)
DataPaths.setPortableVersion()
# Don't start single application in private browsing
if not self.isPrivate():
appId = 'org.autowin.mc'
if self.isPortable():
appId += '.Portable'
if self.isTestModeEnabled():
appId += '.TestMode'
if newInstance:
if not startProfile or startProfile == 'default':
print(
'New instance cannot be started with default profile!')
else:
# Generate unique appId so it is possible to start more
# separate instances of the same profile. It is dangerous to
# run more instance of the same profile, but if the user
# wants it, we should allow it.
appId += '.' + str(QDateTime.currentMSecsSinceEpoch())
self.setAppId(appId)
# If there is nothing to tell other instance, we need to at least weak it
if not messages:
messages.append(' ')
if self.isRunning():
self._isClosing = True
for message in messages:
self.sendMessage(message)
return
if const.OS_MACOS:
self.setQuitOnLastWindowClosed(False)
# TODO:
# disable tabbing issue #2261
# extern void disableWindowTabbing();
# self.disableWindowTabbing()
else:
self.setQuitOnLastWindowClosed(True)
QSettings.setDefaultFormat(QSettings.IniFormat)
QDesktopServices.setUrlHandler('http', self.addNewTab)
QDesktopServices.setUrlHandler('https', self.addNewTab)
QDesktopServices.setUrlHandler('ftp', self.addNewTab)
profileManager = ProfileManager()
profileManager.initConfigDir()
profileManager.initCurrentProfile(startProfile)
Settings.createSettings(
pathjoin(DataPaths.currentProfilePath(), 'settings.ini'))
NetworkManager.registerSchemes()
if self.isPrivate():
self._webProfile = QWebEngineProfile()
else:
self._webProfile = QWebEngineProfile.defaultProfile()
self._webProfile.downloadRequested.connect(self.downloadRequested)
self._networkManager = NetworkManager(self)
self.setupUserScripts()
if not self.isPrivate() and not self.isTestModeEnabled():
self._sessionManager = SessionManager(self)
self._autoSaver = AutoSaver(self)
self._autoSaver.save.connect(
self._sessionManager.autoSaveLastSession)
settings = Settings()
settings.beginGroup('SessionRestore')
wasRunning = settings.value('isRunning', False)
wasRestoring = settings.value('isRestoring', False)
settings.setValue('isRunning', True)
settings.setValue('isRestoring', wasRunning)
settings.endGroup()
settings.sync()
self._isStartingAfterCrash = bool(wasRunning and wasRestoring)
if wasRunning:
QTimer.singleShot(
60 * 1000, lambda: Settings().setValue(
'SessionRestore/isRestoring', False))
# we have to ask about startup session before creating main window
if self._isStartingAfterCrash and self.afterLaunch(
) == self.SelectSession:
self._restoreManager = RestoreManager(
self.sessionManager().askSessionFromUser())
self.loadSettings()
self._plugins = PluginProxy(self)
self._autoFill = AutoFill(self)
self.app.protocolHandlerManager()
if not noAddons:
self._plugins.loadPlugins()
window = self.createWindow(const.BW_FirstAppWindow, startUrl)
window.startingCompleted.connect(self.restoreOverrideCursor)
self.focusChanged.connect(self.onFocusChanged)
if not self.isPrivate() and not self.isTestModeEnabled():
# check updates
settings = Settings()
checkUpdates = settings.value('Web-Browser-Settings/CheckUpdates',
True)
if checkUpdates:
Updater(window)
self.sessionManager().backupSavedSessions()
if self._isStartingAfterCrash or self.afterLaunch(
) == self.RestoreSession:
self._restoreManager = RestoreManager(
self.sessionManager().lastActiveSessionPath())
if not self._restoreManager.isValid():
self.destroyRestoreManager()
if not self._isStartingAfterCrash and self._restoreManager:
self.restoreSession(window, self._restoreManager.restoreData())
QSettings.setPath(QSettings.IniFormat, QSettings.UserScope,
DataPaths.currentProfilePath())
self.messageReceived.connect(self.messageReceivedCb)
self.aboutToQuit.connect(self.saveSettings)
QTimer.singleShot(0, self.postLaunch)
