www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - D language for Graphical User Interface and Cross Platform Development

reply BoQsc <vaidas.boqsc gmail.com> writes:
It seems that by using gtkd project to build your GUI application 
it requires a preinstalled runtime that weights around 40mb, for 
Windows operating systems. (https://gtkd.org/download.html)

A Dlang UI GUI project by Buggins seems to be deprecated and even 
a simple example could not be run anymore. 
(https://github.com/buggins/dlangui)

I'm not aware of any other serious project that could efficiently 
provide a way to build a stable GUI.

What should I do if I want to write a cross-platform application 
with graphical user interface in D? Should I wait until there 
will be better maintained libraries listed on the 
(https://wiki.dlang.org/GUI_Libraries) or there are other ways to 
create and build a GUI D language application?
Jun 17 2020
next sibling parent Oleg B <code.viator gmail.com> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


I think you should work with gtkd, because it best alternative at 
this time.
Jun 17 2020
prev sibling next sibling parent Bastiaan Veelo <Bastiaan Veelo.net> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)


What are the signs that it would be deprecated? The maintainer 
has not been active on GitHub for a few months, it happens. There 
are several open pull requests that may help you. Maybe this one? 
https://github.com/buggins/dlangui/pull/601

--Bastiaan
Jun 17 2020
prev sibling next sibling parent starcanopy <starcanopy protonmail.com> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


Check out tkd, https://github.com/nomad-software/tkd, for 
something akin to Tkinter.
Jun 17 2020
prev sibling next sibling parent reply Zoadian <no no.no> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


vibe.d + vue.js works perfectly
Jun 17 2020
next sibling parent reply Vinod K Chandran <kcvinu82 gmail.com> writes:
On Wednesday, 17 June 2020 at 12:15:07 UTC, Zoadian wrote:


 vibe.d + vue.js works perfectly


Any examples please ?
Jun 17 2020
parent reply Suliman <evermind live.ru> writes:
There is also https://github.com/dayllenger/beamui
Jun 23 2020
parent reply aberba <karabutaworld gmail.com> writes:
On Tuesday, 23 June 2020 at 07:51:57 UTC, Suliman wrote:

 There is also https://github.com/dayllenger/beamui


Seriously,this is it.

Its checks in just about everything would like a D GUI to have. 
Especially CSS-like styling and slimming things down.

Thanks for sharing
Jun 23 2020
parent reply rikki cattermole <rikki cattermole.co.nz> writes:
On 24/06/2020 12:17 AM, aberba wrote:

 On Tuesday, 23 June 2020 at 07:51:57 UTC, Suliman wrote:

 There is also https://github.com/dayllenger/beamui


 
 Seriously,this is it.
 
 Its checks in just about everything would like a D GUI to have. 
 Especially CSS-like styling and slimming things down.
 
 Thanks for sharing


There is no dedicated event loop or windowing library underpinning it.

Unfortunately this means that GtkD is still a better option.
Jun 23 2020
next sibling parent Petar Kirov [ZombineDev] <petar.p.kirov gmail.com> writes:
On Tuesday, 23 June 2020 at 16:28:26 UTC, rikki cattermole wrote:

 On 24/06/2020 12:17 AM, aberba wrote:

 On Tuesday, 23 June 2020 at 07:51:57 UTC, Suliman wrote:

 There is also https://github.com/dayllenger/beamui


 
 Seriously,this is it.
 
 Its checks in just about everything would like a D GUI to 
 have. Especially CSS-like styling and slimming things down.
 
 Thanks for sharing


 There is no dedicated event loop or windowing library 
 underpinning it.

 Unfortunately this means that GtkD is still a better option.


"PRs are welcome" :P
Jun 24 2020
prev sibling next sibling parent M.M. <matus email.cz> writes:
On Tuesday, 23 June 2020 at 16:28:26 UTC, rikki cattermole wrote:

 ...
 Unfortunately this means that GtkD is still a better option.


Why is that _unfortunate_?
Jun 24 2020
prev sibling parent reply WebFreak001 <d.forum webfreak.org> writes:
On Tuesday, 23 June 2020 at 16:28:26 UTC, rikki cattermole wrote:

 On 24/06/2020 12:17 AM, aberba wrote:

 On Tuesday, 23 June 2020 at 07:51:57 UTC, Suliman wrote:

 There is also https://github.com/dayllenger/beamui


 
 Seriously,this is it.
 
 Its checks in just about everything would like a D GUI to 
 have. Especially CSS-like styling and slimming things down.
 
 Thanks for sharing


 There is no dedicated event loop or windowing library 
 underpinning it.

 [...]


it's using SDL, X11 or Win32, waiting for messages using the 
platform specific event loops there. Where did you get your 
assumption there from or what do you mean if you don't mean these 
event loops but some other event loop?
Jun 24 2020
parent rikki cattermole <rikki cattermole.co.nz> writes:
On 25/06/2020 2:09 AM, WebFreak001 wrote:

 On Tuesday, 23 June 2020 at 16:28:26 UTC, rikki cattermole wrote:

 On 24/06/2020 12:17 AM, aberba wrote:

 On Tuesday, 23 June 2020 at 07:51:57 UTC, Suliman wrote:

 There is also https://github.com/dayllenger/beamui


 Seriously,this is it.

 Its checks in just about everything would like a D GUI to have. 
 Especially CSS-like styling and slimming things down.

 Thanks for sharing


 There is no dedicated event loop or windowing library underpinning it.

 [...]


 
 it's using SDL, X11 or Win32, waiting for messages using the platform 
 specific event loops there. Where did you get your assumption there from 
 or what do you mean if you don't mean these event loops but some other 
 event loop?


SDL is the only backend that is capable of you interacting with the 
event loop itself in a meaningful way.

However it wasn't designed for the majority of use cases, a very narrow 
set. While useful, it has significant limitations.

Being able to wait and get system windowing library events is always 
required and each backend is capable of doing that. But that doesn't 
mean it'll play nicely with threads, shared libraries (like X11) or 
other event loops.
Jun 24 2020
prev sibling parent reply Greatsam4sure <greatsam4sure yahoo.com> writes:
On Wednesday, 17 June 2020 at 12:15:07 UTC, Zoadian wrote:

 On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


 vibe.d + vue.js works perfectly


Can you point to a url or tutorial of how to combine vibe.d and 
vue.js to build a desktop app than can work on all operative 
system. I am really interested in this. I will appreciate your 
reply
Jun 19 2020
next sibling parent reply Jan =?UTF-8?B?SMO2bmln?= <hrominium gmail.com> writes:
On Friday, 19 June 2020 at 07:46:02 UTC, Greatsam4sure wrote:

 Can you point to a url or tutorial of how to combine vibe.d and 
 vue.js to build a desktop app than can work on all operative 
 system. I am really interested in this. I will appreciate your 
 reply


dito
Jun 19 2020
parent Andre Pany <andre s-e-a-p.de> writes:
On Friday, 19 June 2020 at 09:10:54 UTC, Jan Hönig wrote:

 On Friday, 19 June 2020 at 07:46:02 UTC, Greatsam4sure wrote:

 Can you point to a url or tutorial of how to combine vibe.d 
 and vue.js to build a desktop app than can work on all 
 operative system. I am really interested in this. I will 
 appreciate your reply


 dito


I was really positive suprised to find a dub package for vue and 
other libraries like sapui5.
https://code.dlang.org/packages/uim-vue

Unfortunately, there is not much explanation / samples.
I will create an issue and ask for them.

Kind regards
André
Jun 19 2020
prev sibling parent Zoadian <no no.no> writes:
On Friday, 19 June 2020 at 07:46:02 UTC, Greatsam4sure wrote:

 On Wednesday, 17 June 2020 at 12:15:07 UTC, Zoadian wrote:

 On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other 
 ways to create and build a GUI D language application?


 vibe.d + vue.js works perfectly


 Can you point to a url or tutorial of how to combine vibe.d and 
 vue.js to build a desktop app than can work on all operative 
 system. I am really interested in this. I will appreciate your 
 reply


Sry I dont have any examples I could share.
You would build your application as any other vue.js app. Best to 
look at their documentation. Vibe.d is only used a a web server. 
You could use arsd or other libs for that too.
Finally I use chromium embedded framework to make it a native 
app. See https://github.com/Zoadian/cefBasedViewerExample for an 
simple example. (Only supports minimum cef functionality for now)
Jun 19 2020
prev sibling next sibling parent reply aberba <karabutaworld gmail.com> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


We're just waiting for a hero to make that happen. DLangUI is the 
most promising pure D GUI but being based on a single 
individual's effort doesn't help get it there yet.

It also tried to do too much instead of a modern and simple 
approach...more modular and customisable to enable others to 
build atop.
Jun 17 2020
parent reply aberba <karabutaworld gmail.com> writes:
On Wednesday, 17 June 2020 at 19:54:58 UTC, aberba wrote:

 On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 [...]


 We're just waiting for a hero to make that happen. DLangUI is 
 the most promising pure D GUI but being based on a single 
 individual's effort doesn't help get it there yet.

 It also tried to do too much instead of a modern and simple 
 approach...more modular and customisable to enable others to 
 build atop.


Some here said they, as in their company/startup, were working on 
a D GUI project but that hasn't happened yet.

There's independent efforts here and there but none has really 
gotten there... enough for building a compelling cross-platform 
product
Jun 17 2020
parent reply Bastiaan Veelo <Bastiaan Veelo.net> writes:
On Wednesday, 17 June 2020 at 19:59:15 UTC, aberba wrote:

 Some here said they, as in their company/startup, were working 
 on a D GUI project but that hasn't happened yet.


You are probably referring to 
https://forum.dlang.org/post/qbsg7d$11s3$1 digitalmars.com

--Bastiaan
Jun 17 2020
parent reply Liu <liiudk gmail.com> writes:
On Wednesday, 17 June 2020 at 20:38:38 UTC, Bastiaan Veelo wrote:

 On Wednesday, 17 June 2020 at 19:59:15 UTC, aberba wrote:

 Some here said they, as in their company/startup, were working 
 on a D GUI project but that hasn't happened yet.


 You are probably referring to 
 https://forum.dlang.org/post/qbsg7d$11s3$1 digitalmars.com

 --Bastiaan


Is he going to write a whole GUI framework from scratch? like Qt?
Jun 17 2020
parent =?iso-8859-1?Q?Robert_M._M=FCnch?= <robert.muench saphirion.com> writes:
On 2020-06-17 21:13:37 +0000, Liu said:


 On Wednesday, 17 June 2020 at 20:38:38 UTC, Bastiaan Veelo wrote:

 On Wednesday, 17 June 2020 at 19:59:15 UTC, aberba wrote:

 Some here said they, as in their company/startup, were working on a D 
 GUI project but that hasn't happened yet.


 
 You are probably referring to 
 https://forum.dlang.org/post/qbsg7d$11s3$1 digitalmars.com
 
 --Bastiaan


 
 Is he going to write a whole GUI framework from scratch? like Qt?


Since that's us I can reply...

Yes, this whole thing is from scratch. Mainly because we don't care 
about any OS specific widgets. We just use the window as a canvas 
container and from there one do it on our own. We used this approach in 
the past and it was one of the best decisions. Zero dependencies, one 
file executable.

We do this, because we want to port our product to a new tech-stack. 
But, as you can imagine, still a long way to go.

We start doing some internal tools which can be CLI or GUI based to 
gain more experience. Overall, the framework parts are working well 
together. The framework design works and is very flexible. So, no walls 
hit so far.

Focus is on extending the widgets functionality and features 
step-by-step. We do as we move forward and do the refactoring while 
learning how to implement things best.

Here is a new teaser: 
https://www.dropbox.com/s/jjefzyneqnxr7pb/dgui_teaser-1.mp4

So, we added 9-patch image support for widget styling.

-- 
Robert M. Münch
http://www.saphirion.com
smarter | better | faster
Jun 22 2020
prev sibling next sibling parent Ernesto Castellotti <erny.castell gmail.com> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


You can link the GtkD interface statically (if you use dub it 
already does) and load the GTK DLL at runtime which you can 
distribute directly within your program folder.


I don't think size is a problem, any software that uses gtk or qt 
on Windows requires about the same amount of space
Jun 18 2020
prev sibling next sibling parent Jacob Carlborg <doob me.com> writes:
On 2020-06-17 12:33, BoQsc wrote:

 It seems that by using gtkd project to build your GUI application it 
 requires a preinstalled runtime that weights around 40mb, for Windows 
 operating systems. (https://gtkd.org/download.html)
 
 A Dlang UI GUI project by Buggins seems to be deprecated and even a 
 simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)
 
 I'm not aware of any other serious project that could efficiently 
 provide a way to build a stable GUI.
 
 What should I do if I want to write a cross-platform application with 
 graphical user interface in D? Should I wait until there will be better 
 maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways to create 
 and build a GUI D language application?


DWT [1] is available as well. It supports Windows and Linux (GTK). On 
Windows no additional libraries are required at runtime, besides the 
system libraries already installed.

[1] https://github.com/d-widget-toolkit/dwt

-- 
/Jacob Carlborg
Jun 20 2020
prev sibling next sibling parent Yhzhao <zyhm qq.com> writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


have a try
https://github.com/aboray/dlangui
Jun 20 2020
prev sibling parent reply =?UTF-8?B?0JLQuNGC0LDQu9C40Lkg0KTQsNC0?= =?UTF-8?B?0LXQtdCy?= writes:
On Wednesday, 17 June 2020 at 10:33:36 UTC, BoQsc wrote:

 It seems that by using gtkd project to build your GUI 
 application it requires a preinstalled runtime that weights 
 around 40mb, for Windows operating systems. 
 (https://gtkd.org/download.html)

 A Dlang UI GUI project by Buggins seems to be deprecated and 
 even a simple example could not be run anymore. 
 (https://github.com/buggins/dlangui)

 I'm not aware of any other serious project that could 
 efficiently provide a way to build a stable GUI.

 What should I do if I want to write a cross-platform 
 application with graphical user interface in D? Should I wait 
 until there will be better maintained libraries listed on the 
 (https://wiki.dlang.org/GUI_Libraries) or there are other ways 
 to create and build a GUI D language application?


What about Sciter ?

Site: https://sciter.com/

D: https://github.com/sciter-sdk/Sciter-Dport
Jun 24 2020
parent reply =?utf-8?Q?Robert_M._M=C3=BCnch?= <robert.muench saphirion.com> writes:
On 2020-06-25 03:33:23 +0000, Виталий Фадеев said:


 What about Sciter ?
 
 Site: https://sciter.com/
 
 D: https://github.com/sciter-sdk/Sciter-Dport


It looks interesting but I never tried it. Any experience with it?

-- 
Robert M. Münch
http://www.saphirion.com
smarter | better | faster
Jun 25 2020
parent reply c-smile <andrew sciter.com> writes:
On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch wrote:

 On 2020-06-25 03:33:23 +0000, Виталий Фадеев said:


 What about Sciter ?
 
 Site: https://sciter.com/
 
 D: https://github.com/sciter-sdk/Sciter-Dport


 It looks interesting but I never tried it. Any experience with 
 it?


Sciter's author here.

Sciter API is pretty compact, it is exposed from sciter.dll as a 
structure ( 
https://github.com/c-smile/sciter-sdk/blob/master/include/sciter-x-api.h#L50 )
and normally application use 20-30 functions of it. Sciter is 
perfectly suitable for D. D integration was one of design targets 
from the very beginning.

Below is slightly orthogonal to the question, just thoughts, my 
pardon.

Just in case, initially Sciter was meant to be written in D. Here 
is the story: https://sciter.com/10-years-road-to-sciter/

I still think that among native languages D lang is the most 
suitable one for GUI development. GC is the must for UI if to 
consider complex ownership graphs that frequently contain loops.

Having said that, it is possible but quite hard to make an 
embeddable/shared (to other systems) GUI engine in D, for very 
same reason as the above. The most feasible approach, I think, is 
along the lines of my Quark project ( https://quark.sciter.com ) 
- self- sufficient executables that contain GUI engine linked 
statically.

If to consider a "perfect and modern D GUI library":

1. It should have unified DOM serializable to HTML/XHTML. There 
are many good reasons for that, from Accessibility (a.k.a. 
Section 508), to things like enabling React alike functionality 
and JSX. D syntax may even support JSX natively in the way I did 
in Sciter's script: 
https://sciter.com/docs/content/script/language/ssx.htm

2. It should be style-able, so is CSS or its subset. It is again 
flexible and 95% UI developers know it already. Style-ability 
here means not just colors but flexibility and configurability of 
element flows (layout manager in Java AWT terms).

3. It shall use GPU rendering as much as possible. That's the 
must for high-DPI monitors.

4. Implementation shall be compact - each D GUI application will 
include it statically and compilations time shall be short.

Please let me know if someone will start doing anything close to 
the the above in D - I can help.
Jun 28 2020
next sibling parent reply aberba <karabutaworld gmail.com> writes:
On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

 On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch 
 wrote:

 [...]


 Sciter's author here.

 [...]


You may check out BeamUI written in 100% D. It's the closest I've 
seen to what you may be talking about.

https://github.com/dayllenger/beamui
Jun 28 2020
parent c-smile <andrew sciter.com> writes:
On Monday, 29 June 2020 at 00:04:31 UTC, aberba wrote:

 On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

 On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch 
 wrote:

 [...]


 Sciter's author here.

 [...]


 You may check out BeamUI written in 100% D. It's the closest 
 I've seen to what you may be talking about.

 https://github.com/dayllenger/beamui


Very interesting project and tremendous amount of work, my 
deepest regards.

thanks a lot for the link.
Jun 29 2020
prev sibling next sibling parent =?iso-8859-1?Q?Robert_M._M=FCnch?= <robert.muench saphirion.com> writes:
On 2020-06-28 18:01:08 +0000, c-smile said:


 Sciter's author here.


Hi Andrew, thank for jumping-in.


 Sciter API is pretty compact, it is exposed from sciter.dll as a 
 structure ( 
 https://github.com/c-smile/sciter-sdk/blob/master/include/sciter-x-api.h#L50 
 ) and normally application use 20-30 functions of it. Sciter is 
 perfectly suitable for D. D integration was one of design targets from 
 the very beginning.


I didn't know that D was taken into account for Sciter nor that it's 
well suited to work with D. Might be a good addition to your web-page 
(if it's not already there and I overlooked it).

So, this means, that all the embedding principals work with D too?


 Just in case, initially Sciter was meant to be written in D. Here is 
 the story: https://sciter.com/10-years-road-to-sciter/


Oh, cool. Again, if this thing is so good integrated with D, that 
should be made more public.


 I still think that among native languages D lang is the most suitable 
 one for GUI development. GC is the must for UI if to consider complex 
 ownership graphs that frequently contain loops.


I agree... it feels very natural to do such frameworks in D.


 Having said that, it is possible but quite hard to make an 
 embeddable/shared (to other systems) GUI engine in D, for very same 
 reason as the above. The most feasible approach, I think, is along the 
 lines of my Quark project ( https://quark.sciter.com ) - self- 
 sufficient executables that contain GUI engine linked statically.


That's a very interesting thing! I have some questions:

* Our goals is to create a zero-dependency standalone EXE application. 
As I read this, this is possible? We would have additional D/C code we 
want to all "link" statically.

* Does quark does anything against reverse engineering? I mean, all the 
script stuff is very nice, but we have to be sure, things are not 
changed, extracted, etc.

* Is the scriping engine, which seems to be genuinly done from scratch, 
fully JS compatible? Or how does it fit into the overall web-stack 
space? Can exteranl frameworks be used, too? Or do these need some 
Sciter specific adjustments?


 If to consider a "perfect and modern D GUI library":
 
 1. It should have unified DOM serializable to HTML/XHTML. There are 
 many good reasons for that, from Accessibility (a.k.a. Section 508), to 
 things like enabling React alike functionality and JSX. D syntax may 
 even support JSX natively in the way I did in Sciter's script: 
 https://sciter.com/docs/content/script/language/ssx.htm


I always see two parts:

1. The "how to code it" part, which should use a declarative DSL that 
integrates with the rest of the D application code pretty simple and 
without any friction. If there HTML/CSS/JS is the best combo, could be 
discussed. At the end of the day, I think this is all more about taste 
than technological superiority.

2. The "how to display" part. I prefer to have a GUI toolkit, that 
doesn't use any native widgets, instead just renders the stuff the app 
needs. I want access from high-level abstraction to low-levels, so I 
can get in between and do whatever is required for my app.


 2. It should be style-able, so is CSS or its subset. It is again 
 flexible and 95% UI developers know it already. Style-ability here 
 means not just colors but flexibility and configurability of element 
 flows (layout manager in Java AWT terms).


Agree, again, if this is CSS or something else, can be discussed. But 
of course you are right, that more and more people know this CSS stuff, 
it doesn't make a lot of sense to reinvent the wheel.


 3. It shall use GPU rendering as much as possible. That's the must for 
 high-DPI monitors.


Yes. Or have a very sophisticated, hight speed sofware renderer.


 4. Implementation shall be compact - each D GUI application will 
 include it statically and compilations time shall be short.


Yep!


 Please let me know if someone will start doing anything close to the 
 the above in D - I can help.


I might turn this the other way and take a deeper look into what you 
have. Beside, doing a GUI library is a fun project, I have a clear 
business use-case behind it.

Going to PM you for more details, that might not be that interesting 
for the community.

-- 
Robert M. Münch
http://www.saphirion.com
smarter | better | faster
Jun 29 2020
prev sibling next sibling parent Paolo Invernizzi <paolo.invernizzi gmail.com> writes:
On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

 On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch 
 wrote:

 [...]


 Sciter's author here.

 [...]


We toyed with Armonia a lot, I remember the DOM tree was stored 
in a single dynamic array, with function to traverse it ...

It was a really cool framework!
Jun 29 2020
prev sibling parent reply =?UTF-8?B?0JLQuNGC0LDQu9C40Lkg0KTQsNC0?= =?UTF-8?B?0LXQtdCy?= writes:
On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

 On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch 
 wrote:

 On 2020-06-25 03:33:23 +0000, Виталий Фадеев said:


 What about Sciter ?
 
 Site: https://sciter.com/
 
 D: https://github.com/sciter-sdk/Sciter-Dport


 It looks interesting but I never tried it. Any experience with 
 it?


 Sciter's author here.


 If to consider a "perfect and modern D GUI library":

 1. It should have unified DOM serializable to HTML/XHTML. There 
 are many good reasons for that, from Accessibility (a.k.a. 
 Section 508), to things like enabling React alike functionality 
 and JSX. D syntax may even support JSX natively in the way I 
 did in Sciter's script: 
 https://sciter.com/docs/content/script/language/ssx.htm

 2. It should be style-able, so is CSS or its subset. It is 
 again flexible and 95% UI developers know it already. 
 Style-ability here means not just colors but flexibility and 
 configurability of element flows (layout manager in Java AWT 
 terms).

 3. It shall use GPU rendering as much as possible. That's the 
 must for high-DPI monitors.

 4. Implementation shall be compact - each D GUI application 
 will include it statically and compilations time shall be short.



 Please let me know if someone will start doing anything close 
 to the the above in D - I can help.


I do.
Everything goes well.

1. HTML will be later, JSX not planned.
Idea is to use native D language.
Like this:

void main()
{
     with ( new App )
     {
         with ( CR!Screen )
         {
             with ( CR!Window )
             {
                 with ( CR!Element )
                 {
                     classes ~= "row";

                     with ( CR!Element )
                     {
                         classes ~= "c1/3 menu";
                     }

                     with ( CR!Element )
                     {
                         classes ~= "c2/3 search center";
                     }

                     with ( CR!Element )
                     {
                         classes ~= "c3/3 indicators right";
                     }
                 }

                 with ( CR!Element )
                 {
                     classes ~= "row";

                     with ( CR!Element )
                     {
                         classes ~= "c1/1 video center";
                     }
                 }
             }
         }
     }
}

2. CSS, of course :)

There will be a function for style.
And destylization.
Like this:

     struct Style
     {
         string    className;
         CHECKER[] checkers;
         STYLER    styler;
         UNSTYLER  unstyler;

         uint weight;
     }

using:

     styles ~= new Style( "row", [], ( ElementStyled* element ) {
         element.width = "parent";
     });

And CSS. How we all love.
Like this:

.row {
     width: 100%;
}


3. Windows GDI as main concept. For using on Android will be 
OpenGL.

Will be surface backend. Like this:

interface ISurface
{
     void BeginPaint ( );
     void RelArea    ( AREA relArea );
     void AbsArea    ( AREA absArea );
     void Path       ( POINT[] points );
     void Color      ( COLOR color );
     void Style      ( LINE_STYLE style );
     void Weight     ( WEIGHT weight );
     void Font       ( FONT font );
     void Fill       ( );
     void Stroke     ( );
     void MoveTo     ( int x, int y );
     void LineTo     ( int x, int y );
     void AngleArc   ( int cx, int cy, int r, float startAngle, 
float sweepAngle, int direction );
     void Char       ( wchar c );
     void Text       ( string text );
     void Image      ( Image image );
     void EndPaint   ( );
}

This is past version. Now I think it will be easier Screen / 
Window / GPU-Backend.

I want keep small Node / Element. And want to use Window as 
Element in DocTree.
It will be beautiful. and I want to keep the principle of 
similarity.

4. Here we have: clibs + D runtime + Phobos. We’ll come up with 
something later...


I want beauty & fast Windows Shell!
I want beauty & fast Windows Open/Save/Select folder dialogs!
I want beauty & fast Windows file manager!
I want beauty & fast Windows applications!
I want beauty & fast & usable Android Offline Maps!
And I love Linux & I want also on Linux!
)
Jun 29 2020
next sibling parent aberba <karabutaworld gmail.com> writes:
On Monday, 29 June 2020 at 13:14:04 UTC, Виталий Фадеев wrote:

 On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

[...]



 [...]


 I do.
 Everything goes well.

 [...]


This reads pretty awesome.
Jun 29 2020
prev sibling parent reply =?UTF-8?B?0JLQuNGC0LDQu9C40Lkg0KTQsNC0?= =?UTF-8?B?0LXQtdCy?= writes:
On Monday, 29 June 2020 at 13:14:04 UTC, Виталий Фадеев wrote:

 On Sunday, 28 June 2020 at 18:01:08 UTC, c-smile wrote:

 On Thursday, 25 June 2020 at 20:42:25 UTC, Robert M. Münch 
 wrote:

 On 2020-06-25 03:33:23 +0000, Виталий Фадеев said:


 What about Sciter ?
 
 Site: https://sciter.com/
 
 D: https://github.com/sciter-sdk/Sciter-Dport


 It looks interesting but I never tried it. Any experience 
 with it?


 Sciter's author here.


 If to consider a "perfect and modern D GUI library":

 1. It should have unified DOM serializable to HTML/XHTML. 
 There are many good reasons for that, from Accessibility 
 (a.k.a. Section 508), to things like enabling React alike 
 functionality and JSX. D syntax may even support JSX natively 
 in the way I did in Sciter's script: 
 https://sciter.com/docs/content/script/language/ssx.htm

 2. It should be style-able, so is CSS or its subset. It is 
 again flexible and 95% UI developers know it already. 
 Style-ability here means not just colors but flexibility and 
 configurability of element flows (layout manager in Java AWT 
 terms).

 3. It shall use GPU rendering as much as possible. That's the 
 must for high-DPI monitors.

 4. Implementation shall be compact - each D GUI application 
 will include it statically and compilations time shall be 
 short.



 Please let me know if someone will start doing anything close 
 to the the above in D - I can help.




In first version was GC. It gived many time for experiments. GC 
take on self dirty work.
Now Node/Element will like this:

struct Node
{
     Node* parent;
     Node* firstChild;
     Node* lastChild;
     Node* prev;
     Node* next;
}


struct Element
{
     Node node;

     alias node this;

     //
     Properties props; // Element properties
     Properties style; // Style properties

     //
     Computed computed;  // <-- after Apply Style and Update. 
Initial Properties + Style Properties + Element Properties

     //
     Node* g; // Window

     //
     Eventer!( MouseEvent ) onMouseMove;
     Eventer!( MouseEvent ) onMouseButton;
     Eventer!( KeyEvent   ) onKey;
     Eventer!( ClickEvent ) onClick;
     Eventer!( SizeEvent  ) onResize;

     //
     uint updateStamp;
}

Robert ( c-smile ),
1. How you see best Node / Element structure ?
Jun 29 2020
parent c-smile <andrew sciter.com> writes:
On Monday, 29 June 2020 at 14:34:45 UTC, Виталий Фадеев wrote:


 Now Node/Element will like this:

 struct Node
 {
     Node* parent;
     Node* firstChild;
     Node* lastChild;
     Node* prev;
     Node* next;
 }


 struct Element
 {
     Node node;

     alias node this;

     //
     Properties props; // Element properties
     Properties style; // Style properties

     //
     Computed computed;  // <-- after Apply Style and Update. 
 Initial Properties + Style Properties + Element Properties

     //
     Node* g; // Window

     //
     Eventer!( MouseEvent ) onMouseMove;
     Eventer!( MouseEvent ) onMouseButton;
     Eventer!( KeyEvent   ) onKey;
     Eventer!( ClickEvent ) onClick;
     Eventer!( SizeEvent  ) onResize;

     //
     uint updateStamp;
 }

 Robert ( c-smile ),
 1. How you see best Node / Element structure ?



Best Node/Element structure is debatable and depends on design 
goals.

Here is Sciter's DOM tree representation

struct node: resource // reference counted entity
{
     weak_handle<element>   parent;
     weak_handle<element>   layout_parent; // normally parent, but 
can be different
     uint                   node_index;    // index in 
element::nodes collection
};

struct text : public node {...};
struct comment : public node {...};

struct element: node {

     tag::symbol_t tag;     // #div, #p, #span, etc.
     attribute_bag atts;    // DOM attributes
     ui_state      state;   // :focus, :hover, :active, etc.

     vector<hnode>        nodes; // child nodes
     handle<layout_data>  ldata; // "rendering tree" data

     hstyle          c_style; // current used style
     hstyle          p_style; // previously used style
     hstyle          d_style; // defined/determined style - 
computed from CSS
                              // declarations
     hstyle_prop_map a_style; // assigned style, can be null - 
element.style["..."] = ...;
     hstyle          p_drawn_style; // previously drawn style, for 
animation triggering

     handle<animation>    animator; // list of animators
     handle<ctl>          behavior; // event handlers a.k.a. 
behaviors

};

struct element in Sciter supports dynamic subclassing ( explained 
here 
https://stackoverflow.com/questions/21212379/changing-vtbl-of-existing-object-on-the-fly
dynamic-subclassing )

So, depending on style applied, particular element can be 
switched to (may have VTBL of derived class)

element_vertical // flex
element_horizontal // flex
element_grid // grid, flex
element_text // text container, like <p>
element_table
element_table_body
element_table_row
etc.
Jun 29 2020