class _StructuredElement(object):
_type = None
def __init__(self, name):
self._name = name
self._fields = OrderedDict()
self._parent = None
def __setitem__(self, name, child):
self._fields[unicode(name)] = child
child._parent = self
def __getitem__(self, name):
return self._fields[unicode(name)]
def __getattr__(self, name):
return self[name]
def __delitem__(self, name):
name = unicode(name)
item = self._fields[name]
del self._fields[name]
item._parent = None
def __str__(self):
return self._get_name()
def __repr__(self):
result = '%s\n' % str(self._get_name())
for field in self._fields.values():
result += self._format_indented('%s' % repr(field))
return result
def __contains__(self, key):
return unicode(key) in self._fields
def _format_indented(self, text):
return ''.join([' %s\n' % line for line in text.splitlines()])
@property
def _raw(self):
return self._get_raw_bytes()
def _get_name(self):
return '%s %s' % (self._type, self._name)
def _get_raw_bytes(self):
return ''.join((field._raw for field in self._fields.values()))
def __len__(self):
return sum(len(field) for field in self._fields.values())
def __nonzero__(self):
return True
def _get_recursive_name(self):
return (self._parent._get_recursive_name()
if self._parent else '') + self._name + '.'
class _StructuredElement(object):
_type = None
def __init__(self, name):
self._name = name
self._fields = OrderedDict()
self._parent = None
def __setitem__(self, name, child):
self._fields[unicode(name)] = child
child._parent = self
def __getitem__(self, name):
return self._fields[unicode(name)]
def __getattr__(self, name):
return self[name]
def __delitem__(self, name):
name = unicode(name)
item = self._fields[name]
del self._fields[name]
item._parent = None
def __str__(self):
return self._get_name()
def __repr__(self):
result = '%s\n' % str(self._get_name())
for field in self._fields.values():
result += self._format_indented('%s' % repr(field))
return result
def __contains__(self, key):
return unicode(key) in self._fields
def _format_indented(self, text):
return ''.join([' %s\n' % line for line in text.splitlines()])
@property
def _raw(self):
return self._get_raw_bytes()
def _get_name(self):
return '%s %s' % (self._type, self._name)
def _get_raw_bytes(self):
return ''.join((field._raw for field in self._fields.values()))
def __len__(self):
return sum(len(field) for field in self._fields.values())
def __nonzero__(self):
return True
def _get_recursive_name(self):
return (self._parent._get_recursive_name() if self._parent else '') + self._name + '.'
def test_set_new_items():
d = OrderedDict()
assert d.keys() == []
assert d.values() == []
d['language'] = 'Python'
assert d.keys() == ['language']
assert d.values() == ['Python']
d['other'] = ('a', 'b', 'c')
assert d.keys() == ['language', 'other']
assert d.values() == ['Python', ('a', 'b', 'c')]
def test_set_repeated_items():
d = OrderedDict()
assert d.keys() == []
assert d.values() == []
d['language'] = 'Python'
assert d.keys() == ['language']
assert d.values() == ['Python']
d['other'] = ('a', 'b', 'c')
assert d.keys() == ['language', 'other']
assert d.values() == ['Python', ('a', 'b', 'c')]
# Same key again:
d['language'] = 'Ruby'
assert d.keys() == ['language', 'other']
assert d.values() == ['Ruby', ('a', 'b', 'c')]
class MessageSequence(object):
def __init__(self):
self.operators = OrderedDict()
self.sequence = []
def _operator(self, name, ip, port):
ip_port = ip_name(ip, port)
if ip_port not in self.operators:
self.operators[ip_port] = Operator(ip_port, name)
else:
self.operators[ip_port].name = name
return self.operators[ip_port]
def _get_operator(self, ip_port):
if ip_port not in self.operators:
self.operators[ip_port] = Operator(ip_port)
return self.operators[ip_port]
def send(self, sender_name, sender, receiver, protocol, message_name, error=""):
self.sequence.append(
(
self._operator(sender_name, *sender),
self._get_operator(ip_name(*receiver)),
msg_name(protocol, message_name),
error,
"sent",
)
)
def receive(self, receiver_name, receiver, sender, protocol, message_name, error=""):
sender_ip_name = ip_name(*sender)
row = (
self._get_operator(sender_ip_name),
self._operator(receiver_name, *receiver),
msg_name(protocol, message_name),
error,
"received",
)
if self.is_named_operator(sender_ip_name):
for i in reversed(range(len(self.sequence))):
if self._matches(self.sequence[i], receiver, sender):
self.sequence[i] = row
return
self.sequence.append(row)
def _matches(self, msg, receiver, sender):
return msg[0].ip_name == ip_name(*sender) and msg[1].ip_name == ip_name(*receiver) and msg[-1] == "sent"
def get_operators(self):
return (operator.name for operator in self.operators.values())
def get(self):
return ((str(elem) for elem in row) for row in self.sequence)
def is_named_operator(self, ip_name):
return ip_name in self.operators and ip_name != self.operators[ip_name].name
class Struct(_StructuredElement):
_type = 'Struct'
def __init__(self, name, type_name, align=1):
self._name = name
self._type = type_name
self._fields = OrderedDict()
self._parent = None
self._align = align
def __len__(self):
result = sum(len(field) for field in self._fields.values())
return self._get_aligned(result)
def _get_aligned(self, length):
return length + (self._align - length % self._align) % self._align
def _get_raw_bytes(self):
result = ''.join((field._raw for field in self._fields.values()))
return result.ljust(self._get_aligned(len(result)), '\x00')
class Bag(_StructuredElement):
_type = 'Bag'
def __init__(self, name):
self._name = name
self._fields = OrderedDict()
self._parent = None
@property
def len(self):
return sum(field.len for field in self._fields.values())
class Struct(_StructuredElement):
_type = 'Struct'
def __init__(self, name, type_name, align=1):
self._name = name
self._type = type_name
self._fields = OrderedDict()
self._parent = None
self._align = align
def __len__(self):
result = sum(len(field) for field in self._fields.values())
return self._get_aligned(result)
def _get_aligned(self, length):
return length + (self._align - length % self._align) % self._align
def _get_raw_bytes(self):
result = ''.join((field._raw for field in self._fields.values()))
return result.ljust(self._get_aligned(len(result)), '\x00')
class Bag(_StructuredElement):
_type = 'Bag'
def __init__(self, name):
self._name = name
self._fields = OrderedDict()
self._parent = None
@property
def len(self):
return sum(field.len for field in self._fields.values())
class MessageSequence(object):
def __init__(self):
self.operators = OrderedDict()
self.sequence = []
def _operator(self, name, ip, port):
ip_port = ip_name(ip, port)
if ip_port not in self.operators:
self.operators[ip_port] = Operator(ip_port, name)
else:
self.operators[ip_port].name = name
return self.operators[ip_port]
def _get_operator(self, ip_port):
if ip_port not in self.operators:
self.operators[ip_port] = Operator(ip_port)
return self.operators[ip_port]
def send(self, sender_name, sender, receiver, protocol, message_name, error=''):
self.sequence.append((self._operator(sender_name, *sender),
self._get_operator(ip_name(*receiver)),
msg_name(protocol, message_name), error, 'sent'))
def receive(self, receiver_name, receiver, sender, protocol, message_name, error=''):
sender_ip_name = ip_name(*sender)
row = (self._get_operator(sender_ip_name), self._operator(receiver_name, *receiver),
msg_name(protocol, message_name), error, 'received')
if self.is_named_operator(sender_ip_name):
for i in reversed(range(len(self.sequence))):
if self._matches(self.sequence[i], receiver, sender):
self.sequence[i] = row
return
self.sequence.append(row)
def _matches(self, msg, receiver, sender):
return msg[0].ip_name == ip_name(*sender) and \
msg[1].ip_name == ip_name(*receiver) and \
msg[-1] == 'sent'
def get_operators(self):
return (operator.name for operator in self.operators.values())
def get(self):
return ((str(elem) for elem in row) for row in self.sequence)
def is_named_operator(self, ip_name):
return ip_name in self.operators and ip_name != self.operators[ip_name].name
class MyFrame(wx.Frame):
def __init__(self, *args, **kwds):
# begin wxGlade: MyFrame.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
self.buttons = []
self.panels = OrderedDict()
self.motors_cfg = XMLRPCMotorConfiguration(self)
self.menubar = wx.MenuBar()
self.menubar.Append(self.motors_cfg.motormenu, self.motors_cfg.motormenu_title)
self.SetMenuBar(self.menubar)
self.abort_panel = XMLRPCAbortPanel(self, -1)
self.panels['motor'] = XMLRPCMotorPanel(self, -1, self.motors_cfg)
self.panels['rapidscan'] = XMLRPCRapidScanPanel(self, -1, self.motors_cfg)
self.panels['findpeak'] = XMLRPCFindPeakPanel(self, -1, self.motors_cfg)
self.panels['count'] = XMLRPCCountPanel(self, -1)
# buttons to disable when moving:
for panel_name in self.panels:
panel = self.panels[panel_name]
self.buttons.extend(panel.buttons)
if hasattr(panel, 'menus') and len(panel.menus) > 0:
for menu, title in panel.menus:
self.menubar.Append(menu, title)
# (this specifically excludes the Abort button, which is NOT disabled)
#self.plot_panel = PlotPanel(self, -1)
self.__set_properties()
self.__do_layout()
# end wxGlade
def __set_properties(self):
# begin wxGlade: MyFrame.__set_properties
self.SetTitle("Motor Control Panel")
# end wxGlade
def __do_layout(self):
# begin wxGlade: MyFrame.__do_layout
sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
sizer_2 = wx.BoxSizer(wx.VERTICAL)
for panel in self.panels.values():
sizer_2.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
sizer_2.Add(panel, 0, wx.EXPAND, 0)
#sizer_1.Add(self.panel_1, 0, wx.EXPAND, 0)
sizer_1.Add(sizer_2)
sizer_1.Add(self.abort_panel, 0, wx.EXPAND, 0)
#sizer_2.Add(sizer_1)
#rs_label = wx.StaticText(self, -1, 'RAPID SCAN:')
#rs_label.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD, 0, ""))
#sizer_2.Add(rs_label, 0,0,0)
#sizer_2.Add(self.panel_2, 0, wx.EXPAND, 0)
#sizer_2.Add(self.panel_3, 0, wx.EXPAND, 0)
#sizer_1.Add(self.plot_panel, 0, wx.EXPAND, 0)
self.SetSizer(sizer_1)
sizer_1.Fit(self)
self.Layout()
# end wxGlade
def disable_all_buttons(self):
""" disables all buttons except the abort button """
old_button_state = []
for button in self.buttons:
old_button_state.append(button.IsEnabled())
button.Disable()
self._stored_button_state = old_button_state
return old_button_state
def restore_button_state(self, button_state=None):
for panel in self.panels.values():
panel.update_all_motors()
if button_state==None: button_state = self._stored_button_state
for i, state in enumerate(button_state):
self.buttons[i].Enable(state)
def update_motors(self, motors):
for panel in self.panels.values():
panel.motors = motors
panel.update_all_motors()
def change_enabled_motors(self, motors_enabled):
for panel in self.panels.values():
panel.motors_enabled = motors_enabled
panel.__do_layout()
