freeopcuaclient.AttrsUI._show_attrs() - Code Metrics - Inspection of "a little better attribute display" - FreeOpcUa/opcua-client-gui - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3ad4a6...52f235 )

by Olivier

created 2016-01-07 12:55 UTC

freeopcuaclient.AttrsUI._show_attrs() B

↳ Parent: freeopcuaclient.AttrsUI

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	6
dl	0
loc	20
rs	8

#! /usr/bin/env python3

import sys
import datetime
from enum import Enum

from PyQt5.QtCore import pyqtSignal, QTimer, Qt, QObject, QSettings, QModelIndex
from PyQt5.QtGui import QStandardItemModel, QStandardItem, QIcon
from PyQt5.QtWidgets import QMainWindow, QWidget, QApplication, QAbstractItemView, QMenu, QAction

from opcua import ua

from freeopcuaclient.uaclient import UaClient
from freeopcuaclient.mainwindow_ui import Ui_MainWindow
from freeopcuaclient import resources


class DataChangeHandler(QObject):
    data_change_fired = pyqtSignal(object, str, str)

    def datachange_notification(self, node, val, data):
        if data.monitored_item.Value.SourceTimestamp:
            dato = data.monitored_item.Value.SourceTimestamp.isoformat()
        elif data.monitored_item.Value.ServerTimestamp:
            dato = data.monitored_item.Value.ServerTimestamp.isoformat()
        else:
            dato = datetime.datetime.now().isoformat()
        self.data_change_fired.emit(node, str(val), dato)


class EventHandler(QObject):
    event_fired = pyqtSignal(object)

    def event_notification(self, event):
        self.event_fired.emit(event)


class EventUI(object):

    def __init__(self, window, uaclient):
        self.window = window
        self.uaclient = uaclient
        self._handler = EventHandler()
        self._subscribed_nodes = []  # FIXME: not really needed
        self.model = QStandardItemModel()
        self.window.ui.evView.setModel(self.model)
        self.window.ui.actionSubscribeEvent.triggered.connect(self._subscribe)
        self.window.ui.actionUnsubscribeEvents.triggered.connect(self._unsubscribe)
        # context menu
        self.window.ui.treeView.addAction(self.window.ui.actionSubscribeEvent)
        self.window.ui.treeView.addAction(self.window.ui.actionUnsubscribeEvents)
        self._handler.event_fired.connect(self._update_event_model, type=Qt.QueuedConnection)

    def clear(self):
        self._subscribed_nodes = []
        self.model.clear()

    def _subscribe(self):
        node = self.window.get_current_node()
        if node is None:
            return
        if node in self._subscribed_nodes:
            print("allready subscribed to event for node: ", node)
            return
        self.window.ui.evDockWidget.raise_()
        try:
            self.uaclient.subscribe_events(node, self._handler)
        except Exception as ex:
            self.window.show_error(ex)
        else:
            self._subscribed_nodes.append(node)

    def _unsubscribe(self):
        node = self.window.get_current_node()
        if node is None:
            return
        self._subscribed_nodes.remove(node)
        self.uaclient.unsubscribe_events(node)

    def _update_event_model(self, event):
        self.model.appendRow([QStandardItem(str(event))])


class DataChangeUI(object):

    def __init__(self, window, uaclient):
        self.window = window
        self.uaclient = uaclient
        self._subhandler = DataChangeHandler()
        self._subscribed_nodes = []
        self.model = QStandardItemModel()
        self.window.ui.subView.setModel(self.model)
        self.window.ui.subView.horizontalHeader().setSectionResizeMode(1)

        self.window.ui.actionSubscribeDataChange.triggered.connect(self._subscribe)
        self.window.ui.actionUnsubscribeDataChange.triggered.connect(self._unsubscribe)

        # populate contextual menu
        self.window.ui.treeView.addAction(self.window.ui.actionSubscribeDataChange)
        self.window.ui.treeView.addAction(self.window.ui.actionUnsubscribeDataChange)

        # handle subscriptions
        self._subhandler.data_change_fired.connect(self._update_subscription_model, type=Qt.QueuedConnection)

    def clear(self):
        self._subscribed_nodes = []
        self.model.clear()

    def _subscribe(self):
        node = self.window.get_current_node()
        if node is None:
            return
        if node in self._subscribed_nodes:
            print("allready subscribed to node: ", node)
            return
        self.model.setHorizontalHeaderLabels(["DisplayName", "Value", "Timestamp"])
        row = [QStandardItem(node.display_name), QStandardItem("No Data yet"), QStandardItem("")]
        row[0].setData(node)
        self.model.appendRow(row)
        self._subscribed_nodes.append(node)
        self.window.ui.subDockWidget.raise_()
        try:
            self.uaclient.subscribe_datachange(node, self._subhandler)
        except Exception as ex:
            self.window.show_error(ex)
            idx = self.model.indexFromItem(row[0])
            self.model.takeRow(idx.row())

    def _unsubscribe(self):
        node = self.window.get_current_node()
        if node is None:
            return
        self.uaclient.unsubscribe_datachange(node)
        self._subscribed_nodes.remove(node)
        i = 0
        while self.model.item(i):
            item = self.model.item(i)
            if item.data() == node:
                self.model.removeRow(i)
            i += 1

    def _update_subscription_model(self, node, value, timestamp):
        i = 0
        while self.model.item(i):
            item = self.model.item(i)
            if item.data() == node:
                it = self.model.item(i, 1)
                it.setText(value)
                it_ts = self.model.item(i, 2)
                it_ts.setText(timestamp)
            i += 1


class AttrsUI(object):

    def __init__(self, window, uaclient):
        self.window = window
        self.uaclient = uaclient
        self.model = QStandardItemModel()
        self.window.ui.attrView.setModel(self.model)
        self.window.ui.attrView.header().setSectionResizeMode(1)

        self.window.ui.treeView.activated.connect(self.show_attrs)
        self.window.ui.treeView.clicked.connect(self.show_attrs)
        self.window.ui.attrRefreshButton.clicked.connect(self.show_attrs)

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

    def showContextMenu(self, position):
        item = self.get_current_item()
        if item:
            self._contextMenu.exec_(self.window.ui.attrView.mapToGlobal(position))

    def get_current_item(self, col_idx=0):
        idx = self.window.ui.attrView.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):
        self.model.clear()

    def show_attrs(self, idx):
        if not isinstance(idx, QModelIndex):
            idx = None
        node = self.window.get_current_node(idx)
        if node:
            self._show_attrs(node)
        else:
            self.model.clear()

    def _show_attrs(self, node):
        try:
            attrs = self.uaclient.get_all_attrs(node)
        except Exception as ex:
            self.window.show_error(ex)
            raise
        self.model.clear()
        self.model.setHorizontalHeaderLabels(['Attribute', 'Value'])
        for k, v in attrs.items():
            if isinstance(v, (ua.NodeId, ua.QualifiedName, ua.LocalizedText)):
                v = v.to_string()
            elif isinstance(v, Enum):
                v = repr(v)
            elif isinstance(v, ua.DataValue):
                print("VALUE:", k, v)
                v = repr(v)
            else:
                v = str(v)
            print(type(k), type(v))
            self.model.appendRow([QStandardItem(k), QStandardItem(v)])


class RefsUI(object):

    def __init__(self, window, uaclient):
        self.window = window
        self.uaclient = uaclient
        self.model = QStandardItemModel()
        self.window.ui.refView.setModel(self.model)
        self.window.ui.refView.horizontalHeader().setSectionResizeMode(1)

        self.window.ui.treeView.activated.connect(self.show_refs)
        self.window.ui.treeView.clicked.connect(self.show_refs)

    def clear(self):
        self.model.clear()

    def show_refs(self, idx):
        node = self.window.get_current_node(idx)
        if not node:
            self.model.clear()
        else:
            self._show_refs(node)

    def _show_refs(self, node):
        self.model.setHorizontalHeaderLabels(['ReferenceType', 'NodeId', "BrowseName", "TypeDefinition"])
        try:
            refs = self.uaclient.get_all_refs(node)
        except Exception as ex:
            self.window.show_error(ex)
            raise
        for ref in refs:
            self.model.appendRow([QStandardItem(str(ref.ReferenceTypeId)),
                                  QStandardItem(str(ref.NodeId)),
                                  QStandardItem(str(ref.BrowseName)),
                                  QStandardItem(str(ref.TypeDefinition))])


class TreeUI(object):

    def __init__(self, window, uaclient):
        self.window = window
        self.uaclient = uaclient
        self.model = TreeViewModel(self.uaclient)
        self.model.clear()  # FIXME: do we need this?
        self.model.error.connect(self.window.show_error)
        self.window.ui.treeView.setModel(self.model)
        self.window.ui.treeView.setUniformRowHeights(True)
        self.window.ui.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.window.ui.treeView.header().setSectionResizeMode(1)

    def clear(self):
        self.model.clear()

    def start(self):
        self.model.clear()
        self.model.add_item(*self.uaclient.get_root_node_and_desc())

    def get_current_node(self, idx):
        it = self.model.itemFromIndex(idx)
        if not it:
            return None
        node = it.data()
        if not node:
            print("No node for item:", it, it.text())
            return None
        node.display_name = it.text()  # FIXME: hack
        return node


class Window(QMainWindow):

    def __init__(self):
        QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.setWindowIcon(QIcon(":/network.svg"))

        # fix stuff imposible to do in qtdesigner
        # remove dock titlebar for addressbar
        w = QWidget()
        self.ui.addrDockWidget.setTitleBarWidget(w)
        # tabify some docks
        self.tabifyDockWidget(self.ui.evDockWidget, self.ui.subDockWidget)
        self.tabifyDockWidget(self.ui.subDockWidget, self.ui.refDockWidget)

        # we only show statusbar in case of errors
        self.ui.statusBar.hide()

        # load settings, seconds arg is default
        self.settings = QSettings("FreeOpcUa", "FreeOpcUaClient")
        self._address_list = self.settings.value("address_list", ["opc.tcp://localhost:4841", "opc.tcp://localhost:53530/OPCUA/SimulationServer/"])
        self._address_list_max_count = int(self.settings.value("address_list_max_count", 10))

        # init widgets
        for addr in self._address_list:
            self.ui.addrComboBox.insertItem(-1, addr)

        self.uaclient = UaClient()

        self.tree_ui = TreeUI(self, self.uaclient)
        self.refs_ui = RefsUI(self, self.uaclient)
        self.attrs_ui = AttrsUI(self, self.uaclient)
        self.datachange_ui = DataChangeUI(self, self.uaclient)
        self.event_ui = EventUI(self, self.uaclient)

        self.resize(int(self.settings.value("main_window_width", 800)), int(self.settings.value("main_window_height", 600)))
        self.restoreState(self.settings.value("main_window_state", b""))

        self.ui.connectButton.clicked.connect(self._connect)
        self.ui.disconnectButton.clicked.connect(self._disconnect)
        # self.ui.treeView.expanded.connect(self._fit)

        self.ui.actionConnect.triggered.connect(self._connect)
        self.ui.actionDisconnect.triggered.connect(self._disconnect)

    def show_error(self, msg, level=1):
        print("showing error: ", msg, level)
        self.ui.statusBar.show()
        self.ui.statusBar.setStyleSheet("QStatusBar { background-color : red; color : black; }")
        self.ui.statusBar.showMessage(str(msg))
        QTimer.singleShot(1500, self.ui.statusBar.hide)

    def get_current_node(self, idx=None):
        if idx is None:
            idx = self.ui.treeView.currentIndex()
        return self.tree_ui.get_current_node(idx)

    def get_uaclient(self):
        return self.uaclient

    def _connect(self):
        uri = self.ui.addrComboBox.currentText()
        try:
            self.uaclient.connect(uri)
        except Exception as ex:
            self.show_error(ex)
            raise

        self._update_address_list(uri)
        self.tree_ui.start()

    def _update_address_list(self, uri):
        if uri == self._address_list[0]:
            return
        if uri in self._address_list:
            self._address_list.remove(uri)
        self._address_list.insert(0, uri)
        if len(self._address_list) > self._address_list_max_count:
            self._address_list.pop(-1)

    def _disconnect(self):
        try:
            self.uaclient.disconnect()
        except Exception as ex:
            self.show_error(ex)
            raise
        finally:
            self.tree_ui.clear()
            self.refs_ui.clear()
            self.attrs_ui.clear()
            self.datachange_ui.clear()
            self.event_ui.clear()

    def closeEvent(self, event):
        self.settings.setValue("main_window_width", self.size().width())
        self.settings.setValue("main_window_height", self.size().height())
        self.settings.setValue("main_window_state", self.saveState())
        self.settings.setValue("address_list", self._address_list)
        self._disconnect()
        event.accept()


class TreeViewModel(QStandardItemModel):

    error = pyqtSignal(str)

    def __init__(self, uaclient):
        super(TreeViewModel, self).__init__()
        self.uaclient = uaclient
        self._fetched = []

    def clear(self):
        QStandardItemModel.clear(self)
        self._fetched = []
        self.setHorizontalHeaderLabels(['DisplayName', "BrowseName", 'NodeId'])

    def add_item(self, node, desc, parent=None):
        data = [QStandardItem(desc.DisplayName.to_string()), QStandardItem(desc.BrowseName.to_string()), QStandardItem(desc.NodeId.to_string())]
        if desc.NodeClass == ua.NodeClass.Object:
            if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.FolderType):
                data[0].setIcon(QIcon(":/folder.svg"))
            else:
                data[0].setIcon(QIcon(":/object.svg"))
        elif desc.NodeClass == ua.NodeClass.Variable:
            if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.PropertyType):
                data[0].setIcon(QIcon(":/property.svg"))
            else:
                data[0].setIcon(QIcon(":/variable.svg"))
        elif desc.NodeClass == ua.NodeClass.Method:
                data[0].setIcon(QIcon(":/method.svg"))

        data[0].setData(node)
        if parent:
            return parent.appendRow(data)
        else:
            return self.appendRow(data)

    def canFetchMore(self, idx):
        item = self.itemFromIndex(idx)
        if not item:
            return True
        node = item.data()
        if node not in self._fetched:
            self._fetched.append(node)
            return True
        return False

    def hasChildren(self, idx):
        item = self.itemFromIndex(idx)
        if not item:
            return True
        node = item.data()
        if node in self._fetched:
            return QStandardItemModel.hasChildren(self, idx)
        return True

    def fetchMore(self, idx):
        parent = self.itemFromIndex(idx)
        if parent:
            self._fetchMore(parent)

    def _fetchMore(self, parent):
        try:
            for node, attrs in self.uaclient.get_children(parent.data()):
                self.add_item(node, attrs, parent)
        except Exception as ex:
            self.error.emit(ex)
            raise


def main():
    app = QApplication(sys.argv)
    client = Window()
    client.show()
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()


1			#! /usr/bin/env python3
2
3			import sys
4			import datetime
5			from enum import Enum
6
7			from PyQt5.QtCore import pyqtSignal, QTimer, Qt, QObject, QSettings, QModelIndex
8			from PyQt5.QtGui import QStandardItemModel, QStandardItem, QIcon
9			from PyQt5.QtWidgets import QMainWindow, QWidget, QApplication, QAbstractItemView, QMenu, QAction
10
11			from opcua import ua
12
13			from freeopcuaclient.uaclient import UaClient
14			from freeopcuaclient.mainwindow_ui import Ui_MainWindow
15			from freeopcuaclient import resources
16
17
18			class DataChangeHandler(QObject):
19			data_change_fired = pyqtSignal(object, str, str)
20
21			def datachange_notification(self, node, val, data):
22			if data.monitored_item.Value.SourceTimestamp:
23			dato = data.monitored_item.Value.SourceTimestamp.isoformat()
24			elif data.monitored_item.Value.ServerTimestamp:
25			dato = data.monitored_item.Value.ServerTimestamp.isoformat()
26			else:
27			dato = datetime.datetime.now().isoformat()
28			self.data_change_fired.emit(node, str(val), dato)
29
30
31			class EventHandler(QObject):
32			event_fired = pyqtSignal(object)
33
34			def event_notification(self, event):
35			self.event_fired.emit(event)
36
37
38			class EventUI(object):
39
40			def __init__(self, window, uaclient):
41			self.window = window
42			self.uaclient = uaclient
43			self._handler = EventHandler()
44			self._subscribed_nodes = [] # FIXME: not really needed
45			self.model = QStandardItemModel()
46			self.window.ui.evView.setModel(self.model)
47			self.window.ui.actionSubscribeEvent.triggered.connect(self._subscribe)
48			self.window.ui.actionUnsubscribeEvents.triggered.connect(self._unsubscribe)
49			# context menu
50			self.window.ui.treeView.addAction(self.window.ui.actionSubscribeEvent)
51			self.window.ui.treeView.addAction(self.window.ui.actionUnsubscribeEvents)
52			self._handler.event_fired.connect(self._update_event_model, type=Qt.QueuedConnection)
53
54			def clear(self):
55			self._subscribed_nodes = []
56			self.model.clear()
57
58			def _subscribe(self):
59			node = self.window.get_current_node()
60			if node is None:
61			return
62			if node in self._subscribed_nodes:
63			print("allready subscribed to event for node: ", node)
64			return
65			self.window.ui.evDockWidget.raise_()
66			try:
67			self.uaclient.subscribe_events(node, self._handler)
68			except Exception as ex:
69			self.window.show_error(ex)
70			else:
71			self._subscribed_nodes.append(node)
72
73			def _unsubscribe(self):
74			node = self.window.get_current_node()
75			if node is None:
76			return
77			self._subscribed_nodes.remove(node)
78			self.uaclient.unsubscribe_events(node)
79
80			def _update_event_model(self, event):
81			self.model.appendRow([QStandardItem(str(event))])
82
83
84			class DataChangeUI(object):
85
86			def __init__(self, window, uaclient):
87			self.window = window
88			self.uaclient = uaclient
89			self._subhandler = DataChangeHandler()
90			self._subscribed_nodes = []
91			self.model = QStandardItemModel()
92			self.window.ui.subView.setModel(self.model)
93			self.window.ui.subView.horizontalHeader().setSectionResizeMode(1)
94
95			self.window.ui.actionSubscribeDataChange.triggered.connect(self._subscribe)
96			self.window.ui.actionUnsubscribeDataChange.triggered.connect(self._unsubscribe)
97
98			# populate contextual menu
99			self.window.ui.treeView.addAction(self.window.ui.actionSubscribeDataChange)
100			self.window.ui.treeView.addAction(self.window.ui.actionUnsubscribeDataChange)
101
102			# handle subscriptions
103			self._subhandler.data_change_fired.connect(self._update_subscription_model, type=Qt.QueuedConnection)
104
105			def clear(self):
106			self._subscribed_nodes = []
107			self.model.clear()
108
109			def _subscribe(self):
110			node = self.window.get_current_node()
111			if node is None:
112			return
113			if node in self._subscribed_nodes:
114			print("allready subscribed to node: ", node)
115			return
116			self.model.setHorizontalHeaderLabels(["DisplayName", "Value", "Timestamp"])
117			row = [QStandardItem(node.display_name), QStandardItem("No Data yet"), QStandardItem("")]
118			row[0].setData(node)
119			self.model.appendRow(row)
120			self._subscribed_nodes.append(node)
121			self.window.ui.subDockWidget.raise_()
122			try:
123			self.uaclient.subscribe_datachange(node, self._subhandler)
124			except Exception as ex:
125			self.window.show_error(ex)
126			idx = self.model.indexFromItem(row[0])
127			self.model.takeRow(idx.row())
128
129			def _unsubscribe(self):
130			node = self.window.get_current_node()
131			if node is None:
132			return
133			self.uaclient.unsubscribe_datachange(node)
134			self._subscribed_nodes.remove(node)
135			i = 0
136			while self.model.item(i):
137			item = self.model.item(i)
138			if item.data() == node:
139			self.model.removeRow(i)
140			i += 1
141
142			def _update_subscription_model(self, node, value, timestamp):
143			i = 0
144			while self.model.item(i):
145			item = self.model.item(i)
146			if item.data() == node:
147			it = self.model.item(i, 1)
148			it.setText(value)
149			it_ts = self.model.item(i, 2)
150			it_ts.setText(timestamp)
151			i += 1
152
153
154			class AttrsUI(object):
155
156			def __init__(self, window, uaclient):
157			self.window = window
158			self.uaclient = uaclient
159			self.model = QStandardItemModel()
160			self.window.ui.attrView.setModel(self.model)
161			self.window.ui.attrView.header().setSectionResizeMode(1)
162
163			self.window.ui.treeView.activated.connect(self.show_attrs)
164			self.window.ui.treeView.clicked.connect(self.show_attrs)
165			self.window.ui.attrRefreshButton.clicked.connect(self.show_attrs)
166
167			# Context menu
168			self.window.ui.attrView.setContextMenuPolicy(Qt.CustomContextMenu)
169			self.window.ui.attrView.customContextMenuRequested.connect(self.showContextMenu)
170			copyaction = QAction("&Copy Value", self.model)
171			copyaction.triggered.connect(self._copy_value)
172			self._contextMenu = QMenu()
173			self._contextMenu.addAction(copyaction)
174
175			def showContextMenu(self, position):
176			item = self.get_current_item()
177			if item:
178			self._contextMenu.exec_(self.window.ui.attrView.mapToGlobal(position))
179
180			def get_current_item(self, col_idx=0):
181			idx = self.window.ui.attrView.currentIndex()
182			return self.model.item(idx.row(), col_idx)
183
184			def _copy_value(self, position):
185			it = self.get_current_item(1)
186			if it:
187			QApplication.clipboard().setText(it.text())
188
189			def clear(self):
190			self.model.clear()
191
192			def show_attrs(self, idx):
193			if not isinstance(idx, QModelIndex):
194			idx = None
195			node = self.window.get_current_node(idx)
196			if node:
197			self._show_attrs(node)
198			else:
199			self.model.clear()
200
201			def _show_attrs(self, node):
202			try:
203			attrs = self.uaclient.get_all_attrs(node)
204			except Exception as ex:
205			self.window.show_error(ex)
206			raise
207			self.model.clear()
208			self.model.setHorizontalHeaderLabels(['Attribute', 'Value'])
209			for k, v in attrs.items():
210			if isinstance(v, (ua.NodeId, ua.QualifiedName, ua.LocalizedText)):
211			v = v.to_string()
212			elif isinstance(v, Enum):
213			v = repr(v)
214			elif isinstance(v, ua.DataValue):
215			print("VALUE:", k, v)
216			v = repr(v)
217			else:
218			v = str(v)
219			print(type(k), type(v))
220			self.model.appendRow([QStandardItem(k), QStandardItem(v)])
221
222
223			class RefsUI(object):
224
225			def __init__(self, window, uaclient):
226			self.window = window
227			self.uaclient = uaclient
228			self.model = QStandardItemModel()
229			self.window.ui.refView.setModel(self.model)
230			self.window.ui.refView.horizontalHeader().setSectionResizeMode(1)
231
232			self.window.ui.treeView.activated.connect(self.show_refs)
233			self.window.ui.treeView.clicked.connect(self.show_refs)
234
235			def clear(self):
236			self.model.clear()
237
238			def show_refs(self, idx):
239			node = self.window.get_current_node(idx)
240			if not node:
241			self.model.clear()
242			else:
243			self._show_refs(node)
244
245			def _show_refs(self, node):
246			self.model.setHorizontalHeaderLabels(['ReferenceType', 'NodeId', "BrowseName", "TypeDefinition"])
247			try:
248			refs = self.uaclient.get_all_refs(node)
249			except Exception as ex:
250			self.window.show_error(ex)
251			raise
252			for ref in refs:
253			self.model.appendRow([QStandardItem(str(ref.ReferenceTypeId)),
254			QStandardItem(str(ref.NodeId)),
255			QStandardItem(str(ref.BrowseName)),
256			QStandardItem(str(ref.TypeDefinition))])
257
258
259			class TreeUI(object):
260
261			def __init__(self, window, uaclient):
262			self.window = window
263			self.uaclient = uaclient
264			self.model = TreeViewModel(self.uaclient)
265			self.model.clear() # FIXME: do we need this?
266			self.model.error.connect(self.window.show_error)
267			self.window.ui.treeView.setModel(self.model)
268			self.window.ui.treeView.setUniformRowHeights(True)
269			self.window.ui.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
270			self.window.ui.treeView.header().setSectionResizeMode(1)
271
272			def clear(self):
273			self.model.clear()
274
275			def start(self):
276			self.model.clear()
277			self.model.add_item(*self.uaclient.get_root_node_and_desc())
278
279			def get_current_node(self, idx):
280			it = self.model.itemFromIndex(idx)
281			if not it:
282			return None
283			node = it.data()
284			if not node:
285			print("No node for item:", it, it.text())
286			return None
287			node.display_name = it.text() # FIXME: hack
288			return node
289
290
291			class Window(QMainWindow):
292
293			def __init__(self):
294			QMainWindow.__init__(self)
295			self.ui = Ui_MainWindow()
296			self.ui.setupUi(self)
297			self.setWindowIcon(QIcon(":/network.svg"))
298
299			# fix stuff imposible to do in qtdesigner
300			# remove dock titlebar for addressbar
301			w = QWidget()
302			self.ui.addrDockWidget.setTitleBarWidget(w)
303			# tabify some docks
304			self.tabifyDockWidget(self.ui.evDockWidget, self.ui.subDockWidget)
305			self.tabifyDockWidget(self.ui.subDockWidget, self.ui.refDockWidget)
306
307			# we only show statusbar in case of errors
308			self.ui.statusBar.hide()
309
310			# load settings, seconds arg is default
311			self.settings = QSettings("FreeOpcUa", "FreeOpcUaClient")
312			self._address_list = self.settings.value("address_list", ["opc.tcp://localhost:4841", "opc.tcp://localhost:53530/OPCUA/SimulationServer/"])
313			self._address_list_max_count = int(self.settings.value("address_list_max_count", 10))
314
315			# init widgets
316			for addr in self._address_list:
317			self.ui.addrComboBox.insertItem(-1, addr)
318
319			self.uaclient = UaClient()
320
321			self.tree_ui = TreeUI(self, self.uaclient)
322			self.refs_ui = RefsUI(self, self.uaclient)
323			self.attrs_ui = AttrsUI(self, self.uaclient)
324			self.datachange_ui = DataChangeUI(self, self.uaclient)
325			self.event_ui = EventUI(self, self.uaclient)
326
327			self.resize(int(self.settings.value("main_window_width", 800)), int(self.settings.value("main_window_height", 600)))
328			self.restoreState(self.settings.value("main_window_state", b""))
329
330			self.ui.connectButton.clicked.connect(self._connect)
331			self.ui.disconnectButton.clicked.connect(self._disconnect)
332			# self.ui.treeView.expanded.connect(self._fit)
333
334			self.ui.actionConnect.triggered.connect(self._connect)
335			self.ui.actionDisconnect.triggered.connect(self._disconnect)
336
337			def show_error(self, msg, level=1):
338			print("showing error: ", msg, level)
339			self.ui.statusBar.show()
340			self.ui.statusBar.setStyleSheet("QStatusBar { background-color : red; color : black; }")
341			self.ui.statusBar.showMessage(str(msg))
342			QTimer.singleShot(1500, self.ui.statusBar.hide)
343
344			def get_current_node(self, idx=None):
345			if idx is None:
346			idx = self.ui.treeView.currentIndex()
347			return self.tree_ui.get_current_node(idx)
348
349			def get_uaclient(self):
350			return self.uaclient
351
352			def _connect(self):
353			uri = self.ui.addrComboBox.currentText()
354			try:
355			self.uaclient.connect(uri)
356			except Exception as ex:
357			self.show_error(ex)
358			raise
359
360			self._update_address_list(uri)
361			self.tree_ui.start()
362
363			def _update_address_list(self, uri):
364			if uri == self._address_list[0]:
365			return
366			if uri in self._address_list:
367			self._address_list.remove(uri)
368			self._address_list.insert(0, uri)
369			if len(self._address_list) > self._address_list_max_count:
370			self._address_list.pop(-1)
371
372			def _disconnect(self):
373			try:
374			self.uaclient.disconnect()
375			except Exception as ex:
376			self.show_error(ex)
377			raise
378			finally:
379			self.tree_ui.clear()
380			self.refs_ui.clear()
381			self.attrs_ui.clear()
382			self.datachange_ui.clear()
383			self.event_ui.clear()
384
385			def closeEvent(self, event):
386			self.settings.setValue("main_window_width", self.size().width())
387			self.settings.setValue("main_window_height", self.size().height())
388			self.settings.setValue("main_window_state", self.saveState())
389			self.settings.setValue("address_list", self._address_list)
390			self._disconnect()
391			event.accept()
392
393
394			class TreeViewModel(QStandardItemModel):
395
396			error = pyqtSignal(str)
397
398			def __init__(self, uaclient):
399			super(TreeViewModel, self).__init__()
400			self.uaclient = uaclient
401			self._fetched = []
402
403			def clear(self):
404			QStandardItemModel.clear(self)
405			self._fetched = []
406			self.setHorizontalHeaderLabels(['DisplayName', "BrowseName", 'NodeId'])
407
408			def add_item(self, node, desc, parent=None):
409			data = [QStandardItem(desc.DisplayName.to_string()), QStandardItem(desc.BrowseName.to_string()), QStandardItem(desc.NodeId.to_string())]
410			if desc.NodeClass == ua.NodeClass.Object:
411			if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.FolderType):
412			data[0].setIcon(QIcon(":/folder.svg"))
413			else:
414			data[0].setIcon(QIcon(":/object.svg"))
415			elif desc.NodeClass == ua.NodeClass.Variable:
416			if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.PropertyType):
417			data[0].setIcon(QIcon(":/property.svg"))
418			else:
419			data[0].setIcon(QIcon(":/variable.svg"))
420			elif desc.NodeClass == ua.NodeClass.Method:
421			data[0].setIcon(QIcon(":/method.svg"))
422
423			data[0].setData(node)
424			if parent:
425			return parent.appendRow(data)
426			else:
427			return self.appendRow(data)
428
429			def canFetchMore(self, idx):
430			item = self.itemFromIndex(idx)
431			if not item:
432			return True
433			node = item.data()
434			if node not in self._fetched:
435			self._fetched.append(node)
436			return True
437			return False
438
439			def hasChildren(self, idx):
440			item = self.itemFromIndex(idx)
441			if not item:
442			return True
443			node = item.data()
444			if node in self._fetched:
445			return QStandardItemModel.hasChildren(self, idx)
446			return True
447
448			def fetchMore(self, idx):
449			parent = self.itemFromIndex(idx)
450			if parent:
451			self._fetchMore(parent)
452
453			def _fetchMore(self, parent):
454			try:
455			for node, attrs in self.uaclient.get_children(parent.data()):
456			self.add_item(node, attrs, parent)
457			except Exception as ex:
458			self.error.emit(ex)
459			raise
460
461
462			def main():
463			app = QApplication(sys.argv)
464			client = Window()
465			client.show()
466			sys.exit(app.exec_())
467
468
469			if __name__ == "__main__":
470			main()
471

FreeOpcUa / opcua-client-gui

Push — master ( 3ad4a6...52f235 )

freeopcuaclient.AttrsUI._show_attrs() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like