Qt Jambi Home

com.trolltech.qt.gui
Class QGraphicsScene

java.lang.Object
  extended by com.trolltech.qt.QSignalEmitter
      extended by com.trolltech.qt.QtJambiObject
          extended by com.trolltech.qt.core.QObject
              extended by com.trolltech.qt.gui.QGraphicsScene
All Implemented Interfaces:
QtJambiInterface

public class QGraphicsScene
extends QObject

The QGraphicsScene class provides a surface for managing a large number of 2D graphical items.

The class serves as a container for QGraphicsItems. It is used together with QGraphicsView for visualizing graphical items, such as lines, rectangles, text, or even custom items, on a 2D surface. QGraphicsScene is part of The Graphics View Framework.

QGraphicsScene also provides functionality that lets you efficiently determine both the location of items, and for determining what items are visible within an arbitrary area on the scene. With the QGraphicsView widget, you can either visualize the whole scene, or zoom in and view only parts of the scene.

Example:

    QGraphicsScene scene;
    scene.addText("Hello, world!");

    QGraphicsView view(&scene);
    view.show();

Note that QGraphicsScene has no visual appearance of its own; it only manages the items. You need to create a QGraphicsView widget to visualize the scene.

To add items to a scene, you start off by constructing a QGraphicsScene object. Then, you have two options: either add your existing QGraphicsItem objects by calling addItem, or you can call one of the convenience functions addEllipse, addLine, addPath, addPixmap, addPolygon, addRect, or addText, which all return a pointer to the newly added item. You can then visualize the scene using QGraphicsView. When the scene changes, (e.g., when an item moves or is transformed) QGraphicsScene emits the changed signal. To remove an item, call removeItem.

QGraphicsScene uses an indexing algorithm to manage the location of items efficiently. By default, a BSP (Binary Space Partitioning) tree is used; an algorithm suitable for large scenes where most items remain static (i.e., do not move around). You can choose to disable this index by calling setItemIndexMethod. For more information about the available indexing algorithms, see the itemIndexMethod property.

The scene's bounding rect is set by calling setSceneRect. Items can be placed at any position on the scene, and the size of the scene is by default unlimited. The scene rect is used only for internal bookkeeping, maintaining the scene's item index. If the scene rect is unset, QGraphicsScene will use the bounding area of all items, as returned by itemsBoundingRect, as the scene rect. However, itemsBoundingRect is a relatively time consuming function, as it operates by collecting positional information for every item on the scene. Because of this, you should always set the scene rect when operating on large scenes.

One of QGraphicsScene's greatest strengths is its ability to efficiently determine the location of items. Even with millions of items on the scene, the items functions can determine the location of an item within few milliseconds. There are several overloads to items: one that finds items at a certain position, one that finds items inside or intersecting with a polygon or a rectangle, and more. The list of returned items is sorted by stacking order, with the topmost item being the first item in the list. For convenience, there is also an itemAt function that returns the topmost item at a given position.

QGraphicsScene maintains selection information for the scene. To select items, call setSelectionArea, and to clear the current selection, call clearSelection. Call selectedItems to get the list of all selected items.

Event Handling and Propagation

Another responsibility that QGraphicsScene has, is to propagate events from QGraphicsView. To send an event to a scene, you construct an event that inherits QEvent, and then send it using, for example, QApplication::sendEvent(). event is responsible for dispatching the event to the individual items. Some common events are handled by convenience event handlers. For example, key press events are handled by keyPressEvent, and mouse press events are handled by mousePressEvent.

Key events are delivered to the focus item. To set the focus item, you can either call setFocusItem, passing an item that accepts focus, or the item itself can call QGraphicsItem::setFocus(). Call focusItem to get the current focus item. For compatibility with widgets, the scene also maintains its own focus information. By default, the scene does not have focus, and all key events are discarded. If setFocus is called, or if an item on the scene gains focus, the scene automatically gains focus. If the scene has focus, hasFocus will return true, and key events will be forwarded to the focus item, if any. If the scene loses focus, (i.e., someone calls clearFocus,) while an item has focus, the scene will maintain its item focus information, and once the scene regains focus, it will make sure the last focus item regains focus.

For mouse-over effects, QGraphicsScene dispatches hover events. If an item accepts hover events (see QGraphicsItem::acceptsHoverEvents()), it will receive a GraphicsSceneHoverEnter event when the mouse enters its area. As the mouse continues moving inside the item's area, QGraphicsScene will send it GraphicsSceneHoverMove events. When the mouse leaves the item's area, the item will receive a GraphicsSceneHoverLeave event.

All mouse events are delivered to the current mouse grabber item. An item becomes the scene's mouse grabber if it accepts mouse events (see QGraphicsItem::acceptedMouseButtons()) and it receives a mouse press. It stays the mouse grabber until it receives a mouse release when no other mouse buttons are pressed. You can call mouseGrabberItem to determine what item is currently grabbing the mouse.

See Also:
QGraphicsItem, QGraphicsView

Nested Class Summary
static class QGraphicsScene.ItemIndexMethod
          This enum describes the indexing algorithms QGraphicsScene provides for managing positional information about items on the scene.
static class QGraphicsScene.SceneLayer
          This enum describes the rendering layers in a QGraphicsScene.
static class QGraphicsScene.SceneLayers
          This QFlag class provides flags for the int enum.
 
Nested classes/interfaces inherited from class com.trolltech.qt.QSignalEmitter
QSignalEmitter.AbstractSignal, QSignalEmitter.Signal0, QSignalEmitter.Signal1<A>, QSignalEmitter.Signal2<A,B>, QSignalEmitter.Signal3<A,B,C>, QSignalEmitter.Signal4<A,B,C,D>, QSignalEmitter.Signal5<A,B,C,D,E>, QSignalEmitter.Signal6<A,B,C,D,E,F>, QSignalEmitter.Signal7<A,B,C,D,E,F,G>, QSignalEmitter.Signal8<A,B,C,D,E,F,G,H>, QSignalEmitter.Signal9<A,B,C,D,E,F,G,H,I>
 
Field Summary
 QSignalEmitter.Signal1<java.util.List<QRectF>> changed
           
 QSignalEmitter.Signal1<QRectF> sceneRectChanged
          This signal is emitted by QGraphicsScene whenever the scene rect changes.
 QSignalEmitter.Signal0 selectionChanged
          This signal is emitted by QGraphicsScene whenever the selection changes.
 
Constructor Summary
QGraphicsScene()
          Equivalent to QGraphicsScene(0).
QGraphicsScene(double x, double y, double width, double height)
          Equivalent to QGraphicsScene(x, y, width, height, 0).
QGraphicsScene(double x, double y, double width, double height, QObject parent)
          Constructs a QGraphicsScene object, using the rectangle specified by (x, y), and the given width and height for its scene rectangle.
QGraphicsScene(QObject parent)
          Constructs a QGraphicsScene object.
QGraphicsScene(QRectF sceneRect)
          Equivalent to QGraphicsScene(sceneRect, 0).
QGraphicsScene(QRectF sceneRect, QObject parent)
          Constructs a QGraphicsScene object, using sceneRect for its scene rectangle.
 
Method Summary
 QGraphicsEllipseItem addEllipse(double x, double y, double w, double h)
          Equivalent to addEllipse(x, y, w, h, QPen(), QBrush()).
 QGraphicsEllipseItem addEllipse(double x, double y, double w, double h, QPen pen)
          Equivalent to addEllipse(x, y, w, h, pen, QBrush()).
 QGraphicsEllipseItem addEllipse(double x, double y, double w, double h, QPen pen, QBrush brush)
          This convenience function is equivalent to calling addEllipse(QRectF(x, y, w, h), pen, brush).
 QGraphicsEllipseItem addEllipse(QRectF rect)
          Equivalent to addEllipse(rect, QPen(), QBrush()).
 QGraphicsEllipseItem addEllipse(QRectF rect, QPen pen)
          Equivalent to addEllipse(rect, pen, QBrush()).
 QGraphicsEllipseItem addEllipse(QRectF rect, QPen pen, QBrush brush)
          Creates and adds an ellipse item to the scene, and returns the item pointer.
 void addItem(QGraphicsItemInterface item)
          Adds or moves the item item and all its childen to the scene.
 QGraphicsLineItem addLine(double x1, double y1, double x2, double y2)
          Equivalent to addLine(x1, y1, x2, y2, QPen()).
 QGraphicsLineItem addLine(double x1, double y1, double x2, double y2, QPen pen)
          This convenience function is equivalent to calling addLine(QLineF(x1, y1, x2, y2), pen).
 QGraphicsLineItem addLine(QLineF line)
          Equivalent to addLine(line, QPen()).
 QGraphicsLineItem addLine(QLineF line, QPen pen)
          Creates and adds a line item to the scene, and returns the item pointer.
 QGraphicsPathItem addPath(QPainterPath path)
          Equivalent to addPath(path, QPen(), QBrush()).
 QGraphicsPathItem addPath(QPainterPath path, QPen pen)
          Equivalent to addPath(path, pen, QBrush()).
 QGraphicsPathItem addPath(QPainterPath path, QPen pen, QBrush brush)
          Creates and adds a path item to the scene, and returns the item pointer.
 QGraphicsPixmapItem addPixmap(QPixmap pixmap)
          Creates and adds a pixmap item to the scene, and returns the item pointer.
 QGraphicsPolygonItem addPolygon(QPolygonF polygon)
          Equivalent to addPolygon(polygon, QPen(), QBrush()).
 QGraphicsPolygonItem addPolygon(QPolygonF polygon, QPen pen)
          Equivalent to addPolygon(polygon, pen, QBrush()).
 QGraphicsPolygonItem addPolygon(QPolygonF polygon, QPen pen, QBrush brush)
          Creates and adds a polygon item to the scene, and returns the item pointer.
 QGraphicsRectItem addRect(double x, double y, double w, double h)
          Equivalent to addRect(x, y, w, h, QPen(), QBrush()).
 QGraphicsRectItem addRect(double x, double y, double w, double h, QPen pen)
          Equivalent to addRect(x, y, w, h, pen, QBrush()).
 QGraphicsRectItem addRect(double x, double y, double w, double h, QPen pen, QBrush brush)
          This convenience function is equivalent to calling addRect(QRectF(x, y, w, h), pen, brush).
 QGraphicsRectItem addRect(QRectF rect)
          Equivalent to addRect(rect, QPen(), QBrush()).
 QGraphicsRectItem addRect(QRectF rect, QPen pen)
          Equivalent to addRect(rect, pen, QBrush()).
 QGraphicsRectItem addRect(QRectF rect, QPen pen, QBrush brush)
          Creates and adds a rectangle item to the scene, and returns the item pointer.
 QGraphicsSimpleTextItem addSimpleText(java.lang.String text)
          Equivalent to addSimpleText(text, QFont()).
 QGraphicsSimpleTextItem addSimpleText(java.lang.String text, QFont font)
          Creates and adds a QGraphicsSimpleTextItem to the scene, and returns the item pointer.
 QGraphicsTextItem addText(java.lang.String text)
          Equivalent to addText(text, QFont()).
 QGraphicsTextItem addText(java.lang.String text, QFont font)
          Creates and adds a text item to the scene, and returns the item pointer.
 void advance()
          This slot advances the scene by one step, by calling QGraphicsItem::advance() for all items on the scene.
 QBrush backgroundBrush()
          Returns the background brush of the scene..
 int bspTreeDepth()
          Returns the depth of QGraphicsScene's BSP index tree.
 void clearFocus()
          Clears focus from the scene.
 void clearSelection()
          Clears the current selection.
 java.util.List<QGraphicsItemInterface> collidingItems(QGraphicsItemInterface item)
          Returns a list of all items that collide with item.
 java.util.List<QGraphicsItemInterface> collidingItems(QGraphicsItemInterface item, Qt.ItemSelectionMode mode)
          Returns a list of all items that collide with item.
protected  void contextMenuEvent(QGraphicsSceneContextMenuEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive context menu events.
 QGraphicsItemGroup createItemGroup(java.util.List<QGraphicsItemInterface> items)
          Groups all items in items into a new QGraphicsItemGroup, and returns a pointer to the group.
 void destroyItemGroup(QGraphicsItemGroup group)
          Reparents all items in group to group's parent item, then removes group from the scene, and finally deletes it.
protected  void dragEnterEvent(QGraphicsSceneDragDropEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive drag enter events for the scene.
protected  void dragLeaveEvent(QGraphicsSceneDragDropEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive drag leave events for the scene.
protected  void dragMoveEvent(QGraphicsSceneDragDropEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive drag move events for the scene.
protected  void drawBackground(QPainter painter, QRectF rect)
          Draws the background of the scene using painter, before any items and the foreground are drawn.
protected  void drawForeground(QPainter painter, QRectF rect)
          Draws the foreground of the scene using painter, after the background and all items have been drawn.
protected  void drawItems(QPainter painter, QGraphicsItemInterface[] items, QStyleOptionGraphicsItem[] options)
          Equivalent to drawItems(painter, items, options, , 0).
protected  void drawItems(QPainter painter, QGraphicsItemInterface[] items, QStyleOptionGraphicsItem[] options, QWidget widget)
          Equivalent to drawItems(painter, items, options, widget, 0).
protected  void dropEvent(QGraphicsSceneDragDropEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive drop events for the scene.
 boolean event(QEvent event)
          Processes the event event, and dispatches it to the respective event handlers.
protected  void focusInEvent(QFocusEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive focus in events.
 QGraphicsItemInterface focusItem()
          Returns the scene's current focus item, or 0 if no item currently has focus.
protected  void focusOutEvent(QFocusEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive focus out events.
 QBrush foregroundBrush()
          Returns the foreground brush of the scene..
static QGraphicsScene fromNativePointer(QNativePointer nativePointer)
          This function returns the QGraphicsScene instance pointed to by nativePointer
 boolean hasFocus()
          Returns true if the scene has focus; otherwise returns false.
 double height()
          This convenience function is equivalent to calling sceneRect().height().
protected  void helpEvent(QGraphicsSceneHelpEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive help events.
protected  void inputMethodEvent(QInputMethodEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive input method events for the scene.
 java.lang.Object inputMethodQuery(Qt.InputMethodQuery query)
          This method is used by input methods to query a set of properties of the scene to be able to support complex input method operations as support for surrounding text and reconversions.
 void invalidate()
          Equivalent to invalidate(QRectF(), AllLayers).
 void invalidate(double x, double y, double w, double h)
          Equivalent to invalidate(x, y, w, h, AllLayers).
 void invalidate(double x, double y, double w, double h, QGraphicsScene.SceneLayer... layers)
          This convenience function is equivalent to calling invalidate(QRectF(x, y, w, h), layers);
 void invalidate(double x, double y, double w, double h, QGraphicsScene.SceneLayers layers)
          This convenience function is equivalent to calling invalidate(QRectF(x, y, w, h), layers);
 void invalidate(QRectF rect)
          Equivalent to invalidate(rect, AllLayers).
 void invalidate(QRectF rect, QGraphicsScene.SceneLayer... layers)
          Invalidates and schedules a redraw of the layers in rect on the scene.
 void invalidate(QRectF rect, QGraphicsScene.SceneLayers layers)
          Invalidates and schedules a redraw of the layers in rect on the scene.
 QGraphicsItemInterface itemAt(double x, double y)
          Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position.
 QGraphicsItemInterface itemAt(QPointF pos)
          Returns the topmost visible item at the specified pos, or 0 if there are no items at this position.
 QGraphicsScene.ItemIndexMethod itemIndexMethod()
          Returns the item indexing method..
 java.util.List<QGraphicsItemInterface> items()
          Returns a list of all items on the scene, in no particular order.
 java.util.List<QGraphicsItemInterface> items(double x, double y, double w, double h)
          This convenience function is equivalent to calling items(QRectF(x, y, w, h).
 java.util.List<QGraphicsItemInterface> items(double x, double y, double w, double h, Qt.ItemSelectionMode mode)
          This convenience function is equivalent to calling items(QRectF(x, y, w, h), mode).
 java.util.List<QGraphicsItemInterface> items(QPainterPath path)
          Returns all visible items that are either inside or intersect with the path path.
 java.util.List<QGraphicsItemInterface> items(QPainterPath path, Qt.ItemSelectionMode mode)
          Returns all visible items that, depending on path, are either inside or intersect with the path path.
 java.util.List<QGraphicsItemInterface> items(QPointF pos)
          Returns all visible items at position pos in the scene.
 java.util.List<QGraphicsItemInterface> items(QPolygonF polygon)
          Returns all visible items that are either inside or intersect with the polygon polygon.
 java.util.List<QGraphicsItemInterface> items(QPolygonF polygon, Qt.ItemSelectionMode mode)
          Returns all visible items that, depending on mode, are either inside or intersect with the polygon polygon.
 java.util.List<QGraphicsItemInterface> items(QRectF rect)
          Returns all visible items that are either inside or intersect with the specified rectangle.
 java.util.List<QGraphicsItemInterface> items(QRectF rect, Qt.ItemSelectionMode mode)
          Returns all visible items that, depending on mode, are either inside or intersect with the specified rect.
 QRectF itemsBoundingRect()
          Calculates and returns the bounding rect of all items on the scene.
protected  void keyPressEvent(QKeyEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive keypress events.
protected  void keyReleaseEvent(QKeyEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive key release events.
protected  void mouseDoubleClickEvent(QGraphicsSceneMouseEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive mouse doubleclick events for the scene.
 QGraphicsItemInterface mouseGrabberItem()
          Returns the current mouse grabber item, or 0 if no item is currently grabbing the mouse.
protected  void mouseMoveEvent(QGraphicsSceneMouseEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive mouse move events for the scene.
protected  void mousePressEvent(QGraphicsSceneMouseEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive mouse press events for the scene.
protected  void mouseReleaseEvent(QGraphicsSceneMouseEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive mouse release events for the scene.
 void removeItem(QGraphicsItemInterface item)
          Removes the item item and all its children from the scene.
 void render(QPainter painter)
          Equivalent to render(painter, QRectF(), QRectF(), Qt::KeepAspectRatio).
 void render(QPainter painter, QRectF target)
          Equivalent to render(painter, target, QRectF(), Qt::KeepAspectRatio).
 void render(QPainter painter, QRectF target, QRectF source)
          Equivalent to render(painter, target, source, Qt::KeepAspectRatio).
 void render(QPainter painter, QRectF target, QRectF source, Qt.AspectRatioMode aspectRatioMode)
          Renders the source rect from scene into target, using painter.
 QRectF sceneRect()
          Returns the scene rectangle; the bounding rectangle of the scene.
 java.util.List<QGraphicsItemInterface> selectedItems()
          Returns a list of all currently selected items.
 QPainterPath selectionArea()
          Returns the selection area that was previously set with setSelectionArea, or an empty QPainterPath if no selection area has been set.
 void setBackgroundBrush(QBrush brush)
          Sets the background brush of the scene.
 void setBspTreeDepth(int depth)
          Sets the depth of QGraphicsScene's BSP index tree to depth.
 void setFocus()
          Equivalent to setFocus(Qt::OtherFocusReason).
 void setFocus(Qt.FocusReason focusReason)
          Sets focus on the scene by sending a QFocusEvent to the scene, passing focusReason as the reason.
 void setFocusItem(QGraphicsItemInterface item)
          Equivalent to setFocusItem(item, Qt::OtherFocusReason).
 void setFocusItem(QGraphicsItemInterface item, Qt.FocusReason focusReason)
          Sets the scene's focus item to item, with the focus reason focusReason, after removing focus from any previous item that may have had focus.
 void setForegroundBrush(QBrush brush)
          Sets the foreground brush of the scene.
 void setItemIndexMethod(QGraphicsScene.ItemIndexMethod method)
          Sets the item indexing method.
 void setSceneRect(double x, double y, double w, double h)
          Sets the scene rectangle; the bounding rectangle of the scene.
 void setSceneRect(QRectF rect)
          Sets the scene rectangle; the bounding rectangle of the scene to rect.
 void setSelectionArea(QPainterPath path)
          Sets the selection area to path.
 void setSelectionArea(QPainterPath path, Qt.ItemSelectionMode arg__2)
          Sets the selection area to path using arg__2 to determine if items are included in the selection area.
 void update()
          Equivalent to update(QRectF()).
 void update(double x, double y, double w, double h)
          This convenience function is equivalent to calling update(QRectF(x, y, w, h));
 void update(QRectF rect)
          Schedules a redraw of the area rect on the scene.
 java.util.List<QGraphicsView> views()
          Returns a list of all the views that display this scene.
protected  void wheelEvent(QGraphicsSceneWheelEvent event)
          This event handler, for event event, can be reimplemented in a subclass to receive mouse wheel events for the scene.
 double width()
          This convenience function is equivalent to calling sceneRect.width.
 
Methods inherited from class com.trolltech.qt.core.QObject
blockSignals, childEvent, children, connectSlotsByName, customEvent, disposeLater, dumpObjectInfo, dumpObjectTree, dynamicPropertyNames, eventFilter, findChild, findChild, findChild, findChildren, findChildren, findChildren, findChildren, installEventFilter, isWidgetType, killTimer, moveToThread, objectName, parent, property, removeEventFilter, setObjectName, setParent, setProperty, signalsBlocked, startTimer, thread, timerEvent
 
Methods inherited from class com.trolltech.qt.QtJambiObject
dispose, disposed, finalize, reassignNativeResources, tr, tr, tr
 
Methods inherited from class com.trolltech.qt.QSignalEmitter
disconnect, disconnect, signalSender
 
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface com.trolltech.qt.QtJambiInterface
disableGarbageCollection, nativeId, nativePointer, reenableGarbageCollection, setJavaOwnership
 

Field Detail

changed

public final QSignalEmitter.Signal1<java.util.List<QRectF>> changed

sceneRectChanged

public final QSignalEmitter.Signal1<QRectF> sceneRectChanged

This signal is emitted by QGraphicsScene whenever the scene rect changes. The rect parameter is the new scene rectangle.

Compatible Slot Signatures:
void mySlot(com.trolltech.qt.core.QRectF rect)
void mySlot()
See Also:
QGraphicsView::updateSceneRect


selectionChanged

public final QSignalEmitter.Signal0 selectionChanged

This signal is emitted by QGraphicsScene whenever the selection changes. You can call selectedItems to get the new list of selected items.

The selection changes whenever an item is selected or unselected, a selection area is set, cleared or otherwise changed, if a preselected item is added to the scene, or if a selected item is removed from the scene.

QGraphicsScene emits this signal only once for group selection operations. For example, if you set a selection area, select or unselect a QGraphicsItemGroup, or if you add or remove from the scene a parent item that contains several selected items, selectionChanged is emitted only once after the operation has completed (instead of once for each item).

Compatible Slot Signature:
void mySlot()
See Also:
setSelectionArea, selectedItems, QGraphicsItem::setSelected

Constructor Detail

QGraphicsScene

public QGraphicsScene()

Equivalent to QGraphicsScene(0).


QGraphicsScene

public QGraphicsScene(QObject parent)

Constructs a QGraphicsScene object. The parent parameter is passed to QObject's constructor.


QGraphicsScene

public QGraphicsScene(QRectF sceneRect)

Equivalent to QGraphicsScene(sceneRect, 0).


QGraphicsScene

public QGraphicsScene(QRectF sceneRect,
                      QObject parent)

Constructs a QGraphicsScene object, using sceneRect for its scene rectangle. The parent parameter is passed to QObject's constructor.

See Also:
sceneRect

QGraphicsScene

public QGraphicsScene(double x,
                      double y,
                      double width,
                      double height)

Equivalent to QGraphicsScene(x, y, width, height, 0).


QGraphicsScene

public QGraphicsScene(double x,
                      double y,
                      double width,
                      double height,
                      QObject parent)

Constructs a QGraphicsScene object, using the rectangle specified by (x, y), and the given width and height for its scene rectangle. The parent parameter is passed to QObject's constructor.

See Also:
sceneRect
Method Detail

addEllipse

public final QGraphicsEllipseItem addEllipse(double x,
                                             double y,
                                             double w,
                                             double h,
                                             QPen pen)

Equivalent to addEllipse(x, y, w, h, pen, QBrush()).


addEllipse

public final QGraphicsEllipseItem addEllipse(double x,
                                             double y,
                                             double w,
                                             double h)

Equivalent to addEllipse(x, y, w, h, QPen(), QBrush()).


addEllipse

public final QGraphicsEllipseItem addEllipse(double x,
                                             double y,
                                             double w,
                                             double h,
                                             QPen pen,
                                             QBrush brush)

This convenience function is equivalent to calling addEllipse(QRectF(x, y, w, h), pen, brush).


addEllipse

public final QGraphicsEllipseItem addEllipse(QRectF rect,
                                             QPen pen)

Equivalent to addEllipse(rect, pen, QBrush()).


addEllipse

public final QGraphicsEllipseItem addEllipse(QRectF rect)

Equivalent to addEllipse(rect, QPen(), QBrush()).


addEllipse

public final QGraphicsEllipseItem addEllipse(QRectF rect,
                                             QPen pen,
                                             QBrush brush)

Creates and adds an ellipse item to the scene, and returns the item pointer. The geometry of the ellipse is defined by rect, and it's pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addLine, addPath, addPixmap, addRect, addText, addItem

addItem

public final void addItem(QGraphicsItemInterface item)

Adds or moves the item item and all its childen to the scene.

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

If the item is already in a different scene, it will first be removed from its old scene, and then added to this scene as a top-level.

See Also:
removeItem, addEllipse, addLine, addPath, addPixmap, addRect, addText

addLine

public final QGraphicsLineItem addLine(double x1,
                                       double y1,
                                       double x2,
                                       double y2)

Equivalent to addLine(x1, y1, x2, y2, QPen()).


addLine

public final QGraphicsLineItem addLine(double x1,
                                       double y1,
                                       double x2,
                                       double y2,
                                       QPen pen)

This convenience function is equivalent to calling addLine(QLineF(x1, y1, x2, y2), pen).


addLine

public final QGraphicsLineItem addLine(QLineF line)

Equivalent to addLine(line, QPen()).


addLine

public final QGraphicsLineItem addLine(QLineF line,
                                       QPen pen)

Creates and adds a line item to the scene, and returns the item pointer. The geometry of the line is defined by line, and it's pen is initialized to pen.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addPath, addPixmap, addRect, addText, addItem

addPath

public final QGraphicsPathItem addPath(QPainterPath path,
                                       QPen pen)

Equivalent to addPath(path, pen, QBrush()).


addPath

public final QGraphicsPathItem addPath(QPainterPath path)

Equivalent to addPath(path, QPen(), QBrush()).


addPath

public final QGraphicsPathItem addPath(QPainterPath path,
                                       QPen pen,
                                       QBrush brush)

Creates and adds a path item to the scene, and returns the item pointer. The geometry of the path is defined by path, and it's pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPixmap, addRect, addText, addItem

addPixmap

public final QGraphicsPixmapItem addPixmap(QPixmap pixmap)

Creates and adds a pixmap item to the scene, and returns the item pointer. The pixmap is defined by pixmap.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPath, addRect, addText, addItem

addPolygon

public final QGraphicsPolygonItem addPolygon(QPolygonF polygon,
                                             QPen pen)

Equivalent to addPolygon(polygon, pen, QBrush()).


addPolygon

public final QGraphicsPolygonItem addPolygon(QPolygonF polygon)

Equivalent to addPolygon(polygon, QPen(), QBrush()).


addPolygon

public final QGraphicsPolygonItem addPolygon(QPolygonF polygon,
                                             QPen pen,
                                             QBrush brush)

Creates and adds a polygon item to the scene, and returns the item pointer. The polygon is defined by polygon, and it's pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPath, addRect, addText, addItem

addRect

public final QGraphicsRectItem addRect(double x,
                                       double y,
                                       double w,
                                       double h,
                                       QPen pen)

Equivalent to addRect(x, y, w, h, pen, QBrush()).


addRect

public final QGraphicsRectItem addRect(double x,
                                       double y,
                                       double w,
                                       double h)

Equivalent to addRect(x, y, w, h, QPen(), QBrush()).


addRect

public final QGraphicsRectItem addRect(double x,
                                       double y,
                                       double w,
                                       double h,
                                       QPen pen,
                                       QBrush brush)

This convenience function is equivalent to calling addRect(QRectF(x, y, w, h), pen, brush).


addRect

public final QGraphicsRectItem addRect(QRectF rect,
                                       QPen pen)

Equivalent to addRect(rect, pen, QBrush()).


addRect

public final QGraphicsRectItem addRect(QRectF rect)

Equivalent to addRect(rect, QPen(), QBrush()).


addRect

public final QGraphicsRectItem addRect(QRectF rect,
                                       QPen pen,
                                       QBrush brush)

Creates and adds a rectangle item to the scene, and returns the item pointer. The geometry of the rectangle is defined by rect, and it's pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPixmap, addPixmap, addText, addItem

addSimpleText

public final QGraphicsSimpleTextItem addSimpleText(java.lang.String text)

Equivalent to addSimpleText(text, QFont()).


addSimpleText

public final QGraphicsSimpleTextItem addSimpleText(java.lang.String text,
                                                   QFont font)

Creates and adds a QGraphicsSimpleTextItem to the scene, and returns the item pointer. The text string is initialized to text, and it's font is initialized to font.

The item's position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPixmap, addPixmap, addRect, addItem

addText

public final QGraphicsTextItem addText(java.lang.String text)

Equivalent to addText(text, QFont()).


addText

public final QGraphicsTextItem addText(java.lang.String text,
                                       QFont font)

Creates and adds a text item to the scene, and returns the item pointer. The text string is initialized to text, and it's font is initialized to font.

The item's position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed once control goes back to the event loop.

See Also:
addEllipse, addLine, addPixmap, addPixmap, addRect, addItem

advance

public final void advance()

This slot advances the scene by one step, by calling QGraphicsItem::advance() for all items on the scene. This is done in two phases: in the first phase, all items are notified that the scene is about to change, and in the second phase all items are notified that they can move. In the first phase, QGraphicsItem::advance() is called passing a value of 0 as an argument, and 1 is passed in the second phase.

See Also:
QGraphicsItem::advance, QGraphicsItemAnimation, QTimeLine

backgroundBrush

public final QBrush backgroundBrush()

Returns the background brush of the scene..

Set this property to changes the scene's background to a different color, gradient or texture. The default background brush is Qt::NoBrush. The background is drawn before (behind) the items.

Example:

    QGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    // a blue background
    scene.setBackgroundBrush(Qt::blue);

    // a gradient background
    QRadialGradient gradient(0, 0, 10);
    gradient.setSpread(QGradient::RepeatSpread);
    scene.setBackgroundBrush(gradient);

QGraphicsScene::render() calls drawBackground to draw the scene background. For more detailed control over how the background is drawn, you can reimplement drawBackground in a subclass of QGraphicsScene.

See Also:
setBackgroundBrush

bspTreeDepth

public final int bspTreeDepth()

Returns the depth of QGraphicsScene's BSP index tree.

This property has no effect when NoIndex is used.

This value determines the depth of QGraphicsScene's BSP tree. The depth directly affects QGraphicsScene's performance and memory usage; the latter growing exponentially with the depth of the tree. With an optimal tree depth, QGraphicsScene can instantly determine the locality of items, even for scenes with thousands or millions of items. This also greatly improves rendering performance.

By default, the value is 0, in which case Qt will guess a reasonable default depth based on the size, location and number of items in the scene. If these parameters change frequently, however, you may experience slowdowns as QGraphicsScene retunes the depth internally. You can avoid potential slowdowns by fixating the tree depth through setting this property.

The depth of the tree and the size of the scene rectangle decide the granularity of the scene's partitioning. The size of each scene segment is determined by the following algorithm:

    QSizeF segmentSize = sceneRect().size() / pow(2, depth - 1);

The BSP tree has an optimal size when each segment contains between 0 and 10 items.

See Also:
setBspTreeDepth, itemIndexMethod

clearFocus

public final void clearFocus()

Clears focus from the scene. If any item has focus when this function is called, it will lose focus, and regain focus again once the scene regains focus.

A scene that does not have focus ignores key events.

See Also:
hasFocus, setFocus, setFocusItem

clearSelection

public final void clearSelection()

Clears the current selection.

See Also:
setSelectionArea, selectedItems

collidingItems

public final java.util.List<QGraphicsItemInterface> collidingItems(QGraphicsItemInterface item)
Returns a list of all items that collide with item. Collisions are determined by calling QGraphicsItem.collidesWithItem(); the collision detection is determined by \a mode. By default, all items whose shape intersects \a item or is contained inside \a item's shape are returned.

The items are returned in descending Z order (i.e., the first item in the list is the top-most item, and the last item is the bottom-most item).


collidingItems

public final java.util.List<QGraphicsItemInterface> collidingItems(QGraphicsItemInterface item,
                                                                   Qt.ItemSelectionMode mode)

Returns a list of all items that collide with item. Collisions are determined by calling QGraphicsItem::collidesWithItem(); the collision detection is determined by mode. By default, all items whose shape intersects item or is contained inside item's shape are returned.

The items are returned in descending Z order (i.e., the first item in the list is the top-most item, and the last item is the bottom-most item).

See Also:
items, itemAt, QGraphicsItem::collidesWithItem

createItemGroup

public final QGraphicsItemGroup createItemGroup(java.util.List<QGraphicsItemInterface> items)

Groups all items in items into a new QGraphicsItemGroup, and returns a pointer to the group. The group is created with the common ancestor of items as its parent, and with position (0, 0). The items are all reparented to the group, and their positions and transformations are mapped to the group. If items is empty, this function will return an empty top-level QGraphicsItemGroup.

QGraphicsScene has ownership of the group item; you do not need to delete it. To dismantle (ungroup) a group, call destroyItemGroup.

See Also:
destroyItemGroup, QGraphicsItemGroup::addToGroup

destroyItemGroup

public final void destroyItemGroup(QGraphicsItemGroup group)

Reparents all items in group to group's parent item, then removes group from the scene, and finally deletes it. The items' positions and transformations are mapped from the group to the group's parent.

See Also:
createItemGroup, QGraphicsItemGroup::removeFromGroup

focusItem

public final QGraphicsItemInterface focusItem()

Returns the scene's current focus item, or 0 if no item currently has focus.

The focus item receives keyboard input when the scene receives a key event.

See Also:
setFocusItem, QGraphicsItem::hasFocus

foregroundBrush

public final QBrush foregroundBrush()

Returns the foreground brush of the scene..

Change this property to set the scene's foreground to a different color, gradient or texture.

The foreground is drawn after (on top of) the items. The default foreground brush is Qt::NoBrush ( i.e. the foreground is not drawn).

Example:

    QGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    // a white semi-transparent foreground
    scene.setForegroundBrush(QColor(255, 255, 255, 127));

    // a grid foreground
    scene.setForegroundBrush(QBrush(Qt::lightGray, Qt::CrossPattern));

QGraphicsScene::render() calls drawForeground to draw the scene foreground. For more detailed control over how the foreground is drawn, you can reimplement the drawForeground function in a QGraphicsScene subclass.

See Also:
setForegroundBrush

hasFocus

public final boolean hasFocus()

Returns true if the scene has focus; otherwise returns false. If the scene has focus, it will will forward key events from QKeyEvent to any item that has focus.

See Also:
setFocus, setFocusItem

height

public final double height()

This convenience function is equivalent to calling sceneRect().height().

See Also:
width

invalidate

public final void invalidate(double x,
                             double y,
                             double w,
                             double h,
                             QGraphicsScene.SceneLayer... layers)

This convenience function is equivalent to calling invalidate(QRectF(x, y, w, h), layers);


invalidate

public final void invalidate(double x,
                             double y,
                             double w,
                             double h)

Equivalent to invalidate(x, y, w, h, AllLayers).


invalidate

public final void invalidate(double x,
                             double y,
                             double w,
                             double h,
                             QGraphicsScene.SceneLayers layers)

This convenience function is equivalent to calling invalidate(QRectF(x, y, w, h), layers);


invalidate

public final void invalidate(QRectF rect,
                             QGraphicsScene.SceneLayer... layers)

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

You can use this function overload to notify QGraphicsScene of changes to the background or the foreground of the scene. This function is commonly used for scenes with tile-based backgrounds to notify changes when QGraphicsView has enabled CacheBackground.

Example:

    QRectF TileScene::rectForTile(int x, int y) const
    {
        // Return the rectangle for the tile at position (x, y).
        return QRectF(x * tileWidth, y * tileHeight, tileWidth, tileHeight);
    }

    void TileScene::setTile(int x, int y, const QPixmap &pixmap)
    {
        // Sets or replaces the tile at position (x, y) with pixmap.
        if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
            tiles[y][x] = pixmap;
            invalidate(rectForTile(x, y), BackgroundLayer);
        }
    }

    void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
    {
        // Draws all tiles that intersect the exposed area.
        for (int y = 0; y < numTilesV; ++y) {
            for (int x = 0; x < numTilesH; ++x) {
                QRectF rect = rectForTile(x, y);
                if (exposed.intersects(rect))
                    painter->drawPixmap(rect.topLeft(), tiles[y][x]);
            }
        }
    }

Note that QGraphicsView currently supports background caching only (see QGraphicsView::CacheBackground). This function is equivalent to calling update if any layer but BackgroundLayer is passed.

See Also:
QGraphicsView::resetCachedContent

invalidate

public final void invalidate(QRectF rect)

Equivalent to invalidate(rect, AllLayers).


invalidate

public final void invalidate()

Equivalent to invalidate(QRectF(), AllLayers).


invalidate

public final void invalidate(QRectF rect,
                             QGraphicsScene.SceneLayers layers)

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

You can use this function overload to notify QGraphicsScene of changes to the background or the foreground of the scene. This function is commonly used for scenes with tile-based backgrounds to notify changes when QGraphicsView has enabled CacheBackground.

Example:

    QRectF TileScene::rectForTile(int x, int y) const
    {
        // Return the rectangle for the tile at position (x, y).
        return QRectF(x * tileWidth, y * tileHeight, tileWidth, tileHeight);
    }

    void TileScene::setTile(int x, int y, const QPixmap &pixmap)
    {
        // Sets or replaces the tile at position (x, y) with pixmap.
        if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
            tiles[y][x] = pixmap;
            invalidate(rectForTile(x, y), BackgroundLayer);
        }
    }

    void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
    {
        // Draws all tiles that intersect the exposed area.
        for (int y = 0; y < numTilesV; ++y) {
            for (int x = 0; x < numTilesH; ++x) {
                QRectF rect = rectForTile(x, y);
                if (exposed.intersects(rect))
                    painter->drawPixmap(rect.topLeft(), tiles[y][x]);
            }
        }
    }

Note that QGraphicsView currently supports background caching only (see QGraphicsView::CacheBackground). This function is equivalent to calling update if any layer but BackgroundLayer is passed.

See Also:
QGraphicsView::resetCachedContent

itemAt

public final QGraphicsItemInterface itemAt(double x,
                                           double y)

Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position.

This convenience function is equivalent to calling itemAt(QPointF(x, y)).


itemAt

public final QGraphicsItemInterface itemAt(QPointF pos)

Returns the topmost visible item at the specified pos, or 0 if there are no items at this position.

See Also:
items, collidingItems

itemIndexMethod

public final QGraphicsScene.ItemIndexMethod itemIndexMethod()

Returns the item indexing method..

QGraphicsScene applies an indexing algorithm to the scene, to speed up item discovery functions like items and itemAt. Indexing is most efficient for static scenes (i.e., where items don't move around). For dynamic scenes, or scenes with many animated items, the index bookkeeping can outweight the fast lookup speeds.

For the common case, the default index method BspTreeIndex works fine. If your scene uses many animations and you are experiencing slowness, you can disable indexing by calling setItemIndexMethod(NoIndex).

See Also:
setItemIndexMethod, bspTreeDepth

items

public final java.util.List<QGraphicsItemInterface> items(QRectF rect)
Returns all visible items that are either inside or intersect with the specified rectangle.


items

public final java.util.List<QGraphicsItemInterface> items(QRectF rect,
                                                          Qt.ItemSelectionMode mode)

Returns all visible items that, depending on mode, are either inside or intersect with the specified rect.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by rect are returned.

See Also:
itemAt

items

public final java.util.List<QGraphicsItemInterface> items(QPointF pos)

Returns all visible items at position pos in the scene. The items are listed in descending Z order (i.e., the first item in the list is the top-most item, and the last item is the bottom-most item).

See Also:
itemAt

items

public final java.util.List<QGraphicsItemInterface> items()

Returns a list of all items on the scene, in no particular order.

See Also:
addItem, removeItem

items

public final java.util.List<QGraphicsItemInterface> items(QPolygonF polygon)
Returns all visible items that are either inside or intersect with the polygon polygon.


items

public final java.util.List<QGraphicsItemInterface> items(QPolygonF polygon,
                                                          Qt.ItemSelectionMode mode)

Returns all visible items that, depending on mode, are either inside or intersect with the polygon polygon.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by polygon are returned.

See Also:
itemAt

items

public final java.util.List<QGraphicsItemInterface> items(double x,
                                                          double y,
                                                          double w,
                                                          double h)
This convenience function is equivalent to calling items(QRectF(x, y, w, h).


items

public final java.util.List<QGraphicsItemInterface> items(double x,
                                                          double y,
                                                          double w,
                                                          double h,
                                                          Qt.ItemSelectionMode mode)

This convenience function is equivalent to calling items(QRectF(x, y, w, h), mode).


items

public final java.util.List<QGraphicsItemInterface> items(QPainterPath path)
Returns all visible items that are either inside or intersect with the path path.


items

public final java.util.List<QGraphicsItemInterface> items(QPainterPath path,
                                                          Qt.ItemSelectionMode mode)

Returns all visible items that, depending on path, are either inside or intersect with the path path.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by path are returned.

See Also:
itemAt

itemsBoundingRect

public final QRectF itemsBoundingRect()

Calculates and returns the bounding rect of all items on the scene. This function works by iterating over all items, and because if this, it can be slow for large scenes.

See Also:
sceneRect

mouseGrabberItem

public final QGraphicsItemInterface mouseGrabberItem()

Returns the current mouse grabber item, or 0 if no item is currently grabbing the mouse. The mouse grabber item is the item that receives all mouse events sent to the scene.

An item becomes a mouse grabber when it receives and accepts a mouse press event, and it stays the mouse grabber until either of the following events occur:

If the item loses its mouse grab, the scene will ignore all mouse events until a new item grabs the mouse (i.e., until a new item receives a mouse press event).


removeItem

public final void removeItem(QGraphicsItemInterface item)

Removes the item item and all its children from the scene. The ownership of item is passed on to the caller (i.e., QGraphicsScene will no longer delete item when destroyed).

See Also:
addItem

render

public final void render(QPainter painter,
                         QRectF target,
                         QRectF source)

Equivalent to render(painter, target, source, Qt::KeepAspectRatio).


render

public final void render(QPainter painter,
                         QRectF target)

Equivalent to render(painter, target, QRectF(), Qt::KeepAspectRatio).


render

public final void render(QPainter painter)

Equivalent to render(painter, QRectF(), QRectF(), Qt::KeepAspectRatio).


render

public final void render(QPainter painter,
                         QRectF target,
                         QRectF source,
                         Qt.AspectRatioMode aspectRatioMode)

Renders the source rect from scene into target, using painter. This function is useful for capturing the contents of the scene onto a paint device, such as a QImage (e.g., to take a screenshot), or for printing with QPrinter. For example:

    QGraphicsScene scene;
    scene.addItem(...
    ...
    QPrinter printer(QPrinter::HighResolution);
    printer.setPageSize(QPrinter::A4);

    QPainter painter(&printer);
    scene.render(&painter);

If source is a null rect, this function will use sceneRect to determine what to render. If target is a null rect, the dimensions of painter's paint device will be used.

The source rect contents will be transformed according to aspectRatioMode to fit into the target rect. By default, the aspect ratio is kept, and source is scaled to fit in target.

See Also:
QGraphicsView::render

sceneRect

public final QRectF sceneRect()

Returns the scene rectangle; the bounding rectangle of the scene.

The scene rectangle defines the extent of the scene. It is primarily used by QGraphicsView to determine the view's default scrollable area, and by QGraphicsScene to manage item indexing.

If unset, or if set to a null QRectF, sceneRect will return the largest bounding rect of all items on the scene since the scene was created (i.e., a rectangle that grows when items are added to or moved in the scene, but never shrinks).

See Also:
setSceneRect, width, height, QGraphicsView::sceneRect

selectedItems

public final java.util.List<QGraphicsItemInterface> selectedItems()

Returns a list of all currently selected items. The items are returned in no particular order.

See Also:
setSelectionArea

selectionArea

public final QPainterPath selectionArea()

Returns the selection area that was previously set with setSelectionArea, or an empty QPainterPath if no selection area has been set.

See Also:
setSelectionArea

setBackgroundBrush

public final void setBackgroundBrush(QBrush brush)

Sets the background brush of the scene. to brush.

Set this property to changes the scene's background to a different color, gradient or texture. The default background brush is Qt::NoBrush. The background is drawn before (behind) the items.

Example:

    QGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    // a blue background
    scene.setBackgroundBrush(Qt::blue);

    // a gradient background
    QRadialGradient gradient(0, 0, 10);
    gradient.setSpread(QGradient::RepeatSpread);
    scene.setBackgroundBrush(gradient);

QGraphicsScene::render() calls drawBackground to draw the scene background. For more detailed control over how the background is drawn, you can reimplement drawBackground in a subclass of QGraphicsScene.

See Also:
backgroundBrush

setBspTreeDepth

public final void setBspTreeDepth(int depth)

Sets the depth of QGraphicsScene's BSP index tree to depth.

This property has no effect when NoIndex is used.

This value determines the depth of QGraphicsScene's BSP tree. The depth directly affects QGraphicsScene's performance and memory usage; the latter growing exponentially with the depth of the tree. With an optimal tree depth, QGraphicsScene can instantly determine the locality of items, even for scenes with thousands or millions of items. This also greatly improves rendering performance.

By default, the value is 0, in which case Qt will guess a reasonable default depth based on the size, location and number of items in the scene. If these parameters change frequently, however, you may experience slowdowns as QGraphicsScene retunes the depth internally. You can avoid potential slowdowns by fixating the tree depth through setting this property.

The depth of the tree and the size of the scene rectangle decide the granularity of the scene's partitioning. The size of each scene segment is determined by the following algorithm:

    QSizeF segmentSize = sceneRect().size() / pow(2, depth - 1);

The BSP tree has an optimal size when each segment contains between 0 and 10 items.

See Also:
bspTreeDepth, itemIndexMethod

setFocus

public final void setFocus()

Equivalent to setFocus(Qt::OtherFocusReason).


setFocus

public final void setFocus(Qt.FocusReason focusReason)

Sets focus on the scene by sending a QFocusEvent to the scene, passing focusReason as the reason. If the scene regains focus after having previously lost it while an item had focus, the last focus item will receive focus with focusReason as the reason.

If the scene already has focus, this function does nothing.

See Also:
hasFocus, clearFocus, setFocusItem

setFocusItem

public final void setFocusItem(QGraphicsItemInterface item)

Equivalent to setFocusItem(item, Qt::OtherFocusReason).


setFocusItem

public final void setFocusItem(QGraphicsItemInterface item,
                               Qt.FocusReason focusReason)

Sets the scene's focus item to item, with the focus reason focusReason, after removing focus from any previous item that may have had focus.

If item is 0, or if it either does not accept focus (i.e., it does not have the QGraphicsItem::ItemIsFocusable flag enabled), or is not visible or not enabled, this function only removes focus from any previous focusitem.

If item is not 0, and the scene does not currently have focus (i.e., hasFocus returns false), this function will call setFocus automatically.

See Also:
focusItem, hasFocus, setFocus

setForegroundBrush

public final void setForegroundBrush(QBrush brush)

Sets the foreground brush of the scene. to brush.

Change this property to set the scene's foreground to a different color, gradient or texture.

The foreground is drawn after (on top of) the items. The default foreground brush is Qt::NoBrush ( i.e. the foreground is not drawn).

Example:

    QGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    // a white semi-transparent foreground
    scene.setForegroundBrush(QColor(255, 255, 255, 127));

    // a grid foreground
    scene.setForegroundBrush(QBrush(Qt::lightGray, Qt::CrossPattern));

QGraphicsScene::render() calls drawForeground to draw the scene foreground. For more detailed control over how the foreground is drawn, you can reimplement the drawForeground function in a QGraphicsScene subclass.

See Also:
foregroundBrush

setItemIndexMethod

public final void setItemIndexMethod(QGraphicsScene.ItemIndexMethod method)

Sets the item indexing method. to method.

QGraphicsScene applies an indexing algorithm to the scene, to speed up item discovery functions like items and itemAt. Indexing is most efficient for static scenes (i.e., where items don't move around). For dynamic scenes, or scenes with many animated items, the index bookkeeping can outweight the fast lookup speeds.

For the common case, the default index method BspTreeIndex works fine. If your scene uses many animations and you are experiencing slowness, you can disable indexing by calling setItemIndexMethod(NoIndex).

See Also:
itemIndexMethod, bspTreeDepth

setSceneRect

public final void setSceneRect(double x,
                               double y,
                               double w,
                               double h)

Sets the scene rectangle; the bounding rectangle of the scene.

The scene rectangle defines the extent of the scene. It is primarily used by QGraphicsView to determine the view's default scrollable area, and by QGraphicsScene to manage item indexing.

If unset, or if set to a null QRectF, sceneRect will return the largest bounding rect of all items on the scene since the scene was created (i.e., a rectangle that grows when items are added to or moved in the scene, but never shrinks).

See Also:
width, height, QGraphicsView::sceneRect

setSceneRect

public final void setSceneRect(QRectF rect)

Sets the scene rectangle; the bounding rectangle of the scene to rect.

The scene rectangle defines the extent of the scene. It is primarily used by QGraphicsView to determine the view's default scrollable area, and by QGraphicsScene to manage item indexing.

If unset, or if set to a null QRectF, sceneRect will return the largest bounding rect of all items on the scene since the scene was created (i.e., a rectangle that grows when items are added to or moved in the scene, but never shrinks).

See Also:
width, height, QGraphicsView::sceneRect

setSelectionArea

public final void setSelectionArea(QPainterPath path)

Sets the selection area to path. All items within this area are immediately selected, and all items outside are unselected. You can get the list of all selected items by calling selectedItems.

For an item to be selected, it must be marked as selectable (QGraphicsItem::ItemIsSelectable).

See Also:
clearSelection, selectionArea

setSelectionArea

public final void setSelectionArea(QPainterPath path,
                                   Qt.ItemSelectionMode arg__2)

Sets the selection area to path using arg__2 to determine if items are included in the selection area.

See Also:
clearSelection, selectionArea

update

public final void update(double x,
                         double y,
                         double w,
                         double h)

This convenience function is equivalent to calling update(QRectF(x, y, w, h));


update

public final void update()

Equivalent to update(QRectF()).


update

public final void update(QRectF rect)

Schedules a redraw of the area rect on the scene.

See Also:
sceneRect, changed

views

public final java.util.List<QGraphicsView> views()

Returns a list of all the views that display this scene.

See Also:
QGraphicsView::scene

width

public final double width()

This convenience function is equivalent to calling sceneRect.width.

See Also:
height

contextMenuEvent

protected void contextMenuEvent(QGraphicsSceneContextMenuEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive context menu events. The default implementation forwards the event to the item at the scene position provided by the event.

See Also:
QGraphicsItem::contextMenuEvent

dragEnterEvent

protected void dragEnterEvent(QGraphicsSceneDragDropEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive drag enter events for the scene.

The default implementation accepts the event and prepares the scene to accept drag move events.

See Also:
QGraphicsItem::dragEnterEvent, dragMoveEvent, dragLeaveEvent, dropEvent

dragLeaveEvent

protected void dragLeaveEvent(QGraphicsSceneDragDropEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive drag leave events for the scene.

See Also:
QGraphicsItem::dragLeaveEvent, dragEnterEvent, dragMoveEvent, dropEvent

dragMoveEvent

protected void dragMoveEvent(QGraphicsSceneDragDropEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive drag move events for the scene.

See Also:
QGraphicsItem::dragMoveEvent, dragEnterEvent, dragLeaveEvent, dropEvent

drawBackground

protected void drawBackground(QPainter painter,
                              QRectF rect)

Draws the background of the scene using painter, before any items and the foreground are drawn. Reimplement this function to provide a custom background for the scene.

All painting is done in scene coordinates. The rect parameter is the exposed rectangle.

See Also:
drawForeground, drawItems

drawForeground

protected void drawForeground(QPainter painter,
                              QRectF rect)

Draws the foreground of the scene using painter, after the background and all items have been drawn. Reimplement this function to provide a custom foreground for the scene.

All painting is done in scene coordinates. The rect parameter is the exposed rectangle.

See Also:
drawBackground, drawItems

drawItems

protected final void drawItems(QPainter painter,
                               QGraphicsItemInterface[] items,
                               QStyleOptionGraphicsItem[] options)

Equivalent to drawItems(painter, items, options, , 0).


drawItems

protected void drawItems(QPainter painter,
                         QGraphicsItemInterface[] items,
                         QStyleOptionGraphicsItem[] options,
                         QWidget widget)

Equivalent to drawItems(painter, items, options, widget, 0).


dropEvent

protected void dropEvent(QGraphicsSceneDragDropEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive drop events for the scene.

See Also:
QGraphicsItem::dropEvent, dragEnterEvent, dragMoveEvent, dragLeaveEvent

event

public boolean event(QEvent event)

Processes the event event, and dispatches it to the respective event handlers.

In addition to calling the convenience event handlers, this function is responsible for converting mouse move events to hover events for when there is no mouse grabber item. Hover events are delivered directly to items; there is no convenience function for them.

Overrides:
event in class QObject
See Also:
contextMenuEvent, keyPressEvent, keyReleaseEvent, mousePressEvent, mouseMoveEvent, mouseReleaseEvent, mouseDoubleClickEvent, focusInEvent, focusOutEvent

focusInEvent

protected void focusInEvent(QFocusEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive focus in events.

The default implementation sets focus on the scene, and then on the last focus item.

See Also:
QGraphicsItem::focusOutEvent

focusOutEvent

protected void focusOutEvent(QFocusEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive focus out events.

The default implementation removes focus from any focus item, then removes focus from the scene.

See Also:
QGraphicsItem::focusInEvent

helpEvent

protected void helpEvent(QGraphicsSceneHelpEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive help events. The events are of type QEvent::ToolTip, which are created when a tooltip is requested.

The default implementation shows the tooltip of the topmost item, i.e., the item with the highest z-value, at the mouse cursor position. If no item has a tooltip set, this function does nothing.

See Also:
QGraphicsItem::toolTip, QGraphicsSceneHelpEvent

inputMethodEvent

protected void inputMethodEvent(QInputMethodEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive input method events for the scene.

The default implementation forwards the event to the focusItem. If no item currently has focus, this function does nothing.

See Also:
QGraphicsItem::inputMethodEvent

inputMethodQuery

public java.lang.Object inputMethodQuery(Qt.InputMethodQuery query)

This method is used by input methods to query a set of properties of the scene to be able to support complex input method operations as support for surrounding text and reconversions.

The query parameter specifies which property is queried.

See Also:
QWidget::inputMethodQuery

keyPressEvent

protected void keyPressEvent(QKeyEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive keypress events. The default implementation forwards the event to current focus item.

See Also:
QGraphicsItem::keyPressEvent, focusItem

keyReleaseEvent

protected void keyReleaseEvent(QKeyEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive key release events. The default implementation forwards the event to current focus item.

See Also:
QGraphicsItem::keyReleaseEvent, focusItem

mouseDoubleClickEvent

protected void mouseDoubleClickEvent(QGraphicsSceneMouseEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive mouse doubleclick events for the scene.

If someone doubleclicks on the scene, the scene will first receive a mouse press event, followed by a release event (i.e., a click), then a doubleclick event, and finally a release event. If the doubleclick event is delivered to a different item than the one that received the first press and release, it will be delivered as a press event. However, tripleclick events are not delivered as doubleclick events in this case.

The default implementation is similar to mousePressEvent.

See Also:
QGraphicsItem::mousePressEvent, QGraphicsItem::mouseMoveEvent, QGraphicsItem::mouseReleaseEvent, QGraphicsItem::setAcceptedMouseButtons

mouseMoveEvent

protected void mouseMoveEvent(QGraphicsSceneMouseEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive mouse move events for the scene.

The default implementation depends on the mouse grabber state. If there is a mouse grabber item, the event is sent to the mouse grabber; otherwise, the event is ignored.

See Also:
QGraphicsItem::mousePressEvent, QGraphicsItem::mouseReleaseEvent, QGraphicsItem::mouseDoubleClickEvent, QGraphicsItem::setAcceptedMouseButtons

mousePressEvent

protected void mousePressEvent(QGraphicsSceneMouseEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive mouse press events for the scene.

The default implementation depends on the state of the scene. If there is a mouse grabber item, then the event is sent to the mouse grabber. Otherwise, it is forwarded to the topmost item that accepts mouse events at the scene position from the event, and that item promptly becomes the mouse grabber item.

If there is no item at the given position on the scene, the selection area is reset, any focus item loses its input focus, and the event is then ignored.

See Also:
QGraphicsItem::mousePressEvent, QGraphicsItem::setAcceptedMouseButtons

mouseReleaseEvent

protected void mouseReleaseEvent(QGraphicsSceneMouseEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive mouse release events for the scene.

The default implementation depends on the mouse grabber state. If there is no mouse grabber, the event is ignored. Otherwise, if there is a mouse grabber item, the event is sent to the mouse grabber. If this mouse release represents the last pressed button on the mouse, the mouse grabber item then loses the mouse grab.

See Also:
QGraphicsItem::mousePressEvent, QGraphicsItem::mouseMoveEvent, QGraphicsItem::mouseDoubleClickEvent, QGraphicsItem::setAcceptedMouseButtons

wheelEvent

protected void wheelEvent(QGraphicsSceneWheelEvent event)

This event handler, for event event, can be reimplemented in a subclass to receive mouse wheel events for the scene.

By default, the event is delivered to the topmost visible item under the cursor. If ignored, the event propagates to the item beneath, and again until the event is accepted, or it reaches the scene. If no items accept the event, it is ignored.

See Also:
QGraphicsItem::wheelEvent

fromNativePointer

public static QGraphicsScene fromNativePointer(QNativePointer nativePointer)
This function returns the QGraphicsScene instance pointed to by nativePointer

Parameters:
nativePointer - the QNativePointer of which object should be returned.

Qt Jambi Home