src/pyqt/gui/cataitems.py

   1 from qt import *
   2
   3 import Item
   4 import CONNECTOR
   5 import Items
   6
   7 class Obj(Item.Item):
   8   def __init__(self,root=None):
   9     Item.Item.__init__(self)
  10     if root:
  11       self.root=root
  12     else:
  13       self.root=self
  14
  15   def selected(self):
  16     if not self.emitting:
  17       self.emitting=1
  18       CONNECTOR.Emit(self.root,"selected",self)
  19       self.emitting=0
  20
  21   def panel(self,parent):
  22     """Retourne un tab widget pour browser/editer la proc"""
  23     tabWidget = QTabWidget( parent )
  24     for name,method in self.panels:
  25       tabWidget.addTab( method(self,tabWidget), name )
  26     return tabWidget
  27
  28   box=panel
  29
  30   def panel1(self,parent):
  31     qvbox=QVBox(parent)
  32     self.text=QTextEdit(qvbox,"log")
  33     self.text.setFrameShape(QTextEdit.NoFrame)
  34     self.text.setTextFormat(QTextEdit.PlainText)
  35     self.text.setWordWrap(QTextEdit.FixedColumnWidth)
  36     #self.text.setWrapColumnOrWidth(120)
  37     self.text.setReadOnly(1)
  38     return qvbox
  39
  40   panels=[("Panel1",panel1)]
  41
  42 class ItemService(Item.Item):
  43   def __init__(self,service,root):
  44     Item.Item.__init__(self)
  45     self.root=root
  46     self.service=service
  47     self.label=service.getName()
  48
  49   def isExpandable(self):
  50     return True
  51
  52   def addNode(self,appli):
  53     appli.addNode(self.service)
  54
  55   def getChildren(self):
  56     sublist=[]
  57     for port in self.service.getSetOfInputPort():
  58       sublist.append(Items.ItemInPort(port,self.root))
  59     for port in self.service.getSetOfOutputPort():
  60       sublist.append(Items.ItemOutPort(port,self.root))
  61     for port in self.service.getSetOfInputDataStreamPort():
  62       sublist.append(Items.ItemInStream(port,self.root))
  63     for port in self.service.getSetOfOutputDataStreamPort():
  64       sublist.append(Items.ItemOutStream(port,self.root))
  65     return sublist
  66
  67   def selected(self):
  68     if not self.emitting:
  69       self.emitting=1
  70       CONNECTOR.Emit(self.root,"selected",self)
  71       self.emitting=0
  72
  73 class ItemType(Item.Item):
  74   def __init__(self,typ,root,name=""):
  75     Item.Item.__init__(self)
  76     self.typ=typ
  77     self.root=root
  78     if name:
  79       self.label=name
  80     else:
  81       self.label=typ.name()
  82
  83   def isExpandable(self):
  84     return True
  85
  86   def getChildren(self):
  87     sublist=[]
  88     return sublist
  89
  90   def selected(self):
  91     if not self.emitting:
  92       self.emitting=1
  93       CONNECTOR.Emit(self.root,"selected",self)
  94       self.emitting=0
  95
  96 class ItemCompo(Item.Item):
  97   def __init__(self,compo,root):
  98     Item.Item.__init__(self)
  99     self.compo=compo
 100     self.root=root
 101     self.label=compo.getName()
 102
 103   def isExpandable(self):
 104     return True
 105
 106   def getChildren(self):
 107     sublist=[]
 108     for service in self.compo._serviceMap.values():
 109       itemservice=ItemService(service,self.root)
 110       sublist.append(itemservice)
 111     return sublist
 112
 113   def selected(self):
 114     if not self.emitting:
 115       self.emitting=1
 116       CONNECTOR.Emit(self.root,"selected",self)
 117       self.emitting=0
 118
 119 class ItemNode(Item.Item):
 120   def __init__(self,node,root):
 121     Item.Item.__init__(self)
 122     self.node=node
 123     self.root=root
 124     self.label=node.getName()
 125
 126   def isExpandable(self):
 127     return True
 128
 129   def addNode(self,appli):
 130     appli.addNode(self.node)
 131
 132   def getChildren(self):
 133     sublist=[]
 134     return sublist
 135
 136   def selected(self):
 137     if not self.emitting:
 138       self.emitting=1
 139       CONNECTOR.Emit(self.root,"selected",self)
 140       self.emitting=0
 141
 142 class ItemComposedNode(Item.Item):
 143   def __init__(self,node,root):
 144     Item.Item.__init__(self)
 145     self.node=node
 146     self.root=root
 147     self.label=node.getName()
 148
 149   def addNode(self,appli):
 150     appli.addNode(self.node)
 151
 152   def isExpandable(self):
 153     return True
 154
 155   def getChildren(self):
 156     sublist=[]
 157     return sublist
 158
 159   def selected(self):
 160     if not self.emitting:
 161       self.emitting=1
 162       CONNECTOR.Emit(self.root,"selected",self)
 163       self.emitting=0
 164
 165 class TypesItem(Item.Item):
 166   """Item for types folder"""
 167   def __init__(self,typeMap,root):
 168     Item.Item.__init__(self)
 169     self.typeMap=typeMap
 170     self.label="Types"
 171     self.root=root
 172
 173   def getIconName(self):
 174     return "folder"
 175
 176   def isExpandable(self):
 177     return True
 178
 179   def getChildren(self):
 180     sublist=[]
 181     for name,typ in self.typeMap.items():
 182       itemtype=ItemType(typ,self.root,name)
 183       sublist.append(itemtype)
 184     return sublist
 185
 186 class ComponentsItem(Item.Item):
 187   """Item for components folder"""
 188   def __init__(self,compoMap,root):
 189     Item.Item.__init__(self)
 190     self.compoMap=compoMap
 191     self.label="Components"
 192     self.root=root
 193
 194   def getIconName(self):
 195     return "folder"
 196
 197   def isExpandable(self):
 198     return True
 199
 200   def getChildren(self):
 201     sublist=[]
 202     for compo in self.compoMap.values():
 203       itemcompo=ItemCompo(compo,self.root)
 204       sublist.append(itemcompo)
 205     return sublist
 206
 207 class NodesItem(Item.Item):
 208   """Item for nodes folder"""
 209   def __init__(self,nodesMap,root):
 210     Item.Item.__init__(self)
 211     self.nodesMap=nodesMap
 212     self.label="Nodes"
 213     self.root=root
 214
 215   def getIconName(self):
 216     return "folder"
 217
 218   def isExpandable(self):
 219     return True
 220
 221   def getChildren(self):
 222     sublist=[]
 223     for node in self.nodesMap.values():
 224       itemnode=ItemNode(node,self.root)
 225       sublist.append(itemnode)
 226     return sublist
 227
 228 class ComposedNodesItem(Item.Item):
 229   """Item for composed nodes folder"""
 230   def __init__(self,composedMap,root):
 231     Item.Item.__init__(self)
 232     self.composedMap=composedMap
 233     self.label="ComposedNodes"
 234     self.root=root
 235
 236   def getIconName(self):
 237     return "folder"
 238
 239   def isExpandable(self):
 240     return True
 241
 242   def getChildren(self):
 243     sublist=[]
 244     for node in self.composedMap.values():
 245       itemnode=ItemComposedNode(node,self.root)
 246       sublist.append(itemnode)
 247     return sublist
 248
 249 class Cata(Obj):
 250   def __init__(self,cata):
 251     Obj.__init__(self)
 252     self.cata=cata
 253     self.label=cata.getName()
 254
 255   def isExpandable(self):
 256     return True
 257
 258   def getChildren(self):
 259     sublist=[]
 260     sublist.append(TypesItem(self.cata._typeMap,self))
 261     sublist.append(NodesItem(self.cata._nodeMap,self))
 262     sublist.append(ComposedNodesItem(self.cata._composednodeMap,self))
 263     sublist.append(ComponentsItem(self.cata._componentMap,self))
 264     return sublist
 265
 266   def dblselected(self):
 267     if not self.emitting:
 268       self.emitting=1
 269       CONNECTOR.Emit(self,"dblselected",self)
 270       self.emitting=0
 271