396 lines
11 KiB
Python
396 lines
11 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""QDarkStyle is a dark stylesheet for Python and Qt applications.
|
|
|
|
This module provides a function to load the stylesheets transparently
|
|
with the right resources file.
|
|
|
|
First, start importing our module
|
|
|
|
.. code-block:: python
|
|
|
|
import qdarkstyle
|
|
|
|
Then you can get stylesheet provided by QDarkStyle for various Qt wrappers
|
|
as shown below
|
|
|
|
.. code-block:: python
|
|
|
|
# PySide
|
|
dark_stylesheet = qdarkstyle.load_stylesheet_pyside()
|
|
# PySide 2
|
|
dark_stylesheet = qdarkstyle.load_stylesheet_pyside2()
|
|
# PyQt4
|
|
dark_stylesheet = qdarkstyle.load_stylesheet_pyqt()
|
|
# PyQt5
|
|
dark_stylesheet = qdarkstyle.load_stylesheet_pyqt5()
|
|
|
|
Alternatively, from environment variables provided by QtPy, PyQtGraph, Qt.Py
|
|
|
|
.. code-block:: python
|
|
|
|
# QtPy
|
|
dark_stylesheet = qdarkstyle.load_stylesheet()
|
|
# PyQtGraph
|
|
dark_stylesheet = qdarkstyle.load_stylesheet(qt_api=os.environ('PYQTGRAPH_QT_LIB'))
|
|
# Qt.Py
|
|
dark_stylesheet = qdarkstyle.load_stylesheet(qt_api=Qt.__binding__)
|
|
|
|
Finally, set your QApplication with it
|
|
|
|
.. code-block:: python
|
|
|
|
app.setStyleSheet(dark_stylesheet)
|
|
|
|
Enjoy!
|
|
|
|
"""
|
|
|
|
# Standard library imports
|
|
import logging
|
|
import os
|
|
import platform
|
|
import warnings
|
|
|
|
# Local imports
|
|
from qdarkstyle.palette import DarkPalette
|
|
|
|
__version__ = "2.8.1"
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
# Folder's path
|
|
REPO_PATH = os.path.dirname(os.path.abspath(os.path.dirname(__file__)))
|
|
|
|
EXAMPLE_PATH = os.path.join(REPO_PATH, 'example')
|
|
IMAGES_PATH = os.path.join(REPO_PATH, 'images')
|
|
PACKAGE_PATH = os.path.join(REPO_PATH, 'qdarkstyle')
|
|
|
|
QSS_PATH = os.path.join(PACKAGE_PATH, 'qss')
|
|
RC_PATH = os.path.join(PACKAGE_PATH, 'rc')
|
|
SVG_PATH = os.path.join(PACKAGE_PATH, 'svg')
|
|
|
|
# File names
|
|
QSS_FILE = 'style.qss'
|
|
QRC_FILE = QSS_FILE.replace('.qss', '.qrc')
|
|
|
|
MAIN_SCSS_FILE = 'main.scss'
|
|
STYLES_SCSS_FILE = '_styles.scss'
|
|
VARIABLES_SCSS_FILE = '_variables.scss'
|
|
|
|
# File paths
|
|
QSS_FILEPATH = os.path.join(PACKAGE_PATH, QSS_FILE)
|
|
QRC_FILEPATH = os.path.join(PACKAGE_PATH, QRC_FILE)
|
|
|
|
MAIN_SCSS_FILEPATH = os.path.join(QSS_PATH, MAIN_SCSS_FILE)
|
|
STYLES_SCSS_FILEPATH = os.path.join(QSS_PATH, STYLES_SCSS_FILE)
|
|
VARIABLES_SCSS_FILEPATH = os.path.join(QSS_PATH, VARIABLES_SCSS_FILE)
|
|
|
|
# Todo: check if we are deprecate all those functions or keep them
|
|
DEPRECATION_MSG = '''This function will be deprecated in v3.0.
|
|
Please, set the wanted binding by using QtPy environment variable QT_API,
|
|
then use load_stylesheet() or use load_stylesheet()
|
|
passing the argument qt_api='wanted_binding'.'''
|
|
|
|
|
|
def _apply_os_patches():
|
|
"""
|
|
Apply OS-only specific stylesheet pacthes.
|
|
|
|
Returns:
|
|
str: stylesheet string (css).
|
|
"""
|
|
os_fix = ""
|
|
|
|
if platform.system().lower() == 'darwin':
|
|
# See issue #12
|
|
os_fix = '''
|
|
QDockWidget::title
|
|
{{
|
|
background-color: {color};
|
|
text-align: center;
|
|
height: 12px;
|
|
}}
|
|
'''.format(color=DarkPalette.COLOR_BACKGROUND_NORMAL)
|
|
|
|
# Only open the QSS file if any patch is needed
|
|
if os_fix:
|
|
_logger.info("Found OS patches to be applied.")
|
|
|
|
return os_fix
|
|
|
|
|
|
def _apply_binding_patches():
|
|
"""
|
|
Apply binding-only specific stylesheet patches for the same OS.
|
|
|
|
Returns:
|
|
str: stylesheet string (css).
|
|
"""
|
|
binding_fix = ""
|
|
|
|
if binding_fix:
|
|
_logger.info("Found binding patches to be applied.")
|
|
|
|
return binding_fix
|
|
|
|
|
|
def _apply_version_patches():
|
|
"""
|
|
Apply version-only specific stylesheet patches for the same binding.
|
|
|
|
Returns:
|
|
str: stylesheet string (css).
|
|
"""
|
|
version_fix = ""
|
|
|
|
if version_fix:
|
|
_logger.info("Found version patches to be applied.")
|
|
|
|
return version_fix
|
|
|
|
|
|
def _apply_application_patches(QCoreApplication, QPalette, QColor):
|
|
"""
|
|
Apply application level fixes on the QPalette.
|
|
|
|
The import names args must be passed here because the import is done
|
|
inside the load_stylesheet() function, as QtPy is only imported in
|
|
that moment for setting reasons.
|
|
"""
|
|
# See issue #139
|
|
color = DarkPalette.COLOR_SELECTION_LIGHT
|
|
qcolor = QColor(color)
|
|
|
|
# Todo: check if it is qcoreapplication indeed
|
|
app = QCoreApplication.instance()
|
|
|
|
_logger.info("Found application patches to be applied.")
|
|
|
|
if app:
|
|
palette = app.palette()
|
|
palette.setColor(QPalette.Normal, QPalette.Link, qcolor)
|
|
app.setPalette(palette)
|
|
else:
|
|
_logger.warn("No QCoreApplication instance found. "
|
|
"Application patches not applied. "
|
|
"You have to call load_stylesheet function after "
|
|
"instantiation of QApplication to take effect. ")
|
|
|
|
|
|
def _load_stylesheet(qt_api=''):
|
|
"""
|
|
Load the stylesheet based on QtPy abstraction layer environment variable.
|
|
|
|
If the argument is not passed, it uses the current QT_API environment
|
|
variable to make the imports of Qt bindings. If passed, it sets this
|
|
variable then make the imports.
|
|
|
|
Args:
|
|
qt_api (str): qt binding name to set QT_API environment variable.
|
|
Default is ''. Possible values are pyside, pyside2
|
|
pyqt4, pyqt5. Not case sensitive.
|
|
|
|
Note:
|
|
- Note that the variable QT_API is read when first imported. So,
|
|
pay attention to the import order.
|
|
- If you are using another abstraction layer, i.e PyQtGraph to do
|
|
imports on Qt things you must set both to use the same Qt
|
|
binding (PyQt, PySide).
|
|
- OS, binding and binding version number, and application specific
|
|
patches are applied in this order.
|
|
|
|
Returns:
|
|
str: stylesheet string (css).
|
|
"""
|
|
|
|
if qt_api:
|
|
os.environ['QT_API'] = qt_api
|
|
|
|
# Import is made after setting QT_API
|
|
from qtpy.QtCore import QCoreApplication, QFile, QTextStream
|
|
from qtpy.QtGui import QColor, QPalette
|
|
|
|
# Then we import resources - binary qrc content
|
|
from qdarkstyle import style_rc
|
|
|
|
# Thus, by importing the binary we can access the resources
|
|
package_dir = os.path.basename(PACKAGE_PATH)
|
|
qss_rc_path = ":" + os.path.join(package_dir, QSS_FILE)
|
|
|
|
_logger.debug("Reading QSS file in: %s" % qss_rc_path)
|
|
|
|
# It gets the qss file from compiled style_rc that was import
|
|
# not from the file QSS as we are using resources
|
|
qss_file = QFile(qss_rc_path)
|
|
|
|
if qss_file.exists():
|
|
qss_file.open(QFile.ReadOnly | QFile.Text)
|
|
text_stream = QTextStream(qss_file)
|
|
stylesheet = text_stream.readAll()
|
|
_logger.info("QSS file sucessfuly loaded.")
|
|
else:
|
|
stylesheet = ""
|
|
# Todo: check this raise type and add to docs
|
|
raise FileNotFoundError("Unable to find QSS file '{}' "
|
|
"in resources.".format(qss_rc_path))
|
|
|
|
_logger.debug("Checking patches for being applied.")
|
|
|
|
# Todo: check execution order for these functions
|
|
# 1. Apply OS specific patches
|
|
stylesheet += _apply_os_patches()
|
|
|
|
# 2. Apply binding specific patches
|
|
stylesheet += _apply_binding_patches()
|
|
|
|
# 3. Apply binding version specific patches
|
|
stylesheet += _apply_version_patches()
|
|
|
|
# 4. Apply palette fix. See issue #139
|
|
_apply_application_patches(QCoreApplication, QPalette, QColor)
|
|
|
|
return stylesheet
|
|
|
|
|
|
def load_stylesheet(*args, **kwargs):
|
|
"""
|
|
Load the stylesheet. Takes care of importing the rc module.
|
|
|
|
Args:
|
|
pyside (bool): True to load the PySide (or PySide2) rc file,
|
|
False to load the PyQt4 (or PyQt5) rc file.
|
|
Default is False.
|
|
or
|
|
|
|
qt_api (str): Qt binding name to set QT_API environment variable.
|
|
Default is '', i.e PyQt5 the default QtPy binding.
|
|
Possible values are pyside, pyside2 pyqt4, pyqt5.
|
|
Not case sensitive.
|
|
|
|
Raises:
|
|
TypeError: If arguments do not match: type, keyword name nor quantity.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
|
|
stylesheet = ""
|
|
arg = None
|
|
|
|
try:
|
|
arg = args[0]
|
|
except IndexError:
|
|
# It is already none
|
|
pass
|
|
|
|
# Number of arguments are wrong
|
|
if (kwargs and args) or len(args) > 1 or len(kwargs) > 1:
|
|
raise TypeError("load_stylesheet() takes zero or one argument: "
|
|
"(new) string type qt_api='pyqt5' or "
|
|
"(old) boolean type pyside='False'.")
|
|
|
|
# No arguments
|
|
if not kwargs and not args:
|
|
stylesheet = _load_stylesheet(qt_api='pyqt5')
|
|
|
|
# Old API arguments
|
|
elif 'pyside' in kwargs or isinstance(arg, bool):
|
|
pyside = kwargs.get('pyside', arg)
|
|
|
|
if pyside:
|
|
stylesheet = _load_stylesheet(qt_api='pyside2')
|
|
if not stylesheet:
|
|
stylesheet = _load_stylesheet(qt_api='pyside')
|
|
|
|
else:
|
|
stylesheet = _load_stylesheet(qt_api='pyqt5')
|
|
if not stylesheet:
|
|
stylesheet = _load_stylesheet(qt_api='pyqt4')
|
|
|
|
# Deprecation warning only for old API
|
|
warnings.warn(DEPRECATION_MSG, DeprecationWarning)
|
|
|
|
# New API arguments
|
|
elif 'qt_api' in kwargs or isinstance(arg, str):
|
|
qt_api = kwargs.get('qt_api', arg)
|
|
stylesheet = _load_stylesheet(qt_api=qt_api)
|
|
|
|
# Wrong API arguments name or type
|
|
else:
|
|
raise TypeError("load_stylesheet() takes only zero or one argument: "
|
|
"(new) string type qt_api='pyqt5' or "
|
|
"(old) boolean type pyside='False'.")
|
|
|
|
return stylesheet
|
|
|
|
|
|
def load_stylesheet_pyside():
|
|
"""
|
|
Load the stylesheet for use in a PySide application.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
return _load_stylesheet(qt_api='pyside')
|
|
|
|
|
|
def load_stylesheet_pyside2():
|
|
"""
|
|
Load the stylesheet for use in a PySide2 application.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
return _load_stylesheet(qt_api='pyside2')
|
|
|
|
|
|
def load_stylesheet_pyqt():
|
|
"""
|
|
Load the stylesheet for use in a PyQt4 application.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
return _load_stylesheet(qt_api='pyqt4')
|
|
|
|
|
|
def load_stylesheet_pyqt5():
|
|
"""
|
|
Load the stylesheet for use in a PyQt5 application.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
return _load_stylesheet(qt_api='pyqt5')
|
|
|
|
|
|
# Deprecation Warning --------------------------------------------------------
|
|
|
|
|
|
def load_stylesheet_from_environment(is_pyqtgraph=False):
|
|
"""
|
|
Load the stylesheet from QT_API (or PYQTGRAPH_QT_LIB) environment variable.
|
|
|
|
Args:
|
|
is_pyqtgraph (bool): True if it is to be set using PYQTGRAPH_QT_LIB.
|
|
|
|
Raises:
|
|
KeyError: if PYQTGRAPH_QT_LIB does not exist.
|
|
|
|
Returns:
|
|
str: the stylesheet string.
|
|
"""
|
|
warnings.warn(DEPRECATION_MSG, DeprecationWarning)
|
|
|
|
if is_pyqtgraph:
|
|
stylesheet = _load_stylesheet(qt_api=os.environ('PYQTGRAPH_QT_LIB'))
|
|
else:
|
|
stylesheet = _load_stylesheet()
|
|
|
|
return stylesheet
|
|
|
|
|
|
# Deprecated ----------------------------------------------------------------
|