Classes
class	Error

class	PyQtClass

class	PyQtMethod

class	PyQtProperty

Functions
	convert_value (value)

	create_pyqt_class (metaobject)

	create_pyqt_object (obj)

	from_variant (variant)

	is_qobject (obj)

	is_scripter_child (qobj)

	unwrap (obj)

	wrap (obj, force=False)

	wrap_variant_object (variant)

Variables
dict	pyqt_classes = {}

dict	qtclasses = {}

dict	variant_converter

Detailed Description

SPDX-FileCopyrightText: 2016 Boudewijn Rempt <boud@valdyas.org>

SPDX-License-Identifier: LGPL-2.0-or-later

Function Documentation

◆ convert_value()

mikro.convert_value ( value )

Convert a given value, upcasting to the highest QObject-based class if possible,
unpacking lists and dicts.

Definition at line 92 of file mikro.py.

def convert_value(value):
    """
    Convert a given value, upcasting to the highest QObject-based class if possible,
    unpacking lists and dicts.
    """
 
    # Check whether it's a dict: if so, convert the keys/values
    if hasattr(value, '__class__') and issubclass(value.__class__, dict) and len(value) > 0:
        return {convert_value(k): convert_value(v) for k, v in value.items()}
 
    # Check whether it's a list: if so, convert the values
    if hasattr(value, '__class__') and issubclass(value.__class__, list) and len(value) > 0:
        return [convert_value(v) for v in value]
 
    if isinstance(value, str):
        # prefer Python strings
        return str(value)
 
    elif isinstance(value, PyQtClass):
        # already wrapped
        return value
 
    # Check whether it's a QObject
    if hasattr(value, '__class__') and issubclass(value.__class__, QObject):
        return wrap(value, True)
 
    if hasattr(value, '__type__') and not (value is None or value.type() is None):
        return from_variant(value)
 
    return value
 

References convert_value(), from_variant(), and wrap().

◆ create_pyqt_class()

mikro.create_pyqt_class ( metaobject )

Definition at line 356 of file mikro.py.

def create_pyqt_class(metaobject):
    class_name = str(metaobject.className())
    cls = pyqt_classes.get(class_name)
    if cls:
        return cls
    attrs = {}
 
    properties = attrs["__properties__"] = {}
    for i in range(metaobject.propertyCount()):
        prop = PyQtProperty(metaobject.property(i))
        prop_name = str(prop.name)
        if prop.read_only:
            properties[prop_name] = attrs[prop_name] = property(prop.get, doc=prop.__doc__)
        else:
            properties[prop_name] = attrs[prop_name] = property(
                prop.get, prop.set, doc=prop.__doc__)
 
    methods = attrs["__methods__"] = {}
    signals = attrs["__signals__"] = {}
    for i in range(metaobject.methodCount()):
        meta_method = metaobject.method(i)
        if meta_method.methodType() != QMetaMethod.MethodType.Signal:
            method = PyQtMethod(meta_method)
            method_name = method.name
            if method_name in attrs:
                # There is already a property with this name
                # So append an underscore
                method_name += "_"
            instance_method = method.instancemethod()
            instance_method.__doc__ = method.__doc__
            methods[method_name] = attrs[method_name] = instance_method
        else:
            method_name = meta_method.name()
            signal_attrs = []
            properties[bytes(method_name).decode('ascii')] = pyqtSignal(meta_method.parameterTypes())
 
    # Dynamically create a class with a base class and a dictionary
    cls = type(class_name, (PyQtClass,), attrs)
    pyqt_classes[class_name] = cls
    return cls
 
 

◆ create_pyqt_object()

mikro.create_pyqt_object ( obj )

 Wrap a QObject and make all slots and properties dynamically available.
 @type obj:  QObject
 @param obj: an unwrapped QObject
 @rtype:     PyQtClass object
 @return:    dynamically created object with all available properties and slots

 This is probably the only function you need from this module.
 Everything else are helper functions and classes.

Definition at line 398 of file mikro.py.

def create_pyqt_object(obj):
    """
     Wrap a QObject and make all slots and properties dynamically available.
     @type obj:  QObject
     @param obj: an unwrapped QObject
     @rtype:     PyQtClass object
     @return:    dynamically created object with all available properties and slots
 
     This is probably the only function you need from this module.
     Everything else are helper functions and classes.
    """
    cls = create_pyqt_class(obj.metaObject())
    return cls(obj)

References create_pyqt_class().

◆ from_variant()

mikro.from_variant ( variant )

convert a QVariant to a Python value

Definition at line 74 of file mikro.py.

def from_variant(variant):
    """
    convert a QVariant to a Python value
    """
    # Check whether it's really a QVariant
    if hasattr(variant, '__type__') and not (variant is None or variant.type() is None):
        typeName = variant.typeName()
        convert = variant_converter.get(typeName)
        if not convert:
            raise ValueError("Could not convert value to %s" % typeName)
        else:
            v = convert(variant)
            return v
 
    # Give up and return
    return variant
 
 

◆ is_qobject()

mikro.is_qobject ( obj )

checks if class or wrapped class is a subclass of QObject

Definition at line 158 of file mikro.py.

def is_qobject(obj):
    """
    checks if class or wrapped class is a subclass of QObject
    """
    if hasattr(obj, "__bases__") and issubclass(unwrap(obj), QObject):
        return True
    else:
        return False
 
 

References unwrap().

◆ is_scripter_child()

mikro.is_scripter_child ( qobj )

walk up the object tree until Scripter or the root is found

Definition at line 168 of file mikro.py.

def is_scripter_child(qobj):
    """
    walk up the object tree until Scripter or the root is found
    """
    found = False
    p = qobj.parent()
    while p and not found:
        if str(p.objectName()) == "Krita":
            found = True
            break
        else:
            p = p.parent()
    return found
 
 

◆ unwrap()

mikro.unwrap ( obj )

if wrapped returns the wrapped object

Definition at line 149 of file mikro.py.

def unwrap(obj):
    """
    if wrapped returns the wrapped object
    """
    if hasattr(obj, "qt"):
        obj = obj.qt
    return obj
 
 

◆ wrap()

mikro.wrap	(		obj,
			force = False )

If a class is not known by PyQt it will be automatically
casted to a known wrapped super class.

But that limits access to methods and properties of this super class.
So instead this functions returns a wrapper class (PyQtClass)
which queries the metaObject and provides access to
all slots and all properties.

Definition at line 126 of file mikro.py.

def wrap(obj, force=False):
    """
    If a class is not known by PyQt it will be automatically
    casted to a known wrapped super class.
 
    But that limits access to methods and properties of this super class.
    So instead this functions returns a wrapper class (PyQtClass)
    which queries the metaObject and provides access to
    all slots and all properties.
    """
    if isinstance(obj, str):
        # prefer Python strings
        return str(obj)
    elif isinstance(obj, PyQtClass):
        # already wrapped
        return obj
    elif obj and isinstance(obj, QObject):
        if force or obj.__class__.__name__ != obj.metaObject().className():
            # Ah this is an unwrapped class
            obj = create_pyqt_object(obj)
    return obj
 
 

References create_pyqt_object().

◆ wrap_variant_object()

mikro.wrap_variant_object ( variant )

convert a QObject or a QWidget to its wrapped superclass

Definition at line 66 of file mikro.py.

def wrap_variant_object(variant):
    """
    convert a QObject or a QWidget to its wrapped superclass
    """
    o = Krita.fromVariant(variant)
    return wrap(o, True)
 
 

References Krita.fromVariant(), and wrap().

Variable Documentation

◆ pyqt_classes

dict mikro.pyqt_classes = {}

Definition at line 353 of file mikro.py.

◆ qtclasses

dict mikro.qtclasses = {}

Definition at line 123 of file mikro.py.

◆ variant_converter

dict mikro.variant_converter

Initial value:

=  {
    "QVariantList": lambda v: v.toList(v),
    "QVariantMap": lambda v: toPyObject(v),
    "QPoint": lambda v: v.toPoint(),
    "str": lambda v: v.toString(),
    "int": lambda v: v.toInt()[0],
    "double": lambda v: v.toDouble()[0],
    "char": lambda v: v.toChar(),
    "QByteArray": lambda v: v.toByteArray(),
    "QPoint": lambda v: v.toPoint(),
    "QPointF": lambda v: v.toPointF(),
    "QSize": lambda v: v.toSize(),
    "QLine": lambda v: v.toLine(),
    "QStringList": lambda v: v.toStringList(),
    "QTime": lambda v: v.toTime(),
    "QDateTime": lambda v: v.toDateTime(),
    "QDate": lambda v: v.toDate(),
    "QLocale": lambda v: v.toLocale(),
    "QUrl": lambda v: v.toUrl(),
    "QRect": lambda v: v.toRect(),
    "QBrush": lambda v: QBrush(v),
    "QFont": lambda v: QFont(v),
    "QPalette": lambda v: QPalette(v),
    "QPixmap": lambda v: QPixmap(v),
    "QImage": lambda v: QImage(v),
    "bool": lambda v: v.toBool(),
    "QObject*": lambda v: wrap_variant_object(v),
    "QWidget*": lambda v: wrap_variant_object(v),
    "ActionMap": lambda v: int(v.count())
}

Definition at line 34 of file mikro.py.

Classes

Functions

Variables