Right now, I am using wxpython to make a UI. But I find out that under windows invironment, the four corners are all angles.
Is it possible to change the form of the four corners and make them more smooth like this?
Short answer: no.
WxPython is based on WxWidgets and, as you can see on WxWidget's homepage:
Unlike other cross-platform toolkits, wxWidgets gives its applications a truly native look and feel because it uses the platform's native API rather than emulating the GUI
Basically this means that WxWidgets and, by extension, WxPython are great choices if you want to design cross platform GUIs that automatically conform to each platform's GUI style. The downside of this is that it is not the best choice of toolkits if you want to make custom GUI elements, like those rounded corners.
I'm not too familiar with Tkinter (another popular Python GUI toolkit) but this previous SO question seems to be exactly what you want. Perhaps you should experiment using Tkinnter instead of WxPython.
----EDIT----
It turns out I was wrong. There IS a way to do it in WxPython, as evidenced by this SO question. However, I maintain that WxPython is best suited to native-style windows and if you want to make completely custom UIs then you'll find better support working with another toolkit.
Related
Need advise from those who have minimum health experience to design GUI interfaces with Python.
When and what to choose depending of GUI complexity?
Which GUI builders can we use to have a better development quality?
This is my first GUI design, and I've did it without GUI builder, at the moment stacked because I've understood, that ObjectListView wrapper for wx.ListCtrl haven't natively to include easily progress bar or gauge elements. (see column "Upload status" from picture).
Note: ObjectListView has progress bar in .Net version, at the moment not in wx.Python.
P.S: I found this wonderful Python GTK+ Full Stack Tutorial
I'm not really sure what you're asking. wxPython and pyQt / pyside are probably the easiest to use on all platforms and will look right on most Operating systems. I know wxPython is specifically designed to wrap the native widgets so if you want your app to look native, I think wxPython is the way to go. If you want to be able to theme/skin your app, then PyQT or pyGTK may be better.
PyQt/PySide supports mobile to some degree, which I don't believe the other two do. If you plan to program for mobile, then you might want to go that route or look at Kivy.
PyQt/PySide have a pretty powerful WYSIWYG editor. wxPython has a couple, but I don't think any of them support all of wx's widgets and their support is spotty. That hasn't stopped me as I do all my coding by hand anyway.
As usual, you'll probably need to read lots of documentation and try each of them to see which one fits your brain and meets your needs best.
Don't use PyGTK if you want cross platform compatibility. GTK3 doesn't work on windows yet (last I checked) and GTK2 has an awful memory leak under windows which has been fixed in the latest source, but no new release has been compiled for windows.
I would put my vote with PySide (more flexible license for commercial options) over PyQt and PySide/PyQt over wxPython simply because I think the GUI designer tool are better! Being able to rapidly create and edit the GUI graphically (and independently of your applications code) is a huge time-saver.
Update: Actually, I'd recommend PyQt over PySide now for stability reasons and long term support. PySide development is lagging, there are very few people fixing bugs and no-one working on support for Qt 5.
PyQT in Windows
PyGTK
PyQT in KDE
PyQT in Windows
PyGTK+3
PyQT in KDE
So if you go with PyQT the design of your application will look different on the different operating systems and desktop environments. I don't have Macintosh so cannot provide a picture how will look my application in it. This is one of my applications written in PyQT and PyGTK+3. Keep in mind that the design will stay as is with PyGTK+3, so there won't be any differences as they are in PyQT. It's definitely the most easiest to learn, as there is a Glade program which will help you to build your design without spending even a minute coding it manually. But with PyQT you can fine tune the application design and it won't make you tear your hair from bugs.
I'd like to develop a desktop app with Ruby. However, I'd like to have a native GUI on every platform (as opposed to a cross-platform GUI Toolkit that looks consistently awful across all platforms).
I expect to have to do different GUIs for each platform (as it's not just looks but also behaviors and idioms that are different), but I wonder what my options are? Especially wondering if there is a clean way to separate front and backend and bind the data properly?
Target Platforms are Windows (Vista & 7, XP is a Bonus), Mac OS X (Cocoa) and Linux (GTK? Qt? No idea).
The Ruby language has excellent Qt library bindings and your scripts will be cross-platform.
Two Kinds of Cross-Platform
It turns out there are two kinds of cross-platform UI toolkits.
One kind draws its own controls, and, like you said, looks equally bad on all platforms. Even worse: it looks out-of-place on all except one.
But there is another kind that just provides a harmonized interface to the native widgets. The best of example of this kind of toolkit is SWT1.. It looks, it is, approximately fully native on each platform, yet it has but a single API.
So you shouldn't simply rule-out all cross-platform toolkits, just rule out the ones that fake the native UI.
Develop the Wrapper Interface
There is a second way. If your program's interface with the user can be directed through a relatively narrow interface, you can simply develop to that interface and then implement the bottom part of it for each platform you want to support. Yes, you have to rewrite one module, but all the other modules stay exactly the same and you get native widgets. You also get the smallest possible executable without lots of bloat.
Perhaps most importantly, you don't have a complex and opaque software layer between your code and the native windowing system. You will probably save as much time debugging as you spend writing the extra module for your first port.
1. I know my Java examples won't help you much unless you are using jRuby, but SWT vs Swing is a really pure example of the right-vs-wrong (IMHO) UI toolkit divide.
The WxWidgets interface claims to use the native interface on Windows, OS X, Linux and UNIX through one API.
Coworkers who have used it in the past enjoyed it well enough, but I've not used it myself.
I'm trying to develop a simple program in python (but this is not a requirement, I can switch to another language if worthwhile) and I'd like to make it very usable by elderly people, is there some GUI library already available?
Well, which OS platform are we standing in? If you are in linux or windows and using C# take a look at MonoDevelop. If in linux, I would stick with QT LAF and there's also GTK too.
Now, if I was in your position I would start making prototypes of the program and presenting them to the ederly, survey them through the process and make best of their inputs. It's not an easy task but it will do the work at the end of the process. Keep it simple and don't try to clutter up the ui design.
if your making a seperate GUI for elderly people it's probably best you make it yourself from whatever existing code/libraries you have.
Like increasing the element and text sizes, and increasing the contrast. But not too much that you make the majority feel patronised.
Most GUI libs support some kind of widgets that can be used for people that have some problem with their eyes or such. However, i don't think that there is a library that is particularly targetted to that. Hence, i would use GTK or Qt. In the end, it comes down to how you design your GUI.
We are planning to develop an application for monitoring and configuring our service (which is running on remote server). After long time of discussion, we decided for python as platform for our app, because we love and know python. But we don't know, what GUI toolkit preferred for our aims. We need fast (for development and running) app, whose users will be Admins, Maintainers and Account managers.
There are two GUI toolkit for python, which we know: wxPython and pyQT.
Anybody have arguments regarding pro and cons? And maybe someone knows any commercial applications, using these products (only python version of toolkits)? Links are desirable.
Thanks.
I choose wxPython after much research. The reasons were:
"wxPython in Action" book by Rappin & Dunn
The voluminous examples that come as part of the wxPython download
The number of projects that have used wxWidgets
The fact that wxPython code runs equally well on Linux, Mac OS/X and Win32
I did consider pyQT and other researchers are successfully using it. After writing many examples in all API's that I considered, I found wxPython ticked the most boxes for me.
As for Tkinter (TIX), I think it looks rather dated.
Unless you are using IronPython or Jython I would not consider using the associated native windowing APIs. For another project which is to be delivered exclusively on .Net, I plan to use WinForms after lots of great feedback from StackOverflow members.
Well, I am a fan of QT: it has a more modern look and feel. However - your choice should be based on your actual requirements. Simple trade studies are helpful for this. Make a list of what features your toolkit must have and what features would be nice to have and then weight each item appropriately. Then look at all your options (TKinter also) and then score them according to your feature list (using the weights you assigned to each feature requirement). At the end it should be evident which one is right for your project.
I've always liked Qt's "signals and slots" conceptual model, though I guess it may take a bit of learning for developers who are more used to other models of event propagation and handling. Personally, given a choice, I'd pick PyQt because of this programming aspect.
You wrote "There is two GUI toolkit for python, which we know: wxPython and pyQT." You are forgetting about the most obvious toolkit: tkinter. That's actually part of a core python distribution, no extra downloads required.
Some people don't like Tk but that's often due to ignorance. Tk is a fine choice for a cross platform toolkit. It uses native widgets on windows (and has for many years) and the latest versions of tk use themed widgets on all platforms.
i've been using wxpython for 3 years .. and now we had to switch into pyqt since qt is integrated in maya 2011 .. however , wxpython is more straight forward and you can easily start working on it and learn it from zero fast .it provides and awesome resources and decumentation . but QT provides more powerful features that you cant find in wxpython , for example ( the multi touch detection) , QT also provides good support for drawing devices like pc tablets and so on .
qt also provides a good designer that makes u create interfaces faster.
one of qt disadvantages is it's license since it's not free like wxpython
A Windows (and Mono) option for a GUI toolkit is provided by IronPython. It provides access to the Winforms and WPF libraries. For examples, see Developing with IronPython & Windows Forms, and many others.
If you want to expand the list of options, consider building a Web App instead of a (local) GUI app. You say your service runs on a remote server, so networking is part of your requirements.
Once you start down that road, Python provides a bewildering amount of options.
I want to point out two strengths that wxPython has compared to pyQt:
It uses native widgets on every supported platform. So the apps have a native look and feel. I'm aware that PyQt uses native styles, but the behavior ("the feel") is reported to be somewhat non-native especially on the Mac.
It provides a wider choice of widgets out of the box.
You should also check out PyGTK. It is similar to pyQT in programming model but does not have any licensing cost since it is LGPL. I always found it nice to work with as a developer. The main drawback over pyQT is that in some cases they take away functionality in things like file chooser dialogs in favour of simplicity for the user.
I want to start programming with D. I have a simple application in mind that needs a GUI but I want to make sure it's portable to Linux/Windows/Mac equally well and with minimal (no) change for each platform.
wxD is looking like the contender of choice because I know the wx toolkit already.
I see fltk4d as a contender and a (unfinished) wrapper around Qt.
Are there any other truly cross platform GUI toolkits for D that will go where I want with little effort and what would the the toolkit of choice for people here?
GtkD should be a very good option for you as a stable Windows/Linux/Mac GUI toolkit.
DWT was once considered the standard, it has its own newsgroup on the Digital Mars server and I think Walter Bright may have called it the standard too. I don't think it's completely working on Mac but this should change in the future.
Here is a nice list of some other options but most have less active development and/or are not yet ready for production.
I have not used any of D's GUI libraries, but I would go with wxD if I wanted to use one now. I would pick it because I think wxD would have the most native looking controls and is cross-platform. Especially since you already know wx, it looks like a good choice.
I'm actually writing a cross-platform GUI library, Dynamin, but I have not released it yet. It is not a port; ported libraries tend to not have as nice of APIs or take advantage of as many language features. But it is not far enough along to do more than simple programs. I also don't have a Mac backend or GTK theme yet.