This page contains notes on a research I am doing to see if it is possible to bring QtGLib closer to Qt, make it more generic and more feature-complete, so that it can be used for anything besides GStreamer. The bullets below describe possible solutions to the various problems that have been showstoppers until now.

== GValue <-> QVariant ==

 * Converting GValue to QVariant:
  * For native types: switch() and convert.
  * For Object/Interface/ParamSpec pointers: --(Store a QGlib::Value into the QVariant and provide template specializations for QVariant::value / qvariant_cast / qVariantValue (qt4 only) that will convert using QGlib::Value::get)-- Screw that. There is no such thing as function template partial specializations.
  * For Enum/Flag types: See below
  * For G_TYPE_POINTER: convert to QMetaType::!VoidStar
  * For Boxed types: provide hooks
 * Converting QVariant to GValue:
  * For native types: ditto.
  * If the QVariant contains a QGlib::Value (object/interface/paramspec ptr that comes from a method in the bindings): obvious.
  * For Object/Interface/ParamSpec pointers: --(Override QVariant::setValue / QVariant::fromValue / qVariantFromValue / qVariantSetValue to store a QGlib::Value directly into the QVariant -> as a result there will be no way to have a QVariant that stores an !ObjectPtr directly.)--
  * For Enum/Flag types: See below
  * For void* / QObject*: store into a G_TYPE_POINTER GValue. Unfortunately we can't do much about other kinds of pointers.
  * For Boxed types: provide hooks

 * Enums/Flags:
  * --(Method 1: Store them as QGlib::Value inside the QVariant and provide template specializations for all the related QVariant methods (using type traits) which will convert to/from QGlib::Value, just like with the object types.)--
   * --(Requires tagging template-wise all the enums/flags that belong to the bindings)--
   * --(Requires also handling other kinds of enums/flags by copying QVariant's own implementation of those methods inside the specializations.)--
  * Method 2: Register qMetaTypeId<enum> <-> GType pairs in global hashtables and convert like native types.

 * Problems:
  * QVariant::convert / QVariant::canConvert will not work correctly. This will need to be documented.
  * QVariant::value will also do conversions for types that a QGlib::Value is stored inside the variant. This is wanted for object types, but maybe not for enums/flags (+ not all conversions may be wanted).
  * QVariant::userType() will always return qMetaTypeId<QGlib::Value> for all object types...
  * Pointer types are a bit problematic... Imagine setting a !VideoWidget* to the "widget" property of qwidgetvideosink. The latter expects a G_TYPE_POINTER, but the conversion cannot be made automatically.

 * Bonus:
  * With QVariant method specializations for QGlib::Value, it will be easy to get the original GValue from a QVariant.

== GObject <-> QObject ==

 * A QMetaObject needs to be generated for every GObject subclass.
  * Can be generated either at runtime or at compile time, but the runtime part has to be there anyway so that we can use signals/slots with classes that are unknown at compile time (gst elements...).
  * It can either be generated from GI or by introspecting manually the signals/properties of a class. The advantage of GI is that we can also bind non-signal methods as Q_SLOTS, although I'm not sure if we want this.
  * There is a QMetaObjectBuilder class in various places (including !QtCore in qt5), but it's not public. -> Copy until it becomes public.
  * Store the metaobject in the GType quark data, since it is not static data in the binary.
 * We need an ObjectBase superclass that will inherit QObject and will define the moc methods:
  * !ObjectBase::metaObject:
   * return g_type_get_qdata(G_TYPE_FROM_INSTANCE(m_object), "_QGLib_QMetaObject");
  * !ObjectBase::qt_metacast:
   * Easy to implement, get the QMetaObject and compare class names like the moc-generated qt_metacast does.
  * !ObjectBase::qt_metacall:
   * For method (signal) calls, we need to convert the void* array to a GValue array and emit the signal. See below.
   * For property reads/writes, we need to convert GValue to/from QVariant. See above.
   * Ignore anything else.
  * !ObjectBase::connectNotify:
   * This is not a moc-generated method, but needs to be overriden so that we know when somebody has connected to a GObject signal.
   * Connect a generic GClosure on the real signal with a marshaller that converts the GValue array to a void* array and calls QMetaObject::activate.
   * ''' BIG POSSIBLE ISSUE HERE: I have never seen QObject signals having return values. We need to check if this is supported '''
    * Turns out it is supported, but does not blend in very well. The return value is not part of the function signature check + you would have to write something like  int r = Q_EMIT foobar(); (or whatever... Q_EMIT is a dummy macro that doesn't do anything at all anyway, but most people think it does magic and probably wouldn't know how to use it in a case like this)

=== void* <-> GValue ===

 * QObject::qt_metacall uses a void* array that contains pointers to the actual parameters of the signal. Moc normally knows about their types, so it does a reinterpret_cast<foo*> and writes on them. In our case, we don't know the types, so we have to do some extra work:
  * For native types (int/long/string/etc...): switch() and convert appropriately.
  * Strings will always be mangled as QStrings, so the dillema with const char* and QByteArray is gone.
  * For pointer types: assume void* and convert like the other native types.
  * For Object/Interface/ParamSpec types: The target will always be a RefPointer<SomeObjectClass>, which has constant size because it contains only a SomeObjectClass* member, so we can reinterpret_cast to RefPointer<RefCountedObject*> and be done with it.
   * This requires changing RefPointer to hold a RefCountedObject* instead of a T* because the pointer might be different for interfaces etc due to multiple inheritance
  * For Boxed types: We need to provide conversion hooks.
  * For enums: Enums don't necessarily have a constant size. They are required to have the size of an integer type, but it can be anything. Solution:
   * For generated static bindings, pad all enums to the size of int and use reinterpret_cast<int*> to write in them. This will also need static assertions at compile time to make sure that all the enums used in the bindings have the same size.
   * For enums that are not known at compile time (say an enum in a gst element), we will let QMetaObject present the argument as being a simple int.
  * For flags: QFlag is just an int, so we can use reinterpret_cast<int*> here as well.
   * For flags that are not known at compile time, do the same as with enums.

== Callbacks ==

 * For every function that takes a callback argument, the public bindings interface will need two functions:
  * A template one that takes a functor as an argument
  * A non-template one that takes a functor wrapper as an argument. The functor wrapper will have some standard interface for calling the functor using a void* array for the arguments. See QSlotObject in qt5's qobject.h to understand what I have in mind.
 * The non-template method will internally have a C callback that will take the functor wrapper in its user_data argument, will convert between C types and C++ types and will call the functor.

 * For dynamic bindings (in case we do that), we can assume that the caller already gives us a functor wrapper as a void*.
  * Step 1: cast to functor wrapper
  * Step 2: generate a C callback using libffi and g-i which will in turn call a generic callback marshaller
  * Step 3: pass the functor and the GIFooInfo (whatever is needed) to the marshaller in its user_data argument.
  * Step 4: pass the generated C callback down to the C method call.
  * Now when our callback is called, the generic callback marshaller will be invoked and all that it will need to do is to convert from C types (given in a void* array) to C++ types (which will also be given to the functor in a void* array).
   * This can basically be done the same way it is done for void* <-> GValue conversion, only that there is no GValue. Not sure if enums coming from the C interface can be trusted to have a specific size, though.

== Subclassing ==

One solution might be the following:

 * Make a subclass that inherits from the wrapper class type that we want to inherit in C, i.e. class MyElement : public QGst::Element
 * Force the programmer to use some macro or even write some very small piece of code that will implement the _get_type() function
  * This will internally register the GType using some boilerplate code wrapped up somewhere in QtGLib
  * This will also need to add the interfaces on the GType, which may be possible to do with some template magic on the list of inherited classes
  * This will also have to register the Foo_new function that is currently used for the wrapping system
 * Implement virtual functions by declaring protected Q_SLOTS with a certain name, for example: vfunc_addElement for GstBin's add_element vfunc.
 * The boilerplate class_init function will use the staticMetaObject to introspect the available slots and for every vfunc_* slot that matches some vfunc in C (use GI to find out what is available) it will generate a C function using libffi that will call some dispatcher which in turn will call the slot using the QMetaObject api.
  * This adds the convenience that nothing has to be declared as virtual on the C++ side, since slots are virtual by design.