Change cursor shape on event key

It seems to be an old bug that was never resolved: setCursor on QGraphicsView don't work when add QWidget on the QGraphicsScene

There is a possible workaround, but it's far from perfect.
First of all, you have to consider that while dealing with a QGraphicsScene and its view[s] is not easy when dealing with mouse events and widget proxies, mostly because of the multiple nested levels of events and interaction between the actual view (and its parent, up to the top level window) and the proxy itself, which is an abstraction of the widget you added to the scene. While Qt devs did a huge amount of work to make it as transparent as possible, at some point you will probably face some unexpected or undesired behavior that is usually hard to fix or work around, and that's also because a graphics scene might be visualized in more than a single view.

Besides the aforementioned bug, you have to consider that a graphics view uses QWidget.setCursor internally whenever any of its items call setCursor on themselves, and since the view is a very complex widget, at some point it might even try to "restore" the cursor if it thinks it should (even if it shouldn't).
Finally, some events which also have something to do with focus might become in the way of all that.

The first workaround is to set the cursor to the view itself (or, better, the view's viewport, which is the actual widget that shows the scene contents). To ensure that, we obviously need to check if the cursor is inside the canvas.

Unfortunately, because of the event handling written above, this could become a bit messy, as some events are even delayed by at least a cycle within the main Qt event loop; the result is that while setting a cursor the first time might work, setting it again might not, and even if it would, it's possible that the cursor will not be applied until the mouse is moved at least by one pixel.
As a second workaround, we need an event filter to bypass all that and check the cursor whenever the mouse is moved within the viewport margins.

class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        # ...
        self.show()

        empty = QPixmap(1240, 1748)
        empty.fill(QColor(Qt.darkGray))
        self.canvas.newPixmap(empty)

        # install an event filter on the view's viewport;
        # this is very, *VERY* important: on the *VIEWPORT*!
        # if you install it on the view, it will *not* work
        self.MainView.viewport().installEventFilter(self)

    def insideCanvasRect(self, pos):
        canvasRect = self.canvas.rect()
        # translate the canvas rect to its top level window to get the actual
        # geometry according to the scene; we can't use canvas.geometry(), as
        # geometry() is based on the widget's parent coordinates, and that
        # parent could also have any number of parents in turn;
        canvasRect.translate(self.canvas.mapTo(self.canvas.window(), QPoint(0, 0)))
        # map the geometry to the view's transformation, which probably uses
        # some scaling, but also translation *and* shearing; the result is a
        # polygon, as with shearing you could transform a rectangle to an
        # irregular quadrilateral
        polygon = self.MainView.mapFromScene(QRectF(canvasRect))
        # tell if the point is within the resulting polygon
        return polygon.containsPoint(pos, Qt.WindingFill)

    def eventFilter(self, source, event):
        if source == self.MainView.viewport() and (
            (event.type() == QEvent.MouseMove and not event.buttons()) or
            (event.type() == QEvent.MouseButtonRelease)
            ):
                # process the event
                super(MainWindow, self).eventFilter(source, event)
                if self.insideCanvasRect(event.pos()):
                    source.setCursor(self.canvas.cursor())
                else:
                    source.unsetCursor()
                # usually a mouse move event within the view's viewport returns False,
                # but in that case the event would be propagated to the parents, up
                # to the top level window, which might reset the *previous* cursor
                # at some point, no matter if we try to avoid that; to prevent that
                # we return True to avoid propagation.
                # Note that this will prevent any upper-level filtering and *could*
                # also create some issues for the drag and drop framework
                if event.type() == QEvent.MouseMove:
                    return True
        return super(MainWindow, self).eventFilter(source, event)

    def keyPressEvent(self, e):
        # send the canvas a fake leave event
        QApplication.sendEvent(self.canvas, QEvent(QEvent.Leave))
        key = e.key()
        if key == Qt.Key_C:
            self.canvas.setCutCursor()
        elif key == Qt.Key_N:
            self.canvas.setNormalCursor()
        elif key == Qt.Key_S:
            self.canvas.setSelectionCursor()
        pos = self.canvas.rect().center()
        event = QEnterEvent(pos, self.canvas.mapTo(self.canvas.window(), pos), self.canvas.mapToGlobal(pos))
        # send a fake enter event (mapped to the center of the widget, just to be sure)
        QApplication.sendEvent(self.canvas, event)
        # if we're inside the widget, set the view's cursor, otherwise it will not
        # be set until the mouse is moved
        if self.insideCanvasRect(self.MainView.viewport().mapFromGlobal(QCursor.pos())):
            self.MainView.viewport().setCursor(self.canvas.cursor())