"""Support for simplified access to data on nodes of type omni.graph.ui.OnViewportDragged

Event node which fires when a viewport drag event occurs in the specified viewport. Note that viewport mouse events must
be enabled on the specified viewport using a SetViewportMode node.
"""

import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
import numpy
class OgnOnViewportDraggedDatabase(og.Database):
    """Helper class providing simplified access to data on nodes of type omni.graph.ui.OnViewportDragged

    Class Members:
        node: Node being evaluated

    Attribute Value Properties:
        Inputs:
            inputs.gesture
            inputs.onlyPlayback
            inputs.useNormalizedCoords
            inputs.viewport
        Outputs:
            outputs.began
            outputs.ended
            outputs.finalPosition
            outputs.initialPosition

    Predefined Tokens:
        tokens.LeftMouseDrag
        tokens.RightMouseDrag
        tokens.MiddleMouseDrag
    """
    # This is an internal object that provides per-class storage of a per-node data dictionary
    PER_NODE_DATA = {}
    # This is an internal object that describes unchanging attributes in a generic way
    # The values in this list are in no particular order, as a per-attribute tuple
    #     Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
    #     Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
    # You should not need to access any of this data directly, use the defined database interfaces
    INTERFACE = og.Database._get_interface([
        ('inputs:gesture', 'token', 0, 'Gesture', 'The input gesture to trigger viewport drag events', {'displayGroup': 'parameters', ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.ALLOWED_TOKENS: 'Left Mouse Drag,Right Mouse Drag,Middle Mouse Drag', ogn.MetadataKeys.ALLOWED_TOKENS_RAW: '{"LeftMouseDrag": "Left Mouse Drag", "RightMouseDrag": "Right Mouse Drag", "MiddleMouseDrag": "Middle Mouse Drag"}', ogn.MetadataKeys.DEFAULT: '"Left Mouse Drag"'}, True, 'Left Mouse Drag', False, ''),
        ('inputs:onlyPlayback', 'bool', 0, 'Only Simulate On Play', 'When true, the node is only computed while Stage is being played', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
        ('inputs:useNormalizedCoords', 'bool', 0, 'Use Normalized Coords', 'When true, the components of 2D position outputs are scaled to between 0 and 1,\nwhere 0 is top/left and 1 is bottom/right.\nWhen false, components are in viewport render resolution pixels.', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
        ('inputs:viewport', 'token', 0, 'Viewport', 'Name of the viewport window to watch for drag events', {ogn.MetadataKeys.LITERAL_ONLY: '1', ogn.MetadataKeys.DEFAULT: '"Viewport"'}, True, 'Viewport', False, ''),
        ('outputs:began', 'execution', 0, 'Began', "Enabled when the drag begins, populating 'Initial Position' with the current mouse position", {}, True, None, False, ''),
        ('outputs:ended', 'execution', 0, 'Ended', "Enabled when the drag ends, populating 'Final Position' with the current mouse position", {}, True, None, False, ''),
        ('outputs:finalPosition', 'double2', 0, 'Final Position', "The mouse position at which the drag ended (valid when 'Ended' is enabled)", {}, True, None, False, ''),
        ('outputs:initialPosition', 'double2', 0, 'Initial Position', "The mouse position at which the drag began (valid when either 'Began' or 'Ended' is enabled)", {}, True, None, False, ''),
    ])
    class tokens:
        LeftMouseDrag = "Left Mouse Drag"
        RightMouseDrag = "Right Mouse Drag"
        MiddleMouseDrag = "Middle Mouse Drag"
    @classmethod
    def _populate_role_data(cls):
        """Populate a role structure with the non-default roles on this node type"""
        role_data = super()._populate_role_data()
        role_data.outputs.began = og.Database.ROLE_EXECUTION
        role_data.outputs.ended = og.Database.ROLE_EXECUTION
        return role_data
    class ValuesForInputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = {"gesture", "onlyPlayback", "useNormalizedCoords", "viewport", "_setting_locked", "_batchedReadAttributes", "_batchedReadValues"}
        """Helper class that creates natural hierarchical access to input attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedReadAttributes = [self._attributes.gesture, self._attributes.onlyPlayback, self._attributes.useNormalizedCoords, self._attributes.viewport]
            self._batchedReadValues = ["Left Mouse Drag", True, False, "Viewport"]

        @property
        def gesture(self):
            return self._batchedReadValues[0]

        @gesture.setter
        def gesture(self, value):
            self._batchedReadValues[0] = value

        @property
        def onlyPlayback(self):
            return self._batchedReadValues[1]

        @onlyPlayback.setter
        def onlyPlayback(self, value):
            self._batchedReadValues[1] = value

        @property
        def useNormalizedCoords(self):
            return self._batchedReadValues[2]

        @useNormalizedCoords.setter
        def useNormalizedCoords(self, value):
            self._batchedReadValues[2] = value

        @property
        def viewport(self):
            return self._batchedReadValues[3]

        @viewport.setter
        def viewport(self, value):
            self._batchedReadValues[3] = value

        def __getattr__(self, item: str):
            if item in self.LOCAL_PROPERTY_NAMES:
                return object.__getattribute__(self, item)
            else:
                return super().__getattr__(item)

        def __setattr__(self, item: str, new_value):
            if item in self.LOCAL_PROPERTY_NAMES:
                object.__setattr__(self, item, new_value)
            else:
                super().__setattr__(item, new_value)

        def _prefetch(self):
            readAttributes = self._batchedReadAttributes
            newValues = _og._prefetch_input_attributes_data(readAttributes)
            if len(readAttributes) == len(newValues):
                self._batchedReadValues = newValues
    class ValuesForOutputs(og.DynamicAttributeAccess):
        LOCAL_PROPERTY_NAMES = {"began", "ended", "finalPosition", "initialPosition", "_batchedWriteValues"}
        """Helper class that creates natural hierarchical access to output attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
            self._batchedWriteValues = { }

        @property
        def began(self):
            value = self._batchedWriteValues.get(self._attributes.began)
            if value:
                return value
            else:
                data_view = og.AttributeValueHelper(self._attributes.began)
                return data_view.get()

        @began.setter
        def began(self, value):
            self._batchedWriteValues[self._attributes.began] = value

        @property
        def ended(self):
            value = self._batchedWriteValues.get(self._attributes.ended)
            if value:
                return value
            else:
                data_view = og.AttributeValueHelper(self._attributes.ended)
                return data_view.get()

        @ended.setter
        def ended(self, value):
            self._batchedWriteValues[self._attributes.ended] = value

        @property
        def finalPosition(self):
            value = self._batchedWriteValues.get(self._attributes.finalPosition)
            if value:
                return value
            else:
                data_view = og.AttributeValueHelper(self._attributes.finalPosition)
                return data_view.get()

        @finalPosition.setter
        def finalPosition(self, value):
            self._batchedWriteValues[self._attributes.finalPosition] = value

        @property
        def initialPosition(self):
            value = self._batchedWriteValues.get(self._attributes.initialPosition)
            if value:
                return value
            else:
                data_view = og.AttributeValueHelper(self._attributes.initialPosition)
                return data_view.get()

        @initialPosition.setter
        def initialPosition(self, value):
            self._batchedWriteValues[self._attributes.initialPosition] = value

        def __getattr__(self, item: str):
            if item in self.LOCAL_PROPERTY_NAMES:
                return object.__getattribute__(self, item)
            else:
                return super().__getattr__(item)

        def __setattr__(self, item: str, new_value):
            if item in self.LOCAL_PROPERTY_NAMES:
                object.__setattr__(self, item, new_value)
            else:
                super().__setattr__(item, new_value)

        def _commit(self):
            _og._commit_output_attributes_data(self._batchedWriteValues)
            self._batchedWriteValues = { }
    class ValuesForState(og.DynamicAttributeAccess):
        """Helper class that creates natural hierarchical access to state attributes"""
        def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
            """Initialize simplified access for the attribute data"""
            context = node.get_graph().get_default_graph_context()
            super().__init__(context, node, attributes, dynamic_attributes)
    def __init__(self, node):
        super().__init__(node)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
        self.inputs = OgnOnViewportDraggedDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
        self.outputs = OgnOnViewportDraggedDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
        dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
        self.state = OgnOnViewportDraggedDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
