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 import QtCore 
 34  from python_qt_binding import QtGui 
 35  from xmlrpclib import Binary 
 36   
 37   
 38 -class ParameterValueItem(QtGui.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 = QtGui.QStandardItem.UserType + 39 
 45    NAME_ROLE = QtCore.Qt.UserRole + 1 
 46    VALUE_ROLE = QtCore.Qt.UserRole + 2 
 47    TYPE_ROLE = QtCore.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      QtGui.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(QtCore.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(QtCore.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 QtGui.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 -class ParameterNameItem(QtGui.QStandardItem): 
114    ''' 
115    The parameter item is stored in the parameter model. This class stores the name  
116    and value of a parameter of ROS parameter server and shows the name. 
117    ''' 
118   
119    ITEM_TYPE = QtGui.QStandardItem.UserType + 38 
120    NAME_ROLE = QtCore.Qt.UserRole + 1 
121    VALUE_ROLE = QtCore.Qt.UserRole + 2 
122    TYPE_ROLE = QtCore.Qt.UserRole + 3 
123   
124 -  def __init__(self, name, value, parent=None): 
125      ''' 
126      Initialize the item object. 
127      @param name: the name of the parameter 
128      @type name: C{str} 
129      @param value: the value of the parameter 
130      @type value: C{str} 
131      ''' 
132      QtGui.QStandardItem.__init__(self, name) 
133      self._name = name 
134      '''@ivar: the name of parameter ''' 
135      self._value = value 
136      '''@ivar: the value of the parameter ''' 
137   
138    @property 
139 -  def name(self): 
140      return self._name 
141   
142    @property 
143 -  def value(self): 
144      return self._value 
145   
146    @value.setter 
147 -  def value(self, value): 
148      self._value = value 
149      self.setText(str(value)) 
150   
151 -  def type(self): 
152      return ParameterValueItem.ITEM_TYPE 
153   
154 -  def data(self, role): 
155      if role == self.NAME_ROLE: 
156        return self.name 
157      elif role == self.VALUE_ROLE: 
158        return str(self.value) 
159      elif role == self.TYPE_ROLE: 
160        return str(type(self.value).replace('<type \'').replace('\'>')) 
161      else: 
162        return QtGui.QStandardItem.data(self, role) 
163   
164 -  def __eq__(self, item): 
165      ''' 
166      Compares the name of parameter. 
167      ''' 
168      if isinstance(item, str) or isinstance(item, unicode): 
169        return self.name.lower() == item.lower() 
170      elif not (item is None): 
171        return self.name.lower() == item.name.lower() 
172      return False 
173   
174 -  def __gt__(self, item): 
175      ''' 
176      Compares the name of parameter. 
177      ''' 
178      if isinstance(item, str) or isinstance(item, unicode): 
179        return self.name.lower() > item.lower() 
180      elif not (item is None): 
181        return self.name.lower() > item.name.lower() 
182      return False 
183   
184   
185 -class ParameterTypeItem(QtGui.QStandardItem): 
186    ''' 
187    The parameter item is stored in the parameter model. This class stores the name  
188    and value of a parameter of ROS parameter server and shows the name. 
189    ''' 
190   
191    ITEM_TYPE = QtGui.QStandardItem.UserType + 40 
192    NAME_ROLE = QtCore.Qt.UserRole + 1 
193    VALUE_ROLE = QtCore.Qt.UserRole + 2 
194    TYPE_ROLE = QtCore.Qt.UserRole + 3 
195   
196 -  def __init__(self, name, value, parent=None): 
197      ''' 
198      Initialize the item object. 
199      @param name: the name of the parameter 
200      @type name: C{str} 
201      @param value: the value of the parameter 
202      @type value: C{str} 
203      ''' 
204      QtGui.QStandardItem.__init__(self, str(type(value)).replace("<type '", '').replace("'>", '')) 
205      self._name = name 
206      '''@ivar: the name of parameter ''' 
207      self._value = value 
208      '''@ivar: the value of the parameter ''' 
209   
210    @property 
211 -  def name(self): 
212      return self._name 
213   
214    @property 
215 -  def value(self): 
216      return self._value 
217   
218    @value.setter 
219 -  def value(self, value): 
220      self._value = value 
221      self.setText(str(value)) 
222   
223 -  def type(self): 
224      return ParameterValueItem.ITEM_TYPE 
225   
226 -  def data(self, role): 
227      if role == self.NAME_ROLE: 
228        return self.name 
229      elif role == self.VALUE_ROLE: 
230        return str(self.value) 
231      elif role == self.TYPE_ROLE: 
232        return str(type(self.value).replace('<type \'').replace('\'>')) 
233      else: 
234        return QtGui.QStandardItem.data(self, role) 
235   
236 -  def __eq__(self, item): 
237      ''' 
238      Compares the name of parameter. 
239      ''' 
240      if isinstance(item, str) or isinstance(item, unicode): 
241        return self.name.lower() == item.lower() 
242      elif not (item is None): 
243        return self.name.lower() == item.name.lower() 
244      return False 
245   
246 -  def __gt__(self, item): 
247      ''' 
248      Compares the name of parameter. 
249      ''' 
250      if isinstance(item, str) or isinstance(item, unicode): 
251        return self.name.lower() > item.lower() 
252      elif not (item is None): 
253        return self.name.lower() > item.name.lower() 
254      return False 
255   
256   
257   
258 -class ParameterModel(QtGui.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      QtGui.QStandardItemModel.__init__(self) 
272      self.setColumnCount(len(ParameterModel.header)) 
273      self.setHorizontalHeaderLabels([label for label, width in ParameterModel.header]) 
274   
275 -  def flags(self, index): 
276      ''' 
277      @param index: parent of the list 
278      @type index: L{PySide.QtCore.QModelIndex} 
279      @return: Flag or the requestet item 
280      @rtype: L{PySide.QtCore.Qt.ItemFlag} 
281      @see: U{http://www.pyside.org/docs/pyside-1.0.1/PySide/QtCore/Qt.html} 
282      ''' 
283      if not index.isValid(): 
284        return QtCore.Qt.NoItemFlags 
285      if index.column() == 2: 
286        return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable 
287      return QtCore.Qt.ItemIsEnabled | QtCore.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 not parameterItem.name 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