← Back to branch summary

~sjdv1982/hivesystem/trunk

« back to all changes in this revision

Viewing changes to hiveguilib/PGui/AntennaFoldState.py

  • Committer: Sjoerd de Vries
  • Date: 2014-06-09 10:19:38 UTC
  • mfrom: (182.1.43 hive-view)
  • Revision ID: sjdv1982@gmail.com-20140609101938-7ji5g0buo09r0se6
merged with hive-view branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
hiveguilib/PGui/AntennaFoldState.py
 
1
import weakref
 
2
 
 
3
class Antenna(object):
 
4
  def __init__(self, typ):
 
5
    self.typ = typ
 
6
    self.fold = False
 
7
    self.foldable = True
 
8
  def __str__(self): 
 
9
    return ",".join((str(self.typ), str(self.fold)))
 
10
 
 
11
class AntennaFoldState(object):
 
12
  def __init__(self, nodecanvas, workermanager):
 
13
    self._sync = {}
 
14
    self._init_form = {}
 
15
    self._init_widget = {}
 
16
    self._nodecanvas = weakref.ref(nodecanvas)
 
17
    self._workermanager = weakref.ref(workermanager)
 
18
    self._pAntennaFoldState = self._AntennaFoldStateClass(self)
 
19
    self.states = {}    
 
20
  
 
21
  def create_worker(self, workerid, antennas, guiparams):    
 
22
    state = {}
 
23
    for a, typ in antennas:
 
24
      antenna = Antenna(typ)
 
25
      if a in guiparams:
 
26
        p = guiparams[a]
 
27
        foldable = p.get("foldable", True)
 
28
        if not foldable:
 
29
          antenna.foldable = False
 
30
          fold = False
 
31
        else:
 
32
          fold = p.get("fold", False)
 
33
        antenna.fold = fold
 
34
      state[a] = antenna
 
35
    if not len(state): state = None
 
36
    self.states[workerid] = state
 
37
    
 
38
  def remove_worker(self, workerid):
 
39
    state = self.states.pop(workerid)
 
40
    self._init_form.pop(workerid, None)
 
41
    self._init_widget.pop(workerid, None)
 
42
    self._sync.pop(workerid, None)
 
43
    if state is not None:
 
44
      self._pAntennaFoldState.remove_worker(workerid)
 
45
 
 
46
  def rename_worker(self, workerid, newid):
 
47
    state = self.states.pop(workerid)
 
48
    self.states[newid] = state
 
49
    for d in self._init_form, self._init_widget, self._sync:
 
50
      if workerid not in d: continue
 
51
      x = d.pop(workerid)
 
52
      d[newid] = x
 
53
    self._pAntennaFoldState.rename_worker(workerid, newid)
 
54
 
 
55
  def init_form(self, workerid, form):
 
56
    if workerid in self._init_form: return
 
57
    self._init_form[workerid] = True
 
58
    self._pAntennaFoldState.init_form(workerid, form)
 
59
          
 
60
  def init_widget(self, workerid, widget, controller):
 
61
    if workerid in self._init_widget: return
 
62
    self._init_widget[workerid] = True    
 
63
    self._pAntennaFoldState.init_widget(workerid, widget, controller)
 
64
    state = self.states[workerid]
 
65
    if state is None: return
 
66
    for a in state:
 
67
      antenna = state[a]
 
68
      if antenna.fold:
 
69
        self._pAntennaFoldState.p_fold(workerid, a)
 
70
      else:
 
71
        self._pAntennaFoldState.p_expand(workerid, a)
 
72
        
 
73
  def gui_sets_value(self, workerid, member, value):
 
74
    variable = self._nodecanvas().get_antenna_connected_variable(workerid, member)
 
75
    self._workermanager()._update_variable(variable, value)
 
76
 
 
77
  def fold(self, workerid, member):
 
78
    antenna = self.states[workerid][member]
 
79
    assert not antenna.fold
 
80
    if not antenna.foldable: return
 
81
    antenna.fold = True     
 
82
    folded, value = self._nodecanvas().fold_antenna_connection(workerid, member, antenna.typ, onload=False)
 
83
    if not folded:
 
84
      antenna.fold = False
 
85
      return
 
86
    if workerid in self._init_widget:
 
87
      self._pAntennaFoldState.p_fold(workerid, member)  
 
88
    self._pAntennaFoldState.p_set_value(workerid, member, value)
 
89
  
 
90
  def gui_folds(self, workerid, member):
 
91
    self.fold(workerid, member)
 
92
    
 
93
  def gui_expands(self, workerid, member):
 
94
    self.expand(workerid, member)
 
95
  
 
96
  def expand(self, workerid, member):
 
97
    antenna = self.states[workerid][member]
 
98
    if not antenna.fold: return
 
99
    antenna.fold = False
 
100
    self._nodecanvas().expand_antenna_connection(workerid, member)
 
101
    if workerid in self._init_widget:
 
102
      self._pAntennaFoldState.p_expand(workerid, member)
 
103
    
 
104
  def p(self):
 
105
    return self._pAntennaFoldState
 
106
    
 
107
  def sync(self, workerid, onload):
 
108
    """
 
109
    Synchronizes all folded variables
 
110
    If a folded antenna has a connection:
 
111
      Retrieve the variable and update the parameter GUI
 
112
    If not:  
 
113
      Create a new variable based on the parameter GUI
 
114
    """    
 
115
    state = self.states[workerid]
 
116
    if state is None: return
 
117
    assert workerid not in self._sync, workerid
 
118
    assert workerid not in self._init_widget, workerid
 
119
    self._sync[workerid] = True    
 
120
    for a in state:
 
121
      antenna = state[a]
 
122
      if not onload and not antenna.fold: continue
 
123
      folded, value = self._nodecanvas().fold_antenna_connection(
 
124
       workerid,a, antenna.typ, onload
 
125
      )
 
126
      if not folded:
 
127
        antenna.fold = False
 
128
        continue  
 
129
      antenna.fold = True
 
130
      self._pAntennaFoldState.p_set_value(workerid, a, value)
 
131
      
 
132
      
 
 
b'\\ No newline at end of file'