class XamlWindow(Window):
def __init__(self):
rd = ResourceDictionary()
rd.Source = Uri("pack://application:,,,/ClassicAssist.Shared;component/Resources/DarkTheme.xaml")
self.Resources.MergedDictionaries.Add(rd)
self.Background = self.Resources["ThemeWindowBackgroundBrush"]
self.Content = XamlReader.Parse(xaml)
self.Title = "Durability"
self.Topmost = True
self.SizeToContent = SizeToContent.Width
self.Height = 400
self.refreshTime = TimeSpan.FromSeconds(30)
self.listView = self.Content.FindName('listView')
self.startButton = self.Content.FindName('startButton')
self.startButton.Click += self.onClick
self.timer = DispatcherTimer()
self.timer.Tick += self.onTick
self.timer.Interval = TimeSpan().FromSeconds(0)
self.timer.Start()
self.timer.Interval = self.refreshTime
self.Running = True
def onClick(self, sender, event):
self.Running = not self.Running
self.startButton.Content = "Start" if not self.Running else 'Stop'
if self.Running:
print 'Starting timer...'
self.timer.Interval = TimeSpan().FromSeconds(0)
self.timer.Start()
self.timer.Interval = self.refreshTime
else:
print 'Stopping timer...'
self.timer.Stop()
self.listView.Items.Clear()
def onTick(self, sender, event):
print 'Updating durabilities'
self.listView.Items.Clear()
durabilities = []
for layer in layers:
(res, durability) = GetDurability(layer)
if res:
durabilities.append(LayerDurability(layer, durability))
sorted = durabilities.OrderBy(lambda i: int(i.Durability))
for item in sorted:
self.listView.Items.Add(item)
if timer_counter > MAXTIMERCOUNT - 1:
print "Time out! %d tests didn't finish." % len(remaining_tests)
# stop timer
ht.Stop()
else:
timer_counter += 1
for test in tests:
# TODO get test file from Iso store
done_file = None
if False:
lines = File.ReadAllLines(done_file)
done_code = int(lines[0].strip())
remaining_tests.remove(test)
if done_code == 0:
sl.log_info(test + ' done.')
else:
sl.log_error(test + ' failed.')
# are we done?
if remaining_tests:
tests = list(remaining_tests)
else:
# stop timer
ht.Stop()
ht.Tick += CheckForDonFile
ht.Start()
HtmlPage.Plugin.SetStyleAttribute("width", "1px")
HtmlPage.Plugin.SetStyleAttribute("height", "1px")
class _Messenger(object):
'''
Thread-safe messenger that ensures that all message handlers are executed
in main dispatcher thread.
This class should be used as singleton. It is not enforced, but recomanded
way of getting instance is by using :meth:`_Messenger.instance` class
method.
'''
_instance = None
@classmethod
def instance(cls, interval=5):
'''
Returns existing instance of messenger. If one does not exist it will
be created and returned.
:param int interval:
Number of miliseconds that represents interval when messages will
be processed.
Note that this parameter will be used only the first time when
instance is requested, every other time it will be ignored
because existing instance of :class:`._Messenger` is returned.
'''
if not cls._instance:
cls._instance = _Messenger(interval)
return cls._instance
def __init__(self, interval=5):
'''
:param int interval:
Number of milliseconds that represents interval when messages will
be processed.
'''
self._subscribers = defaultdict(list)
self._messages = Queue()
self._lock = Lock()
self._timer = DispatcherTimer()
self._timer.Interval = TimeSpan.FromMilliseconds(5)
self._timer.Tick += self._execute
self._timer.Start()
def send(self, message, *args, **kwargs):
'''
Sends provided message to all listeners. Message is only added to
queue and will be processed on next tick.
:param Message message:
Message to send.
'''
self._messages.put((message, args, kwargs), False)
def subscribe(self, message, handler):
'''
Adds hander for specified message.
:param str message:
Name of message to subscribe to.
:param callable handler:
Handler for this message type. Handler must receive single parameter
and that parameter will be instance of sent message.
'''
with self._lock:
ref = WeakCallable(handler, self._on_collect)
self._subscribers[message].append(ref)
# TODO: Unsubscribing with WeakCallable does not work
def unsubscribe(self, message, handler):
'''
Removes handler from message listeners.
:param str message:
Name of message to unsubscribe handler from.
:param callable handler:
Callable that should be removed as handler for `message`.
'''
with self._lock:
self._subscribers[message].remove(WeakCallable(handler))
def _execute(self, sender, event_args):
'''
Event handler for timer that processes all queued messages.
'''
with self._lock:
while not self._messages.empty():
msg, args, kwargs = self._messages.get(False)
for subscriber in self._subscribers[msg]:
try:
subscriber(*args, **kwargs)
except weakref.ReferenceError:
# Reference to handler is lost and it is OK to silence it
pass
def _on_collect(self, ref):
with self._lock:
for msg in self._subscribers:
if ref in self._subscribers[msg]:
self._subscribers[msg].remove(ref)
me.Volume1_MouseEnterValue.To = buttonOverHexValue
me.Volume2_MouseEnterValue.To = buttonOverHexValue
me.NextA_MouseEnterValue.To = buttonOverHexValue
me.NextB_MouseEnterValue.To = buttonOverHexValue
me.PreviousA_MouseEnterValue.To = buttonOverHexValue
me.PreviousB_MouseEnterValue.To = buttonOverHexValue
me.FullA_MouseEnterValue.To = buttonOverHexValue
me.FullB_MouseEnterValue.To = buttonOverHexValue
me.FullC_MouseEnterValue.To = buttonOverHexValue
me.FullD_MouseEnterValue.To = buttonOverHexValue
# UI update timer
_positionTimer = DispatcherTimer()
_positionTimer.Interval = TimeSpan(0, 0, 0, 0, 100)
_positionTimer.Tick += positionTimer_Tick
_positionTimer.Start()
#get XML from page DOM
name = Application.Current.Host.InitParams["xamlid"].Split("-")[0]
xmlSettings = HtmlPage.Document.GetElementById(name + "-settings").text
settings = MediaInfo(xmlSettings)
# assign values declared in markup
_loop = settings.Loop
me.Width = settings.Width
me.Height = settings.Height
if settings.Poster != "":
me.Poster.Source = BitmapImage(
Uri(EnsureAbsoluteFilePath(settings.Poster), UriKind.Absolute))
class MainWindow(Window):
def __init__(self):
'''
get the window design from Window.xaml
FindLogicalNode maps each component to a variable
+= maps an event to a function, the name of the event can be found in Windows class help file
'''
Window.__init__(self)
stream = StreamReader("Window.xaml")
window = XamlReader.Load(stream.BaseStream)
self._timer = DispatcherTimer()
self._timer.Tick += self._timer_Tick
self._timer.Interval = TimeSpan.FromMilliseconds(10) 'run the timer every 10ms'
self._timer.Start()
initializing = True
print("main window")
while Transfer.all_connected() == False and initializing:
if MessageBox.Show("Devices not initialized, retry?","warning", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes:
Transfer.reinitialize()
else:
initializing = False
if initializing == False:
Application.Current.Shutdown()
return
self.UI_x = LogicalTreeHelper.FindLogicalNode(window, "UI_x")
self.UI_x.Content = KCubeDCServoUI.CreateLargeView(Transfer.x)
self.UI_y = LogicalTreeHelper.FindLogicalNode(window, "UI_y")
self.UI_y.Content = KCubeDCServoUI.CreateLargeView(Transfer.y)
self.UI_z = LogicalTreeHelper.FindLogicalNode(window, "UI_z")
self.UI_z.Content = KCubeDCServoUI.CreateLargeView(Transfer.z)
self.UI_rx = LogicalTreeHelper.FindLogicalNode(window, "UI_rx")
self.UI_rx.Content = KCubeDCServoUI.CreateLargeView(Transfer.rx)
self.UI_ry = LogicalTreeHelper.FindLogicalNode(window, "UI_ry")
self.UI_ry.Content = KCubeDCServoUI.CreateLargeView(Transfer.ry)
self.UI_r = LogicalTreeHelper.FindLogicalNode(window, "UI_r")
self.UI_r.Content = KCubeDCServoUI.CreateLargeView(Transfer.r)
self.Help = LogicalTreeHelper.FindLogicalNode(window, "Help")
self.Help.Click += self.Help_Click
self.ZUp = LogicalTreeHelper.FindLogicalNode(window, "ZUp")
self.ZUp.Checked += self.ZUp_Checked
self.ZUp.Unchecked += self.ZUp_Unchecked
self.ZDown = LogicalTreeHelper.FindLogicalNode(window, "ZDown")
self.ZDown.Checked += self.ZDown_Checked
self.ZDown.Unchecked += self.ZDown_Unchecked
self.ViewMode = LogicalTreeHelper.FindLogicalNode(window, "ViewMode")
self.ViewMode.SelectionChanged += self.ViewMode_Changed
self.Button1 = LogicalTreeHelper.FindLogicalNode(window, "Button1")
self.Button1.Click += self.Button1_Click
self.Mode = LogicalTreeHelper.FindLogicalNode(window, "Mode")
self.Mode.Text = "High speed mode"
self.RotateAngle = LogicalTreeHelper.FindLogicalNode(window, "Angle")
self.Title = "Gaming..."
'''lock the size'''
Application().Run(window)
def ViewMode_Changed(self, sender, e):
if self.ViewMode.SelectedValue.Name == "SimpleMode":
self.UI_x.Content = KCubeDCServoUI.CreateSmallView(Transfer.x)
self.UI_y.Content = KCubeDCServoUI.CreateSmallView(Transfer.y)
self.UI_z.Content = KCubeDCServoUI.CreateSmallView(Transfer.z)
self.UI_rx.Content = KCubeDCServoUI.CreateSmallView(Transfer.rx)
self.UI_ry.Content = KCubeDCServoUI.CreateSmallView(Transfer.ry)
self.UI_r.Content = KCubeDCServoUI.CreateSmallView(Transfer.r)
if self.ViewMode.SelectedValue.Name == "ComplexMode":
self.UI_x.Content = KCubeDCServoUI.CreateLargeView(Transfer.x)
self.UI_y.Content = KCubeDCServoUI.CreateLargeView(Transfer.y)
self.UI_z.Content = KCubeDCServoUI.CreateLargeView(Transfer.z)
self.UI_rx.Content = KCubeDCServoUI.CreateLargeView(Transfer.rx)
self.UI_ry.Content = KCubeDCServoUI.CreateLargeView(Transfer.ry)
self.UI_r.Content = KCubeDCServoUI.CreateLargeView(Transfer.r)
self.SizeToContent = True
def Button1_Click(self, sender, e):
try:
angle = float(self.RotateAngle.Text)
Transfer.rotate(angle)
except ValueError:
MessageBox.Show("Input invalid")
self.RotateAngle.Clear()
def _timer_Tick(self, sender, e):
'''
keeps running to get the command and control.
event is the signal from Xbox controller
'''
#Transfer.check()\
#print("for/bavk/stop:{0}{1}{2}".format(Transfer.rx.Status.IsMovingForward, Transfer.rx.Status.IsMovingBackward, Transfer.rx.Status.IsMoving))
events = get_events()
for event in events:
if event.type == EVENT_BUTTON_RELEASED and event.button == "BACK":
Transfer.close()
if event.type == EVENT_BUTTON_RELEASED and event.button == "START":
Transfer.__init__()
#self.__init__() !!!!
if event.type == EVENT_BUTTON_PRESSED and event.button == "LEFT_SHOULDER":
if self.Mode.Text == "Low speed mode":
Transfer.setspeed([200000, 500000, 25000, 300000])
self.Mode.Text = "High speed mode"
else:
Transfer.setspeed([20000, 20000, 2500, 5000])
self.Mode.Text = "Low speed mode"
print(Transfer.speed)
WrongInfo = Transfer.move(event)
if WrongInfo != 'None':
MessageBox.Show(WrongInfo)
def ZUp_Checked(self, sender, e):
'''
the function for the checkbox (the switch of z up/down)
'''
if self.ZDown.IsChecked == True:
try:
Transfer.z.Stop(0)
except:
pass
sleep(0.5)
self.ZDown.IsChecked = False
Transfer.z.MoveContinuousAtVelocity(FORWARD, 500)
def ZUp_Unchecked(self, sender, e):
Transfer.z.Stop(0)
def ZDown_Checked(self, sender, e):
if self.ZUp.IsChecked == True:
try:
Transfer.z.Stop(0)
except:
pass
sleep(0.5)
self.ZUp.IsChecked = False
Transfer.z.MoveContinuousAtVelocity(BACKWARD, 500)
def ZDown_Unchecked(self, sender, e):
Transfer.z.Stop(0)
def Help_Click(self, sender, e):
'''
can show a help file after clicking the help
'''
pass
class MyWindow(Window):
def __init__(self):
self.mouse_drag = False
self.animal_window = None
self.selected_animal = None
self.mouse_start_point = Point(0, 0)
self.start_time = time()
self.world = world.World(500, 200, constants=WorldConstants())
self.window = wpf.LoadComponent(self,
'iron_unconditioned_reflexes.xaml')
self._create_and_start_timer()
self._renderer = Renderer(self.canvas, self.world)
self.world.food_timer = self.food_slider.Value
self._renderer.draw_food_smell = self.food_smell_checkBox.IsChecked
self._renderer.draw_eat_distance = self.eat_distance_checkBox.IsChecked
self._renderer.draw_chunks = self.chunks_checkBox.IsChecked
self._renderer.draw_animal_smell = self.animal_smell_checkBox.IsChecked
self._simulation_scenario = SimulationScenario(self)
def _create_and_start_timer(self):
self.timer = DispatcherTimer()
self.timer.Tick += self.dispatcherTimer_Tick
self.timer.Interval = TimeSpan(0, 0, 0, 0, self.timer_slider.Value)
self.timer.Start()
def dispatcherTimer_Tick(self, sender, e):
self._simulation_scenario.tic()
self._check_performance()
self._show_world_info_in_ui()
self.world.update()
self._renderer.render()
if self.animal_window:
self.animal_window.update()
def _check_performance(self):
if self.world.time % 10 == 0:
performance = (time() - self.start_time) / 10.0
self.performance_textblock.Text = "performance={}".format(
performance)
self.start_time = time()
def _show_world_info_in_ui(self):
self.world_time_textblock.Text = "world time={}".format(
self.world.time)
self.animal_count_textblock.Text = "animal count={}".format(
len(self.world.animals))
self.food_count_textblock.Text = "food count={}".format(
len(self.world.food))
def timer_slider_ValueChanged(self, sender, e):
self.timer.Interval = TimeSpan(0, 0, 0, 0, sender.Value)
def scale_slider_ValueChanged(self, sender, e):
# todo fix this crutch
if hasattr(self, 'canvas'):
self.canvas.RenderTransform = ScaleTransform(
sender.Value, sender.Value)
def canvas_SizeChanged(self, sender, e):
self.world.width = int(sender.ActualWidth)
self.world.height = int(sender.ActualHeight)
def canvas_MouseRightButtonDown(self, sender, e):
self.mouse_drag = True
self.mouse_start_point = e.GetPosition(self.canvas)
def canvas_MouseRightButtonUp(self, sender, e):
self.mouse_drag = False
def canvas_MouseLeave(self, sender, e):
self.mouse_drag = False
def canvas_MouseMove(self, sender, e):
if self.mouse_drag:
point = e.GetPosition(self.canvas)
left = self.parent_canvas.GetLeft(self.canvas)
top = self.parent_canvas.GetTop(self.canvas)
if float.IsNaN(left):
left = 0
if float.IsNaN(top):
top = 0
self.parent_canvas.SetLeft(
self.canvas, left + point.X - self.mouse_start_point.X)
self.parent_canvas.SetTop(self.canvas,
top + point.Y - self.mouse_start_point.Y)
def canvas_MouseWheel(self, sender, e):
self.scale_slider.Value += (e.Delta / 120) * 0.05
def food_slider_ValueChanged(self, sender, e):
self.world.food_timer = int(sender.Value)
def food_smell_changed(self, sender, e):
self._renderer.draw_food_smell = self.food_smell_checkBox.IsChecked
def eat_distance_changed(self, sender, e):
self._renderer.draw_eat_distance = self.eat_distance_checkBox.IsChecked
def chunks_changed(self, sender, e):
self._renderer.draw_chunks = self.chunks_checkBox.IsChecked
def animal_smell_changed(self, sender, e):
self._renderer.draw_animal_smell = self.animal_smell_checkBox.IsChecked
def MenuItem_Click(self, sender, e):
if self.animal_window is None or not self.animal_window.IsLoaded:
self.animal_window = AnimalWindow()
self.animal_window.animal = self.selected_animal
self.animal_window.Show()
def canvas_MouseLeftButtonDown(self, sender, e):
point = e.GetPosition(self.canvas)
self.selected_animal = self.world.get_animal(point.X, point.Y)
self._renderer.selected_animal = self.selected_animal
if self.animal_window:
self.animal_window.animal = self.selected_animal
