def __init__(self,parent,id,title=""):
wx.Frame.__init__(self,parent,title = title,pos = (15,15),size = (1260,800))
mainsplitter = MultiSplitterWindow(self, style=wx.SP_3D | wx.SP_LIVE_UPDATE)
mainsplitter.SetOrientation(wx.VERTICAL)
self.splitterpanel1 = MainPanel(mainsplitter)
self.splitterpanel2 = BottomPanel(mainsplitter)
mainsplitter.AppendWindow(self.splitterpanel1, -1)
mainsplitter.AppendWindow(self.splitterpanel2, -1)
mainsplitter.SetSashPosition(0, 410)
def __init__(self,parent):
wx.Panel.__init__(self, parent, pos = (5,409),size = (1000,350),style=wx.TAB_TRAVERSAL | wx.BORDER_SIMPLE)
mainsplitter = MultiSplitterWindow(self)
mainsplitter.SetOrientation(wx.VERTICAL)
self.splitterpanel_result = ResultPanel(mainsplitter)
self.splitterpanel_log = LogPanel(mainsplitter)
mainsplitter.AppendWindow(self.splitterpanel_result,0)
mainsplitter.AppendWindow(self.splitterpanel_log,0)
mainsplitter.SetSashPosition(0,200)
def __init__(self,parent,id):
#Fenster initialiseren
wx.Frame.__init__(self, parent=parent, id=id, title='Remote', size=(200,200))
#Fenster aufteilen in mehrere Unterfenster
splitter = MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
#Unterfenster initialisieren (in jeweiligen Klassen) und anhaengen
panel1=Controlpanel(splitter)
graph1=MatplotPanel1(splitter)
graph2=MatplotPanel2(splitter)
graph3=MatplotPanel3(splitter)
splitter.AppendWindow(panel1)
splitter.AppendWindow(graph1)
splitter.AppendWindow(graph2)
splitter.AppendWindow(graph3)
#setzt Trennlinie
splitter.SetSashPosition(1,600)
splitter.SetSashPosition(0,170)
#verbindet Schliessen-Knopf mit Funktion
self.Bind(wx.EVT_CLOSE,self.closewindow)
class MainWindow(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, 'Planet Hunt', size=(1400, 600))
self.splitter = MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
# The passing references to panels and controsl to each other
# seems a bit sloppy and I want to do away with it. Not sure how yet.
data_display_panel = DataDisplayPanel(self.splitter)
data_modify_panel = DataModifyPanel(self.splitter, data_display_panel)
data_search_panel = DataSearchPanel(self.splitter, data_display_panel,
data_modify_panel)
self.splitter.AppendWindow(data_search_panel, sashPos=150)
self.splitter.AppendWindow(data_display_panel, sashPos=1050)
self.splitter.AppendWindow(data_modify_panel)
status_bar = self.CreateStatusBar()
menubar_main = wx.MenuBar()
file_menu = wx.Menu()
edit_menu = wx.Menu()
file_menu.Append(wx.NewIdRef(), 'Connect...',
'Connect to a new server')
file_menu.Append(wx.NewIdRef(), 'Close', 'Quit the application')
menubar_main.Append(file_menu, 'File')
menubar_main.Append(edit_menu, 'Edit')
self.SetMenuBar(menubar_main)
self.SetStatusBar(status_bar)
def force_update(self):
# Jiggle the splitter 'sash' around to force a redraw.
# No, I don't like having to do this but I can't figure out the
# proper way to make the matplotlib graphs actually show up.
sp = self.splitter.GetSashPosition(0)
self.splitter.SetSashPosition(0, sp+1)
self.splitter.SetSashPosition(0, sp+0)
def close_window(self, event):
self.Destroy()
class PanelMiners(wx.Panel):
lock = threading.RLock()
def __init__(self, parent, frame, num_miners=4):
wx.Panel.__init__(self, parent=parent, id=wx.ID_ANY)
self.parent = parent
self.frame = frame
self.resize_lock = False
self.num_miners = num_miners
self.devicesJson = self.loadDevices()
self.splitter = MultiSplitterWindow(self,
id=wx.ID_ANY,
style=wx.SP_LIVE_UPDATE)
self.splitter.SetOrientation(wx.HORIZONTAL)
self.splitter.SetMinimumPaneSize(1)
self.miner0 = PMI.PanelMinerInstance(self.splitter, self, "Miner #0",
self.devicesJson['miner0'],
self.devicesJson['miner0num'],
self.devicesJson['devices'])
self.miner1 = PMI.PanelMinerInstance(self.splitter, self, "Miner #1",
self.devicesJson['miner1'],
self.devicesJson['miner1num'],
self.devicesJson['devices'])
self.miner2 = PMI.PanelMinerInstance(self.splitter, self, "Miner #2",
self.devicesJson['miner2'],
self.devicesJson['miner2num'],
self.devicesJson['devices'])
self.miner3 = PMI.PanelMinerInstance(self.splitter, self, "Miner #3",
self.devicesJson['miner3'],
self.devicesJson['miner3num'],
self.devicesJson['devices'])
self.splitter.AppendWindow(self.miner0)
self.splitter.AppendWindow(self.miner1)
self.splitter.AppendWindow(self.miner2)
self.splitter.AppendWindow(self.miner3)
self.splitter.Bind(wx.EVT_SIZE, self.resizeMinerPanels)
#self.splitter.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGING, self.sashChanging)
#self.splitter.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.resizeMinerPanels)
self.collapsePanel = CollapsePanel(self, self.devicesJson['resize'],
self.devicesJson['transfer'])
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizerW = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(self.splitter, 1, wx.EXPAND)
sizerW.Add(self.collapsePanel, 1, wx.EXPAND | wx.LEFT | wx.RIGHT, -1)
sizer.Add(sizerW, 0, wx.EXPAND | wx.TOP, 1)
self.SetSizer(sizer)
def loadDevices(self):
f = open(DEVICES_FILE)
data = f.read()
f.close()
return json.loads(data)
def saveDevices(self):
sel0 = self.miner0.handler.deviceCombo.GetValue()
sel1 = self.miner1.handler.deviceCombo.GetValue()
sel2 = self.miner2.handler.deviceCombo.GetValue()
sel3 = self.miner3.handler.deviceCombo.GetValue()
num0 = self.miner0.handler.deviceNum.GetValue()
num1 = self.miner1.handler.deviceNum.GetValue()
num2 = self.miner2.handler.deviceNum.GetValue()
num3 = self.miner3.handler.deviceNum.GetValue()
self.devicesJson['miner0'] = sel0
self.devicesJson['miner1'] = sel1
self.devicesJson['miner2'] = sel2
self.devicesJson['miner3'] = sel3
self.devicesJson['miner0num'] = num0
self.devicesJson['miner1num'] = num1
self.devicesJson['miner2num'] = num2
self.devicesJson['miner3num'] = num3
self.devicesJson['resize'] = self.collapsePanel.resizeBtn.GetValue()
self.devicesJson['transfer'] = self.collapsePanel.transferBtn.GetValue(
)
io.open(DEVICES_FILE, 'wt',
encoding='utf-8').write(unicode(json.dumps(self.devicesJson)))
def deviceChanged(self):
if self.collapsePanel.transferBtn.GetValue():
devices = [
self.miner0.handler.getDevice(),
self.miner1.handler.getDevice(),
self.miner2.handler.getDevice(),
self.miner3.handler.getDevice()
]
self.frame.notebook.broadcastEventToAllTabs(event_id="miner",
event_value=devices)
def executeAlgo(self, maxAlgo, switch):
if switch:
self.stopMiners()
else:
self.stopCrashedMiners()
ret0 = self.miner0.executeAlgo(maxAlgo, switch)
ret1 = self.miner1.executeAlgo(maxAlgo, switch)
ret2 = self.miner2.executeAlgo(maxAlgo, switch)
ret3 = self.miner3.executeAlgo(maxAlgo, switch)
if (ret0 is None and ret1 is None and ret2 is None and ret3 is None):
return None
return ret0 or ret1 or ret2 or ret3
def stopMiners(self, wait=False, exit=False):
self.miner0.stopMiner(exit)
self.miner1.stopMiner(exit)
self.miner2.stopMiner(exit)
self.miner3.stopMiner(exit)
if exit:
self.stopLoop(self.checkMinersExited)
elif wait:
self.stopLoop(self.checkMinersReady)
self.frame.notebook.broadcastEventToAllTabs(event_id="stop_mining")
def stopCrashedMiners(self):
if self.miner0.minerStatus() == PMI.STATUS_CRASHED:
self.miner0.stopMiner()
if self.miner1.minerStatus() == PMI.STATUS_CRASHED:
self.miner1.stopMiner()
if self.miner2.minerStatus() == PMI.STATUS_CRASHED:
self.miner2.stopMiner()
if self.miner3.minerStatus() == PMI.STATUS_CRASHED:
self.miner3.stopMiner()
def stopLoop(self, endFunction):
success = False
i = 0
str_ini = "Waiting for miners to die "
from miner import PanelMinerInstance
while i < PanelMinerInstance.MAX_ITERATIONS:
if not endFunction():
time.sleep(0.5)
i += 1
str_out = str_ini + str(i)
print str_out
else:
str_out = "MINERS done, Bye!"
print str_out
#time.sleep(2)
success = True
break
print "Miners: Exited with success = " + str(success)
if not success:
str_out = "MINERS Dammit"
print str_out
time.sleep(5)
def checkMinerCrashed(self):
if self.miner0.minerStatus() == PMI.STATUS_CRASHED or \
self.miner1.minerStatus() == PMI.STATUS_CRASHED or \
self.miner2.minerStatus() == PMI.STATUS_CRASHED or \
self.miner3.minerStatus() == PMI.STATUS_CRASHED:
return False
return True
def checkMinersReady(self):
if ( self.miner0.minerStatus() in (PMI.STATUS_READY, PMI.STATUS_DISABLED, PMI.STATUS_CRASHED, PMI.STATUS_EXITED, PMI.STATUS_EXITING ) ) and \
( self.miner1.minerStatus() in (PMI.STATUS_READY, PMI.STATUS_DISABLED, PMI.STATUS_CRASHED, PMI.STATUS_EXITED, PMI.STATUS_EXITING ) ) and \
( self.miner2.minerStatus() in (PMI.STATUS_READY, PMI.STATUS_DISABLED, PMI.STATUS_CRASHED, PMI.STATUS_EXITED, PMI.STATUS_EXITING ) ) and \
( self.miner3.minerStatus() in (PMI.STATUS_READY, PMI.STATUS_DISABLED, PMI.STATUS_CRASHED, PMI.STATUS_EXITED, PMI.STATUS_EXITING ) ):
return True
return False
def checkMinersExited(self):
if ( self.miner0.minerStatus() == PMI.STATUS_EXITED ) and \
( self.miner1.minerStatus() == PMI.STATUS_EXITED ) and \
( self.miner2.minerStatus() == PMI.STATUS_EXITED ) and \
( self.miner3.minerStatus() == PMI.STATUS_EXITED ):
return True
return False
def checkMinersSelected(self):
if ( self.miner0.minerStatus() == PMI.STATUS_DISABLED ) and \
( self.miner1.minerStatus() == PMI.STATUS_DISABLED ) and \
( self.miner2.minerStatus() == PMI.STATUS_DISABLED ) and \
( self.miner3.minerStatus() == PMI.STATUS_DISABLED ):
return False
return True
def resizeMinerPanels(self, event=None, slide=False, forceResize=False):
try:
if not self.collapsePanel.resizeBtn.GetValue() and not forceResize:
event.Skip()
return
width = self.parent.GetSize()[0]
best = width / self.num_miners
num_ready = sum(
1 for miner in
[self.miner0, self.miner1, self.miner2, self.miner3]
if miner.minerStatus() is not PMI.STATUS_DISABLED)
#num_rinning = sum(1 for miner in [self.miner0, self.miner1, self.miner2, self.miner3] if miner.minerStatus() == PMI.STATUS_RUNNING)
factor = 1.5
factor = factor if num_ready == 0 else factor + (
float(num_ready * 1.5) / 10)
#factor = 1.5 if num_ready == 0 else 1.5 * ( 1 + ( self.num_miners - float(num_ready) - 1 ) / 10 )
num_not_ready = self.num_miners - num_ready
if num_ready == 0 or num_not_ready == 0 or forceResize:
wide = narrow = best
else:
factored_num_ready = num_ready * factor
factored_total = factored_num_ready + num_not_ready
factor_ready = float(factored_num_ready) / factored_total
factor_not_ready = float(num_not_ready) / factored_total
wide = (factor_ready * width) / num_ready
narrow = (factor_not_ready * width) / num_not_ready
#no slide effect allowed for resize event triggered calls to the function for performance reasons.
if not slide:
self.splitter.SetSashPosition(
0,
int(wide if self.miner0.minerStatus() != PMI.
STATUS_DISABLED else narrow))
self.splitter.SetSashPosition(
1,
int(wide if self.miner1.minerStatus() != PMI.
STATUS_DISABLED else narrow))
self.splitter.SetSashPosition(
2,
int(wide if self.miner2.minerStatus() != PMI.
STATUS_DISABLED else narrow))
self.splitter.SetSashPosition(
3,
int(wide if self.miner3.minerStatus() != PMI.
STATUS_DISABLED else narrow))
if event:
event.Skip()
return
thread = threading.Thread(target=self.resizeMinerPanelsThread,
args=(wide, narrow))
thread.start()
except (PyDeadObjectError, AttributeError):
pass
def resizeMinerPanelsThread(self, wide, narrow):
try:
#with PanelMiners.lock:
if self.resize_lock:
time.sleep(0.5)
if not self.resize_lock:
self.resize_lock = True
target0 = int(wide if self.miner0.minerStatus() != PMI.
STATUS_DISABLED else narrow)
target1 = int(wide if self.miner1.minerStatus() != PMI.
STATUS_DISABLED else narrow)
target2 = int(wide if self.miner2.minerStatus() != PMI.
STATUS_DISABLED else narrow)
target3 = int(wide if self.miner3.minerStatus() != PMI.
STATUS_DISABLED else narrow)
steps = 15
for w in range(1, steps):
#if self.resize_lock == False:
# break
delta0 = target0 - self.splitter.GetSashPosition(0)
delta1 = target1 - self.splitter.GetSashPosition(1)
delta2 = target2 - self.splitter.GetSashPosition(2)
delta3 = target3 - self.splitter.GetSashPosition(3)
pct = float(w) / steps
self.splitter.SetSashPosition(
0,
self.splitter.GetSashPosition(0) + pct * delta0)
self.splitter.SetSashPosition(
1,
self.splitter.GetSashPosition(1) + pct * delta1)
self.splitter.SetSashPosition(
2,
self.splitter.GetSashPosition(2) + pct * delta2)
self.splitter.SetSashPosition(
3,
self.splitter.GetSashPosition(3) + pct * delta3)
time.sleep(0.01)
self.resize_lock = False
except PyDeadObjectError:
pass
def setButtonExpanded(self, expanded):
self.collapsePanel.setButtonExpanded(expanded)
def getExpansionStatus(self):
return self.collapsePanel.collapseBtn.GetValue()
class TodoFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent=parent, title=title, size=(400, 400))
self.model = None
self.parent = parent
self.edit_window_visible = False
self.k1 = ''
self.k2 = ''
self.k3 = ''
self.listen()
self.status_bar = TodoStatusBar(self)
self.SetStatusBar(self.status_bar)
self.switch = False
# Menu entries
self.button_menu_ID1 = wx.NewId()
self.button_menu_ID2 = wx.NewId()
self.button_menu_ID3 = wx.NewId()
self.button_menu_ID4 = wx.NewId()
self.Bind(wx.EVT_MENU, self.OnMenuEntrySort, id=self.button_menu_ID1)
self.Bind(wx.EVT_MENU, self.OnMenuEntryInfo, id=self.button_menu_ID2)
self.Bind(wx.EVT_MENU,
self.OnMenuEntryVisualReport,
id=self.button_menu_ID3)
self.Bind(wx.EVT_MENU,
self.OnMenuEntryToggleEditWindow,
id=self.button_menu_ID4)
# Multiple keybindings states
self.state_C_x_ID = wx.NewId()
self.state_ID2 = wx.NewId()
self.state_undo_ID = wx.NewId()
self.Bind(wx.EVT_MENU, self.OnState_C_x, id=self.state_C_x_ID)
self.Bind(wx.EVT_MENU, self.OnState2, id=self.state_ID2)
self.Bind(wx.EVT_MENU, self.OnStateUndo, id=self.state_undo_ID)
self.accelerator_entries = [
# Single keybindings
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('S'), self.button_menu_ID1),
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('I'), self.button_menu_ID2),
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('R'), self.button_menu_ID3),
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('E'), self.button_menu_ID4),
# Multiple keybindings
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('x'), self.state_C_x_ID),
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('f'), self.state_ID2),
wx.AcceleratorEntry(wx.ACCEL_CTRL, ord('g'), self.state_undo_ID)
]
self.accelerator_table = wx.AcceleratorTable(self.accelerator_entries)
self.SetAcceleratorTable(self.accelerator_table)
# temp_data must not be empty for selection to work correctly
self.update_temp_data()
self.main_panel = wx.Panel(self)
self.main_panel_sizer = wx.BoxSizer(wx.VERTICAL)
self.main_splitter = MultiSplitterWindow(self.main_panel,
style=wx.SP_LIVE_UPDATE
| wx.SP_BORDER)
self.main_splitter.SetOrientation(wx.HORIZONTAL)
# self.main_splitter.SetMinimumPaneSize(0)
self.panel = TodoListCtrlPanel(self.main_splitter)
self.panel.get_listctr().colorize()
self.SetBackgroundColour(wx.Colour(255, 119, 0))
self.edit_window = TodoEditWindow(self.main_splitter)
self.edit_window.Hide()
self.main_splitter.AppendWindow(self.panel, self.GetSize()[1] / 3 * 2)
self.search_box = SearchBox(self)
self.panel.get_listctr().brother_widget = self.search_box
# self.Bind(wx.EVT_CHAR_HOOK, self.OnSearch, self.search_box)
self.search_box.Bind(wx.EVT_TEXT, self.OnSearch, self.search_box)
# self.Bind(wx.EVT_TEXT_ENTER, self.OnEnter) #, self.search_box)
self.Bind(wx.EVT_TEXT_ENTER, self.OnSearch) #, self.search_box)
# self.Bind(wx.EVT_CHAR, self.OnBackspace, self.search_box)
# self.Bind(wx.EVT_CHAR_HOOK, self.OnEnter) # , self.search_box)
self.Bind(wx.EVT_SET_FOCUS, self.OnBackspace, self.search_box)
self.Bind(wx.EVT_KILL_FOCUS, self.OnBackspace, self.search_box)
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnBackspace, self.search_box)
self.Bind(wx.EVT_SIZE, self.OnSize, self)
self.search_box.Bind(wx.EVT_CHAR, self.OnChar, self.search_box)
self.search_box.SetFocus()
self.main_slider = wx.Slider(
# self, 100, 25, 1, 100, (30, 60), (250, -1),
self.status_bar,
100,
25,
1,
len(temp_data),
(30, 60),
(250, -1),
wx.SL_HORIZONTAL | wx.SL_AUTOTICKS) # |wx.SL_LABELS)
self.main_slider.SetTickFreq(5, 1)
self.main_slider.SetLineSize(5)
self.main_slider.SetPageSize(5)
self.main_slider.SetBackgroundColour(wx.Colour(80, 80, 80))
self.main_slider.Bind(wx.EVT_SLIDER, self.OnSlider, self.main_slider)
# TODO: Add text for current value or move it somewhere else
# self.main_slider.SetPosition((self.status_bar.GetFieldRect(1).x+200, 0))
self.addTaskButton = wx.Button(self, 0,
'Add &task') # , size=(125, -1))
self.addTaskButton.SetBackgroundColour(wx.Colour(255, 77, 0))
self.addTaskButton.Bind(wx.EVT_BUTTON, self.OnClickAddTaskButton,
self.addTaskButton)
self.setPriorityButton = wx.Button(self, 0, 'Set &priority')
self.setPriorityButton.SetBackgroundColour(wx.Colour(255, 77, 0))
self.setPriorityButton.Bind(wx.EVT_BUTTON,
self.OnClickSetPriorityButton,
self.setPriorityButton)
self.deleteTaskButton = wx.Button(self, 0, '&Delete task')
self.deleteTaskButton.SetBackgroundColour(wx.Colour(255, 77, 0))
self.deleteTaskButton.Bind(wx.EVT_BUTTON, self.OnClickDeleteTaskButton,
self.deleteTaskButton)
self.moreButton = wx.Button(self, 0, '&More')
self.moreButton.SetBackgroundColour(wx.Colour(255, 77, 0))
self.moreButton.Bind(wx.EVT_BUTTON, self.OnClickMoreButton,
self.moreButton)
self.main_panel_sizer.Add(self.main_splitter, 1, wx.EXPAND | wx.ALL)
self.main_panel.SetSizer(self.main_panel_sizer)
self.main_splitter.Layout()
self.main_panel.Layout()
self.buttonSizer = wx.BoxSizer(wx.HORIZONTAL)
self.panel.sizer.Layout()
# self.buttonSizer.Add(self.main_slider, 0, wx.ALIGN_LEFT|wx.ALL)
self.buttonSizer.Add(self.addTaskButton, 0, wx.ALIGN_LEFT | wx.ALL)
self.buttonSizer.Add(self.setPriorityButton, 0,
wx.ALIGN_RIGHT | wx.ALL)
self.buttonSizer.Add(self.deleteTaskButton, 0, wx.ALIGN_RIGHT | wx.ALL)
self.buttonSizer.Add(self.moreButton, 0, wx.ALIGN_RIGHT | wx.ALL)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.search_box, 0, wx.GROW | wx.ALL, 6)
# self.sizer.Add(self.addTaskButton, 0, wx.ALIGN_RIGHT|wx.ALL)
# self.sizer.Add(self.setPriorityButton, 0, wx.ALIGN_RIGHT|wx.ALL)
self.sizer.Add(self.buttonSizer, 0, wx.ALIGN_RIGHT | wx.ALL)
self.sizer.Add(self.main_panel, 1, wx.EXPAND | wx.ALL)
# self.sizer.Add(self.panel, 1, wx.EXPAND|wx.ALL)
# self.sizer.Add(self.edit_window, 1, wx.EXPAND|wx.ALL)
# self.sizer.Add(self.main_splitter, 1, wx.EXPAND|wx.ALL)
self.SetSizer(self.sizer)
self.SetAutoLayout(True)
self.Show(True)
def register(self, model):
self.model = model
def OnSlider(self, event):
print self.main_slider.GetValue()
self.main_slider.SetRange(1, len(temp_data))
# previous = 0
# next = 0
current = self.main_slider.GetValue()
# # XXX
# # This would be more efficient, but it does not check
# # milliseconds/nanoseconds yet.
# if current > 0:
# previous = self.main_slider.GetValue() - 1
# else:
# previous = self.main_slider.GetMax() - 1
# if current < self.main_slider.GetMax():
# next = self.main_slider.GetValue() + 1
# else:
# next = 0
# self.panel.get_listctr().SetItemState(previous, 0, -1)
# self.panel.get_listctr().SetItemState(next, 0, -1)
# This can become inefficient for large lists.
item = 0
while True:
item = self.panel.get_listctr().GetNextItem(
item, wx.LIST_NEXT_ALL, wx.LIST_STATE_SELECTED)
if item == -1:
break
self.panel.get_listctr().SetItemState(
item, 0, wx.LIST_STATE_SELECTED | wx.LIST_STATE_FOCUSED)
self.panel.get_listctr().SetItemState(
current - 1, wx.LIST_STATE_SELECTED | wx.LIST_STATE_FOCUSED,
wx.LIST_STATE_SELECTED | wx.LIST_STATE_FOCUSED)
self.panel.get_listctr().EnsureVisible(current)
self.panel.get_listctr().SetFocus()
event.Skip()
def OnSize(self, event):
# TODO: Make param of SetSashPosition dynamic
self.main_splitter.SetSashPosition(0, self.GetSize()[0] / 3 * 2)
event.Skip()
def OnState_C_x(self, event):
print 'C-x - SWITCH: ', self.switch
self.switch = True
event.Skip()
def OnState2(self, event):
print 'C-x - SWITCH: ', self.switch
if self.switch:
self.OnMenuEntrySort(event)
event.Skip()
def OnStateUndo(self, event):
print 'C-x - SWITCH: ', self.switch
self.switch = False
event.Skip()
def listen(self):
# keycode = event.GetKeyCode()
self.Bind(wx.EVT_KEY_DOWN, self._OnFirstChar)
self.Bind(wx.EVT_KEY_DOWN, self._OnSecondChar)
self.Bind(wx.EVT_KEY_DOWN, self._OnThirdChar)
# if keycode == wx.WXK_TAB:
if self.k1 == wx.WXK_TAB:
if self.k2 == 'x':
if self.k3 == 'j':
self.OnMenuEntrySort()
def _OnFirstChar(self, event):
print "foo" * 80
self.k1 = event.GetKeyCode()
def _OnSecondChar(self, event):
self.k2 = chr(event.GetKeyCode())
def _OnThirdChar(self, event):
self.k3 = chr(event.GetKeyCode())
def OnMenuEntrySort(self, event):
self._sort_temp_data()
self._reload_view(do_reload_temp_data=False)
def OnMenuEntryInfo(self, event):
dialog = wx.MessageDialog(self, 'This is some information. ', 'Info',
wx.OK | wx.ICON_INFORMATION)
dialog.ShowModal()
dialog.Destroy()
def OnMenuEntryVisualReport(self, event):
VisualReport(title='Report', data=data)
event.Skip()
def OnMenuEntryToggleEditWindow(self, event):
if not self.edit_window_visible:
self.main_splitter.AppendWindow(self.edit_window)
self.edit_window.Show()
self.edit_window_visible = True
else:
self.main_splitter.DetachWindow(self.edit_window)
self.edit_window.Hide()
self.edit_window_visible = False
def OnChar(self, event):
if event.GetKeyCode() == 9: # TAB
self.panel.get_listctr().SetFocus()
elif event.GetKeyCode() == 13: # ENTER
print 'ENTER'
else:
event.Skip()
def OnClickAddTaskButton(self, event):
dialog = wx.TextEntryDialog(self, 'New task:', 'TASK', 'TODO')
dialog.SetValue('TASK')
new_task = ''
if dialog.ShowModal() == wx.ID_OK:
new_task = dialog.GetValue()
choice_dialog = wx.SingleChoiceDialog(
self,
'Select priority',
'Priority',
[str(i) for i in xrange(1, 8)], # TODO: Make dynamic
wx.CHOICEDLG_STYLE)
if choice_dialog.ShowModal() == wx.ID_OK:
new_priority = int(choice_dialog.GetStringSelection())
self.model.add_task(new_task,
new_priority) # Append to the model
# data.append([new_task, new_priority]) # Append to the views data list
# Redisplay the list
self._reload_view()
choice_dialog.Destroy()
dialog.Destroy()
def OnClickSetPriorityButton(self, event):
# FIXME: Does not set the priority for the right items yet
# for idx in self.panel.get_listctr().GetSelectedItems():
# while self.panel.get_listctr().GetNextSelected(0):
# print "%10s %s" % (idx, self.temp[idx])
# for idx, item in enumerate(self.panel.get_listctr().temp):
# if item.IsSelected:
# print item
print "``````````", self.panel.get_listctr().selected_items
for sel_item in self.panel.get_listctr().selected_items:
dialog = wx.SingleChoiceDialog(self, 'Select priority', 'Priority',
[str(i) for i in xrange(1, 8)],
wx.CHOICEDLG_STYLE)
if dialog.ShowModal() == wx.ID_OK:
print 'Item: %s; Selection %s' % (sel_item,
dialog.GetStringSelection())
for idx, item in enumerate(data.get_as_list()):
if sel_item.label == item.label:
new_priority = int(dialog.GetStringSelection())
print 'INDEX: ', self.model.task_list.get_task_at(idx)
self.model.set_priority(
idx, new_priority) # Set for the model
data.get_task_at(
idx
).priority = new_priority # Set for the views data list
print "NEW: ", item.label, ' - ', new_priority
# Redisplay the list
self._reload_view()
dialog.Destroy()
def OnClickDeleteTaskButton(self, event):
choice_dlg = wx.SingleChoiceDialog(
self, 'Really delte the following task(s)?', 'Delete', [
i[0] + ' (priority: ' + str(i[1]) + ')'
for i in self.panel.get_listctr().selected_items
], wx.CHOICEDLG_STYLE)
if choice_dlg.ShowModal() == wx.ID_OK:
# new_priority = int(choice_dlg.GetStringSelection())
for item in self.panel.get_listctr().selected_items:
for idx, task in enumerate(data):
if item == task:
self.model.remove_task(
(idx + 1)) # Remove from the model
data.pop(idx - 1) # Remove from the views data list
# Redisplay the list
self._reload_view()
break
choice_dlg.Destroy()
def OnClickMoreButton(self, event):
# self._sort_temp_data()
# self._reload_view(do_reload_temp_data=False)
button_menu = wx.Menu()
button_menu.Append(self.button_menu_ID1, '&Sort\tCtrl+S/C-x C-f')
button_menu.Append(self.button_menu_ID2, '&Info\tCtrl+I')
button_menu.Append(self.button_menu_ID3, 'Visual &Report\tCtrl+R')
button_menu.Append(self.button_menu_ID4, 'Toggle &Edit window\tCtrl+E')
self.PopupMenu(button_menu, self.moreButton.GetPosition())
button_menu.Destroy()
def OnSearch(self, event):
# value = self.search_box.GetValue()
# if not value:
# print 'Nothing entered'
# return
# keycode = event.GetKeyCode()
current = str(self.search_box.GetValue())
# current = str(self.search_box.GetLineText(0))
# wx.KeyEvent(wx.WXK_RETURN)
# current = str(self.search_box.GetRange(0, self.search_box.GetInsertionPoint()))
# current = str(self.search_box.GetValue())
# self.update_temp_data(current)
# print 'KEYCODE: ', keycode
# if keycode == 8: # Backspace key
if False: # TODO: Improve or remove
self.panel.get_listctr().ClearAll()
self._clear_temp_data()
else:
print 'CURRENT: ', current
# self.panel.get_listctr().update(current)
self.panel.get_listctr().ClearAll()
# self._clear_temp_data()
self.update_temp_data(current)
self.panel.get_listctr().Populate(temp_data)
self.Layout()
event.Skip()
def _reload_view(self, do_reload_temp_data=True):
self.panel.get_listctr().ClearAll()
if do_reload_temp_data:
self.update_temp_data()
self.panel.get_listctr().Populate(temp_data)
self.Layout()
def _clear_temp_data(self):
temp_data.clear()
def OnBackspace(self, event):
keycode = event.GetKeyCode()
print 'KEYCODE: ', keycode
if keycode == 8: # Backspace key
self.panel.get_listctr().ClearAll()
else:
self.OnSearch(event)
def OnEnter(self, event):
keycode = event.GetKeyCode()
print 'KEYCODE: ', keycode
def update_temp_data(self, string=''):
self._clear_temp_data()
for item in data.get_as_list():
if string in item.label or string in str(item.priority):
# print 'MATCH: ', item
temp_data.add(item)
self.status_bar.set_tasks(len(temp_data))
def _sort_temp_data(self):
temp_data.sort_alphabetically()
temp_data.sort_numerically()
