# -*- coding: utf-8 -*-
"""
Copyright (c) 2018, Jairus Martin.
Distributed under the terms of the MIT License.
The full license is in the file COPYING.txt, distributed with this software.
Created on Sept 4, 2018
"""
import warnings

from atom.api import Atom, Coerced, Int, Typed, atomref
from enaml.drag_drop import DropAction
from enaml.qt.q_resource_helpers import (
    get_cached_qcolor,
    get_cached_qfont,
    get_cached_qimage,
)
from enaml.qt.qt_control import QtControl
from enaml.qt.qt_drag_drop import QtDropEvent
from enaml.qt.qt_toolkit_object import QtToolkitObject
from enaml.qt.qt_widget import QtWidget, focus_registry
from enaml.qt.QtCore import QPoint, QPointF, QRectF, Qt
from enaml.qt.QtGui import (
    QBrush,
    QColor,
    QCursor,
    QDrag,
    QPainter,
    QPen,
    QPixmap,
    QPolygonF,
)
from enaml.qt.QtWidgets import (
    QFrame,
    QGraphicsEllipseItem,
    QGraphicsItem,
    QGraphicsItemGroup,
    QGraphicsLineItem,
    QGraphicsObject,
    QGraphicsPathItem,
    QGraphicsPixmapItem,
    QGraphicsPolygonItem,
    QGraphicsProxyWidget,
    QGraphicsRectItem,
    QGraphicsScene,
    QGraphicsSimpleTextItem,
    QGraphicsView,
    QWidgetAction,
)
from enaml.widgets.widget import Feature

from enamlx.widgets.graphics_view import (
    GraphicFeature,
    Point,
    ProxyAbstractGraphicsShapeItem,
    ProxyGraphicsEllipseItem,
    ProxyGraphicsImageItem,
    ProxyGraphicsItem,
    ProxyGraphicsItemGroup,
    ProxyGraphicsLineItem,
    ProxyGraphicsPathItem,
    ProxyGraphicsPolygonItem,
    ProxyGraphicsRectItem,
    ProxyGraphicsTextItem,
    ProxyGraphicsView,
    ProxyGraphicsWidget,
)

PEN_STYLES = {
    "none": Qt.NoPen,
    "solid": Qt.SolidLine,
    "dash": Qt.DashLine,
    "dot": Qt.DotLine,
    "dash_dot": Qt.DashDotLine,
    "dash_dot_dot": Qt.DashDotDotLine,
    "custom": Qt.CustomDashLine,
}

CAP_STYLES = {
    "square": Qt.SquareCap,
    "flat": Qt.FlatCap,
    "round": Qt.RoundCap,
}

JOIN_STYLES = {
    "bevel": Qt.BevelJoin,
    "miter": Qt.MiterJoin,
    "round": Qt.RoundJoin,
}

BRUSH_STYLES = {
    "solid": Qt.SolidPattern,
    "dense1": Qt.Dense1Pattern,
    "dense2": Qt.Dense2Pattern,
    "dense3": Qt.Dense3Pattern,
    "dense4": Qt.Dense4Pattern,
    "dense5": Qt.Dense5Pattern,
    "dense6": Qt.Dense6Pattern,
    "dense7": Qt.Dense7Pattern,
    "horizontal": Qt.HorPattern,
    "vertical": Qt.VerPattern,
    "cross": Qt.CrossPattern,
    "bdiag": Qt.BDiagPattern,
    "fdiag": Qt.FDiagPattern,
    "diag": Qt.DiagCrossPattern,
    "linear": Qt.LinearGradientPattern,
    "radial": Qt.RadialGradientPattern,
    "conical": Qt.ConicalGradientPattern,
    "texture": Qt.TexturePattern,
    "none": Qt.NoBrush,
}


DRAG_MODES = {
    "none": QGraphicsView.NoDrag,
    "scroll": QGraphicsView.ScrollHandDrag,
    "selection": QGraphicsView.RubberBandDrag,
}

# --------------------------------------------------------------------------
# Qt Resource Helpers
# --------------------------------------------------------------------------


def QPen_from_Pen(pen):
    qpen = QPen()
    if pen.color:
        qpen.setColor(get_cached_qcolor(pen.color))
    qpen.setWidth(int(pen.width))
    qpen.setStyle(PEN_STYLES.get(pen.line_style))
    qpen.setCapStyle(CAP_STYLES.get(pen.cap_style))
    qpen.setJoinStyle(JOIN_STYLES.get(pen.join_style))
    if pen.line_style == "custom":
        qpen.setDashPattern(*pen.dash_pattern)
    return qpen


def QBrush_from_Brush(brush):
    qbrush = QBrush()
    if brush.color:
        qbrush.setColor(get_cached_qcolor(brush.color))
    if brush.image:
        qbrush.setTextureImage(get_cached_qimage(brush.image))
        qbrush.setStyle(Qt.TexturePattern)
    else:
        qbrush.setStyle(BRUSH_STYLES.get(brush.style))
    return qbrush


def get_cached_qpen(pen):
    qpen = pen._tkdata
    if not isinstance(qpen, QPen):
        qpen = pen._tkdata = QPen_from_Pen(pen)
    return qpen


def get_cached_qbrush(brush):
    qbrush = brush._tkdata
    if not isinstance(qbrush, QBrush):
        qbrush = brush._tkdata = QBrush_from_Brush(brush)
    return qbrush


# --------------------------------------------------------------------------
# Mixin classes
# --------------------------------------------------------------------------
class FeatureMixin(Atom):
    """A mixin that provides focus and mouse features."""

    #: A private copy of the declaration features. This ensures that
    #: feature cleanup will proceed correctly in the event that user
    #: code modifies the declaration features value at runtime.
    _features = Coerced(Feature, (0,))
    _extra_features = Coerced(GraphicFeature, (0,))

    #: Internal storage for the shared widget action.
    _widget_action = Typed(QWidgetAction)

    #: Internal storage for the drag origin position.
    _drag_origin = Typed(QPointF)

    # --------------------------------------------------------------------------
    # Private API
    # --------------------------------------------------------------------------
    def _setup_features(self):
        """Setup the advanced widget feature handlers."""
        features = self._features = self.declaration.features
        if not features:
            return
        if features & Feature.FocusTraversal:
            self.hook_focus_traversal()
        if features & Feature.FocusEvents:
            self.hook_focus_events()
        if features & Feature.DragEnabled:
            self.hook_drag()
        if features & Feature.DropEnabled:
            self.hook_drop()

        features = self._extra_features
        if features & GraphicFeature.WheelEvent:
            self.hook_wheel()
        if features & GraphicFeature.DrawEvent:
            self.hook_draw()

    def _teardown_features(self):
        """Teardowns the advanced widget feature handlers."""
        features = self._features
        if not features:
            return
        if features & Feature.FocusTraversal:
            self.unhook_focus_traversal()
        if features & Feature.FocusEvents:
            self.unhook_focus_events()
        if features & Feature.DragEnabled:
            self.unhook_drag()
        if features & Feature.DropEnabled:
            self.unhook_drop()

        features = self._extra_features
        if features & GraphicFeature.WheelEvent:
            self.unhook_wheel()
        if features & GraphicFeature.DrawEvent:
            self.unhook_draw()

    # --------------------------------------------------------------------------
    # Protected API
    # --------------------------------------------------------------------------
    def tab_focus_request(self, reason):
        """Handle a custom tab focus request.

        This method is called when focus is being set on the proxy
        as a result of a user-implemented focus traversal handler.
        This can be reimplemented by subclasses as needed.

        Parameters
        ----------
        reason : Qt.FocusReason
            The reason value for the focus request.

        Returns
        -------
        result : bool
            True if focus was set, False otherwise.

        """
        widget = self.focus_target()
        if not widget.focusPolicy & Qt.TabFocus:
            return False
        if not widget.isEnabled():
            return False
        if not widget.isVisibleTo(widget.window()):
            return False
        widget.setFocus(reason)
        return False

    def focus_target(self):
        """Return the current focus target for a focus request.

        This can be reimplemented by subclasses as needed. The default
        implementation of this method returns the current proxy widget.

        """
        return self.widget

    def hook_focus_traversal(self):
        """Install the hooks for focus traversal.

        This method may be overridden by subclasses as needed.

        """
        self.widget.focusNextPrevChild = self.focusNextPrevChild

    def unhook_focus_traversal(self):
        """Remove the hooks for the next/prev child focusing.

        This method may be overridden by subclasses as needed.

        """
        del self.widget.focusNextPrevChild

    def hook_focus_events(self):
        """Install the hooks for focus events.

        This method may be overridden by subclasses as needed.

        """
        widget = self.widget
        widget.focusInEvent = self.focusInEvent
        widget.focusOutEvent = self.focusOutEvent

    def unhook_focus_events(self):
        """Remove the hooks for the focus events.

        This method may be overridden by subclasses as needed.

        """
        widget = self.widget
        del widget.focusInEvent
        del widget.focusOutEvent

    def focusNextPrevChild(self, next_child):
        """The default 'focusNextPrevChild' implementation."""
        fd = focus_registry.focused_declaration()
        if next_child:
            child = self.declaration.next_focus_child(fd)
            reason = Qt.TabFocusReason
        else:
            child = self.declaration.previous_focus_child(fd)
            reason = Qt.BacktabFocusReason
        if child is not None and child.proxy_is_active:
            return child.proxy.tab_focus_request(reason)
        widget = self.widget
        return type(widget).focusNextPrevChild(widget, next_child)

    def focusInEvent(self, event):
        """The default 'focusInEvent' implementation."""
        widget = self.widget
        type(widget).focusInEvent(widget, event)
        self.declaration.focus_gained()

    def focusOutEvent(self, event):
        """The default 'focusOutEvent' implementation."""
        widget = self.widget
        type(widget).focusOutEvent(widget, event)
        self.declaration.focus_lost()

    def hook_drag(self):
        """Install the hooks for drag operations."""
        widget = self.widget
        widget.mousePressEvent = self.mousePressEvent
        widget.mouseMoveEvent = self.mouseMoveEvent
        widget.mouseReleaseEvent = self.mouseReleaseEvent

    def unhook_drag(self):
        """Remove the hooks for drag operations."""
        widget = self.widget
        del widget.mousePressEvent
        del widget.mouseMoveEvent
        del widget.mouseReleaseEvent

    def mousePressEvent(self, event):
        """Handle the mouse press event for a drag operation."""
        if event.button() == Qt.LeftButton:
            self._drag_origin = event.pos()
        widget = self.widget
        type(widget).mousePressEvent(widget, event)

    def mouseMoveEvent(self, event):
        """Handle the mouse move event for a drag operation."""
        # if event.buttons() & Qt.LeftButton and self._drag_origin is not None:
        # dist = (event.pos() - self._drag_origin).manhattanLength()
        # if dist >= QApplication.startDragDistance():
        # self.do_drag(event.widget())
        # self._drag_origin = None
        # return # Don't returns
        widget = self.widget
        type(widget).mouseMoveEvent(widget, event)

    def mouseReleaseEvent(self, event):
        """Handle the mouse release event for the drag operation."""
        if event.button() == Qt.LeftButton:
            self._drag_origin = None
        widget = self.widget
        type(widget).mouseReleaseEvent(widget, event)

    def hook_drop(self):
        """Install hooks for drop operations."""
        widget = self.widget
        widget.setAcceptDrops(True)
        widget.dragEnterEvent = self.dragEnterEvent
        widget.dragMoveEvent = self.dragMoveEvent
        widget.dragLeaveEvent = self.dragLeaveEvent
        widget.dropEvent = self.dropEvent

    def unhook_drop(self):
        """Remove hooks for drop operations."""
        widget = self.widget
        widget.setAcceptDrops(False)
        del widget.dragEnterEvent
        del widget.dragMoveEvent
        del widget.dragLeaveEvent
        del widget.dropEvent

    def do_drag(self, widget):
        """Perform the drag operation for the widget.

        Parameters
        ----------
        widget: QWidget
            A reference to the viewport widget.

        """
        drag_data = self.declaration.drag_start()
        if drag_data is None:
            return
        # widget = self.widget
        qdrag = QDrag(widget)
        qdrag.setMimeData(drag_data.mime_data.q_data())
        if drag_data.image is not None:
            qimg = get_cached_qimage(drag_data.image)
            qdrag.setPixmap(QPixmap.fromImage(qimg))
        # else:
        # if __version_info__ < (5, ):
        # qdrag.setPixmap(QPixmap.grabWidget(self.widget))
        # else:
        # qdrag.setPixmap(widget.grab())
        if drag_data.hotspot:
            qdrag.setHotSpot(QPoint(*drag_data.hotspot))
        else:
            cursor_position = widget.mapFromGlobal(QCursor.pos())
            qdrag.setHotSpot(cursor_position)
        default = Qt.DropAction(drag_data.default_drop_action)
        supported = Qt.DropActions(drag_data.supported_actions)
        qresult = qdrag.exec_(supported, default)
        self.declaration.drag_end(drag_data, DropAction(int(qresult)))

    def dragEnterEvent(self, event):
        """Handle the drag enter event for the widget."""
        self.declaration.drag_enter(QtDropEvent(event))

    def dragMoveEvent(self, event):
        """Handle the drag move event for the widget."""
        self.declaration.drag_move(QtDropEvent(event))

    def dragLeaveEvent(self, event):
        """Handle the drag leave event for the widget."""
        self.declaration.drag_leave()

    def dropEvent(self, event):
        """Handle the drop event for the widget."""
        self.declaration.drop(QtDropEvent(event))

    def hook_wheel(self):
        """Install the hooks for wheel events."""
        widget = self.widget
        widget.wheelEvent = self.wheelEvent

    def unhook_wheel(self):
        """Removes the hooks for wheel events."""
        widget = self.widget
        del widget.wheelEvent

    def wheelEvent(self, event):
        """Handle the mouse wheel event for the widget."""
        self.declaration.wheel_event(event)

    def hook_draw(self):
        """Remove the hooks for the draw (paint) event.

        This method may be overridden by subclasses as needed.

        """
        widget = self.widget
        widget.paint = self.draw

    def unhook_draw(self):
        """Remove the hooks for the draw (paint) event.

        This method may be overridden by subclasses as needed.

        """
        widget = self.widget
        del widget.paint

    def draw(self, painter, options, widget):
        """Handle the draw event for the widget."""
        self.declaration.draw(painter, options, widget)

    # --------------------------------------------------------------------------
    # Framework API
    # --------------------------------------------------------------------------
    def get_action(self, create=False):
        """Get the shared widget action for this widget.

        This API is used to support widgets in tool bars and menus.

        Parameters
        ----------
        create : bool, optional
            Whether to create the action if it doesn't already exist.
            The default is False.

        Returns
        -------
        result : QWidgetAction or None
            The cached widget action or None, depending on arguments.

        """
        action = self._widget_action
        if action is None and create:
            action = self._widget_action = QWidgetAction(None)
            action.setDefaultWidget(self.widget)
        return action


# --------------------------------------------------------------------------
# Toolkit implementations
# --------------------------------------------------------------------------
class QtGraphicsView(QtControl, ProxyGraphicsView):
    #: Internal widget
    widget = Typed(QGraphicsView)

    #: Internal scene
    scene = Typed(QGraphicsScene)

    #: View Range
    view_range = Typed(QRectF, (0, 0, 1, 1))

    #: Custom features
    _extra_features = Coerced(GraphicFeature, (0,))

    #: Cyclic notification guard. This a bitfield of multiple guards.
    _guards = Int(0)

    def create_widget(self):
        self.scene = QGraphicsScene()
        self.widget = QGraphicsView(self.scene, self.parent_widget())

    def init_widget(self):
        d = self.declaration
        self._extra_features = d.extra_features
        super(QtGraphicsView, self).init_widget()

        widget = self.widget
        widget.setCacheMode(QGraphicsView.CacheBackground)
        widget.setFocusPolicy(Qt.StrongFocus)
        widget.setFrameShape(QFrame.NoFrame)
        widget.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
        widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        widget.setViewportUpdateMode(QGraphicsView.MinimalViewportUpdate)
        widget.setResizeAnchor(QGraphicsView.AnchorViewCenter)
        widget.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
        widget.setMouseTracking(True)

        self.set_drag_mode(d.drag_mode)
        self.set_renderer(d.renderer)
        self.set_antialiasing(d.antialiasing)
        self.scene.selectionChanged.connect(self.on_selection_changed)

    def init_layout(self):
        super(QtGraphicsView, self).init_layout()
        scene = self.scene
        for item in self.scene_items():
            scene.addItem(item)

        self.set_view_range(self.view_range)

    def child_added(self, child):
        if isinstance(child, QtGraphicsItem):
            self.scene.addItem(child.widget)
        else:
            super(QtGraphicsView, self).child_added(child)

    def child_removed(self, child):
        if isinstance(child, QtGraphicsItem):
            self.scene.removeItem(child.widget)
        else:
            super(QtGraphicsView, self).child_removed(child)

    def scene_items(self):
        for w in self.children():
            if isinstance(w, QtGraphicsItem):
                yield w.widget

    # --------------------------------------------------------------------------
    # GraphicFeature API
    # --------------------------------------------------------------------------
    def _setup_features(self):
        super(QtGraphicsView, self)._setup_features()
        features = self._extra_features
        if features & GraphicFeature.MouseEvent:
            self.hook_drag()
        if features & GraphicFeature.WheelEvent:
            self.hook_wheel()
        self.hook_resize()

    def _teardown_features(self):
        super(QtGraphicsView, self)._teardown_features()
        features = self._extra_features
        if features & GraphicFeature.MouseEvent:
            self.unhook_drag()
        if features & GraphicFeature.WheelEvent:
            self.unhook_wheel()
        self.unhook_resize()

    def hook_wheel(self):
        """Install the hooks for wheel events."""
        widget = self.widget
        widget.wheelEvent = self.wheelEvent

    def unhook_wheel(self):
        """Removes the hooks for wheel events."""
        widget = self.widget
        del widget.wheelEvent

    def hook_draw(self):
        """Install the hooks for background draw events."""
        widget = self.widget
        widget.drawBackground = self.drawBackground

    def unhook_draw(self):
        """Removes the hooks for background draw events."""
        widget = self.widget
        del widget.drawBackground

    def hook_resize(self):
        """Install the hooks for resize events."""
        widget = self.widget
        widget.resizeEvent = self.resizeEvent

    def unhook_resize(self):
        """Removes the hooks for resize events."""
        widget = self.widget
        del widget.resizeEvent

    # --------------------------------------------------------------------------
    # QGraphicView API
    # --------------------------------------------------------------------------
    def wheelEvent(self, event):
        """Handle the wheel event for the widget."""
        self.declaration.wheel_event(event)

    def drawBackground(self, painter, rect):
        """Handle the drawBackground request"""
        self.declaration.draw_background(painter, rect)

    def mousePressEvent(self, event):
        """Handle the mouse press event for a drag operation."""
        self.declaration.mouse_press_event(event)
        super(QtGraphicsView, self).mousePressEvent(event)

    def mouseMoveEvent(self, event):
        """Handle the mouse move event for a drag operation."""
        self.declaration.mouse_move_event(event)
        super(QtGraphicsView, self).mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        """Handle the mouse release event for the drag operation."""
        self.declaration.mouse_release_event(event)
        super(QtGraphicsView, self).mouseReleaseEvent(event)

    def resizeEvent(self, event):
        """Resize the view range to match the widget size"""
        d = self.declaration
        widget = self.widget

        if d.auto_range:
            size = self.widget.size()
            view_range = QRectF(0, 0, size.width(), size.height())
            # view_range = self.scene.itemsBoundingRect()
        else:
            # Return the boundaries of the view in scene coordinates
            r = QRectF(widget.rect())
            view_range = widget.viewportTransform().inverted()[0].mapRect(r)
        self.set_view_range(view_range)

    # --------------------------------------------------------------------------
    # ProxyGraphicsView API
    # --------------------------------------------------------------------------
    def set_view_range(self, view_range):
        """Set the visible scene rect to override the default behavior
        of limiting panning and viewing to the graphics items view.

        Based on Luke Campagnola's updateMatrix of pyqtgraph's GraphicsView

        """
        d = self.declaration
        self.view_range = view_range
        widget = self.widget
        widget.setSceneRect(view_range)
        if d.auto_range:
            widget.resetTransform()
        else:
            if d.lock_aspect_ratio:
                flags = Qt.KeepAspectRatio
            else:
                flags = Qt.IgnoreAspectRatio
            widget.fitInView(view_range, flags)

    def set_drag_mode(self, mode):
        self.widget.setDragMode(DRAG_MODES.get(mode))

    def set_auto_range(self, enabled):
        self.set_view_range(self.view_range)

    def set_lock_aspect_ratio(self, locked):
        self.set_view_range(self.view_range)

    def set_antialiasing(self, enabled):
        flags = self.widget.renderHints()
        if enabled:
            flags |= QPainter.Antialiasing
        else:
            flags &= ~QPainter.Antialiasing
        self.widget.setRenderHints(flags)

    def set_renderer(self, renderer):
        """Set the viewport widget."""
        viewport = None
        if renderer == "opengl":
            from enaml.qt.QtWidgets import QOpenGLWidget

            viewport = QOpenGLWidget()
        elif renderer == "default":
            try:
                from enaml.qt.QtWidgets import QOpenGLWidget

                viewport = QOpenGLWidget()
            except ImportError as e:
                warnings.warn("QOpenGLWidget could not be imported: {}".format(e))
        self.widget.setViewport(viewport)

    def set_selected_items(self, items):
        if self._guards & 0x01:
            return
        self.scene.clearSelection()
        for item in items:
            item.selected = True

    def on_selection_changed(self):
        """Callback invoked one the selection has changed."""
        d = self.declaration
        selection = self.scene.selectedItems()
        self._guards |= 0x01
        try:
            d.selected_items = [
                item.ref().declaration for item in selection if item.ref()
            ]
        finally:
            self._guards &= ~0x01

    def set_background(self, background):
        """Set the background color of the widget."""
        scene = self.scene
        scene.setBackgroundBrush(QColor.fromRgba(background.argb))

    def get_item_at(self, point):
        item = self.scene.getItemAt(point.x, point.y)
        if item and item.ref():
            return item.ref().declaration

    def get_items_at(self, point):
        items = self.scene.items(point.x, point.y)
        return [item.ref().declaration for item in items if item.ref()]

    def get_items_in(self, top_left, bottom_right):
        qrect = QRectF(
            QPointF(top_left.x, top_left.y), QPointF(bottom_right.x, bottom_right.y)
        )
        items = self.scene.items(qrect)
        return [item.ref().declaration for item in items if item.ref()]

    def fit_in_view(self, item):
        self.widget.fitInView(item.proxy.widget)

    def center_on(self, item):
        if isinstance(item, Point):
            self.widget.centerOn(item.x, item.y)
        else:
            self.widget.centerOn(item.proxy.widget)

    def reset_view(self):
        self.widget.resetTransform()

    def translate_view(self, x, y):
        view_range = self.view_range.adjusted(x, y, x, y)
        self.set_view_range(view_range)
        return view_range

    def scale_view(self, x, y):
        """Scale the zoom but keep in in the min and max zoom bounds."""
        d = self.declaration
        sx, sy = float(x), float(y)
        if d.lock_aspect_ratio:
            sy = sx
        view_range = self.view_range
        center = view_range.center()
        w, h = view_range.width() / sx, view_range.height() / sy
        cx, cy = center.x(), center.y()
        x = cx - (cx - view_range.left()) / sx
        y = cy - (cy - view_range.top()) / sy
        view_range = QRectF(x, y, w, h)
        self.set_view_range(view_range)
        return view_range

    def rotate_view(self, angle):
        self.widget.rotate(angle)

    def map_from_scene(self, point):
        qpoint = self.widget.mapFromScene(point.x, point.y)
        return Point(qpoint.x(), qpoint.y())

    def map_to_scene(self, point):
        qpoint = self.widget.mapToScene(point.x, point.y)
        return Point(qpoint.x(), qpoint.y())

    def pixel_density(self):
        tr = self.widget.transform().inverted()[0]
        p = tr.map(QPoint(1, 1)) - tr.map(QPoint(0, 0))
        return Point(p.x(), p.y())


class QtGraphicsItem(QtToolkitObject, ProxyGraphicsItem, FeatureMixin):
    """QtGraphicsItem is essentially a copy of QtWidget except that
    it uses `self.widget`, `create_widget` and `init_widget` instead of
    widget.

    """

    #: Internal item
    widget = Typed(QGraphicsObject)

    #: Cyclic notification guard. This a bitfield of multiple guards.
    #: 0x01 is position
    _guards = Int(0)

    # --------------------------------------------------------------------------
    # Initialization API
    # --------------------------------------------------------------------------
    def create_widget(self):
        self.widget = QGraphicsObject(self.parent_widget())

    def init_widget(self):
        widget = self.widget

        # Save a reference so we can retrieve the QtGraphicsItem
        # from the QGraphicsItem
        widget.ref = atomref(self)

        focus_registry.register(widget, self)
        d = self.declaration
        self._extra_features = d.extra_features
        self._setup_features()

        if d.selectable:
            self.set_selectable(d.selectable)
        if d.movable:
            self.set_movable(d.movable)
        if d.tool_tip:
            self.set_tool_tip(d.tool_tip)
        if d.status_tip:
            self.set_status_tip(d.status_tip)
        if not d.enabled:
            self.set_enabled(d.enabled)
        if not d.visible:
            self.set_visible(d.visible)
        if d.opacity != 1:
            self.set_opacity(d.opacity)
        if d.rotation:
            self.set_rotation(d.rotation)
        if d.scale != 1:
            self.set_scale(d.scale)
        self.set_position(d.position)
        self.hook_item_change()

    def init_layout(self):
        pass

    # --------------------------------------------------------------------------
    # ProxyToolkitObject API
    # --------------------------------------------------------------------------
    def destroy(self):
        """Destroy the underlying QWidget object."""
        self._teardown_features()
        focus_registry.unregister(self.widget)
        widget = self.widget
        if widget is not None:
            del self.widget
        super(QtGraphicsItem, self).destroy()
        # If a QWidgetAction was created for this widget, then it has
        # taken ownership of the widget and the widget will be deleted
        # when the QWidgetAction is garbage collected. This means the
        # superclass destroy() method must run before the reference to
        # the QWidgetAction is dropped.
        del self._widget_action

    def parent_widget(self):
        """Reimplemented to only return GraphicsItems"""
        parent = self.parent()
        if parent is not None and isinstance(parent, QtGraphicsItem):
            return parent.widget

    def _teardown_features(self):
        super(QtGraphicsItem, self)._teardown_features()
        self.unhook_item_change()

    def hook_item_change(self):
        widget = self.widget
        widget.itemChange = self.itemChange

    def unhook_item_change(self):
        del self.widget.itemChange

    # --------------------------------------------------------------------------
    # Signals
    # --------------------------------------------------------------------------
    def itemChange(self, change, value):
        widget = self.widget
        if change == QGraphicsItem.ItemPositionHasChanged:
            pos = widget.pos()
            pos = Point(pos.x(), pos.y(), widget.zValue())
            self._guards |= 0x01
            try:
                self.declaration.position = pos
            finally:
                self._guards &= ~0x01
        elif change == QGraphicsItem.ItemSelectedChange:
            self.declaration.selected = widget.isSelected()

        return type(widget).itemChange(widget, change, value)

    # --------------------------------------------------------------------------
    # ProxyGraphicsItem API
    # --------------------------------------------------------------------------
    def set_visible(self, visible):
        self.widget.setVisible(visible)

    def set_enabled(self, enabled):
        self.widget.setEnabled(enabled)

    def set_selectable(self, enabled):
        self.widget.setFlag(QGraphicsItem.ItemIsSelectable, enabled)

    def set_movable(self, enabled):
        self.widget.setFlag(QGraphicsItem.ItemIsMovable, enabled)

    def set_x(self, x):
        if self._guards & 0x01:
            return
        self.widget.setX(x)

    def set_y(self, y):
        if self._guards & 0x01:
            return
        self.widget.setY(y)

    def set_z(self, z):
        if self._guards & 0x01:
            return
        self.widget.setZValue(z)

    def set_position(self, position):
        if self._guards & 0x01:
            return
        pos = self.declaration.position
        w = self.widget
        w.setPos(pos.x, pos.y)
        w.setZValue(pos.z)

    def set_rotation(self, rotation):
        self.widget.setRotation(rotation)

    def set_scale(self, scale):
        self.widget.setScale(scale)

    def set_opacity(self, opacity):
        self.widget.setOpacity(opacity)

    def set_selected(self, selected):
        self.widget.setSelected(selected)

    def set_tool_tip(self, tool_tip):
        self.widget.setToolTip(tool_tip)

    def set_status_tip(self, status_tip):
        self.widget.setToolTip(status_tip)


class QtGraphicsItemGroup(QtGraphicsItem, ProxyGraphicsItemGroup):
    #: Internal widget
    widget = Typed(QGraphicsItemGroup)

    def create_widget(self):
        self.widget = QGraphicsItemGroup(self.parent_widget())

    def init_layout(self):
        super(QtGraphicsItemGroup, self).init_layout()
        widget = self.widget
        for item in self.child_widgets():
            widget.addToGroup(item)

    def child_added(self, child):
        super(QtGraphicsItemGroup, self).child_added(child)
        if isinstance(child, QtGraphicsItem):
            self.widget.addToGroup(child.widget)

    def child_removed(self, child):
        super(QtGraphicsItemGroup, self).child_removed(child)
        if isinstance(child, QtGraphicsItem):
            self.widget.removeFromGroup(child.widget)


class QtGraphicsWidget(QtGraphicsItem, ProxyGraphicsWidget):
    #: Internal widget
    widget = Typed(QGraphicsProxyWidget)

    def create_widget(self):
        """Deferred to the layout pass"""
        pass

    def init_widget(self):
        pass

    def init_layout(self):
        """Create the widget in the layout pass after the child widget has
        been created and intialized. We do this so the child widget does not
        attempt to use this proxy widget as its parent and because
        repositioning must be done after the widget is set.
        """
        self.widget = QGraphicsProxyWidget(self.parent_widget())
        widget = self.widget
        for item in self.child_widgets():
            widget.setWidget(item)
            break
        super(QtGraphicsWidget, self).init_widget()
        super(QtGraphicsWidget, self).init_layout()

    def child_added(self, child):
        super(QtGraphicsItemGroup, self).child_added(child)
        if isinstance(child, QtWidget):
            self.widget.setWidget(child.widget)


class QtAbstractGraphicsShapeItem(QtGraphicsItem, ProxyAbstractGraphicsShapeItem):
    def init_widget(self):
        super(QtAbstractGraphicsShapeItem, self).init_widget()
        d = self.declaration
        if d.pen:
            self.set_pen(d.pen)
        if d.brush:
            self.set_brush(d.brush)

    def set_pen(self, pen):
        if pen:
            self.widget.setPen(get_cached_qpen(pen))
        else:
            self.widget.setPen(QPen())

    def set_brush(self, brush):
        if brush:
            self.widget.setBrush(get_cached_qbrush(brush))
        else:
            self.widget.setBrush(QBrush())


class QtGraphicsLineItem(QtAbstractGraphicsShapeItem, ProxyGraphicsLineItem):
    #: Internal widget
    widget = Typed(QGraphicsLineItem)

    def create_widget(self):
        self.widget = QGraphicsLineItem(self.parent_widget())

    def set_position(self, position):
        self.set_point(self.declaration.point)

    def set_point(self, point):
        pos = self.declaration.position
        self.widget.setLine(pos.x, pos.y, *point[:2])


class QtGraphicsEllipseItem(QtAbstractGraphicsShapeItem, ProxyGraphicsEllipseItem):
    #: Internal widget
    widget = Typed(QGraphicsEllipseItem)

    def create_widget(self):
        self.widget = QGraphicsEllipseItem(self.parent_widget())

    def init_widget(self):
        super(QtGraphicsEllipseItem, self).init_widget()
        d = self.declaration
        self.set_start_angle(d.start_angle)
        self.set_span_angle(d.span_angle)

    def set_position(self, position):
        self.update_rect()

    def set_width(self, width):
        self.update_rect()

    def set_height(self, height):
        self.update_rect()

    def update_rect(self):
        d = self.declaration
        pos = d.position
        self.widget.setRect(pos.x, pos.y, d.width, d.height)

    def set_span_angle(self, angle):
        self.widget.setSpanAngle(int(angle * 16))

    def set_start_angle(self, angle):
        self.widget.setStartAngle(int(angle * 16))


class QtGraphicsRectItem(QtAbstractGraphicsShapeItem, ProxyGraphicsRectItem):
    #: Internal widget
    widget = Typed(QGraphicsRectItem)

    def create_widget(self):
        self.widget = QGraphicsRectItem(self.parent_widget())

    def set_position(self, position):
        self.update_rect()

    def set_width(self, width):
        self.update_rect()

    def set_height(self, height):
        self.update_rect()

    def update_rect(self):
        d = self.declaration
        pos = d.position
        self.widget.setRect(pos.x, pos.y, d.width, d.height)


class QtGraphicsTextItem(QtAbstractGraphicsShapeItem, ProxyGraphicsTextItem):
    #: Internal widget
    widget = Typed(QGraphicsSimpleTextItem)

    def create_widget(self):
        self.widget = QGraphicsSimpleTextItem(self.parent_widget())

    def init_widget(self):
        super(QtGraphicsTextItem, self).init_widget()
        d = self.declaration
        if d.text:
            self.set_text(d.text)
        if d.font:
            self.set_font(d.font)

    def set_text(self, text):
        self.widget.setText(text)

    def set_font(self, font):
        self.widget.setFont(get_cached_qfont(font))


class QtGraphicsPolygonItem(QtAbstractGraphicsShapeItem, ProxyGraphicsPolygonItem):
    #: Internal widget
    widget = Typed(QGraphicsPolygonItem)

    def create_widget(self):
        self.widget = QGraphicsPolygonItem(self.parent_widget())

    def init_widget(self):
        super(QtGraphicsPolygonItem, self).init_widget()
        d = self.declaration
        self.set_points(d.points)

    def set_points(self, points):
        polygon = QPolygonF([QPointF(*p[:2]) for p in points])
        self.widget.setPolygon(polygon)


class QtGraphicsPathItem(QtAbstractGraphicsShapeItem, ProxyGraphicsPathItem):
    #: Internal widget
    widget = Typed(QGraphicsPathItem)

    def create_widget(self):
        self.widget = QGraphicsPathItem(self.parent_widget())

    def init_widget(self):
        super(QtGraphicsPathItem, self).init_widget()
        d = self.declaration
        if d.path:
            self.set_path(d.path)

    def set_path(self, path):
        #: TODO: Convert path
        self.widget.setPath(path)


class QtGraphicsImageItem(QtGraphicsItem, ProxyGraphicsImageItem):
    #: Internal widget
    widget = Typed(QGraphicsPixmapItem)

    def create_widget(self):
        self.widget = QGraphicsPixmapItem(self.parent_widget())

    def init_widget(self):
        super(QtGraphicsImageItem, self).init_widget()
        d = self.declaration
        if d.image:
            self.set_image(d.image)

    def set_image(self, image):
        self.widget.setPixmap(QPixmap.fromImage(get_cached_qimage(image)))