News for hackers. Stuff that matters.
Re:C++ UI Libraries by guido_vongraum on Friday May 10, 2019 @03:00PM (#19881089)
That separate language can be learned in a few days and leave you wondering how one guy managed to make things more logical than a crowd of people around JS.

If 5MB is a con, what do you say about 30MB for Qt and ~100MB for Electron?

Also, could you please elaborate on the first statement?

Re:C++ UI Libraries by BubRoss on Friday May 10, 2019 @03:09PM (#19881184)
Markup languages for a GUI where isn't needed is a pain because you have a source of indirection when you could just pass the data that the UI library wants directly. Why have a separate text representation and if it must be there, why HTML and CSS? Json would allow you to give the information directly instead of using the convoluted rules of a system that has evolved over decades?

A text language that isn't just values being passed creates new rules and an opaque layer when it is completely unnecessary.

I don't know why Qt takes 50MBs or more for hello world or why anyone would use electron at all. At least Qt will run fast and not have lag and latency. Electron is just the worst of all worlds unless all someone knows is JavaScript.

Re:C++ UI Libraries by c-smile on Friday May 10, 2019 @04:57PM (#19882154)
Sciter's author here...

"Markup languages for a GUI where isn't needed..."

You've missed big picture.

Markup language defines DOM structure (tree of UI objects). And you must have DOM in your application, either as tree of DOM nodes or tree of window nodes.

ANY UI application uses DOM tree in either form. And so ANY application uses some sort of markup language. Either binary one (e.g. Windows dialog resources) or text based ones (XAML,HTML,QML, etc). And HTML parsing is not significantly slower (https://www.codeproject.com/Articles/14076/Fast-and-Compact-...) then deciphering of binary formats. Yet the Accessibility ... that thing alone mandates DOM tree to be present.

Of course you can have UI where components are nailed down to pixel grids and colors but think about HighRes monitors, RTL languages, support of night/day theming, branding, etc.

Considering all that you will quickly understand that you need all three components: DOM, style system for the DOM and code that changes state of that DOM. Just to have all this modular an manageable on the long run.

Re:C++ UI Libraries by geezerjay on Saturday May 11, 2019 @04:25AM (#19885201)
> Markup language defines DOM structure (tree of UI objects). And you must have DOM in your application, either as tree of DOM nodes or tree of window nodes.

You've argued that UIs require a DOM. Ok, so UIs require a DOM.

That still fails to make a case for needing a separate proprietary markup language to define a DOM, let alone a XML-based one.

Even the Qt folks learned that lesson nearly a decade ago with the introduction of QML.

https://en.wikipedia.org/wiki/QML

Re:C++ UI Libraries by BubRoss on Friday May 10, 2019 @05:56PM (#19882624)
I don't think I've missed much.

> ANY UI application uses DOM tree in either form. And so ANY application uses some sort of markup language.

You are conflating DOM and markup language with heirarchy/dependencies. It isn't necessary to have a text language with lots of different overlapping rules and syntax.

> And HTML parsing is not significantly slower

It's not about speed, it's about unnecessary complexity just to get a layout heirarchy and dependencies.

> UI where components are nailed down to pixel grids and colors

That's a false dichotomy. UIs have been laying out their components without parsing text for almost half a century.

Re:C++ UI Libraries by c-smile on Friday May 10, 2019 @06:28PM (#19882861)
> a text language with lots of different overlapping rules and syntax.

Could you elaborate more on this? What are those overlapping rules?

> unnecessary complexity just to get a layout heirarchy and dependencies.

I have no idea why you think it is so complex...

DOM element is this:

    class Element {
       weak_ptr<Element>    parent;
       vector<ptr<Element>> children;
       map<...>             attributes;
    }
And you will see EXACTLY the same structure in any GUI framework/system.
Re:C++ UI Libraries by BubRoss on Friday May 10, 2019 @06:58PM (#19883063)
I'm talking about unnecessary complexity when laying out the gui, not implementation. There is no reason to introduce HTML with the various rules in various places, verbosity and indirection. It's a scenario that seems like when all you have is a hammer, everything looks like a nail.

> And you will see EXACTLY the same structure in any GUI framework/system.

I'm sure it works fine, but I wouldn't get stuck on thinking there is no other way.

Re:C++ UI Libraries by c-smile on Friday May 10, 2019 @08:38PM (#19883634)
"a hammer" you mean Electron and it's full scale browser, right?

"I wouldn't get stuck on thinking there is no other way"

There is a way, named "Dear ImGUI", that does not use DOM structure but rather recreates its on each paint event.

Re:C++ UI Libraries by BubRoss on Friday May 10, 2019 @09:34PM (#19883912)
You need to focus, no one is talking about electron. It's in its own world of nonsense.

> There is a way, named "Dear ImGUI"

I'm not talking about immediate GUIs (and they use a heirarchy for layout too of course). You put some example c++ and said every GUI has that same structure, which isn't necessarily true. A heirarchy doesn't have to be implemented with a tree of pointers.

I'm not saying these things can't work, but saying 'this is how it must be done' is just not true.

Re:C++ UI Libraries by jcelerier on Saturday May 11, 2019 @01:46AM (#19884779)
But it is though. If you need to have accessibility support in your GUI, all the native accessibility APIs are based on trees so you're going to have to create that tree one way or another.
Re:C++ UI Libraries by c-smile on Saturday May 11, 2019 @01:13AM (#19884682)
> every GUI has that same structure, which isn't necessarily true

I'd insist on EVERY here. Container holds list of children. Child holds reference to parent - typical tree implementation.

If you have in mind something else - please show.

Re:C++ UI Libraries by BubRoss on Saturday May 11, 2019 @09:02AM (#19885946)
You showed a few lines of C++. Even for heirarchy,this doesn't need to be a tree of pointers. It's not so bad if it is, but data can be represented as tables or arrays of attributes. Really in a ui the layout is about dependencies and doesn't strictly have to be hierarchy. It's not all that important, just saying that everything must be done in a certain way is ridiculous.
Re:C++ UI Libraries by c-smile on Saturday May 11, 2019 @11:25AM (#19886623)
You can do inside whatever you want but you shall provide an API similar to these two functions: HWND GetParent(HWND child) and EnumChildWindows(HWND parent, callback).

Once again: IAccessibility mandates tree organization of your UI. You can do whatever you want but your UI framework MUST expose UI structure as a tree.

Re:C++ UI Libraries by BubRoss on Saturday May 11, 2019 @12:37PM (#19886998)
This is just moving the goal posts. First you said every GUI needs a markup language, then a specific pointer tree internal structure, now accessibility and specific exposed API.
Re:C++ UI Libraries by ahartmetz on Friday May 10, 2019 @03:36PM (#19881463)
You only need to ship what you use. QtCore + QtWidgets is more like 15 MB. QtNetwork is another couple MB. The biggest part is QtWebEngine which contains Blink, the core of Chrome.

Edit: QtCore + QtQuick + QtQml should also be roughly 15 MB

Re:C++ UI Libraries by pierrebai on Friday May 10, 2019 @03:31PM (#19881416)
Why Qt takes 50 MBs for hello world?

Simple: because that is not true.

I have an application written for Qt and the Qt DLLs for Windows 16-bit are about 16 MB. (Core, Gui, Widgets, WinExtras, style and imageformats.) But, frankly, even if it were true, the disk size of the framework should be extremely low on a list of criteria. As others have noted, the pros and cons listed are not convincing.

Re:C++ UI Libraries by guido_vongraum on Friday May 10, 2019 @03:42PM (#19881535)
I believe 50MB is an exaggeration, but not too far-fetched one. More of a problem is the proliferation and duplication of these DLLs all over the storage when many Qt-based apps are installed. A quick Everything query shows that right now I've got 290MB of Qt*.dlls on my drive.
Re:C++ UI Libraries by the_pwner224 on Friday May 10, 2019 @09:58PM (#19884028)
Seems more like an issue with Windows and its ecosystem of nonfree software.

On most of the Unix-like distros, the maintainers fetch & compile the applications that they make available in the repositories. They can provide a few packages for the various Qt libs, and add these as dependencies to the hundreds/thousands of programs that use Qt. The Qt libs are only downloaded once regardless of whether you have 1 or 20 end-user Qt applications.

Dynamic loading and library updates aren't an issue since the distro maintainers recompile all the Qt-dependent applications whenever Qt has a major update. Older versions can be kept around for programs that haven't been updated in a long time (e.g. I have Qt4 installed on my system as a dependency even though Qt5 has been out for a long time), so there's little extra burden on developers. And with the exception of a few nonfree programs, the entire system works with one system-wide copy of any library.

Of course that doesn't fix the issue for Windows/macOS users, but there's an obvious and proven solution which works, and if main reason it doesn't work for Windows/macOS is because most developers for those platforms restrict the users of their software using nonfree licensing, it only seems fair to blame those ecosystems and OSs instead of blaming Qt.

Re:C++ UI Libraries by guido_vongraum on Saturday May 11, 2019 @05:28AM (#19885357)
Correct me if I'm wrong, but Windows ecosystem doesn't forbid e.g. Java applications to use the same system-wide JRE, which has to be installed once, manually. It would be a nightmare if every Java app installed its own copy of JRE. Still can happen, like in case of Processing, but that's more of an exception.
Re:C++ UI Libraries by jcelerier on Saturday May 11, 2019 @08:07AM (#19885755)
> Correct me if I'm wrong, but Windows ecosystem doesn't forbid e.g. Java applications to use the same system-wide JRE, which has to be installed once, manually. It would be a nightmare if every Java app installed its own copy of JRE. Still can happen, like in case of Processing, but that's more of an exception.

uh... you were right in 2005. Nowadays the standard is for every app to ship its JRE - having to have to install a system wide JRE is part of the stuff that gave Java such a bad and bloaty reputation.

Re:C++ UI Libraries by geezerjay on Saturday May 11, 2019 @04:27AM (#19885207)
> I believe 50MB is an exaggeration, but not too far-fetched one.

That's quite an inelegant way to state that you know you've made a false claim but yet you still stick by it.

Re:C++ UI Libraries by guido_vongraum on Saturday May 11, 2019 @05:08AM (#19885313)
In the light of 290MB of scattered DLLs mentioned above, I believe that this is more than elegant way to advocate the guy who made this false claim - if you read carefully enough, you'll notice that it wasn't me. Care to check?
Re:C++ UI Libraries by guido_vongraum on Friday May 10, 2019 @03:16PM (#19881259)
> I don't know why Qt takes 50MBs or more for hello world or why anyone would use electron at all

You have all my sympathy here :) Well, it should also be noted that 5MB is the size of Sciter's dynamic library. Compiled statically, there will be less contributing to the app's size.

As to markup languages, well, maybe, but I think they are a lot more expressive for things that are styled, positioned via constraints, dynamic and animated. That's completely different approach compared to predefined component libs like WinForms etc.