In addition, this fix includes Python-related fixes: because
of the short lifetime of Python references, the functionality
was not as expected sometimes. Keeping copies of LayerPropertiesIterators
helped. Some tweaks were required to maintain the delete() semantics.
The main fix was to not register the original class when
adding it as a child class. Otherwise duplication happened.
This requires sorting of some kind when generating the classes.
Some refactoring has been applied here.
Reimplementing virtual functions with
"const &" arguments wasn't behaving as
expected because these arguments were
copied.
Now, "const &" for arguments (in virtual
function reimplementation) is not implemented
as a copy.
In addition, now it's possible to declare
results as references always (also if const &).
See gsiTest.cc:1078 for example:
// gsi::arg_make_reference makes the function's return value
// always being taken as a reference
gsi::method<C_P, const CopyDetector &, const CopyDetector &, gsi::arg_make_reference> ("pass_cd_cref_as_ref", &C_P::pass_cd_cref)
Needed to refactor the class hierarchy of the Python classes.
Basically the module specific base class was removed as it does
not provide any benefit. The object layout of the PyObject
specialization was modified such that the payload is attached
to the end. This is compatible with the hidden extensions
which Python adds to normal objects.
- The deferred method scheduler is now automatically created
when required and when there is a QApplication
- QApplication and related have argv constructors
The issue is with "dllexport": previously, dllexport was present on
exposed templates tool (= visibility(default) for gcc/clang). This
ensured MacOS compatibility since then the typeinfo is corretly
shared and dynamic_cast/typeid works.
For Windows, the "dllexport" equivalent requires the template
instantiations to be declared "external" which is a coding nightmare.
The solution is to provide separate macros for real (non-specialized,
not explicitly instantiated) templates (.._PUBLIC_TEMPLATE) which
is defined as empty for Windows and "visiblity(default)" for gcc/clang.
1.) Startup issue:
This is solved by making sure templates with virtual functions
are made visible in the DSO. This way, dynamic_cast is possible
across DSO's.
Scary: clang/MacOS wants the forward declarations be declared visible as well.
2.) Menu issue:
The best solution is to have only one QMenuBar. The navigator
now gets a synthetic menu bar composed of QToolButtons.
The fix consisted of introducing "factory" type virtual
methods which ensure that a reference is held to the
returned object. This is important for implementing
factory methods in Python. Without this, the object
get destroyed before we have a chance to increment the
reference count.
This commit deals with the deployment issue on Windows
where there is no global Ruby/Python installation and
the installer needs to package all required files.
The solution is to read the Ruby/Python path from a
file that is evaluated upon startup. The installer will
install these files together with the executable for
Windows. This feature is only enabled on Windows.
A specific issue occured: since the location of the
file needs to be determined, the path of the executable
needs to be known. The Ruby initialization requires the
path to be set very early, before QCoreApplication is
instantiated. But Qt complains in QCoreApplication::applicationDirPath
so that this approach cannot be used for this purpose.
The problem is caused by an implementation detail:
To monitor the lifetime of Qt objects, a monitoring
object is attached to them. This used to happen through
child objects but attaching such issues QChildEvents
which - if routed over script objects - will itself
required objects to be attached a monitoring object.
The solution is to attach monitoring objects through
QObject dynamic properties.
* Salt packages can host native Ruby and Python
libraries now. The "ruby_lib" and "python_lib"
templates provide such native libraries.
This way we can basically wrap every native
extension in such a package.
* Ability to supply binary plugins through
Salt packages as well.
With this change it is possible to bind signals to functions
accepting less arguments. For example:
def triggered():
...
b = pya.QPushButton()
b.clicked(triggered)
b.emit_clicked(True)
wasn't working before since triggered() gets one parameter
(checked) and the call fails. Now, additional parameters are
ignored.
* The solution consists of attaching a bridge object
to QObjects. If the host object is destroyed, the
bridge object will notify the script client
* The bridge object attachment is optimized so it
only happens if required (but still too often ...)
* The child object of QChildEvent gets a special
handling since this object is almost dead in case
of remove. This special handling consists of
a special, stripped class which is used to
only represent QObject in that particular case.
Matthias Koefferlein
Thomas Ferreira de Lima
matthias