DQuick a GUI Library (prototype)

[Flamaros]

I want to share a short presentation of the project I am working
on with friends. It's a prototype of a GUI library written in D.

This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the moment
because a lot of things are missing and it's plenty of bugs.

The development is really slow, so don't expect to see a real
demonstration a day.

The link :
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing

PS : Download it for a better quality

[w0rp]

Cool. Any work put into developing GUI libraries for D interests
me. You should put something up on github once you feel happy
enough about the code being worth showing to others.

[Jacob Carlborg]

I want to share a short presentation of the project I am working on with
friends. It's a prototype of a GUI library written in D.
This pdf contains our vision of what the project would be. Samples are
directly extracted from our prototype and works. We are not able to
share more than this presentation for the moment because a lot of things
are missing and it's plenty of bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing

I don't think Lua will work in this community. I've tried with Ruby and
people didn't like it. Although it might be different with Lua. My
experience is you have two choices: a markup language, i.e. JSON, YAML
and so on or using D.

[Flamaros]

On Wednesday, 21 August 2013 at 08:04:23 UTC, Jacob Carlborg

Post by Jacob Carlborg

Post by Flamaros
I want to share a short presentation of the project I am
working on with
friends. It's a prototype of a GUI library written in D.
This pdf contains our vision of what the project would be.
Samples are
directly extracted from our prototype and works. We are not
able to
share more than this presentation for the moment because a lot of things
are missing and it's plenty of bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing

I don't think Lua will work in this community. I've tried with
Ruby and people didn't like it. Although it might be different
with Lua. My experience is you have two choices: a markup
language, i.e. JSON, YAML and so on or using D.

Markup languages can't be used in our case, we need to provide
scripting capabilities.
It's a prototype essentially cause of Lua, that why we think to
add a front-end to simplify the Lua syntax like removing
"function() ... end" for property binding.

For the moment we can't use D as script language for our project,
just because there is no API to parse and execute a d file as
script.

[Jacob Carlborg]

For the moment we can't use D as script language for our project, just
because there is no API to parse and execute a d file as script.

You can do something like this:

import dquick.dsl;
import std.stdio;

void executeSciprt ()
{
mixin(import("foo.d"));
}

void main ()
{
initialize();
executeSciprt();
writeln(DQuickDsl.serialize());
}

When you want to "execute" the D script you use the above as a template
and only need to replace the file name, in this case "foo.d", and create
a file. Compile that file run the resulting executable, this is easily
done using rdmd. Retrieve the serialized data, deserialized it and do
want you need with the data structures.

[Flamaros]

On Wednesday, 21 August 2013 at 09:23:27 UTC, Jacob Carlborg

Post by Jacob Carlborg

Post by Flamaros
For the moment we can't use D as script language for our
project, just
because there is no API to parse and execute a d file as
script.

import dquick.dsl;
import std.stdio;
void executeSciprt ()
{
mixin(import("foo.d"));
}
void main ()
{
initialize();
executeSciprt();
writeln(DQuickDsl.serialize());
}
When you want to "execute" the D script you use the above as a
template and only need to replace the file name, in this case
"foo.d", and create a file. Compile that file run the resulting
executable, this is easily done using rdmd. Retrieve the
serialized data, deserialized it and do want you need with the
data structures.

Maybe something can be done with a load of a compiled dll
resulting of the compilation of script files. But it doesn't
seems to be a really good way.

I am not sure to understand correctly your suggestion, I don't
see how the application will be able to create GUI items from
"foo.d". Need "foo.d" embed a code to serialize the GUI items
structure to a file that the application will load?

[Jacob Carlborg]

I am not sure to understand correctly your suggestion, I don't see how
the application will be able to create GUI items from "foo.d". Need
"foo.d" embed a code to serialize the GUI items structure to a file that
the application will load?

This is a complete example:

http://pastebin.com/2C4Z2wFR

Which will print this:

http://pastebin.com/Tj1vVHsF

If we look at the code above, evertyrthing below the "main" function
would be in a separate module, "dquick.dls" for example. The string
"code" contains the D script, corresponding to the Lua code. That would
be in its own file, imported using:

import("filename.d");

The tool currently executing the Lua code would instead generate a new
file with the "main" and "executeScript" functions as above. Then it
will proceed as I described in my previous post.

[Jacob Carlborg]

Post by Jacob Carlborg
http://pastebin.com/2C4Z2wFR

I'm using the Orange library to perform the actual serialization:

https://github.com/jacob-carlborg/orange

[Jacob Carlborg]

Post by Jacob Carlborg
http://pastebin.com/2C4Z2wFR
http://pastebin.com/Tj1vVHsF
If we look at the code above, evertyrthing below the "main" function
would be in a separate module, "dquick.dls" for example. The string
"code" contains the D script, corresponding to the Lua code. That would
import("filename.d");
The tool currently executing the Lua code would instead generate a new
file with the "main" and "executeScript" functions as above. Then it
will proceed as I described in my previous post.

Although I don't know what to do about the delegates. They can't be
serialized.

[dennis luehring]

Post by Flamaros
Markup languages can't be used in our case, we need to provide
scripting capabilities.
It's a prototype essentially cause of Lua, that why we think to
add a front-end to simplify the Lua syntax like removing
"function() ... end" for property binding.
For the moment we can't use D as script language for our project,
just because there is no API to parse and execute a d file as
script.

why use scripting at all - D is blasting fast compiled - so whats the
benefit of using "another" language - i understand the need for C++
based systems but in D...

best sample of using D for scripting is Manu Evans (from
http://remedygames.com/) Talk at DConf

http://dconf.org/talks/evans_1.pdf

[Andrej Mitrovic]

Post by dennis luehring
why use scripting at all - D is blasting fast compiled - so whats the
benefit of using "another" language - i understand the need for C++
based systems but in D...

I still don't understand what DQuick has to do with D if you end up
having to use a separate scripting language to use it. Wouldn't it
then be more appropriate to post about DQuick in the Lua newsgroups?

[Flamaros]

On Wednesday, 21 August 2013 at 10:30:59 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by dennis luehring
why use scripting at all - D is blasting fast compiled - so
whats the
benefit of using "another" language - i understand the need
for C++
based systems but in D...

I still don't understand what DQuick has to do with D if you
end up
having to use a separate scripting language to use it. Wouldn't
it
then be more appropriate to post about DQuick in the Lua
newsgroups?

DQuick is for D applications, scripts are just for interfaces.

Interfaces have to be separate from the application to be edited
by artists or other non developer persons.

Here is a link to our model (QtQuick samples) :

The main advantage of D is the traits that simplify the binding
of D objects to the script language. Qt use moc to do this and
it's really intrusive, because it extend the c++ syntax. Our
solution is directly based on primitive types of D. Instead of
QtQuick if DQuick isn't ported to a platform, it will easier to
use the native GUI library for this particular platform. With Qt
wrappers have to be create to convert types (QList =>
std::list,...)

[dennis luehring]

Post by Flamaros
On Wednesday, 21 August 2013 at 10:30:59 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by dennis luehring
why use scripting at all - D is blasting fast compiled - so
whats the
benefit of using "another" language - i understand the need
for C++
based systems but in D...

I still don't understand what DQuick has to do with D if you
end up
having to use a separate scripting language to use it. Wouldn't
it
then be more appropriate to post about DQuick in the Lua
newsgroups?

DQuick is for D applications, scripts are just for interfaces.

and why not use D as the scripting language as the remedygames guys do?
or just using Lua because its already running?

Post by Flamaros
Interfaces have to be separate from the application to be edited
by artists or other non developer persons.

but trivial D code looks like trivial Lua code

Post by Flamaros
http://youtu.be/8G4U7QWRajg
The main advantage of D is the traits that simplify the binding
of D objects to the script language. Qt use moc to do this and
it's really intrusive, because it extend the c++ syntax. Our
solution is directly based on primitive types of D. Instead of
QtQuick if DQuick isn't ported to a platform, it will easier to
use the native GUI library for this particular platform. With Qt
wrappers have to be create to convert types (QList =>
std::list,...)

thats nice

[Flamaros]

On Wednesday, 21 August 2013 at 11:28:23 UTC, dennis luehring

Post by dennis luehring

Post by Flamaros
On Wednesday, 21 August 2013 at 10:30:59 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by dennis luehring
why use scripting at all - D is blasting fast compiled - so
whats the
benefit of using "another" language - i understand the need
for C++
based systems but in D...

I still don't understand what DQuick has to do with D if you
end up
having to use a separate scripting language to use it.
Wouldn't
it
then be more appropriate to post about DQuick in the Lua
newsgroups?

DQuick is for D applications, scripts are just for interfaces.

and why not use D as the scripting language as the remedygames
guys do?
or just using Lua because its already running?

The remedy solution isn't portable and/or to hard to put in place
for a prototype.
Yes Lua is a easier to use for us.

[Jacob Carlborg]

Post by Andrej Mitrovic
I still don't understand what DQuick has to do with D if you end up
having to use a separate scripting language to use it. Wouldn't it
then be more appropriate to post about DQuick in the Lua newsgroups?

I assume:

A. It's written in D
B. You can write GUI code in D as well. This syntax is just something
that should be easier, possibly something that a GUI builder can
generate and parse

[Flamaros]

On Wednesday, 21 August 2013 at 11:44:19 UTC, Jacob Carlborg

Post by Jacob Carlborg

Post by Andrej Mitrovic
I still don't understand what DQuick has to do with D if you
end up
having to use a separate scripting language to use it.
Wouldn't it
then be more appropriate to post about DQuick in the Lua
newsgroups?

A. It's written in D
B. You can write GUI code in D as well. This syntax is just
something that should be easier, possibly something that a GUI
builder can generate and parse

D syntax isn't an issue. We want do a GUI editor that can
generate and parse GUI files.

We need take a deeper look to your proposition.

[Flamaros]

I may forget to tell that we want to be able to reload the GUI
dynamically for the editor. It have to be possible to edit a
property binding code without reloading the application.

[Jacob Carlborg]

D syntax isn't an issue. We want do a GUI editor that can generate and
parse GUI files.
We need take a deeper look to your proposition.

Ok, then you don't need that complicated solution I gave you. In the GUI
editor just serialize the widgets you have in memory to XML or some
other suitable format. When the GUI editor opens a GUI file just
deserialize and the widgets will be restored, hopefully :). I guess this
is basically what Xcode/Interface Builder does.

[Jacob Carlborg]

Post by Jacob Carlborg
Ok, then you don't need that complicated solution I gave you. In the GUI
editor just serialize the widgets you have in memory to XML or some
other suitable format. When the GUI editor opens a GUI file just
deserialize and the widgets will be restored, hopefully :). I guess this
is basically what Xcode/Interface Builder does.

I've been planning to create GUI builder for DWT. That would work like
described above.

[Flamaros]

I just migrate our repository to a public one on github. If some
of you might be interested by the implementation.

https://github.com/D-Quick/DQuick

[Chris]

On Wednesday, 21 August 2013 at 08:04:23 UTC, Jacob Carlborg

Post by Jacob Carlborg

Post by Flamaros
I want to share a short presentation of the project I am
working on with
friends. It's a prototype of a GUI library written in D.
This pdf contains our vision of what the project would be.
Samples are
directly extracted from our prototype and works. We are not
able to
share more than this presentation for the moment because a lot of things
are missing and it's plenty of bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing

I don't think Lua will work in this community. I've tried with
Ruby and people didn't like it. Although it might be different
with Lua. My experience is you have two choices: a markup
language, i.e. JSON, YAML and so on or using D.

Great stuff! I am definitely in favor of a pure D GUI. And again,
D has the benefit of hindsight.

Lua might work, because it's cross platform in the sense that you
can deliver a stand alone interpreter, and it's fast. However, I
wonder why this should be necessary. A pure D solution might be
better.

[Baz]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

It looks really interesting. Some of the specifications really
talks to me...I Hope you'll do it!

[Flamaros]

Post by Baz

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works.
We are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

It looks really interesting. Some of the specifications really
talks to me...I Hope you'll do it!

Can you tell a little more on which specifications you are
interested in?

[Andrei Alexandrescu]

I want to share a short presentation of the project I am working on
with friends. It's a prototype of a GUI library written in D.
This pdf contains our vision of what the project would be. Samples are
directly extracted from our prototype and works. We are not able to
share more than this presentation for the moment because a lot of
things are missing and it's plenty of bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

It looks really interesting. Some of the specifications really talks to
me...I Hope you'll do it!

Yah, I was also impressed upon skimming the deck. Good luck!

Andrei

[Michael]

Lua itself can be embedded into any system.
At least we need a gui library that written in purely D way.

+1 Lua for scripting.

[Sebastian Graf]

Post by Michael
Lua itself can be embedded into any system.
At least we need a gui library that written in purely D way.
+1 Lua for scripting.

+1 from me too.
I had exactly the same idea some time ago, but was overwhelmed by
the shear complexity.
If you go the lua route, you should look into MoonScript.org
(CoffeeScript for lua => nicer function literals) and dig into
reactive programming and my take on it:
https://github.com/sgraf812/push

[Jacob Carlborg]

Post by Sebastian Graf
+1 from me too.
I had exactly the same idea some time ago, but was overwhelmed by the
shear complexity.
If you go the lua route, you should look into MoonScript.org
(CoffeeScript for lua => nicer function literals) and dig into reactive
programming and my take on it: https://github.com/sgraf812/push

CoffeeScript is nice too. But I don't see a reason to use something
other than a markup language if only a GUI builder should read and write
those files.

[Flamaros]

Post by Jacob Carlborg

Post by Sebastian Graf
+1 from me too.
I had exactly the same idea some time ago, but was overwhelmed by the
shear complexity.
If you go the lua route, you should look into MoonScript.org
(CoffeeScript for lua => nicer function literals) and dig into reactive
programming and my take on it: https://github.com/sgraf812/push

CoffeeScript is nice too. But I don't see a reason to use
something other than a markup language if only a GUI builder
should read and write those files.

The GUI editor will allow to write expression in addition of a
classic value setter.

It's really useful to have few pieces of code directly on the GUI
side notably when it's only related to the organisations of GUI
elements.

[Jacob Carlborg]

The GUI editor will allow to write expression in addition of a classic
value setter.

What do you mean with "expression" ?

[Flamaros]

Post by Jacob Carlborg

The GUI editor will allow to write expression in addition of a classic
value setter.

What do you mean with "expression" ?

something like :
function()
return parent.width
end

That the way of how works property binding.

[Jacob Carlborg]

Post by Flamaros
function()
return parent.width
end
That the way of how works property binding.

Can't you bind that to a named method in a controller, or similar? Then
you would store the name of the controller/class and the name of the method.

[Flamaros]

Post by Jacob Carlborg

Post by Flamaros
function()
return parent.width
end
That the way of how works property binding.

Can't you bind that to a named method in a controller, or
similar? Then you would store the name of the controller/class
and the name of the method.

That not always so simple.

With DQuick the D application is like a slave that contains data,
and the GUI is free to display the data in many ways.
Property binding act like a part of the controller if we are
talking about the MVC model.
Notice that if a data in the application side change, depending
properties binding will be updated, so the GUI too.

At my office we port an application from iOS to Android, Windows
and MacOSX. We actually rewrite the GUI for other platforms in
QtQuick, which allow us to let the main code has it. We only add
few wrappers because QtQuick support only Qt types for objects we
need to bind in QML (javascript language used for GUI).

[Jacob Carlborg]

Post by Flamaros
That not always so simple.
With DQuick the D application is like a slave that contains data, and
the GUI is free to display the data in many ways.
Property binding act like a part of the controller if we are talking
about the MVC model.
Notice that if a data in the application side change, depending
properties binding will be updated, so the GUI too.

If I understand you correctly that's how it work on using Xcode on Mac
OS X as well. But Apple manage without a script language for the GUI
code. It's XML and a binary format.

[Flamaros]

Post by Jacob Carlborg

Post by Flamaros
That not always so simple.
With DQuick the D application is like a slave that contains
data, and
the GUI is free to display the data in many ways.
Property binding act like a part of the controller if we are
talking
about the MVC model.
Notice that if a data in the application side change, depending
properties binding will be updated, so the GUI too.

If I understand you correctly that's how it work on using Xcode
on Mac OS X as well. But Apple manage without a script language
for the GUI code. It's XML and a binary format.

A lot of GUI system that respect the MVC system put the
controller in the native code.

[Jacob Carlborg]

A lot of GUI system that respect the MVC system put the controller in
the native code.

And you don't want that? Or what has that do to with anything?

[Flamaros]

Post by Jacob Carlborg

Post by Flamaros
A lot of GUI system that respect the MVC system put the
controller in
the native code.

And you don't want that? Or what has that do to with anything?

With DQuick the Controller is in the script side, it's more
flexible.

Imagine a list of thumbnail of projects, to put a special
thumbnail in the list that will allow creation of a new one. This
special '+' thumbnail is created completely on the script side.
If GUI designer want to go back on this design the developer will
not be impacted because he can modify the controller with the
view.

[goughy]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

It is cross-platform, MIT licensed, mature, and is by the same
guys that _wrote_ Lua. Oh, and Lua is bundled already, of
course. Plus it has a pure C interface (easy to wrap), canvas,
GL support, imaging, plotting, webkit, scintilla editor support
plus more.

I certainly don't want to discourage any input in pure D, but it
would be a much less daunting exercise, IMO. I personally think
the way D has adopted the CURL library to gain some quick wins in
the network protocol area is probably a more sustainable model
given the size of the community.

Its gonna take a long time to get anywhere if everything is NIH.

Just my 2c.

[Andrej Mitrovic]

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

It doesn't seem to support OSX, Unicode, cascading menus:

http://www.tecgraf.puc-rio.br/iup/en/to_do.html

But otherwise I agree starting from scratch is really difficult.

[Andrej Mitrovic]

Post by Andrej Mitrovic

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

It doesn't seem to support OSX

I meant to say native OSX, It uses GTK on that platform.

[Jacob Carlborg]

Post by Andrej Mitrovic
I meant to say native OSX, It uses GTK on that platform.

Thank you, otherwise you might have made some Mac OS X users angry :)

[Andrej Mitrovic]

Post by Jacob Carlborg

Post by Andrej Mitrovic
I meant to say native OSX, It uses GTK on that platform.

Thank you, otherwise you might have made some Mac OS X users angry :)

Hey I'm not on the OSX hate-train. :)

[Andrej Mitrovic]

Post by Andrej Mitrovic
http://www.tecgraf.puc-rio.br/iup/en/to_do.html
But otherwise I agree starting from scratch is really difficult.

Plus it seems to flicker on resize. It's not looking good.

[Flamaros]

On Thursday, 22 August 2013 at 13:29:10 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Andrej Mitrovic
http://www.tecgraf.puc-rio.br/iup/en/to_do.html
But otherwise I agree starting from scratch is really
difficult.

Plus it seems to flicker on resize. It's not looking good.

Yep, it's a known issue. I don't know why the resize event of
window come so late, it seems to be a SDL issue. I began a direct
win32 implementation, but their is no display for the moment,
something seems to be wrong with the opengl context.

[Andrej Mitrovic]

Post by Flamaros
Yep, it's a known issue. I don't know why the resize event of
window come so late, it seems to be a SDL issue. I began a direct
win32 implementation, but their is no display for the moment,
something seems to be wrong with the opengl context.

I was referring to the IUP library though, not your library. As for
flicker, this is usually handled by returning 1 for the WM_ERASEBKGND
message.

The IUP flicker I saw was in its hbox example, which had buttons in a
layout (horizontal box), and as the buttons moved when you resize the
window they would flicker. Maybe they should try using a backbuffer if
they don't already do. But anyway, I don't know IUP internals to know
what is going wrong.

[Andrej Mitrovic]

Post by Andrej Mitrovic
The IUP flicker I saw was in its hbox example, which had buttons in a
layout (horizontal box), and as the buttons moved when you resize the
window they would flicker.

Interestingly it only flickers if I use the resize handle on the
window, but if I resize via e.g. AutoHotkey then there's no flicker. I
guess it's just some internal bug.

[Michael]

Full support of Unicode in upcoming release at end of August.
OS X in progress, help needed.

Development and bugs fixing are very active, mailing lists
available via sf.net.

[Andrej Mitrovic]

Post by Michael
Full support of Unicode in upcoming release at end of August.
OS X in progress, help needed.
Development and bugs fixing are very active, mailing lists
available via sf.net.

But where's the bug tracker?

[Michael]

Post by Andrej Mitrovic
But where's the bug tracker?
The official support mechanism is by e-mail, using
iup at tecgraf.puc-rio.br

Additional info on official site ;)

By the way there is no problem in communication with Tecgraf IUP
team.

[Andrej Mitrovic]

Post by Andrej Mitrovic
The official support mechanism is by e-mail, using
iup at tecgraf.puc-rio.br

Well that's discouraging..

[Michael]

On Thursday, 22 August 2013 at 21:11:32 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Andrej Mitrovic
The official support mechanism is by e-mail, using
iup at tecgraf.puc-rio.br

Well that's discouraging..

For me it's no problem)
For additional comments it's better to contact a official team
manager.

[Andrej Mitrovic]

Post by Michael
For me it's no problem)

How are other people supposed to track bugs? Anytime someone runs into
a bug that other people have already run into, the user has to waste
time writing emails when the bug was already reported.

I have very low confidence in a project without a public issue
tracker, that hosts on sourceforge and uses CVS. That's all I'm
saying.

[Michael]

On Thursday, 22 August 2013 at 21:44:57 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Michael
For me it's no problem)

How are other people supposed to track bugs? Anytime someone
runs into
a bug that other people have already run into, the user has to
waste
time writing emails when the bug was already reported.
I have very low confidence in a project without a public issue
tracker, that hosts on sourceforge and uses CVS. That's all I'm
saying.

They really have a successful collaboration via mail and mailing
list.

[Zz]

Here is an old IUP wrapper in D.
https://code.google.com/p/iupd/

Zz

Post by Michael
On Thursday, 22 August 2013 at 21:44:57 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Michael
For me it's no problem)

How are other people supposed to track bugs? Anytime someone
runs into
a bug that other people have already run into, the user has to
waste
time writing emails when the bug was already reported.
I have very low confidence in a project without a public issue
tracker, that hosts on sourceforge and uses CVS. That's all I'm
saying.

They really have a successful collaboration via mail and
mailing list.

[Flamaros]

On Thursday, 22 August 2013 at 12:34:20 UTC, Andrej Mitrovic

Post by Andrej Mitrovic
But otherwise I agree starting from scratch is really difficult.

That the reason we only tell that is a prototype, we firstly want
to test the property binding concept, and we choose D because we
like it.

[Andrej Mitrovic]

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

It looks like Rikki Cattermole[1] made a D binding[2] to IUP:

[1] : http://forum.dlang.org/thread/pvplfosyrrgigtuspvbw at forum.dlang.org#post-afokkalgzxrsbnvpqgou:40forum.dlang.org

[2] : https://bitbucket.org/alphaglosined/libglosined (see the iup directory)

I don't know in what state that is, or how finished it is.

A more friendly D API built on top would of course be welcome. If I
wasn't so busy with Tk lately I would take a stab at it, but I don't
have the time now.

[Michael]

Post by Andrej Mitrovic
http://forum.dlang.org/thread/pvplfosyrrgigtuspvbw at forum.dlang.org#post-afokkalgzxrsbnvpqgou:40forum.dlang.org
[2] : https://bitbucket.org/alphaglosined/libglosined (see the
iup directory)

It's looks as low-level-one-to-one D binding to C.

Now I trying to build a somewhat from examples and tests on
Debian. It's looks pretty well. And it seems that a one-to-one
bindings not so good, some api is specific to C, some not
necessary to D.

[Rikki Cattermole]

On Thursday, 22 August 2013 at 19:04:52 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

http://forum.dlang.org/thread/pvplfosyrrgigtuspvbw at forum.dlang.org#post-afokkalgzxrsbnvpqgou:40forum.dlang.org
[2] : https://bitbucket.org/alphaglosined/libglosined (see the
iup directory)
I don't know in what state that is, or how finished it is.
A more friendly D API built on top would of course be welcome.
If I
wasn't so busy with Tk lately I would take a stab at it, but I
don't
have the time now.

They were complete if I remember right when I made them.
I moved on from IUP libraries written by the same group e.g. IM
for usage with IUP.
Which I never finished.
If anyone is interested in using them please take them I'm
applying no license on it.

There is also another bindings on I think google code but I can't
find it now.

I'm also working on my own GUI toolkit however it is far from at
the stage I would like to show it to the community.
https://github.com/rikkimax/DOOGLE if your interested in looking
what I got so far.

[Andrej Mitrovic]

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

I've had another look at this, and the documentation tells me there's
limitations and generally a requirement to handle platform-specific
behavior in many cases, which could get in the way.

For most widgets, after you create them, you can't change their
behavior except maybe their appearance (e.g. text and image). That's a
big limitation imo.

There's platform-dependent behavior that you need to be aware of, such as:

-----
When you change the active tab the focus is usually not changed. If
you want to control the focus behavior call IupSetFocus in the
TABCHANGE_CB callback. Unfortunately this does not works in GTK and in
Motif, because in both systems the focus will be set by the system
after the callback is called.
-----

There's a lot of these GTK/Windows specific notes, I'd hate to end up
writing a lot of code wrapped inside of version(GTK) statements.

There's basic features not supported such as:

-----
Notice that there is no attribute to disable a single tab. This is a
design decision of all native toolkits, not a IUP decision. It is so
because a disabled tab is a confusing interface situation.
-----

Tcl's Tk does it, as does Qt, and probably other libraries. Here's the
Tkinter version:
http://www.pyinmyeye.com/2012/08/tkinter-notebook-demo.html.

Anyway, as a simple GUI library it might even be worth wrapping. But I
think the DQuick devs and D programmers want something much more.

[Flamaros]

On Thursday, 29 August 2013 at 17:08:22 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by goughy
Could I recommend you evaluate IUP first?
(http://www.tecgraf.puc-rio.br/iup/)

I've had another look at this, and the documentation tells me
there's
limitations and generally a requirement to handle
platform-specific
behavior in many cases, which could get in the way.
For most widgets, after you create them, you can't change their
behavior except maybe their appearance (e.g. text and image).
That's a
big limitation imo.
There's platform-dependent behavior that you need to be aware
-----
When you change the active tab the focus is usually not
changed. If
you want to control the focus behavior call IupSetFocus in the
TABCHANGE_CB callback. Unfortunately this does not works in GTK
and in
Motif, because in both systems the focus will be set by the
system
after the callback is called.
-----
There's a lot of these GTK/Windows specific notes, I'd hate to
end up
writing a lot of code wrapped inside of version(GTK) statements.
-----
Notice that there is no attribute to disable a single tab. This
is a
design decision of all native toolkits, not a IUP decision. It
is so
because a disabled tab is a confusing interface situation.
-----
Tcl's Tk does it, as does Qt, and probably other libraries.
Here's the
http://www.pyinmyeye.com/2012/08/tkinter-notebook-demo.html.
Anyway, as a simple GUI library it might even be worth
wrapping. But I
think the DQuick devs and D programmers want something much
more.

As DQuick isn't based on OS native GUI libraries and it's intend
to have exactly the same behaviors of those native libraries, the
user will have the responsibility to customize those kind of
behaviors.
In the default package there will be no support for focus for
sample. I don't know how is it on other OS, but on windows
buttons and scroll-bars have really weird behaviors, for
scroll-bars you'll loose control on it if your mouse cursor is
too far (button always down), but when the cursor come back to an
acceptable distance the scroll-bar move appropriately,...

With DQuick it will not a problem to have larger mouse area than
a button which is really useful for interfaces controlled by
fingers.

To have some controls (around widget) that have simple behaviors
acceptable for almost all OS/platform, we'll certainly do
something like QtQuick Controls. This is an add-on which provide
a simple way to support focus.

[Andrej Mitrovic]

Post by Flamaros
I don't know how is it on other OS, but on windows
buttons and scroll-bars have really weird behaviors, for
scroll-bars you'll lose control on it if your mouse cursor is
too far (button always down), but when the cursor come back to an
acceptable distance the scroll-bar move appropriately,...

You need to track the cursor if you want to avoid this behavior, using
SetCapture, and later releasing with ReleaseCapture (I think even
TrackMouseEvent needs to be called at some point).

I've got an old Cairo-based slider example where you can move the
slider even when you're way off the screen:

https://github.com/AndrejMitrovic/cairoDSamples/blob/master/slider.d#L209

[Gour]

On Thu, 29 Aug 2013 19:08:09 +0200

Post by Andrej Mitrovic
Anyway, as a simple GUI library it might even be worth wrapping. But I
think the DQuick devs and D programmers want something much more.

Based on what I've seen, Tk-8.6 is quite good and available *today*,
while DQuick is still prototype only.


Sincerely,
Gour

[Flamaros]

Post by Gour
On Thu, 29 Aug 2013 19:08:09 +0200

Post by Andrej Mitrovic
Anyway, as a simple GUI library it might even be worth
wrapping. But I
think the DQuick devs and D programmers want something much
more.

Based on what I've seen, Tk-8.6 is quite good and available
*today*,
while DQuick is still prototype only.
Sincerely,
Gour

The way will be very long for DQuick, I only start working on
font rendering.
It would certainly took years before seeing something usable for
production with DQuick, and only if the development doesn't stop
before this point.

[Andrej Mitrovic]

Post by Gour
Based on what I've seen, Tk-8.6 is quite good and available *today*,
while DQuick is still prototype only.

I especially like its configurable event mechanism, because I can
build my own event propagation mechanism on top of it, and provide
something more useful on the D side. For example, people used to WPF
have tunneling and bubbling of events, and this is something that can
be done in a Tk wrapper.

[Jakob Ovrum]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

If you do decide to use Lua, I strongly recommend checking out
LuaD[1]. Shameless self-promotion, yes; but the goal of LuaD is
to be an uncompromising, superior alternative to using the Lua C
API directly, for any project.

[1] https://github.com/JakobOvrum/LuaD

[Flamaros]

Post by Jakob Ovrum

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works.
We are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

If you do decide to use Lua, I strongly recommend checking out
LuaD[1]. Shameless self-promotion, yes; but the goal of LuaD is
to be an uncompromising, superior alternative to using the Lua
C API directly, for any project.
[1] https://github.com/JakobOvrum/LuaD

As we decided to open our code, we'll accept pull request.

All Lua related code is in the folder : src/dquick/script
Entry point of those object is dmlEngine.d

repo : https://github.com/D-Quick/DQuick

[Jakob Ovrum]

Post by Flamaros
As we decided to open our code, we'll accept pull request.
All Lua related code is in the folder : src/dquick/script
Entry point of those object is dmlEngine.d
repo : https://github.com/D-Quick/DQuick

Thank you for the invitation. As LuaD does not yet support Lua
API version 5.2, I'm putting the recommendation on hold until it
does ;) It was always on the roadmap, anyway.

[1100110]

Post by Flamaros
As we decided to open our code, we'll accept pull request.
All Lua related code is in the folder : src/dquick/script
Entry point of those object is dmlEngine.d
repo : https://github.com/D-Quick/DQuick

Thank you for the invitation. As LuaD does not yet support Lua API
version 5.2, I'm putting the recommendation on hold until it does ;) It
was always on the roadmap, anyway.

May I say that I *love* LuaD.

It's one of my favorite projects to showcase the express-ability of D.
The C API for Lua is difficult to use, but you made the embedded
language much more embedded IMHO.

What I'm saying is if you abandon it I'll be very very sad.

[Flamaros]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

After the publication of our sources :
https://github.com/D-Quick/DQuick

I have migrate our bugs report too :
https://github.com/D-Quick/DQuick/issues?state=open

[Andrej Mitrovic]

Post by Flamaros
https://github.com/D-Quick/DQuick

P.S.: You should really add license headers in your files and/or a license file.

[Flamaros]

On Friday, 6 September 2013 at 15:25:25 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Flamaros
https://github.com/D-Quick/DQuick

P.S.: You should really add license headers in your files
and/or a license file.

Certainly, I'll try to do it this weekend.

[Flamaros]

Post by Flamaros
On Friday, 6 September 2013 at 15:25:25 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Flamaros
https://github.com/D-Quick/DQuick

P.S.: You should really add license headers in your files
and/or a license file.

Certainly, I'll try to do it this weekend.

We choose the boost one.

[Andrej Mitrovic]

Post by Flamaros
We choose the boost one.

That's great, but your license file is empty:
https://github.com/D-Quick/DQuick/blob/master/License.txt

[Flamaros]

On Saturday, 7 September 2013 at 15:03:22 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Flamaros
We choose the boost one.

https://github.com/D-Quick/DQuick/blob/master/License.txt

I fill the wrong file due to a wrong naming.

Sorry.

[Flamaros]

Post by Flamaros
On Saturday, 7 September 2013 at 15:03:22 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Flamaros
We choose the boost one.

https://github.com/D-Quick/DQuick/blob/master/License.txt

I fill the wrong file due to a wrong naming.
Sorry.

We are making some progress, but a lot of work need to be done.
Recent changes :
- Text wrapping (NoWrap, Any, Wrap, WordWrap)
- Font loaded from name instead of path (Windows only for the
moment)
- Auto binding of Sub-Objects

Coming :
- A scrolling item
- Adding clipping on Items with scissors

So the project isn't dead :-)

[Flamaros]

Post by Flamaros

Post by Flamaros
On Saturday, 7 September 2013 at 15:03:22 UTC, Andrej Mitrovic

Post by Andrej Mitrovic

Post by Flamaros
We choose the boost one.

https://github.com/D-Quick/DQuick/blob/master/License.txt

I fill the wrong file due to a wrong naming.
Sorry.

We are making some progress, but a lot of work need to be done.
- Text wrapping (NoWrap, Any, Wrap, WordWrap)
- Font loaded from name instead of path (Windows only for the
moment)
- Auto binding of Sub-Objects
- A scrolling item
- Adding clipping on Items with scissors
So the project isn't dead :-)

Clipping and Scrolling are done.

Bruno will work on adding array support by Lua.

I'll clean/fix code in the same time as adding new items/features.

[Gour]

On Tue, 20 Aug 2013 23:22:45 +0200

Post by Flamaros
I want to share a short presentation of the project I am working
on with friends. It's a prototype of a GUI library written in D.

The state of GI bindings in D was the main reason I gave up idea to use
D for writing multi-platform GUI app in this nice language.

Gtk(D) does not look good on anything which is non-Linux and the state
of the GTK support on both Mac OS X & Windows is pretty poor.

There are no Qt bindings and nothing, afaik, happened from the attempt
to provide wx bindings, so your project might provide some light at the
end of the tunnel giving hope to use D as 'general programming
language'.

Wishing you all the best!


Sincerely,
Gour

[Flamaros]

Post by Gour
On Tue, 20 Aug 2013 23:22:45 +0200

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.

The state of GI bindings in D was the main reason I gave up
idea to use
D for writing multi-platform GUI app in this nice language.
Gtk(D) does not look good on anything which is non-Linux and
the state
of the GTK support on both Mac OS X & Windows is pretty poor.
There are no Qt bindings and nothing, afaik, happened from the
attempt
to provide wx bindings, so your project might provide some
light at the
end of the tunnel giving hope to use D as 'general programming
language'.
Wishing you all the best!
Sincerely,
Gour

Thank you for your encouragements.

[Christian Manning]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

This is great! Will check this out ASAP I think. I migrated a Qt
Widgets project to QML/QtQuick and I've quite enjoyed working
with it, but having something with similar goals in D will bring
me back to the language most probably. In fact, that project was
originally written in D but I became frustrated with some things
at the time (lack of shared libs for plugins, GUI, etc.), so it
was rewritten in c++11.

Although I don't think I shall be rewriting its current state in
D (the thought of porting 15k+ lines by myself is rather daunting
;)

Chris

[Flamaros]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

A little news :
We works on text rendering and D objects binding.

https://github.com/D-Quick/DQuick

[Flamaros]

Post by Flamaros

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works.
We are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

We works on text rendering and D objects binding.

PS : D objects means that an instance of a D class can be
accessible from Lua scripts.

Only method with supported types are accessible, we will add the
possibility to declare D classes for non Lua Types.

Post by Flamaros
https://github.com/D-Quick/DQuick

[Ivan via Digitalmars-d]

Post by Flamaros
I want to share a short presentation of the project I am
working on with friends. It's a prototype of a GUI library
written in D.
This pdf contains our vision of what the project would be.
Samples are directly extracted from our prototype and works. We
are not able to share more than this presentation for the
moment because a lot of things are missing and it's plenty of
bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

Is this still being developed?

[Xavier Bigand via Digitalmars-d]

Post by Ivan via Digitalmars-d

I want to share a short presentation of the project I am working on
with friends. It's a prototype of a GUI library written in D.
This pdf contains our vision of what the project would be. Samples are
directly extracted from our prototype and works. We are not able to
share more than this presentation for the moment because a lot of
things are missing and it's plenty of bugs.
The development is really slow, so don't expect to see a real
demonstration a day.
https://docs.google.com/file/d/0BygGiQfhIcvGOGlrWlBFNWNBQ3M/edit?usp=sharing
PS : Download it for a better quality

Is this still being developed?

Yes it is, but development is still slow.

You can follow last progress on github : https://github.com/D-Quick/DQuick