I'm looking to use SCons as my prefered method of building my mainly Qt based applications. I'm just learning SCons and I'm struggling to find documentation or tutorials on the topic. Can anyone point me in the right direction please?
This is a start but is there anything better out there?
(I work mainly on Windows)
Kind Regards,
We are using Qt4 and SCons together on Windows simply because we need SCons excellent customization possibilities. The Qt4 tools have proved themselves to be complete enough for our needs, although we do not use all facets of the Qt4 toolkit. The manual is on the Qt4 tools web page
Try here and here.
I would suggest you though to try cmake instead. It has much better documentation and is being used by KDE.
Related
After looking at some OCaml graphics related projects it seems that no one using it for building GUI.
why ?
is there any modern alternatives to those outdated libraries ?
My colleagues and I use OCaml to build iOS apps that we sell. Everything is coded in OCaml, including the GUI. However, making a full OCaml binding to Cocoa Touch would be a very large undertaking, so we concentrate on building the parts that we need. It's definitely possible (and in fact enjoyable) to use OCaml for building real-world GUIs, but to get a really convenient environment would take some serious backing or a pretty big community effort. (If you're interested in our efforts, follow the link in my profile.)
I don't think you will find recent GUI bindings on the old OCaml website. As a rule of thumb, you should consider anything not available through OPAM as outdated. The most "mature" and "wall-supported" bindings for OCaml seem to be LablGtk found here: http://lablgtk.forge.ocamlcore.org/
Many people these days consider that the only GUI "library" that's not outdated is the Web. Whatever your stance on that matter, it's good to know that web is a portable alternative to traditional GUI, and that there are very serious libraries and tools available to program for the web with OCaml (from Ocsigen to Ocamlnet).
After working extensively with Microsoft development tools, I migrated to ubuntu and QT for research purposes.
QT is a great framework, up to now there's nothing I needed and it's not there.
However the tools-ecosystem around QT is a bit behind microsoft's ecosystem (V.Studio, Expression Suite)
More specifically, QT Creator is quite nice, but the lack of a 'standard' tool like MS-Blend (which I think is a must, complementary to V.Studio) or the various Adobe tools is pretty apparent, in the case of developing fancy interfaces, animations etc. And Animations (e.g. menu's apperaing/disapperaing from the side) are a bit painful to hardcode without a 'graphical'-tool.
Do you have any tool to propose for this reason, that I'm not aware of?
PS - Just to avoid misunderstandings, I know about qml/Qt_Quick/qdesigner/qt_Animation - http://doc.qt.digia.com/qt/animation-overview.html. I'm referring to accombining software that make's life easier and reduces time needed for hardcoding stuff
Direct answer:
No there is no tool available in Qt arena that matches the capabilities of Microsoft Blend.
There is this question, which discusses a similar situation; a comparison between .NET and Qt in terms of UI designing.
I'm trying to learn how to program qt. I know c++ very well, and have been able to do the standard hellow world program. I cannot find any books or documention on qt. I did find a tutriol,at
http://www.digitalfanatics.org/projects/qt_tutorial/chapter01.html but the project would not compile, said it could not find include file #include .
Does anubofy know of a book or anything that will tell you how to program the qt frame work?
There is a comprehensive list of books over at Qt Developer Network.
And the documentation for Qt is quite good, with several tutorials as a great place to start.
The link you are directing to above is referring to an old version of Qt, I would guess. The page at least seems to be dated back to 2004. Qt has gone a long way since then, especially when it comes to tools.
Using Qt Creator is probably the best way to start working with Qt applications, as it handles most of the setup needed to get started with a Qt project without having to resort too often to the command line (unless that is how you prefer to do it, of course.)
For Nokia phones you should check out the QML framework for any GUI you're making. Qt Creator has a simple designer for QML and you'll probably find some good help in the QML Getting Started tutorial.
It is easily connected to anything you make in C++, but gives you more ease and freedom in making user interfaces. But if you prefer to do everything in C++, all the things you can do in QML can be done using only C++ end as well.
The book C++ GUI Programming with Qt 4 is the definitive guide to programming Qt, I think. But you can also learn much from the Qt documentation itself, if you know where to start. The Qt documentation is really good and extensive, a perfect reference. And as Qt is also very intuitive, the doc can also help you find new functionality (If you have an idea, how some feature could be realized in Qt, it is often realized just that way).
Put shortly: For those familiar with language bindings in Qt and Gtk+. E.g. python and ruby. Are there any quality or capability difference?
More background: I know C++ and Qt very well. Minimal experience with Gtk+. I know C++ is not ideal for language bindings due to the lack of a well defined ABI (application binary interface). I also read that Gtk+ was designed to be bound to other languages. So I wonder how this manifets itself in practice. Are the Gtk+ bindings better maintained or work better in some way than their Qt counterparts?
I am presently quite interested in the Go language, and they have started developing Gtk+ bindings. However C++ bindings is far away. It makes me wonder whether learning Gtk+ is worth it.
I've used GTK and Qt in C++ and also PyGTK and PyQt in Python quite extensively.
Qt beats GTK hands down - its a much more flexible, modern and clean API. GTK is also lacking some features that are important to me. From a framework point of view, I'd recommend Qt.
As for langauge bindings (I can only speak about Python, since I've never used the Ruby equivalents), I think PyGTK (using Glade and a wrapper like Padraig Bradys libglade) make GUI programming insanely easy and fun. However, if you can GPL your software (or pay the license fee), then PyQt is also a good option, and while not quite as friendly as PyGTK + Glade (in that with GTK you can define your UI in Glade as a separate XML file, so you can tweak the UI without touching code; in Qt if you want to use QtDesigner, you have to generate code using uic, if I remember correctly) the API itself is really really nice to use and mirrors the Qt frameworks clean design very closely.
Over all, I'd probably recommend using PyQt over PyGTK, but I may be biased since I much prefer Qt over GTK nowadays, though you could try both out and see which you prefer - they are both almost trivial to get working.
If you are looking for a great book on PyQt, I'd recomment Rapid GUI Programming qith Python and Qt.
To summarize: IMHO Qt beats GTK in both quality and capability. Both PyGTK and PyQt are of excellent quality and capability mirrors the underlying framework, though PyGTK can load Glade xml files.
I think that GTK bindings are older than Qt ones (and so a bit more mature) but they are both usable and your previous knowledge of Qt should be the main factor in your choice.
I developed small GUIs using both Qt and GTK with their python bindings and found the two equivalent. Some regrets though on the PyQt bindings with Qt container (QVector, ...) that are not translated into regular python data structure and thus add a bit of complexity to the code. I didn't recall the same issues using PyGTK.
I have worked with both PyQt and PyGTK and I would say they're both regularly mantained and synched with their parent frameworks. However, and this is completely subjective, I found more rewarding working with PyGTK than with PyQt, even if I hadn't previously written any code using GTK. If you know well Qt, go with Qt though.
I have been trying a few combinations around Qt : RubyQt, JRuby + Jambi, PyQt. The first one quickly ends up in various segmentation-faults. My Qt skills may be the problem but all in all the seg faults are not quite readable. The forum for RubyQt is nearly dead so don't expect to find much information there.
So I moved to JRuby + Jambi. This worked until well, I reached some missing functions here and there. Plus I had to implement a proper signal/connect for JRuby. So, more or less a hack. Not convincing.
Finally I moved to Python (wich I don't like very much). But woooh, what a difference. Bindings are up to date, I have still to ecnounter a segmetatio fault, error messages are most of the time very explanatory. So as far as I'm concerned Python+Qt is a clear winner.
Please note that I was trying these combinations in order to find a proper language/qt binding so that I can create a production ready with my commutation hours (roughly 2 hours a day). So my tolerance to small-but-annoying problems such as segmentation faults is 0. I also have to develop on Windows and Linux. So Windows installation is necessary (and once again, Python is a clear winner here).
there are C++ gtk+ bindings. Google for gtkmm.
Each project using SCons seems to be reinventing the wheel.
I would be glad to take someones directory layout, and/or solution for variant builds(debug/release), and/or testing framework, and/or best practices.
Even several not-too-simple examples would help.
You may be interested in Google's Software Construction Toolkit that was made open source in February 2009. It adds new features on top of SCons, such as improved Visual Studio project file generation, unit test functions, and distributed builds with distcc or incredibuild.
The SCons Recipes in the wiki is a good place to start. In addition take a look at other projects which use SCons, e.g. the Ardour build system. If that doesn't cut it, there are a few third party SCons extensions you may want to take a look at:
Parts
Aqualid
To the best of my knowledge, there are no SCons best practices which were agreed upon. The SCons community seems to favor adaptability over "canonicalization". It is not hard to design a decent SCons-based build system from scratch, though. (Once you have understood how VariantDir works, at least.)
If you are using Eclipse for C++ development you may want to check out this SCons builder plugin (http://nic-nac-project.org/~lothar/eclipse/update/SConsBuilderPlugin.html)
Another good example of SCons use is build system for MIT-licensed Godot game engine:
https://github.com/okamstudio/godot/wiki/compiling_intro