I developed a simple QT application on Windows using QT creator 5.8 with good result. I used a simple form with QSpinBox.
To fix the color of the QSpinBox I wrote in the related style sheet
color:rgb(255,255,255);
Then I moved the application on MaxOs but the look of QSpinBox changed.
Did you have a similar problem ? How did you fix it ?
Thank you very much for your help and cooperation
regards
This is because the QWidget appearance actually depends on the platform. One (limited) solution is to use the palette, with setForegroundRole
The other is to use stylesheets, like you did, but you very likely will have to redefine more to obtain the desired result, and result will of course depend on the platform. You can actually make the result completely custom using only stylesheet. Just make sure to set the "border" style to avoid problems.
Here is Qt documentation about style sheets: Qt StyleSheets
Related
I've been struggling with learning how to use stylesheets to customize the look of my widgets in Qt.
For example, after much effort, I just figured out that the name of the property that determines what color the text on a QComboBox drop-down menu is when it is mouse-over'd is selection-color, and the background color is selection-background-color. But most of that I discovered by random guess-and-check.
Where can I find documentation that will actually tell me these things so I don't have to guess? Does Qt follow some sort of standard naming convention?
http://doc.qt.nokia.com/latest/stylesheet-reference.html
http://doc.qt.io/qt-5/stylesheet-examples.html
The above link gives examples for pretty much every control. For the combobox it mentions the QAbstractItemView, and mentions that you need selection-background-color etc... to style it - with an example.
It doesn't always explain what each property does however, which is where the doc that baysmith linked to comes in.
So with these two documents together you should be in good shape.
I wanted to consult with the sages here regarding Qt and skinning, get your opinion and chart a path for my development. My requirements are as follows:
My Qt/C++ application (cross platform with Mac, Windows and Linux versions) needs to have modular skins.
A skin is defined as a set of one or more elements: - Window background texture - Look/feel of UI controls such as edit boxes, drop down, radio buttons, buttons etc. - Look/feel of window "caption", resize grips etc.
Skins will be installed with the application installer, allowing the user to choose which one he/she wants to use. Users should be able to change skins on the fly.
Can I go the QML route? should this be custom and based on simple resources which are built into the application? Any design advice will be appreciated.
Thanks.
If I understood you correctly then stylesheet is the best way forward. You can create stylesheets similar to CSS and then pass them as command line option to your application or load on invocation to style your application at runtime. That way you can create multiple stylesheets each having a different look and feel and allow user to load them at will. Since its CSS it doesn't need any new learning and you can keep all your styling outside your source code.
Here are a list of resources that can get you up and running quickly:
http://blog.qt.io/blog/2007/11/27/theming-qt-for-fun-and-profit/
http://doc.qt.io/qt-5/stylesheet.html
I haven't played with QML yet, but you could also create a custom QStyle implementation that supports your resource format. Note that you'd lose style sheet support if you went this route.
Changing window captions is a little trickier if you want portability.
QML, if I understand correctly, doesn't really skin the widgets, it mainly deals with GUI layout etc etc.
QStyle is used to change the looks. It is a bit low-level though, and requires programming, so if you want to load different user-created skins (from an XML or so) it might be tricky to support extensive skinning. Chaining colors and a few items are easy enough though. (There might be someone else who've done something you could re-use.. not sure.)
For modifying widgets, use QStyle::polish(). You could use that to change the background picture (if it's a top-level window, or of a certain class). There are numerous repaint method to change almost every part of every widget.
Store/load the style using QSettings, by reading and setting the desired Style just after QApplication but before your main window is constructed.
I've got a cross platform Qt app, and no matter how I tweak the UI, it always looks good on some platforms and bad on others, due to the differences between UI styles.
For example, margins seem to be universally set, even while the underlying elements shift in size dramatically from one platform to another.
What's the recommended way to handle this?
Probably the safest way is to have the most basic UI to start with. Personally I use the qt's css type of styling. Also make sure when you subclass your widgets, you properly override event methods (i.e. resizeEvent(...), hand off parameters to a super class when appropriate. etc) Following basic recommendations from the Qt Docs should do it.
Another note on layouts, make sure you are using:
enum QSizePolicy::Policy
appropriately and your layouts flow well when resized etc, instead of using fixed positions...
Please take a look at QWindowsStyle, QWindowsXPStyle, QPlastiqueStyle.
And use
void QApplication::setStyle ( QStyle * style ) [static]
By doing this you should have one look on all OS-es.
Does Qt support ribbon control?
I want to share with you the link to site has published screenshots of their component Qtitan Ribbon for Qt.
http://www.devmachines.com/qtitanribbon-overview.html
While there is no dedicated Ribbon widget in Qt, you can fashion something similar yourself. You could take a QTabWidget and put some buttons inside (and optionally style it to look a bit more like Microsoft's Ribbon). Depending on what you're trying to accomplish, that might suffice.
One of their sample apps apparently has a ribbon, so it should be do-able.
http://qt.nokia.com/images/products/vtk-designer-opengl-screenshot
You can take any JavaScript/JQuery ribbon, insert it into QWebView and do whatever you want with it, using the Qt Webkit Bridge.
There is no Qt ribbon control.
I believe there are license issues preventing Nokia from developing a ribbon control that is similar to Microsofts.
There are free alternatives to QtitanRibbon by now, for example, checkout:
https://github.com/martijnkoopman/Qt-Ribbon-Widget
You can even directly use it in any *.ui file!
Simply add a QTabWidget in QtDesigner and then promote that widget to the Ribbon class.
No, it doesn't. I didn't find out any plan to support it in the future.
We use QtitanRibbon, and it works very well for us. Support has been good, documentation on the short side. Worth noting that it not only provides a ribbon UI, it also makes it convenient to implement dark mode (or in our case, we opted for grey mode).
Has anybody experience in building a custom style in Qt? What I have in my mind is a complete new style that affects all kind of widgets. I have seen some examples in the web for a custom combo box. But I have no idea how much time and code it takes to build a "complete" new custom style ... maybe someone can give me a hint.
We think of using Qt 4.3 (or even newer) ...
Check out the Stylesheets facility in Qt 4. While it's still a hassle, it's way easier than doing a full-on custom style. You can just adjust one visual facet at a time and try it out.
It pays attention to inheritance. So if you style the font in QWidget, then every visual widget will also use that font. And so on.
I have developed a "new" style that changed the appearance of much of an application. It did take some time, and quite a bit of experimentation. I also derived my style from the generic windows style, to allow it to handle some of the stuff I didn't want to mess with. All told, I think it took me a week to get most of what I wanted, with practically no prior exposure to the styles.
In order to actually develop one, I would get into the source for their styles example, which has a "wood" style. I put my own style in place of the example style, and started changing things while using the example program to check how it looked. Depending on how you are developing it, you might want to have a configuration file so you can easily change some of the values without recompiling.
You might want to look at existing styles. You can find quite a few of them on kde-look.org, in the Styles / 4.0 section.
We've done it in the past (in Qt 3), and it's extremely time-consuming. We had a lot of problems with flickering, redraws not working the way we expected, sluggish behavior, bugs in the Qt implementation. It a lot less straight-forward than it seems, and there's little support or user experience too. Unless you need something really particular (as we did), I'd say it's not worth the trouble.
Other frameworks are supposed to make it easier (some Java-based?), but I don't have first hand experience.
If you don't need to radically change the widget style, you might want to try using widget style sheets:
http://doc.qt.digia.com/4.4/stylesheet.html