Each widget should only be concerned with painting itself in the paint event so that it is clipped correctly against other widgets. Your paint event should not paint on other widgets. If you do it correctly, there are no problems with putting it inside a QFrame.
What you want to do is to create your own QWidget subclass and do the painting from there. I found a usable example that shows the whole process here:. I still dont understand what you mean by "drawing on QFrame". You should not draw on other widgets at all. A widget should only draw on itself and not refer to other widgets inside of the paintEvent. Just create a QWidget subclass and re-implement paintEvent as in the example above. Draw everything you need and there should be no need to have pointers to other widgets there.
After that you can put it inside a QFrame just like any other widget and Qt will ensure that your cust om child widget gets painted first, and then the QFrame paints itself on top of it.
That said, if all you need is a frame around your custom painted widget, perhaps you could simply draw a rectangle yourself and avoid using a QFrame at all. I am doing everything with QWidgets, and QLabel. Why am I using a QFrame? I only need to change the position of my QFrame and everything inside is moved as well.
But now I would like to add some lines connecting the sniper pointing to the monsters. I could also use a QImage but then I had to move the position and "rotating" the image, but that seems to be little too much work, especially the rotating. You are achieving really impressive things with widgets that they were not primarily designed to do.
Doing it this way would still allow you to move the scene around without changing "thousands of variables". You could for instance still put your gamecanvas widget inside a QScrollArea, or you could have a global viewPortPosition that you add when you draw the sprites. It might be a bit of work to change all of your drawing this way but it is probably better than trying to let widgets draw on top of each other but I think it would be worth it.
If you want a simple hack that works, you can try to replace QFrame with QWidget subclass since it does not set a clip but essentially achieves the same. The monsters are. I can create up to monsters that are moving through the path without caching the animations and everything works smoothly.
I would argue my method would be simpler, not harder but you can save that for your next game. Another suggestion is to look at the GraphicsView classes. QGraphicsItem is a little more lightweight than QLabel and provides built in collision detection. But performance doesn't really matter that much when computers are as powerful as they are. Good luck though.
Your game already looks really fun and I happen to love tower defence games :. But the imagination to rewrite everything in QPainters little scared me, seems like lots of work. My first aim was actually creating a Tower Defense game where you can build the towers anywhere you like and the monster had to find a way through your "maze".
But right now I have to postpone my plans to February after exams, QT is just one of six other subjects.Drawing and Filling. The QPaintDevice class is the base class of objects that can be painted, i.
QPainter can draw on any QPaintDevice subclass. The QWidget class is the base class of user interface elements in the Qt Widgets module. It receives mouse, keyboard and other events from the window system, and paints a representation of itself on the screen. QImage supports several image formats including monochrome, 8-bit, bit and alpha-blended images.
One advantage of using QImage as a paint device is that it is possible to guarantee the pixel exactness of any drawing operation in a platform-independent way. Another benefit is that the painting can be performed in another thread than the current GUI thread.
The QPixmap class is an off-screen image representation which is designed and optimized for showing images on screen. Unlike QImagethe pixel data in a pixmap is internal and is managed by the underlying window system, i.
To optimize drawing with QPixmapQt provides the QPixmapCache class which can be used to store temporary pixmaps that are expensive to generate without using more storage space than the cache limit. Qt also provides the QBitmap convenience class, inheriting QPixmap. QBitmap guarantees monochrome 1-bit depth pixmaps, and is mainly used for creating custom QCursor and QBrush objects, constructing QRegion objects.
The QPicture class is a paint device that records and replays QPainter commands. A picture serializes painter commands to an IO device in a platform-independent format.
QPicture is also resolution independent, i. Qt provides the QPicture::load and QPicture::save functions as well as streaming operators for loading and saving pictures. Support for a new backend can be implemented by deriving from the QPaintDevice class and reimplementing the virtual QPaintDevice::paintEngine function to tell QPainter which paint engine should be used to draw on this particular device.
To actually be able to draw on the device, this paint engine must be a custom paint engine created by deriving from the QPaintEngine class. Documentation contributions included herein are the copyrights of their respective owners. Qt and respective logos are trademarks of The Qt Company Ltd.
The dark mode beta is finally here. Change your preferences any time. Stack Overflow for Teams is a private, secure spot for you and your coworkers to find and share information. On pushing the button I want a line to be drawn across the "Graphics View" widget. I have changed the name of the "Graphics View" widget to gv by right-clicking the widget in design view and then selecting change objectName. I am not able to understand how should the line be drawn.
But I got more confused. In your case, you'd create a QGraphicsLineItem and add it to the scene, or directly create it as an item of the scene by calling the addLine member function of your QGraphicsScene instance. All drawing will be done by Qt itself, assuming that you did connect your graphics view and scene properly.
Be sure to read The Graphics View Frameworkwhich gives you an overview over how these components work. QPainter provides highly optimized functions to do most of the drawing GUI programs require. Learn more. Asked 9 years, 7 months ago. Active 3 years, 2 months ago. Viewed 7k times. Kindly help me with this. A small sample code shall be really helpful for me as I am new to Qt.
Active Oldest Votes. Jim Brissom Jim Brissom Martin Beckett Martin Beckett I created a widget MyDisplayWidget. But I have designed a form mainwindow.
How do I include this new widget in that gui? There is a lot of coding to be done to be able to use custom widgets in Qt's designer application.
If you want to use your custom widget in your mainwindow, use the designer application to put a place holder widget or frame and then in the code for your main window, create an instance of your custom widget and add it to the place holder. See doc.Creating custom widget is not a hard problem, but there are a few things you should consider. This is about creating a completely new widget that is not included in the standard list of widgets.
Creating Custom Widgets
This blog is meant as a check-list you can go to, when you create a new widget. Just run through the items below and you are well on your way to creating a good widget that will serve you well in many different circumstances.
But I will give you a bunch of hints and tips on how to do a properly good job when you are tasked with creating a custom widget. This is perhaps a surprisingly long list. As you gain experience, this simple list will be enough.
One of the things you should always do is handle sizing. But in my almost 21 years as a Qt developer, I have so far not seen a single case where it was a good idea not to use the layouts. The one thing you must do is to give it a size hint.
Just override the sizeHint method and return the proper size for this widget. The trick is to figure out what the proper size is. In some cases this will rely on font size, or the contents. In those cases, you need to notify the layout system that the size hint has changed, if the content or font changes.
You do this by calling updateGeometry. For a few widgets, the height depends on how wide the widget is set, or the width depends on the height. In these cases, override the heightForWidth or widthForHeight methods. Those are pretty rare, though. It is the size policy that tells the layout managers how to use the size information from the widget. You need to set those correctly. In an upcoming blog entry, I will go into detail about the layouts and the size policies, so I will only briefly mention those here.
In most cases you simply call setSizePolicy with the policies for vertical and horizontal. Find the proper size policies in the documentation. Finally, remember that many widgets have different size policies for vertical and horizontal. There are basically only two that makes sense: No focus or strong focus. But this is admittedly a rare thing to do. Unless you are creating an invisible container widget, you are of course going to need some painting. Implement the paintEvent method.
Those are to implement the size hint and paint event by just calling the style. In both cases, you need a style option. Initialize that and call the proper method on the current style. I usually create a private method on the d-pointer that sets up the fields of the style option. In this case, you can reuse the styling code to handle size and painting by calling the style with the proper option object.
And then you implement the input handlers to change the widget behaviour.The Basic Drawing example shows how to display basic graphics primitives in a variety of styles using the QPainter class.
QPainter performs low-level painting on widgets and other paint devices. The class can draw everything from simple lines to complex shapes like pies and chords. It can also draw aligned text and pixmaps. Normally, it draws in a "natural" coordinate system, but it can in addition do view and world transformation. The example provides a render area, displaying the currently active shape, and lets the user manipulate the rendered shape and its appearance using the QPainter parameters: The user can change the active shape Shapeand modify the QPainter 's pen Pen WidthPen StylePen CapPen Joinbrush Brush Style and render hints Antialiasing.
In addition the user can rotate a shape Transformations ; behind the scenes we use QPainter 's ability to manipulate the coordinate system to perform the rotation. First we will review the Window class, then we will take a look at the RenderArea class. The Window class inherits QWidgetand is the application's main window displaying a RenderArea widget in addition to several parameter widgets. We declare the various widgets, and three private slots updating the RenderArea widget: The shapeChanged slot updates the RenderArea widget when the user changes the currently active shape.
We call the penChanged slot when either of the QPainter 's pen parameters changes. And the brushChanged slot updates the RenderArea widget when the user changes the painter's brush style. In the constructor we create and initialize the various widgets appearing in the main application window. First we create the RenderArea widget that will render the currently active shape.
Then we create the Shape combobox, and add the associated items i. QPainter 's pen is a QPen object; the QPen class defines how a painter should draw lines and outlines of shapes. A pen has several properties: Width, style, cap and join. A pen's width can be zero or greater, but the most common width is zero.
Subscribe to RSS
Note that this doesn't mean 0 pixels, but implies that the shape is drawn as smoothly as possible although perhaps not mathematically correct. The pen style defines the line type. The default style is solid Qt::SolidLine. Setting the style to none Qt::NoPen tells the painter to not draw lines or outlines.
The pen cap defines how the end points of lines are drawn. And the pen join defines how two lines join when multiple connected lines are drawn. The cap and join only apply to lines with a width of 1 pixel or greater.
The dark mode beta is finally here. Change your preferences any time. Stack Overflow for Teams is a private, secure spot for you and your coworkers to find and share information. I'm writing a PyQt application and am having some trouble creating a custom list view.
I'd like the list to contain arbitrary widgets one custom widget in particular. How would I go about this? It seems that the alternative would be to create a table or grid view wrapped in a scrollbar.
To clarify, the custom widgets are interactive contain buttonsso the solution requires more than painting a widget. I think you need to subclass QItemDelegate. QItemDelegate can be used to provide custom display features and editor widgets for item views based on QAbstractItemView subclasses. Using a delegate for this purpose allows the display and editing mechanisms to be customized and developed independently from the model and view.
Basically as you can see it checks if the column to be painted is of a specific index, if so it paints a progress bar. I think you could tweak it a little and instead of using a QStyleOption you could use your own widget. While investigating your question I've stumbled upon this thread, which elaborates how to paint a custom widget using a QItemDelegate, I believe it has all the info you might need. Instanciating multiple rows is then just a matter of creating a widget item, and associate the custom widget to the item's row.
Idan's answer works well, but I'll post a simpler example I came up with. This item delegate just draws a black rectangle for each item. Sets the given widget to be displayed in the cell in the given row and column, passing the ownership of the widget to the table. If cell widget A is replaced with cell widget B, cell widget A will be deleted.A plugin is a dynamic library that can be loaded at run-time to extend an application.
Qt makes it possible to create custom plugins and to load them using QPluginLoader. To ensure that plugins don't get lost, it is also possible to link them statically to the executable.
If you want to learn how to make your own application extensible through plugins, we recommend that you start by reading this overview, which explains how to make an application use plugins.
Afterwards, you can read the Basic Tools and Extra Filters overviews, which show how to implement static and dynamic plugins, respectively. We will start by reviewing the interfaces defined in interfaces. They are implemented in the plugins. The BrushInterface class declares four pure virtual functions. The first pure virtual function, brushesreturns a list of strings that identify the brushes provided by the plugin. By returning a QStringList instead of a QStringwe make it possible for a single plugin to provide multiple brushes.
The other functions have a brush parameter to identify which brush among those returned by brushes is used.
Implement the row with a custom Widget
The class also has a virtual destructor. Interface classes usually don't need such a destructor because it would make little sense to delete the object that implements the interface through a pointer to the interfacebut some compilers emit a warning for classes that declare virtual functions but no virtual destructor. We provide the destructor to keep these compilers happy. The ShapeInterface class declares a shapes function that works the same as BrushInterface 's brushes function, and a generateShape function that has a shape parameter.
Shapes are represented by a QPainterPatha data type that can represent arbitrary 2D shapes or combinations of shapes. The parent parameter can be used by the plugin to pop up a dialog asking the user to specify more information. The FilterInterface class declares a filters function that returns a list of filter names, and a filterImage function that applies a filter to an image.
The first argument is the name of the interface. The second argument is a string identifying the interface in a unique way. By convention, we use a "Java package name" syntax to identify interfaces. If we later change the interfaces, we must use a different string to identify the new interface; otherwise, the application might crash. It is therefore a good idea to include a version number in the string, as we did above. A note on naming: It might have been tempting to give the brushesshapesand filters functions a more generic name, such as keys or features.
However, that would have made multiple inheritance impractical. When creating interfaces, we should always try to give unique names to the pure virtual functions. Here, we'll concentrate on the parts of the code that are related to plugins.
The loadPlugins function is called from the MainWindow constructor to detect plugins and update the BrushShapesand Filters menus. We start by handling static plugins available through QPluginLoader::staticInstances. To the application that uses the plugin, a Qt plugin is simply a QObject. That QObject implements plugin interfaces using multiple inheritance. The next step is to load dynamic plugins. On Unix, this is just a matter of initializing the QDir variable with QApplication::applicationDirPaththe path of the executable file, and to do a cd.
On Windows and macOS, this file is usually located in a subdirectory, so we need to take this into account.