Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://mevislab.github.io/pythonqt/PythonQt_8h_source.html below:

PythonQt: PythonQt.h Source File

(

T*

(object))->_wrapper = wrapper;

T()

{

; }

T()

{

; }

T()

{

; }

((

*

(

T2*

(

T1*

(0x100))))

- (

*

(

T1*

(0x100))));

IgnoreSiteModule = 2,

PythonAlreadyInitialized = 8

Type_Subtract = 1 << 1,

Type_Multiply = 1 << 2,

Type_Divide = 1 << 3,

Type_LShift = 1 << 8,

Type_RShift = 1 << 9,

Type_InplaceAdd = 1 << 10,

Type_InplaceSubtract = 1 << 11,

Type_InplaceMultiply = 1 << 12,

Type_InplaceDivide = 1 << 13,

Type_InplaceMod = 1 << 14,

Type_InplaceAnd = 1 << 15,

Type_InplaceOr = 1 << 16,

Type_InplaceXor = 1 << 17,

Type_InplaceLShift = 1 << 18,

Type_InplaceRShift = 1 << 19,

Type_Length = 1 << 20,

Type_MappingSetItem = 1 << 21,

Type_MappingGetItem = 1 << 22,

Type_EnterExit = 1 << 23,

Type_Invert = 1 << 29,

Type_RichCompare = 1 << 30,

Type_NonZero = 1 << 31,

(

flags = IgnoreSiteModule | RedirectStdOut,

QByteArray& pythonQtModuleName = QByteArray());

(

* typeName,

* parentTypeName,

upcastingOffset=0);

QVariant

(

*

,

QString& callable,

QVariantList& args = QVariantList(),

QVariantMap& kwargs = QVariantMap());

QVariant

(

* callable,

QVariantList& args = QVariantList(),

QVariantMap& kwargs = QVariantMap());

initPythonQtModule(

redirectStdOut,

QByteArray& pythonQtModuleName);

QString getReturnTypeOfWrappedMethodHelper(

& variableObject,

QString& methodName,

QString& context);

* getObjectByType(

QString& typeName);

stdOutRedirectCB(

QString& str);

stdErrRedirectCB(

QString& str);

(

flags,

QByteArray& pythonQtModuleName);

_uniqueModuleCount;

ConstructorDecorator = 2,

DestructorDecorator = 4,

InstanceDecorator = 8,

AllDecorators = 0xffff

(

* typeName,

* parentTypeName,

upcastingOffset);

*

(

* ptr,

QByteArray& name,

passOwnership =

);

setupSharedLibrarySuffixes();

* packageByName(

* name);

QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;

QHash<QByteArray, PythonQtClassInfo *> _knownClassInfos;

QHash<QByteArray, bool> _knownQObjectClassNames;

QHash<QByteArray, QByteArray> _knownLazyClasses;

QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;

QByteArray _pythonQtModuleName;

QStringList _importIgnorePaths;

QStringList _sharedLibrarySuffixes;

QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;

QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;

QHash<QByteArray, PyObject*> _packages;

_PythonQtObjectPtr_metaId;

_PythonQtSafeObjectPtr_metaId;

_systemExitExceptionHandlerEnabled;

QString PythonQtInputChangedCB(void *callData)

declares the callback that is called from the write() function

int PythonQtUpcastingOffset()

returns the offset that needs to be added to upcast an object of type T1 to T2

QObject * PythonQtCreateObject()

helper template to create a derived QObject class

void PythonQtQObjectWrappedCB(QObject *object)

void PythonQtShellSetInstanceWrapperCB(void *object, PythonQtInstanceWrapper *wrapper)

void * PythonQtPolymorphicHandlerCB(const void *ptr, const char **class_name)

void PythonQtVoidPtrCB(void *object)

QString PythonQtQObjectMissingAttributeCB(QObject *object, const QString &attribute)

void PythonQtQObjectNoLongerWrappedCB(QObject *object)

void PythonQtSetInstanceWrapperOnShell(void *object, PythonQtInstanceWrapper *wrapper)

QObject * PythonQtQObjectCreatorFunctionCB()

callback to create a QObject lazily

a class that stores all required information about a Qt object (and an optional associated C++ class ...

Some methods to set properties of PythonQt from Python.

Factory interface for C++ classes that can be wrapped by QObject objects.

Some helper methods that allow testing of the ownership.

stores information about a specific signal/slot/method

PythonQtNewOwnerOfThis(const T &t)

Allow conversion from T to PythonQtNewOwnerOfThis<T>

a smart pointer that stores a PyObject pointer and that handles reference counting automatically

PythonQtPassOwnershipToCPP(const T &t)

Allow conversion from T to PythonQtPassOwnershipToCPP<T>

PythonQtPassOwnershipToPython(const T &t)

Allow conversion from T to PythonQtPassOwnershipToPython<T>

internal PythonQt details

void * unwrapForeignWrapper(const QByteArray &classname, PyObject *obj)

try to unwrap the given object to a C++ pointer using the foreign wrapper factories

void handleVirtualOverloadReturnError(const char *signature, const PythonQtMethodInfo *methodInfo, PyObject *result)

called by virtual overloads when a python return value can not be converted to the required Qt type

static PyObject * wrapMemoryAsBuffer(const void *data, Py_ssize_t size)

create a read-only buffer object from the given memory

void registerClass(const QMetaObject *metaobject, const char *package=nullptr, PythonQtQObjectCreatorFunctionCB *wrapperCreator=nullptr, PythonQtShellSetInstanceWrapperCB *shell=nullptr, PyObject *module=nullptr, int typeSlots=0)

registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)

const QMetaObject * setupDynamicMetaObjectChain(PythonQtClassWrapper *type, const QMetaObject *prototypeMetaObject)

recursively creates the dynamic meta object chain down to the Qt class wrapper.

PythonQtClassWrapper * createNewPythonQtClassWrapper(PythonQtClassInfo *info, PyObject *module, const QByteArray &pythonClassName)

helper method that creates a PythonQtClassWrapper object (returns a new reference)

void registerQObjectClassNames(const QStringList &names)

const QStringList & sharedLibrarySuffixes()

get the suffixes that are used for shared libraries

void removeWrapperPointer(void *obj)

remove the wrapper ptr again

void setTaskDoneCallback(const PythonQtObjectPtr &callable)

int handleMetaCall(QObject *object, PythonQtInstanceWrapper *wrapper, QMetaObject::Call call, int id, void **args)

redirected from shell classes, tries to call the given meta call on the Python wrapper.

PyObject * wrapQObject(QObject *obj)

wrap the given QObject into a Python object (or return existing wrapper!)

void addPolymorphicHandler(const char *typeName, PythonQtPolymorphicHandlerCB *cb)

add a handler for polymorphic downcasting

static PyObject * createNewPythonQtEnumWrapper(const char *enumName, PyObject *parentObject)

helper that creates a new int derived class that represents the enum of the given name (returns a new...

bool isMethodDescriptor(PyObject *object) const

returns true if the object is a method descriptor (same as inspect.ismethoddescriptor() in inspect....

void registerCPPClass(const char *typeName, const char *parentTypeName=nullptr, const char *package=nullptr, PythonQtQObjectCreatorFunctionCB *wrapperCreator=nullptr, PythonQtShellSetInstanceWrapperCB *shell=nullptr, PyObject *module=nullptr, int typeSlots=0)

static PyObject * wrapMemoryAsBuffer(void *data, Py_ssize_t size)

create a read-write buffer object from the given memory

bool addParentClass(const char *typeName, const char *parentTypeName, int upcastingOffset)

add parent class relation

PythonQtObjectPtr pythonQtModule() const

get access to the PythonQt module

bool isPythonQtSafeObjectPtrMetaId(int id)

returns if the id is the id for PythonQtSafeObjectPtr

PythonQtClassInfo * currentClassInfoForClassWrapperCreation()

get the current class info (for the next PythonQtClassWrapper that is created) and reset it to NULL a...

QString getSignature(PyObject *object)

determines the signature of the given callable object (similar as pydoc)

PythonQtObjectPtr checkAndRunCoroutine(const PythonQtObjectPtr &object)

Runs the given coroutine (via asyncio), returns a scheduled task if it object is a coroutine.

bool isPythonQtObjectPtrMetaId(int id)

returns if the id is the id for PythonQtObjectPtr

PythonQtClassInfo * lookupClassInfoAndCreateIfNotPresent(const char *typeName)

lookup existing classinfo and return new if not yet present

PythonQtObjectPtr createModule(const QString &name, PyObject *pycode)

creates the new module from the given pycode

void callMethodInPython(QMetaMethod &method, PythonQtInstanceWrapper *wrapper, void **args)

calls the given method on Python function with same name.

bool isPythonQtAnyObjectPtrMetaId(int id)

returns if the id is either PythonQtObjectPtr or PythonQtSafeObjectPtr

const QMetaObject * buildDynamicMetaObject(PythonQtClassWrapper *type, const QMetaObject *prototypeMetaObject)

builds and returns the dynamic meta object for the given type, derived from prototypeMetaObject.

void registerLazyClass(const QByteArray &name, const QByteArray &moduleToImport)

const QMetaObject * getDynamicMetaObject(PythonQtInstanceWrapper *wrapper, const QMetaObject *prototypeMetaObject)

get the dynamic meta object for the given wrapper. It will contain the signals/slots that have been a...

static PyObject * createEnumValueInstance(PyObject *enumType, unsigned int enumValue)

create a new instance of the given enum type with given value (returns a new reference)

static PyObject * dummyTuple()

the dummy tuple (which is empty and may be used to detected that a wrapper is called from internal wr...

PyObject * wrapPtr(void *ptr, const QByteArray &name, bool passOwnership=false)

void addWrapperPointer(void *obj, PythonQtInstanceWrapper *wrapper)

add the wrapper pointer (for reuse if the same obj appears while wrapper still exists)

PythonQtClassInfo * getClassInfo(const QMetaObject *meta)

get the class info for a meta object (if available)

void shellClassDeleted(void *shellClass)

called by destructor of shells to allow invalidation of the Python wrapper

void registerGlobalNamespace(const char *typeName, const char *package, PythonQtQObjectCreatorFunctionCB *wrapperCreator, const QMetaObject &metaObject, PyObject *module=nullptr)

Same as above, but all enums of the created wrapper will also be added to the given package and to th...

PythonQtObjectPtr createAsyncioFuture()

Creates a new asyncio.Future object.

void removeSignalEmitter(QObject *obj)

called when a signal emitting QObject is destroyed to remove the signal handler from the hash map

void addDecorators(QObject *o, int decoTypes)

add a decorator object

~PythonQtPrivate() override

PythonQtClassInfo * getClassInfo(const QByteArray &className)

get the class info for a meta object (if available)

PythonQtInstanceWrapper * createNewPythonQtInstanceWrapper(QObject *obj, PythonQtClassInfo *info, void *wrappedPtr=nullptr)

helper method that creates a PythonQtInstanceWrapper object and registers it in the object map

PythonQt::ProfilingCB * profilingCB() const

returns the profiling callback, which may be NULL

default importer implementation using QFile to load python code

receives all signals for one QObject

The main interface to the Python Qt binding, realized as a singleton.

QVariant call(PyObject *object, const QString &callable, const QVariantList &args=QVariantList(), const QVariantMap &kwargs=QVariantMap())

call the given python callable in the scope of object, returns the result converted to a QVariant

PythonQtObjectPtr lookupCallable(PyObject *object, const QString &name)

static QString qObjectMissingAttributeCallback(QObject *o, const QString &attribute)

call the callback if it is set

void systemExitExceptionRaised(int exitCode)

void evalFile(PyObject *object, const QString &filename)

evaluates the given script code from file

void addInstanceDecorators(QObject *o)

bool removeSignalHandler(QObject *obj, const char *signal, PyObject *receiver)

remove a signal handler from the given signal of obj

PythonQtObjectPtr createModuleFromFile(const QString &name, const QString &filename)

void setQObjectMissingAttributeCallback(PythonQtQObjectMissingAttributeCB *cb)

set a callback that is called when a QObject does not have a specific attribute.

void setSystemExitExceptionHandlerEnabled(bool value)

void addClassDecorators(QObject *o)

PythonQtObjectPtr importModule(const QString &name)

InitFlags

flags that can be passed to PythonQt::init()

QString getReturnTypeOfWrappedMethod(const QString &typeName, const QString &methodName)

returns the return type of the method methodName of a wrapped c++ type referenced by typeName

static void init(int flags=IgnoreSiteModule|RedirectStdOut, const QByteArray &pythonQtModuleName=QByteArray())

ObjectType

defines the object types for introspection

ProfilingCallbackState

enum for profiling callback

static void cleanup()

cleanup of the singleton

static void setEnableThreadSupport(bool flag)

void registerCPPClass(const char *typeName, const char *parentTypeName=nullptr, const char *package=nullptr, PythonQtQObjectCreatorFunctionCB *wrapperCreator=nullptr, PythonQtShellSetInstanceWrapperCB *shell=nullptr)

void addSysPath(const QString &path)

prepend a path to sys.path to allow importing from it

TypeSlots

flags that tell PythonQt which operators to expect on the registered type

bool addParentClass(const char *typeName, const char *parentTypeName, int upcastingOffset=0)

bool hadError() const

return true if handleError() has been called and an error occurred.

void registerQObjectClassNames(const QStringList &names)

void addWrapperFactory(PythonQtCppWrapperFactory *factory)

add the given factory to PythonQt (ownership stays with caller)

PythonQtObjectPtr parseFile(const QString &filename)

parses the given file (using PythonQt's own import mechanism) and returns the python code object,...

void registerClass(const QMetaObject *metaobject, const char *package=nullptr, PythonQtQObjectCreatorFunctionCB *wrapperCreator=nullptr, PythonQtShellSetInstanceWrapperCB *shell=nullptr)

registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)

void setRedirectStdInCallbackEnabled(bool enabled)

void removeVariable(PyObject *module, const QString &name)

remove the given variable

void removeWrapperFactory(PythonQtCppWrapperFactory *factory)

remove the wrapper factory

bool addSignalHandler(QObject *obj, const char *signal, PyObject *receiver)

add a signal handler to the given signal of obj and connect it to a callable receiver

QVariant getNativeVariable(PyObject *object, const QString &name)

get the variable with the name of the object as QVariant of type PythonQtObjectPtr,...

QVariant evalScript(const QString &script, PyObject *globals, PyObject *locals, int start)

evaluates the given script code in context of given globals and locals and returns the result value

QVariant evalCode(PyObject *object, PyObject *pycode)

QVariant evalScript(PyObject *object, const QString &script, int start=Py_file_input)

evaluates the given script code and returns the result value

static void qObjectNoLongerWrappedCB(QObject *o)

call the callback if it is set

void setRedirectStdInCallback(PythonQtInputChangedCB *callback, void *callbackData=nullptr)

const QStringList & getImporterIgnorePaths()

get paths that the importer should ignore

void setImporter(PythonQtImportFileInterface *importInterface)

PythonQtObjectPtr createModuleFromScript(const QString &name, const QString &script=QString())

QStringList introspection(PyObject *object, const QString &objectname, ObjectType type)

read vars etc. in scope of an object, optional looking inside of an object objectname

void addObject(PyObject *object, const QString &name, QObject *qObject)

add the given qObject to the python object as a variable with name (it can be removed via clearVariab...

void pythonStdErr(const QString &str)

emitted when python outputs something to stderr (and redirection is turned on)

void installDefaultImporter()

void addPolymorphicHandler(const char *typeName, PythonQtPolymorphicHandlerCB *cb)

add a handler for polymorphic downcasting

PyObject * helpCalled(PythonQtClassInfo *info)

called by internal help methods

void setModuleImportPath(PyObject *module, const QStringList &paths)

sets the path list of a module to the given list (important for local imports)

void removeSignalHandlers()

globally removes all signal handlers (connections between QObjects and Python).

void addVariable(PyObject *object, const QString &name, const QVariant &v)

add the given variable to the object

PythonQtObjectPtr getMainModule()

get the main module of python

void addDecorators(QObject *o)

this will add the object both as class and instance decorator (ownership is passed to PythonQt)

void setQObjectWrappedCallback(PythonQtQObjectWrappedCB *cb)

set a callback that is called when a QObject with parent == NULL is wrapped by PythonQt

QVariant call(PyObject *callable, const QVariantList &args=QVariantList(), const QVariantMap &kwargs=QVariantMap())

call the given python object, returns the result converted to a QVariant

bool systemExitExceptionHandlerEnabled() const

void addWrapperFactory(PythonQtForeignWrapperFactory *factory)

add the given factory to PythonQt (ownership stays with caller)

QVariant getVariable(PyObject *object, const QString &name)

get the variable with the name of the object, returns an invalid QVariant on error

void removeWrapperFactory(PythonQtForeignWrapperFactory *factory)

remove the wrapper factory

static PythonQtPrivate * priv()

get access to internal data (should not be used on the public API, but is used by some C functions)

PythonQtObjectPtr lookupObject(PyObject *module, const QString &name)

void setImporterIgnorePaths(const QStringList &paths)

set paths that the importer should ignore

void pythonHelpRequest(const QByteArray &cppClassName)

emitted when help() is called on a PythonQt object and ExternalHelp is enabled

bool removeSignalHandler(QObject *obj, const char *signal, PyObject *module, const QString &objectname)

remove a signal handler from the given signal of obj

PyObject * callAndReturnPyObject(PyObject *callable, const QVariantList &args=QVariantList(), const QVariantMap &kwargs=QVariantMap())

call the given python object, returns the result as new PyObject

QString getReturnTypeOfWrappedMethod(PyObject *module, const QString &objectname)

returns the return type of the method of a wrapped c++ object referenced by objectname

bool addSignalHandler(QObject *obj, const char *signal, PyObject *module, const QString &objectname)

add a signal handler to the given signal of obj and connect it to a callable objectname in module

void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB *cb)

set a callback that is called when a QObject with parent == NULL is no longer wrapped by PythonQt

static PythonQtImportFileInterface * importInterface()

get access to the file importer (if set)

PythonQtObjectPtr parseFileWithPythonLoaders(const QString &filename)

void pythonStdOut(const QString &str)

emitted when python outputs something to stdout (and redirection is turned on)

void overwriteSysPath(const QStringList &paths)

overwrite the python sys path (call this directly after PythonQt::init() if you want to change the st...

void ProfilingCB(ProfilingCallbackState state, const char *className, const char *methodName, PyObject *args)

static PythonQt * self()

get the singleton instance

QStringList introspectObject(PyObject *object, ObjectType type)

read vars etc. in scope of the given object

void clearNotFoundCachedMembers()

bool handleError(bool printStack=true)

PythonQtObjectPtr createUniqueModule()

QStringList introspectType(const QString &typeName, ObjectType type)

void setProfilingCallback(ProfilingCB *cb)

sets a callback that is called before and after function calls for profiling

a Python wrapper object for Qt objects and C++ objects (that are themselves wrapped by wrapper QObjec...

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4