Qt bindings for D

[Max Samukha]

On Tuesday, 22 October 2013 at 21:01:49 UTC, w0rp wrote:
> On Wednesday, 16 October 2013 at 09:56:21 UTC, Max Samukha 
> wrote:
>> On Wednesday, 16 October 2013 at 07:25:08 UTC, w0rp wrote:
>>> On Wednesday, 16 October 2013 at 06:53:24 UTC, Jacob Carlborg 
>>> wrote:
>>>> In D, using the GC, you can call GC.addRoot to avoid that 
>>>> problem.
>>>
>>> Yes, I was thinking of using core.memory stuff to stop things 
>>> from being collected, or perhaps scan inside Qt memory. For 
>>> instance, you could store a class pointer inside of a QObject 
>>> with setProperty. One option is to have QObject in D hold an 
>>> array of pointers for keeping references to children, etc. 
>>> There are some tricky parts.
>>>
>>> ---
>>> // Okay, this is a root object, when do we collect this?
>>> auto widget = new QWidget();
>>>
>>> // This is just a free object, not attached to anything.
>>> // Clearly we can collect this.
>>> auto label = new QLabel("Hello!");
>>>
>>> auto layout = new QHBoxLayout;
>>>
>>> layout.addWidget(label);
>>>
>>> // Wait, now label implicitly becomes a child object of 
>>> widget.
>>> // its memory is now managed by that, so when do we collect 
>>> it?
>>> widget.setLayout(layout);
>>>
>>> // Does this work?
>>> assert(label.parent is widget);
>>> ---
>>>
>>> So in other words, I haven't yet reached a point where I 
>>> think, "Yes, I have covered every case and I'm happy."
>>
>> I've ended up with a system that would not allocate Qt objects 
>> on the GC heap at all:
>>
>> // This would be destroyed at the end of the scope,
>> auto widget = scoped!QWidget;
>>
>> // Or, if we allocate the object on heap, we should care
>> // to destroy it unless Qt takes ownership at some point after
>> // construction.
>> auto widget = make!QWidget;
>> ...
>> dispose(widget);
>>
>> auto widget = make!QLabel("Hello!");
>> auto layout = make!QHBoxLayout;
>>
>> // Safe to pass ownership to parent because no GC is involved.
>> layout.addWidget(label);
>> // ditto
>> widget.setLayout(layout);
>>
>>
>> // This would work because references to polymorphic Qt 
>> objects are
>> // implemented as tagged pointers, and in this case
>> // both references would point to the same C++ object.
>> assert(label.parent is widget);
>>
>> In other words, you manage memory the same way you do in Qt.
>>
>> Advantages:
>> - Noticeable simplification of the generator and bindings.
>> - Performance - no redundant copies, hash lookups, etc.
>> - Fewer problems with multithreading.
>>
>> Disadvantages:
>> - You have to be as careful about memory management as you are 
>> in Qt.
>> - Implementation requires a debugged D compiler, which does 
>> not exist yet. :)
>>
>> An interesting endeavor would be to figure out whether things 
>> could be simplified with "interface(C++)".
>
>
> There's one very big disadvantage there, I think. It looks 
> ugly. I do have to point out that this opinion somewhat stems 
> from me just not liking 'scoped.' I think the above example 
> just makes me think, "The best solution has not yet been 
> found." Again, I don't know what that is yet.

There is no best solution. You have to trade off. For my purpose, 
that was the best option, which was maintainable, performant and 
correct (apparenty). I do not care much about how it looks, given 
that it is concise. Some don't like the look of chinese 
hieroglyphs or black skin. I for one don't see much beauty in 
"new". Anyway, the project QtD was intended for was cancelled 
long ago, so you are free to transform it according to yor vision.