AttrsWidget._show_attrs() - Code Metrics - Inspection of "better display and edit of complex values" - FreeOpcUa/opcua-widgets - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#5)

by Olivier

created 2016-11-07 19:46 UTC

AttrsWidget._show_attrs() A

↳ Parent: AttrsWidget

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	1

Metric	Value
cc	4
c	6
b	0
f	1
dl	0
loc	13
rs	9.2

import traceback

from PyQt5.QtCore import pyqtSignal, Qt, QObject, QSettings
from PyQt5.QtGui import QStandardItemModel, QStandardItem
from PyQt5.QtWidgets import QApplication, QMenu, QAction, QStyledItemDelegate, QComboBox, QVBoxLayout, QCheckBox, QDialog

from opcua import ua
from opcua import Node
from opcua.common.ua_utils import string_to_val, val_to_string

from uawidgets.get_node_dialog import GetNodeButton


class BitEditor(QDialog):
    """
    Edit bits in data
    FIXME: this should be a dialog but a Widget appearing directly in treewidget
    Patch welcome
    """

    def __init__(self, parent, attr, val):
        QDialog.__init__(self, parent)
        layout = QVBoxLayout(self)
        self.setLayout(layout)
        self.boxes = []
        self.enum = attr_to_enum(attr)
        for el in self.enum:
            box = QCheckBox(el.name, parent)
            layout.addWidget(box)
            self.boxes.append(box)
            if ua.ua_binary.test_bit(val, el.value):
                box.setChecked(True)
            else:
                box.setChecked(False)

    def get_byte(self):
        data = 0
        for box in self.boxes:
            if box.isChecked():
                data = ua.ua_binary.set_bit(data, self.enum[box.text()].value)
        return data


class _Data(object):
    def is_editable(self):
        if self.uatype != ua.VariantType.ExtensionObject:
            return True
        return False


class AttributeData(_Data):
    def __init__(self, attr, value, uatype):
        self.attr = attr
        self.value = value
        self.uatype = uatype


class MemberData(_Data):
    def __init__(self, obj, name, value, uatype):
        self.obj = obj
        self.name = name
        self.value = value
        self.uatype = uatype


class ListData(_Data):
    def __init__(self, mylist, idx, val, uatype):
        self.mylist = mylist
        self.idx = idx
        self.value = val
        self.uatype = uatype


class AttrsWidget(QObject):

    error = pyqtSignal(Exception)
    modified = pyqtSignal()

    def __init__(self, view, show_timestamps=True):
        QObject.__init__(self, view)
        self.view = view
        self._timestamps = show_timestamps
        delegate = MyDelegate(self.view, self)
        delegate.error.connect(self.error.emit)
        self.settings = QSettings()
        self.view.setItemDelegate(delegate)
        self.model = QStandardItemModel()
        self.model.setHorizontalHeaderLabels(['Attribute', 'Value', 'DataType'])
        state = self.settings.value("attrs_widget", None)
        if state is not None:
            self.view.header().restoreState(state)
        self.view.setModel(self.model)
        self.current_node = None
        self.model.itemChanged.connect(self._item_changed)
        self.view.header().setSectionResizeMode(0)
        self.view.header().setStretchLastSection(True)
        self.view.expanded.connect(self._item_expanded)
        self.view.collapsed.connect(self._item_collapsed)

        # Context menu
        self.view.setContextMenuPolicy(Qt.CustomContextMenu)
        self.view.customContextMenuRequested.connect(self.showContextMenu)
        copyaction = QAction("&Copy Value", self.model)
        copyaction.triggered.connect(self._copy_value)
        self._contextMenu = QMenu()
        self._contextMenu.addAction(copyaction)

    def save_state(self):
        self.settings.setValue("attrs_widget", self.view.header().saveState())

    def _item_expanded(self, idx):
        if not idx.parent().isValid():
            # only for value attributes which a re childs
            # maybe add more tests
            return
        it = self.model.itemFromIndex(idx.sibling(0, 1))
        it.setText("")

    def _item_collapsed(self, idx):
        it = self.model.itemFromIndex(idx.sibling(0, 1))
        data = it.data(Qt.UserRole)
        it.setText(val_to_string(data.value))

    def _item_changed(self, item):
        self.modified.emit()

    def showContextMenu(self, position):
        item = self.get_current_item()
        if item:
            self._contextMenu.exec_(self.view.viewport().mapToGlobal(position))

    def get_current_item(self, col_idx=0):
        idx = self.view.currentIndex()
        return self.model.item(idx.row(), col_idx)

    def _copy_value(self, position):
        it = self.get_current_item(1)
        if it:
            QApplication.clipboard().setText(it.text())

    def clear(self):
        # remove all rows but not header!!
        self.model.removeRows(0, self.model.rowCount())

    def reload(self):
        self.show_attrs(self.current_node)

    def show_attrs(self, node):
        self.current_node = node
        self.clear()
        if self.current_node:
            self._show_attrs()
        self.view.expandToDepth(0)

    def _show_attrs(self):
        attrs = self.get_all_attrs()
        for attr, dv in attrs:
            try:
                # crashing here put down the application, we do not want that
                # so we use try/except
                if attr == ua.AttributeIds.Value:
                    self._show_value_attr(attr, dv)
                else:
                    self._show_attr(attr, dv)
            except Exception as ex:
                traceback.print_exc()
                self.error.emit(ex)

    def _show_attr(self, attr, dv):
        if attr == ua.AttributeIds.DataType:
            string = data_type_to_string(dv.Value.Value)
        elif attr in (ua.AttributeIds.AccessLevel,
                      ua.AttributeIds.UserAccessLevel,
                      ua.AttributeIds.WriteMask,
                      ua.AttributeIds.UserWriteMask,
                      ua.AttributeIds.EventNotifier):
            string = enum_to_string(attr, dv.Value.Value)
        else:
            string = val_to_string(dv.Value.Value)
        name_item = QStandardItem(attr.name)
        vitem = QStandardItem(string)
        vitem.setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
        self.model.appendRow([name_item, vitem, QStandardItem(dv.Value.VariantType.name)])

    def _show_value_attr(self, attr, dv):
        name_item = QStandardItem("Value")
        vitem = QStandardItem()
        items = self._show_val(name_item, None, "Value", dv.Value.Value, dv.Value.VariantType)
        items[1].setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
        row = [name_item, vitem, QStandardItem(dv.Value.VariantType.name)]
        self.model.appendRow(row)
        self._show_timestamps(name_item, dv)

    def _show_val(self, parent, obj, name, val, vtype):
        name_item = QStandardItem(name)
        vitem = QStandardItem()
        vitem.setText(val_to_string(val))
        vitem.setData(MemberData(obj, name, val, vtype), Qt.UserRole)
        row = [name_item, vitem, QStandardItem(vtype.name)]
        # if we have a list or extension object we display children
        if isinstance(val, list):
            row[2].setText("List of " + vtype.name)
            self._show_list(name_item, val, vtype)
        elif vtype == ua.VariantType.ExtensionObject:
            self._show_ext_obj(name_item, val)
        parent.appendRow(row)
        return row

    def _show_list(self, parent, mylist, vtype):
        for idx, val in enumerate(mylist):
            name_item = QStandardItem(str(idx))
            vitem = QStandardItem()
            vitem.setText(val_to_string(val))
            vitem.setData(ListData(mylist, idx, val, vtype), Qt.UserRole)
            row = [name_item, vitem, QStandardItem(vtype.name)]
            parent.appendRow(row)
            if vtype == ua.VariantType.ExtensionObject:
                self._show_ext_obj(name_item, val)
        return row
    
    def refresh_list(self, parent, mylist, vtype):
        while parent.hasChildren():
            self.model.removeRow(0, parent.index())
        self._show_list(parent, mylist, vtype)

    def _show_ext_obj(self, item, val):
        item.setText(item.text() + ": " + val.__class__.__name__)
        for att_name, att_type in val.ua_types.items():
            member_val = getattr(val, att_name)
            attr = getattr(ua.VariantType, att_type)
            self._show_val(item, val, att_name, member_val, attr)

    def _show_timestamps(self, item, dv):
        #while item.hasChildren():
            #self.model.removeRow(0, item.index())
        string = val_to_string(dv.ServerTimestamp)
        item.appendRow([QStandardItem("Server Timestamp"), QStandardItem(string), QStandardItem(ua.VariantType.DateTime.name)])
        string = val_to_string(dv.SourceTimestamp)
        item.appendRow([QStandardItem("Source Timestamp"), QStandardItem(string), QStandardItem(ua.VariantType.DateTime.name)])


    def get_all_attrs(self):
        attrs = [attr for attr in ua.AttributeIds]
        try:
            dvs = self.current_node.get_attributes(attrs)
        except Exception as ex:
            self.error.emit(ex)
            raise
        res = []
        for idx, dv in enumerate(dvs):
            if dv.StatusCode.is_good():
                res.append((attrs[idx], dv))
        res.sort(key=lambda x: x[0].name)
        return res


class MyDelegate(QStyledItemDelegate):

    error = pyqtSignal(Exception)

    def __init__(self, parent, attrs_widget):
        QStyledItemDelegate.__init__(self, parent)
        self.attrs_widget = attrs_widget

    def createEditor(self, parent, option, idx):
        if idx.column() != 1:
            return None
        item = self.attrs_widget.model.itemFromIndex(idx)
        data = item.data(Qt.UserRole)
        if not data.is_editable():
            return None
        text = item.text()
        if isinstance(data, (ListData, MemberData)):
            return QStyledItemDelegate.createEditor(self, parent, option, idx)
        elif data.attr == ua.AttributeIds.NodeId:
            return None
        elif data.uatype == ua.VariantType.Boolean:
            combo = QComboBox(parent)
            combo.addItem("True")
            combo.addItem("False")
            combo.setCurrentText(text)
            return combo
        elif data.attr == ua.AttributeIds.NodeClass:
            combo = QComboBox(parent)
            for nclass in ua.NodeClass:
                combo.addItem(nclass.name)
            combo.setCurrentText(text)
            return combo
        elif data.attr == ua.AttributeIds.DataType:
            nodeid = getattr(ua.ObjectIds, text)
            node = Node(self.attrs_widget.current_node.server, nodeid)
            startnode = Node(self.attrs_widget.current_node.server, ua.ObjectIds.BaseDataType)
            button = GetNodeButton(parent, node, startnode)
            return button
        elif data.attr in (ua.AttributeIds.AccessLevel,
                           ua.AttributeIds.UserAccessLevel,
                           ua.AttributeIds.WriteMask,
                           ua.AttributeIds.UserWriteMask,
                           ua.AttributeIds.EventNotifier):
            return BitEditor(parent, data.attr, data.value)
        else:
            return QStyledItemDelegate.createEditor(self, parent, option, idx)

    #def setEditorData(self, editor, index):
        #pass

    def setModelData(self, editor, model, idx):
        # if user is setting a value on a null variant, try using the nodes datatype instead
        data = model.data(idx, Qt.UserRole)

        if isinstance(data, AttributeData):
            self._set_attribute_data(data, editor, model, idx)
        elif isinstance(data, MemberData):
            self._set_member_data(data, editor, model, idx)
        elif isinstance(data, ListData):
            self._set_list_data(data, editor, model, idx)
        else:
            print("Error while setting model data, data is ", data)

    def _set_list_data(self, data, editor, model, idx):
        text = editor.text()
        data.mylist[data.idx] = string_to_val(text, data.uatype)
        model.setItemData(idx, {Qt.DisplayRole: text, Qt.UserRole: data})
        attr_data = self._get_attr_data(idx, model)
        self._write_attr(attr_data)

    def _set_member_data(self, data, editor, model, idx):
        val = string_to_val(editor.text(), data.uatype)
        data.value = val
        model.setItemData(idx, {Qt.DisplayRole: editor.text(), Qt.UserRole: data})
        setattr(data.obj, data.name, val)
        attr_data = self._get_attr_data(idx, model)
        self._write_attr(attr_data)

    def _get_attr_data(self, idx, model):
        while True:
            idx = idx.parent()
            it = model.itemFromIndex(idx.sibling(0, 1))
            data = it.data(Qt.UserRole)
            if isinstance(data, AttributeData):
                return data

    def _get_parent_data(self, idx, model):
        parent_idx = idx.parent()
        it = model.itemFromIndex(parent_idx.sibling(0, 1))
        return parent_idx, it.data(Qt.UserRole)

    def _set_attribute_data(self, data, editor, model, idx):
        if data.uatype is ua.VariantType.Null:
            try:
                data.uatype = self.attrs_widget.current_node.get_data_type_as_variant_type()
            except Exception as ex:
                self.error.emit(ex)
                raise

        if data.attr == ua.AttributeIds.NodeClass:
            data.value = ua.NodeClass[editor.currentText()]
            text = editor.currentText()
        elif data.attr == ua.AttributeIds.DataType:
            data.value = editor.get_node().nodeid
            text = data_type_to_string(data.value)
        elif data.attr in (ua.AttributeIds.AccessLevel,
                           ua.AttributeIds.UserAccessLevel,
                           ua.AttributeIds.WriteMask,
                           ua.AttributeIds.UserWriteMask,
                           ua.AttributeIds.EventNotifier):
            data.value = editor.get_byte()
            text = enum_to_string(data.attr, data.value)
        else:
            if isinstance(editor, QComboBox):
                text = editor.currentText()
            else:
                text = editor.text()
            data.value = string_to_val(text, data.uatype)
        model.setItemData(idx, {Qt.DisplayRole: text, Qt.UserRole: data})
        self._write_attr(data)
        if isinstance(data.value, list):
            # we need to refresh children
            item = self.attrs_widget.model.itemFromIndex(idx.sibling(0, 0))
            self.attrs_widget.refresh_list(item, data.value, data.uatype)

    def _write_attr(self, data):
        dv = ua.DataValue(ua.Variant(data.value, varianttype=data.uatype))
        try:
            print("Writing ", dv, " to ", data.attr)
            self.attrs_widget.current_node.set_attribute(data.attr, dv)
        except Exception as ex:
            self.error.emit(ex)
            raise


def data_type_to_string(dtype):
    # a bit too complex, we could just display browse name of node but it requires a query
    if isinstance(dtype.Identifier, int) and dtype.Identifier < 63:
        string = ua.datatype_to_varianttype(dtype).name
    elif dtype.Identifier in ua.ObjectIdNames:
        string = ua.ObjectIdNames[dtype.Identifier]
    else:
        string = dtype.to_string()
    return string


def attr_to_enum(attr):
    attr_name = attr.name
    if attr_name.startswith("User"):
        attr_name = attr_name[4:]
    return getattr(ua, attr_name)


def enum_to_string(attr, val):
    attr_enum = attr_to_enum(attr)
    string = ", ".join([e.name for e in attr_enum.parse_bitfield(val)])
    return string


1			import traceback
2
3			from PyQt5.QtCore import pyqtSignal, Qt, QObject, QSettings
4			from PyQt5.QtGui import QStandardItemModel, QStandardItem
5			from PyQt5.QtWidgets import QApplication, QMenu, QAction, QStyledItemDelegate, QComboBox, QVBoxLayout, QCheckBox, QDialog
6
7			from opcua import ua
8			from opcua import Node
9			from opcua.common.ua_utils import string_to_val, val_to_string
10
11			from uawidgets.get_node_dialog import GetNodeButton
12
13
14			class BitEditor(QDialog):
15			"""
16			Edit bits in data
17			FIXME: this should be a dialog but a Widget appearing directly in treewidget
18			Patch welcome
19			"""
20
21			def __init__(self, parent, attr, val):
22			QDialog.__init__(self, parent)
23			layout = QVBoxLayout(self)
24			self.setLayout(layout)
25			self.boxes = []
26			self.enum = attr_to_enum(attr)
27			for el in self.enum:
28			box = QCheckBox(el.name, parent)
29			layout.addWidget(box)
30			self.boxes.append(box)
31			if ua.ua_binary.test_bit(val, el.value):
32			box.setChecked(True)
33			else:
34			box.setChecked(False)
35
36			def get_byte(self):
37			data = 0
38			for box in self.boxes:
39			if box.isChecked():
40			data = ua.ua_binary.set_bit(data, self.enum[box.text()].value)
41			return data
42
43
44			class _Data(object):
45			def is_editable(self):
46			if self.uatype != ua.VariantType.ExtensionObject:
47			return True
48			return False
49
50
51			class AttributeData(_Data):
52			def __init__(self, attr, value, uatype):
53			self.attr = attr
54			self.value = value
55			self.uatype = uatype
56
57
58			class MemberData(_Data):
59			def __init__(self, obj, name, value, uatype):
60			self.obj = obj
61			self.name = name
62			self.value = value
63			self.uatype = uatype
64
65
66			class ListData(_Data):
67			def __init__(self, mylist, idx, val, uatype):
68			self.mylist = mylist
69			self.idx = idx
70			self.value = val
71			self.uatype = uatype
72
73
74			class AttrsWidget(QObject):
75
76			error = pyqtSignal(Exception)
77			modified = pyqtSignal()
78
79			def __init__(self, view, show_timestamps=True):
80			QObject.__init__(self, view)
81			self.view = view
82			self._timestamps = show_timestamps
83			delegate = MyDelegate(self.view, self)
84			delegate.error.connect(self.error.emit)
85			self.settings = QSettings()
86			self.view.setItemDelegate(delegate)
87			self.model = QStandardItemModel()
88			self.model.setHorizontalHeaderLabels(['Attribute', 'Value', 'DataType'])
89			state = self.settings.value("attrs_widget", None)
90			if state is not None:
91			self.view.header().restoreState(state)
92			self.view.setModel(self.model)
93			self.current_node = None
94			self.model.itemChanged.connect(self._item_changed)
95			self.view.header().setSectionResizeMode(0)
96			self.view.header().setStretchLastSection(True)
97			self.view.expanded.connect(self._item_expanded)
98			self.view.collapsed.connect(self._item_collapsed)
99
100			# Context menu
101			self.view.setContextMenuPolicy(Qt.CustomContextMenu)
102			self.view.customContextMenuRequested.connect(self.showContextMenu)
103			copyaction = QAction("&Copy Value", self.model)
104			copyaction.triggered.connect(self._copy_value)
105			self._contextMenu = QMenu()
106			self._contextMenu.addAction(copyaction)
107
108			def save_state(self):
109			self.settings.setValue("attrs_widget", self.view.header().saveState())
110
111			def _item_expanded(self, idx):
112			if not idx.parent().isValid():
113			# only for value attributes which a re childs
114			# maybe add more tests
115			return
116			it = self.model.itemFromIndex(idx.sibling(0, 1))
117			it.setText("")
118
119			def _item_collapsed(self, idx):
120			it = self.model.itemFromIndex(idx.sibling(0, 1))
121			data = it.data(Qt.UserRole)
122			it.setText(val_to_string(data.value))
123
124			def _item_changed(self, item):
125			self.modified.emit()
126
127			def showContextMenu(self, position):
128			item = self.get_current_item()
129			if item:
130			self._contextMenu.exec_(self.view.viewport().mapToGlobal(position))
131
132			def get_current_item(self, col_idx=0):
133			idx = self.view.currentIndex()
134			return self.model.item(idx.row(), col_idx)
135
136			def _copy_value(self, position):
137			it = self.get_current_item(1)
138			if it:
139			QApplication.clipboard().setText(it.text())
140
141			def clear(self):
142			# remove all rows but not header!!
143			self.model.removeRows(0, self.model.rowCount())
144
145			def reload(self):
146			self.show_attrs(self.current_node)
147
148			def show_attrs(self, node):
149			self.current_node = node
150			self.clear()
151			if self.current_node:
152			self._show_attrs()
153			self.view.expandToDepth(0)
154
155			def _show_attrs(self):
156			attrs = self.get_all_attrs()
157			for attr, dv in attrs:
158			try:
159			# crashing here put down the application, we do not want that
160			# so we use try/except
161			if attr == ua.AttributeIds.Value:
162			self._show_value_attr(attr, dv)
163			else:
164			self._show_attr(attr, dv)
165			except Exception as ex:
166			traceback.print_exc()
167			self.error.emit(ex)
168
169			def _show_attr(self, attr, dv):
170			if attr == ua.AttributeIds.DataType:
171			string = data_type_to_string(dv.Value.Value)
172			elif attr in (ua.AttributeIds.AccessLevel,
173			ua.AttributeIds.UserAccessLevel,
174			ua.AttributeIds.WriteMask,
175			ua.AttributeIds.UserWriteMask,
176			ua.AttributeIds.EventNotifier):
177			string = enum_to_string(attr, dv.Value.Value)
178			else:
179			string = val_to_string(dv.Value.Value)
180			name_item = QStandardItem(attr.name)
181			vitem = QStandardItem(string)
182			vitem.setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
183			self.model.appendRow([name_item, vitem, QStandardItem(dv.Value.VariantType.name)])
184
185			def _show_value_attr(self, attr, dv):
186			name_item = QStandardItem("Value")
187			vitem = QStandardItem()
188			items = self._show_val(name_item, None, "Value", dv.Value.Value, dv.Value.VariantType)
189			items[1].setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
190			row = [name_item, vitem, QStandardItem(dv.Value.VariantType.name)]
191			self.model.appendRow(row)
192			self._show_timestamps(name_item, dv)
193
194			def _show_val(self, parent, obj, name, val, vtype):
195			name_item = QStandardItem(name)
196			vitem = QStandardItem()
197			vitem.setText(val_to_string(val))
198			vitem.setData(MemberData(obj, name, val, vtype), Qt.UserRole)
199			row = [name_item, vitem, QStandardItem(vtype.name)]
200			# if we have a list or extension object we display children
201			if isinstance(val, list):
202			row[2].setText("List of " + vtype.name)
203			self._show_list(name_item, val, vtype)
204			elif vtype == ua.VariantType.ExtensionObject:
205			self._show_ext_obj(name_item, val)
206			parent.appendRow(row)
207			return row
208
209			def _show_list(self, parent, mylist, vtype):
210			for idx, val in enumerate(mylist):
211			name_item = QStandardItem(str(idx))
212			vitem = QStandardItem()
213			vitem.setText(val_to_string(val))
214			vitem.setData(ListData(mylist, idx, val, vtype), Qt.UserRole)
215			row = [name_item, vitem, QStandardItem(vtype.name)]
216			parent.appendRow(row)
217			if vtype == ua.VariantType.ExtensionObject:
218			self._show_ext_obj(name_item, val)
219			return row
220
221			def refresh_list(self, parent, mylist, vtype):
222			while parent.hasChildren():
223			self.model.removeRow(0, parent.index())
224			self._show_list(parent, mylist, vtype)
225
226			def _show_ext_obj(self, item, val):
227			item.setText(item.text() + ": " + val.__class__.__name__)
228			for att_name, att_type in val.ua_types.items():
229			member_val = getattr(val, att_name)
230			attr = getattr(ua.VariantType, att_type)
231			self._show_val(item, val, att_name, member_val, attr)
232
233			def _show_timestamps(self, item, dv):
234			#while item.hasChildren():
235			#self.model.removeRow(0, item.index())
236			string = val_to_string(dv.ServerTimestamp)
237			item.appendRow([QStandardItem("Server Timestamp"), QStandardItem(string), QStandardItem(ua.VariantType.DateTime.name)])
238			string = val_to_string(dv.SourceTimestamp)
239			item.appendRow([QStandardItem("Source Timestamp"), QStandardItem(string), QStandardItem(ua.VariantType.DateTime.name)])
240
241
242			def get_all_attrs(self):
243			attrs = [attr for attr in ua.AttributeIds]
244			try:
245			dvs = self.current_node.get_attributes(attrs)
246			except Exception as ex:
247			self.error.emit(ex)
248			raise
249			res = []
250			for idx, dv in enumerate(dvs):
251			if dv.StatusCode.is_good():
252			res.append((attrs[idx], dv))
253			res.sort(key=lambda x: x[0].name)
254			return res
255
256
257			class MyDelegate(QStyledItemDelegate):
258
259			error = pyqtSignal(Exception)
260
261			def __init__(self, parent, attrs_widget):
262			QStyledItemDelegate.__init__(self, parent)
263			self.attrs_widget = attrs_widget
264
265			def createEditor(self, parent, option, idx):
266			if idx.column() != 1:
267			return None
268			item = self.attrs_widget.model.itemFromIndex(idx)
269			data = item.data(Qt.UserRole)
270			if not data.is_editable():
271			return None
272			text = item.text()
273			if isinstance(data, (ListData, MemberData)):
274			return QStyledItemDelegate.createEditor(self, parent, option, idx)
275			elif data.attr == ua.AttributeIds.NodeId:
276			return None
277			elif data.uatype == ua.VariantType.Boolean:
278			combo = QComboBox(parent)
279			combo.addItem("True")
280			combo.addItem("False")
281			combo.setCurrentText(text)
282			return combo
283			elif data.attr == ua.AttributeIds.NodeClass:
284			combo = QComboBox(parent)
285			for nclass in ua.NodeClass:
286			combo.addItem(nclass.name)
287			combo.setCurrentText(text)
288			return combo
289			elif data.attr == ua.AttributeIds.DataType:
290			nodeid = getattr(ua.ObjectIds, text)
291			node = Node(self.attrs_widget.current_node.server, nodeid)
292			startnode = Node(self.attrs_widget.current_node.server, ua.ObjectIds.BaseDataType)
293			button = GetNodeButton(parent, node, startnode)
294			return button
295			elif data.attr in (ua.AttributeIds.AccessLevel,
296			ua.AttributeIds.UserAccessLevel,
297			ua.AttributeIds.WriteMask,
298			ua.AttributeIds.UserWriteMask,
299			ua.AttributeIds.EventNotifier):
300			return BitEditor(parent, data.attr, data.value)
301			else:
302			return QStyledItemDelegate.createEditor(self, parent, option, idx)
303
304			#def setEditorData(self, editor, index):
305			#pass
306
307			def setModelData(self, editor, model, idx):
308			# if user is setting a value on a null variant, try using the nodes datatype instead
309			data = model.data(idx, Qt.UserRole)
310
311			if isinstance(data, AttributeData):
312			self._set_attribute_data(data, editor, model, idx)
313			elif isinstance(data, MemberData):
314			self._set_member_data(data, editor, model, idx)
315			elif isinstance(data, ListData):
316			self._set_list_data(data, editor, model, idx)
317			else:
318			print("Error while setting model data, data is ", data)
319
320			def _set_list_data(self, data, editor, model, idx):
321			text = editor.text()
322			data.mylist[data.idx] = string_to_val(text, data.uatype)
323			model.setItemData(idx, {Qt.DisplayRole: text, Qt.UserRole: data})
324			attr_data = self._get_attr_data(idx, model)
325			self._write_attr(attr_data)
326
327			def _set_member_data(self, data, editor, model, idx):
328			val = string_to_val(editor.text(), data.uatype)
329			data.value = val
330			model.setItemData(idx, {Qt.DisplayRole: editor.text(), Qt.UserRole: data})
331			setattr(data.obj, data.name, val)
332			attr_data = self._get_attr_data(idx, model)
333			self._write_attr(attr_data)
334
335			def _get_attr_data(self, idx, model):
336			while True:
337			idx = idx.parent()
338			it = model.itemFromIndex(idx.sibling(0, 1))
339			data = it.data(Qt.UserRole)
340			if isinstance(data, AttributeData):
341			return data
342
343			def _get_parent_data(self, idx, model):
344			parent_idx = idx.parent()
345			it = model.itemFromIndex(parent_idx.sibling(0, 1))
346			return parent_idx, it.data(Qt.UserRole)
347
348			def _set_attribute_data(self, data, editor, model, idx):
349			if data.uatype is ua.VariantType.Null:
350			try:
351			data.uatype = self.attrs_widget.current_node.get_data_type_as_variant_type()
352			except Exception as ex:
353			self.error.emit(ex)
354			raise
355
356			if data.attr == ua.AttributeIds.NodeClass:
357			data.value = ua.NodeClass[editor.currentText()]
358			text = editor.currentText()
359			elif data.attr == ua.AttributeIds.DataType:
360			data.value = editor.get_node().nodeid
361			text = data_type_to_string(data.value)
362			elif data.attr in (ua.AttributeIds.AccessLevel,
363			ua.AttributeIds.UserAccessLevel,
364			ua.AttributeIds.WriteMask,
365			ua.AttributeIds.UserWriteMask,
366			ua.AttributeIds.EventNotifier):
367			data.value = editor.get_byte()
368			text = enum_to_string(data.attr, data.value)
369			else:
370			if isinstance(editor, QComboBox):
371			text = editor.currentText()
372			else:
373			text = editor.text()
374			data.value = string_to_val(text, data.uatype)
375			model.setItemData(idx, {Qt.DisplayRole: text, Qt.UserRole: data})
376			self._write_attr(data)
377			if isinstance(data.value, list):
378			# we need to refresh children
379			item = self.attrs_widget.model.itemFromIndex(idx.sibling(0, 0))
380			self.attrs_widget.refresh_list(item, data.value, data.uatype)
381
382			def _write_attr(self, data):
383			dv = ua.DataValue(ua.Variant(data.value, varianttype=data.uatype))
384			try:
385			print("Writing ", dv, " to ", data.attr)
386			self.attrs_widget.current_node.set_attribute(data.attr, dv)
387			except Exception as ex:
388			self.error.emit(ex)
389			raise
390
391
392			def data_type_to_string(dtype):
393			# a bit too complex, we could just display browse name of node but it requires a query
394			if isinstance(dtype.Identifier, int) and dtype.Identifier < 63:
395			string = ua.datatype_to_varianttype(dtype).name
396			elif dtype.Identifier in ua.ObjectIdNames:
397			string = ua.ObjectIdNames[dtype.Identifier]
398			else:
399			string = dtype.to_string()
400			return string
401
402
403			def attr_to_enum(attr):
404			attr_name = attr.name
405			if attr_name.startswith("User"):
406			attr_name = attr_name[4:]
407			return getattr(ua, attr_name)
408
409
410			def enum_to_string(attr, val):
411			attr_enum = attr_to_enum(attr)
412			string = ", ".join([e.name for e in attr_enum.parse_bitfield(val)])
413			return string
414

FreeOpcUa / opcua-widgets

Pull Request — master (#5)

AttrsWidget._show_attrs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like