Source Code for Module node_manager_fkie.parameter_list_model

  1  # Software License Agreement (BSD License) 
  2  # 
  3  # Copyright (c) 2012, Fraunhofer FKIE/US, Alexander Tiderko 
  4  # All rights reserved. 
  5  # 
  6  # Redistribution and use in source and binary forms, with or without 
  7  # modification, are permitted provided that the following conditions 
  8  # are met: 
  9  # 
 10  #  * Redistributions of source code must retain the above copyright 
 11  #    notice, this list of conditions and the following disclaimer. 
 12  #  * Redistributions in binary form must reproduce the above 
 13  #    copyright notice, this list of conditions and the following 
 14  #    disclaimer in the documentation and/or other materials provided 
 15  #    with the distribution. 
 16  #  * Neither the name of Fraunhofer nor the names of its 
 17  #    contributors may be used to endorse or promote products derived 
 18  #    from this software without specific prior written permission. 
 19  # 
 20  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 21  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 22  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 23  # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
 24  # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
 25  # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 26  # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 27  # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
 28  # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 29  # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
 30  # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 31  # POSSIBILITY OF SUCH DAMAGE. 
 32   
 33  from python_qt_binding.QtCore import QSize, Qt 
 34  from python_qt_binding.QtGui import QStandardItem, QStandardItemModel 
 35  from xmlrpclib import Binary 
 36   
 37   
 38 -class ParameterValueItem(QStandardItem): 
 39      ''' 
 40      The parameter item is stored in the parameter model. This class stores the name 
 41      and value of a parameter of ROS parameter server and shows the value. 
 42      ''' 
 43   
 44      ITEM_TYPE = QStandardItem.UserType + 39 
 45      NAME_ROLE = Qt.UserRole + 1 
 46      VALUE_ROLE = Qt.UserRole + 2 
 47      TYPE_ROLE = Qt.UserRole + 3 
 48   
 49 -    def __init__(self, name, value, parent=None): 
 50          ''' 
 51          Initialize the item object. 
 52          @param name: the name of the parameter 
 53          @type name: C{str} 
 54          @param value: the value of the parameter 
 55          @type value: C{str} 
 56          ''' 
 57          QStandardItem.__init__(self, unicode(value) if not isinstance(value, Binary) else str(value)) 
 58          self._name = name 
 59          '''@ivar: the name of parameter ''' 
 60          self._value = value 
 61          '''@ivar: the value of the parameter ''' 
 62          if isinstance(value, (str, unicode)) and value.find('\n') > -1: 
 63              self.setSizeHint(QSize(-1, 45)) 
 64   
 65      @property 
 66 -    def name(self): 
 67          return self._name 
 68   
 69      @property 
 70 -    def value(self): 
 71          return self._value 
 72   
 73      @value.setter 
 74 -    def value(self, value): 
 75          self._value = value 
 76          self.setText(unicode(value) if not isinstance(value, Binary) else str(value)) 
 77          if isinstance(value, (str, unicode)) and value.find('\n') > -1: 
 78              self.setSizeHint(QSize(-1, 45)) 
 79   
 80 -    def type(self): 
 81          return ParameterValueItem.ITEM_TYPE 
 82   
 83 -    def data(self, role): 
 84          if role == self.NAME_ROLE: 
 85              return self.name 
 86          elif role == self.VALUE_ROLE: 
 87              return str(self.value) 
 88          elif role == self.TYPE_ROLE: 
 89              return str(type(self.value).replace('<type \'').replace('\'>')) 
 90          else: 
 91              return QStandardItem.data(self, role) 
 92   
 93 -    def __eq__(self, item): 
 94          ''' 
 95          Compares the value of parameter. 
 96          ''' 
 97          if isinstance(item, str) or isinstance(item, unicode): 
 98              return unicode(self.value) == item 
 99          elif not (item is None): 
100              return unicode(self.value) == unicode(item.value) 
101          return False 
102   
103 -    def __gt__(self, item): 
104          ''' 
105          Compares the value of parameter. 
106          ''' 
107          if isinstance(item, str) or isinstance(item, unicode): 
108              return unicode(self.value) > item 
109          elif not (item is None): 
110              return unicode(self.value) > unicode(item.value) 
111          return False 
112   
113   
114 -class ParameterNameItem(QStandardItem): 
115      ''' 
116      The parameter item is stored in the parameter model. This class stores the name 
117      and value of a parameter of ROS parameter server and shows the name. 
118      ''' 
119   
120      ITEM_TYPE = QStandardItem.UserType + 38 
121      NAME_ROLE = Qt.UserRole + 1 
122      VALUE_ROLE = Qt.UserRole + 2 
123      TYPE_ROLE = Qt.UserRole + 3 
124   
125 -    def __init__(self, name, value, parent=None): 
126          ''' 
127          Initialize the item object. 
128          @param name: the name of the parameter 
129          @type name: C{str} 
130          @param value: the value of the parameter 
131          @type value: C{str} 
132          ''' 
133          QStandardItem.__init__(self, name) 
134          self._name = name 
135          '''@ivar: the name of parameter ''' 
136          self._value = value 
137          '''@ivar: the value of the parameter ''' 
138   
139      @property 
140 -    def name(self): 
141          return self._name 
142   
143      @property 
144 -    def value(self): 
145          return self._value 
146   
147      @value.setter 
148 -    def value(self, value): 
149          self._value = value 
150          self.setText(str(value)) 
151   
152 -    def type(self): 
153          return ParameterValueItem.ITEM_TYPE 
154   
155 -    def data(self, role): 
156          if role == self.NAME_ROLE: 
157              return self.name 
158          elif role == self.VALUE_ROLE: 
159              return str(self.value) 
160          elif role == self.TYPE_ROLE: 
161              return str(type(self.value).replace('<type \'').replace('\'>')) 
162          else: 
163              return QStandardItem.data(self, role) 
164   
165 -    def __eq__(self, item): 
166          ''' 
167          Compares the name of parameter. 
168          ''' 
169          if isinstance(item, str) or isinstance(item, unicode): 
170              return self.name.lower() == item.lower() 
171          elif not (item is None): 
172              return self.name.lower() == item.name.lower() 
173          return False 
174   
175 -    def __gt__(self, item): 
176          ''' 
177          Compares the name of parameter. 
178          ''' 
179          if isinstance(item, str) or isinstance(item, unicode): 
180              return self.name.lower() > item.lower() 
181          elif not (item is None): 
182              return self.name.lower() > item.name.lower() 
183          return False 
184   
185   
186 -class ParameterTypeItem(QStandardItem): 
187      ''' 
188      The parameter item is stored in the parameter model. This class stores the name 
189      and value of a parameter of ROS parameter server and shows the name. 
190      ''' 
191   
192      ITEM_TYPE = QStandardItem.UserType + 40 
193      NAME_ROLE = Qt.UserRole + 1 
194      VALUE_ROLE = Qt.UserRole + 2 
195      TYPE_ROLE = Qt.UserRole + 3 
196   
197 -    def __init__(self, name, value, parent=None): 
198          ''' 
199          Initialize the item object. 
200          @param name: the name of the parameter 
201          @type name: C{str} 
202          @param value: the value of the parameter 
203          @type value: C{str} 
204          ''' 
205          QStandardItem.__init__(self, str(type(value)).replace("<type '", '').replace("'>", '')) 
206          self._name = name 
207          '''@ivar: the name of parameter ''' 
208          self._value = value 
209          '''@ivar: the value of the parameter ''' 
210   
211      @property 
212 -    def name(self): 
213          return self._name 
214   
215      @property 
216 -    def value(self): 
217          return self._value 
218   
219      @value.setter 
220 -    def value(self, value): 
221          self._value = value 
222          self.setText(str(value)) 
223   
224 -    def type(self): 
225          return ParameterValueItem.ITEM_TYPE 
226   
227 -    def data(self, role): 
228          if role == self.NAME_ROLE: 
229              return self.name 
230          elif role == self.VALUE_ROLE: 
231              return str(self.value) 
232          elif role == self.TYPE_ROLE: 
233              return str(type(self.value).replace('<type \'').replace('\'>')) 
234          else: 
235              return QStandardItem.data(self, role) 
236   
237 -    def __eq__(self, item): 
238          ''' 
239          Compares the name of parameter. 
240          ''' 
241          if isinstance(item, str) or isinstance(item, unicode): 
242              return self.name.lower() == item.lower() 
243          elif not (item is None): 
244              return self.name.lower() == item.name.lower() 
245          return False 
246   
247 -    def __gt__(self, item): 
248          ''' 
249          Compares the name of parameter. 
250          ''' 
251          if isinstance(item, str) or isinstance(item, unicode): 
252              return self.name.lower() > item.lower() 
253          elif not (item is None): 
254              return self.name.lower() > item.name.lower() 
255          return False 
256   
257   
258 -class ParameterModel(QStandardItemModel): 
259      ''' 
260      The model to manage the list with parameter in ROS network. 
261      ''' 
262      header = [('Parameter', 300), 
263                ('Type', 50), 
264                ('Value', -1)] 
265      '''@ivar: the list with columns C{[(name, width), ...]}''' 
266   
267 -    def __init__(self): 
268          ''' 
269          Creates a new list model. 
270          ''' 
271          QStandardItemModel.__init__(self) 
272          self.setColumnCount(len(ParameterModel.header)) 
273          self.setHorizontalHeaderLabels([label for label, _ in ParameterModel.header]) 
274   
275 -    def flags(self, index): 
276          ''' 
277          @param index: parent of the list 
278          @type index: U{QtCore.QModelIndex<https://srinikom.github.io/pyside-docs/PySide/QtCore/QModelIndex.html>} 
279          @return: Flag or the requestet item 
280          @rtype: U{QtCore.Qt.ItemFlag<https://srinikom.github.io/pyside-docs/PySide/QtCore/Qt.html>} 
281          @see: U{http://www.pyside.org/docs/pyside-1.0.1/PySide/QtCore/Qt.html} 
282          ''' 
283          if not index.isValid(): 
284              return Qt.NoItemFlags 
285          if index.column() == 2: 
286              return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable 
287          return Qt.ItemIsEnabled | Qt.ItemIsSelectable 
288   
289 -    def updateModelData(self, parameters): 
290          ''' 
291          Updates the parameter list model. New parameter will be inserted in sorting 
292          order. Not available parameter removed from the model. 
293          @param parameters: The dictionary with parameter 
294          @type parameters: C{dict(parameter name : value)} 
295          ''' 
296          parameter_names = parameters.keys() 
297          root = self.invisibleRootItem() 
298          # remove not available items 
299          for i in reversed(range(root.rowCount())): 
300              parameterItem = root.child(i) 
301              if parameterItem.name not in parameter_names: 
302                  root.removeRow(i) 
303          # add new items 
304          for (name, value) in parameters.items(): 
305              doAddItem = True 
306              for i in range(root.rowCount()): 
307                  parameterItem = root.child(i) 
308                  if (parameterItem == name): 
309                      # update item 
310                      parameterValueItem = root.child(i, 2) 
311                      parameterValueItem.value = value 
312                      doAddItem = False 
313                      break 
314                  elif (parameterItem > name): 
315                      root.insertRow(i, self.createParameter(name, value)) 
316                      doAddItem = False 
317                      break 
318              if doAddItem: 
319                  root.appendRow(self.createParameter(name, value)) 
320   
321 -    def createParameter(self, name, value): 
322          ''' 
323          Creates the list of the items. This list is used for the 
324          visualization of the parameter as a table row. 
325          @param name: the parameter name 
326          @type name: C{str} 
327          @param value: the value of the parameter 
328          @type value: each value, that can be converted to C{str} using L{str()} 
329          @return: the list for the representation as a row 
330          @rtype: C{[L{ParameterNameItem}, L{ParameterValueItem}]} 
331          ''' 
332          items = [] 
333          item = ParameterNameItem(name, value) 
334          item.setEditable(False) 
335          items.append(item) 
336          item = ParameterTypeItem(name, value) 
337          item.setEditable(False) 
338          items.append(item) 
339          itemValue = ParameterValueItem(name, value) 
340          itemValue.setEditable(True) 
341          items.append(itemValue) 
342          return items 
343