| """ | |
| File: | |
| JetCreator.py | |
| Contents and purpose: | |
| Jet file creation utility for JET sound engine | |
| Copyright (c) 2008 Android Open Source Project | |
| Licensed under the Apache License, Version 2.0 (the "License"); | |
| you may not use this file except in compliance with the License. | |
| You may obtain a copy of the License at | |
| http://www.apache.org/licenses/LICENSE-2.0 | |
| Unless required by applicable law or agreed to in writing, software | |
| distributed under the License is distributed on an "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| See the License for the specific language governing permissions and | |
| limitations under the License. | |
| """ | |
| from __future__ import with_statement | |
| import wx | |
| import sys | |
| import thread | |
| import copy | |
| import wx.html | |
| import operator | |
| from wx.lib.mixins.listctrl import CheckListCtrlMixin, ListCtrlAutoWidthMixin | |
| from eas import * | |
| from JetFile import * | |
| from JetUtils import * | |
| from JetCtrls import * | |
| from JetDialogs import * | |
| from JetSegGraph import SegmentGraph, Marker | |
| from JetAudition import * | |
| from JetStatusEvent import * | |
| import img_favicon | |
| import img_New | |
| provider = wx.SimpleHelpProvider() | |
| wx.HelpProvider_Set(provider) | |
| class JetCreator(wx.Frame): | |
| """ Main window of JetCreator utility """ | |
| def __init__(self, parent, id, jetConfigFile, importFlag=False): | |
| wx.Frame.__init__(self, parent, id, size=(1050, 720), style=wx.DEFAULT_FRAME_STYLE | wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX) | |
| self.myicon = img_favicon.getIcon() | |
| self.SetIcon(self.myicon) | |
| self.UndoStack = [] | |
| self.RedoStack = [] | |
| self.queueSegs = [] | |
| self.clipBoard = None | |
| self.jet = None | |
| self.playerLock = threading.RLock() | |
| self.SetKeepPlayingFlag(True) | |
| self.currentSegmentName = None | |
| self.currentSegmentIndex = None | |
| self.currentEventName = None | |
| self.currentEventIndex = None | |
| self.currentCtrl = "" | |
| self.currentJetConfigFile = jetConfigFile | |
| self.paused = False | |
| self.eventlistSort = (0, 1) | |
| self.seglistSort = (0, 1) | |
| if self.currentJetConfigFile == "": | |
| FileKillClean(JetDefs.UNTITLED_FILE) | |
| self.currentJetConfigFile = JetDefs.UNTITLED_FILE | |
| self.jet_file = JetFile(self.currentJetConfigFile, "") | |
| if not ValidateConfig(self.jet_file): | |
| FileKillClean(JetDefs.UNTITLED_FILE) | |
| self.currentJetConfigFile = JetDefs.UNTITLED_FILE | |
| self.jet_file = JetFile(self.currentJetConfigFile, "") | |
| if self.currentJetConfigFile == JetDefs.UNTITLED_FILE: | |
| self.LoadDefaultProperties() | |
| self.initLayout() | |
| self.initStatusBar() | |
| self.createMenuBar() | |
| self.createToolbar() | |
| self.SetCurrentFile(self.currentJetConfigFile) | |
| self.initHelp() | |
| self.graph.ClickCallbackFct = self.GraphTriggerClip | |
| EVT_JET_STATUS(self, self.OnJetStatusUpdate) | |
| wx.EVT_CLOSE(self, self.OnClose) | |
| self.Centre() | |
| self.Show(True) | |
| if importFlag: | |
| self.OnJetImportArchive(None) | |
| self.eventList.OnSortOrderChangedAlert = self.OnEventSortOrderChanged | |
| self.segList.OnSortOrderChangedAlert = self.OnSegSortOrderChanged | |
| def initLayout(self): | |
| """ Initializes the screen layout """ | |
| panel = wx.Panel(self, -1) | |
| hboxMain = wx.BoxSizer(wx.HORIZONTAL) | |
| leftPanel = wx.Panel(panel, -1) | |
| leftTopPanel = wx.Panel(leftPanel, -1) | |
| leftBotPanel = wx.Panel(leftPanel, -1) | |
| rightPanel = wx.Panel(panel, -1) | |
| self.segList = JetCheckListCtrl(rightPanel) | |
| for title, width, fld in JetDefs.SEGMENT_GRID: | |
| self.segList.AddCol(title, width) | |
| self.eventList = JetListCtrl(rightPanel) | |
| for title, width, fld in JetDefs.CLIPS_GRID: | |
| self.eventList.AddCol(title, width) | |
| self.eventList.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnEventListClick) | |
| self.segList.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSegListClick) | |
| self.segList.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnSegmentUpdate) | |
| self.eventList.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnEventUpdate) | |
| self.segList.BindCheckBox(self.OnSegmentChecked) | |
| BUT_SIZE = (95, 25) | |
| self.btnAddSeg = wx.Button(leftTopPanel, -1, JetDefs.BUT_ADD, size=BUT_SIZE) | |
| self.btnRevSeg = wx.Button(leftTopPanel, -1, JetDefs.BUT_REVISE, size=BUT_SIZE) | |
| self.btnDelSeg = wx.Button(leftTopPanel, -1, JetDefs.BUT_DELETE, size=BUT_SIZE) | |
| self.btnMoveSeg = wx.Button(leftTopPanel, -1, JetDefs.BUT_MOVE, size=BUT_SIZE) | |
| self.btnQueueAll = wx.Button(leftTopPanel, -1, JetDefs.BUT_QUEUEALL, size=BUT_SIZE) | |
| self.btnDequeueAll = wx.Button(leftTopPanel, -1, JetDefs.BUT_DEQUEUEALL, size=BUT_SIZE) | |
| self.btnPlay = wx.Button(leftTopPanel, -1, JetDefs.BUT_PLAY, size=BUT_SIZE) | |
| self.btnPause = wx.Button(leftTopPanel, -1, JetDefs.BUT_PAUSE, size=BUT_SIZE) | |
| self.btnAudition = wx.Button(leftTopPanel, -1, JetDefs.BUT_AUDITION, size=BUT_SIZE) | |
| self.btnAddEvt = wx.Button(leftBotPanel, -1, JetDefs.BUT_ADD, size=BUT_SIZE) | |
| self.btnRevEvt = wx.Button(leftBotPanel, -1, JetDefs.BUT_REVISE, size=BUT_SIZE) | |
| self.btnDelEvt = wx.Button(leftBotPanel, -1, JetDefs.BUT_DELETE, size=BUT_SIZE) | |
| self.btnMoveEvents = wx.Button(leftBotPanel, -1, JetDefs.BUT_MOVE, size=BUT_SIZE) | |
| self.Bind(wx.EVT_BUTTON, self.OnSegmentAdd, id=self.btnAddSeg.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnSegmentUpdate, id=self.btnRevSeg.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnSegmentDelete, id=self.btnDelSeg.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnSegmentsMove, id=self.btnMoveSeg.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnSelectAll, id=self.btnQueueAll.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnDeselectAll, id=self.btnDequeueAll.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnPlay, id=self.btnPlay.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnPause, id=self.btnPause.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnAudition, id=self.btnAudition.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnEventAdd, id=self.btnAddEvt.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnEventUpdate, id=self.btnRevEvt.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnEventDelete, id=self.btnDelEvt.GetId()) | |
| self.Bind(wx.EVT_BUTTON, self.OnEventsMove, id=self.btnMoveEvents.GetId()) | |
| BORDER = 5 | |
| BUT_SPACE = 3 | |
| vBoxLeftTop = wx.BoxSizer(wx.VERTICAL) | |
| vBoxLeftBot = wx.BoxSizer(wx.VERTICAL) | |
| vBoxLeftTop.Add(self.btnAddSeg, 0, wx.TOP, BORDER) | |
| vBoxLeftTop.Add(self.btnRevSeg, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnDelSeg, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnMoveSeg, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add((-1, 12)) | |
| vBoxLeftTop.Add(self.btnQueueAll, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnDequeueAll, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnPlay, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnPause, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftTop.Add(self.btnAudition, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftBot.Add(self.btnAddEvt, 0) | |
| vBoxLeftBot.Add(self.btnRevEvt, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftBot.Add(self.btnDelEvt, 0, wx.TOP, BUT_SPACE) | |
| vBoxLeftBot.Add(self.btnMoveEvents, 0, wx.TOP, BUT_SPACE) | |
| leftTopPanel.SetSizer(vBoxLeftTop) | |
| leftBotPanel.SetSizer(vBoxLeftBot) | |
| vboxLeft = wx.BoxSizer(wx.VERTICAL) | |
| vboxLeft.Add(leftTopPanel, 1, wx.EXPAND) | |
| vboxLeft.Add(leftBotPanel, 1, wx.EXPAND) | |
| vboxLeft.Add((-1, 25)) | |
| leftPanel.SetSizer(vboxLeft) | |
| self.log = wx.TextCtrl(rightPanel, -1) | |
| self.graph = SegmentGraph(rightPanel, size=(-1, 50)) | |
| vboxRight = wx.BoxSizer(wx.VERTICAL) | |
| vboxRight.Add(self.segList, 4, wx.EXPAND | wx.TOP, BORDER) | |
| vboxRight.Add((-1, 10)) | |
| vboxRight.Add(self.eventList, 3, wx.EXPAND | wx.TOP, BORDER) | |
| vboxRight.Add((-1, 10)) | |
| vboxRight.Add(self.log, 0, wx.EXPAND) | |
| vboxRight.Add((-1, 5)) | |
| vboxRight.Add(self.graph, 1, wx.EXPAND) | |
| vboxRight.Add((-1, 10)) | |
| rightPanel.SetSizer(vboxRight) | |
| hboxMain.Add(leftPanel, 0, wx.EXPAND | wx.RIGHT | wx.LEFT, BORDER) | |
| hboxMain.Add(rightPanel, 1, wx.EXPAND) | |
| hboxMain.Add((BORDER, -1)) | |
| panel.SetSizer(hboxMain) | |
| pnlGraph = wx.Panel(leftBotPanel, -1) | |
| graphSizer1 = wx.BoxSizer(wx.VERTICAL) | |
| pnlGraph.SetSizer(graphSizer1) | |
| graphBox = wx.StaticBox(pnlGraph, wx.ID_ANY, label='Graph') | |
| graphSizer2 = wx.StaticBoxSizer(graphBox, wx.VERTICAL) | |
| self.chkGraphLabels = wx.CheckBox(pnlGraph, -1, JetDefs.GRAPH_LBLS) | |
| self.chkGraphClips = wx.CheckBox(pnlGraph, -1, JetDefs.GRAPH_TRIGGER) | |
| self.chkGraphAppEvts = wx.CheckBox(pnlGraph, -1, JetDefs.GRAPH_APP) | |
| graphSizer2.Add(self.chkGraphLabels, 0, wx.TOP, BUT_SPACE) | |
| graphSizer2.Add(self.chkGraphClips, 0, wx.TOP, BUT_SPACE) | |
| graphSizer2.Add(self.chkGraphAppEvts, 0, wx.TOP | wx.BOTTOM, BUT_SPACE) | |
| graphSizer1.Add((-1, 10)) | |
| graphSizer1.Add(graphSizer2) | |
| vBoxLeftBot.Add(pnlGraph, 0, wx.TOP, BUT_SPACE) | |
| self.Bind(wx.EVT_CHECKBOX, self.OnSetGraphOptions, id=self.chkGraphLabels.GetId()) | |
| self.Bind(wx.EVT_CHECKBOX, self.OnSetGraphOptions, id=self.chkGraphClips.GetId()) | |
| self.Bind(wx.EVT_CHECKBOX, self.OnSetGraphOptions, id=self.chkGraphAppEvts.GetId()) | |
| def initHelp(self): | |
| """ Initializes the help text for screen elements """ | |
| self.SetHelpText(GetJetHelpText(JetDefs.MAIN_DLG_CTRLS, '')) | |
| self.segList.SetHelpText(GetJetHelpText(JetDefs.MAIN_DLG_CTRLS, JetDefs.MAIN_SEGLIST)) | |
| self.eventList.SetHelpText(GetJetHelpText(JetDefs.MAIN_DLG_CTRLS, JetDefs.MAIN_EVENTLIST)) | |
| self.graph.SetHelpText(GetJetHelpText(JetDefs.AUDITION_CTRLS, JetDefs.AUDITION_GRAPH)) | |
| def initStatusBar(self): | |
| """ Initializes the status bar """ | |
| self.statusbar = self.CreateStatusBar() | |
| def OnSelectAll(self, event): | |
| """ Called from select all button """ | |
| num = self.segList.GetItemCount() | |
| for i in range(num-1, -1, -1): | |
| self.segList.CheckItem(i) | |
| def OnDeselectAll(self, event): | |
| """ Called from deselect all button """ | |
| num = self.segList.GetItemCount() | |
| for i in range(num-1, -1, -1): | |
| self.segList.CheckItem(i, False) | |
| def LoadSegList(self): | |
| """ Loads up the list of segments """ | |
| self.seglistSort = (IniGetValue(self.currentJetConfigFile, JetDefs.INI_SEGSORT, JetDefs.INI_SEGSORT_0, 'int', 0), IniGetValue(self.currentJetConfigFile, JetDefs.INI_SEGSORT, JetDefs.INI_SEGSORT_1, 'int', 1)) | |
| segments = self.jet_file.GetSegments() | |
| if self.seglistSort[0] == 0: | |
| self.SegSort(segments, "segname") | |
| elif self.seglistSort[0] == 1: | |
| self.SegSort(segments, "filename") | |
| elif self.seglistSort[0] == 2: | |
| self.SegSort(segments, "dlsfile") | |
| elif self.seglistSort[0] == 3: | |
| self.SegSort(segments, "start") | |
| elif self.seglistSort[0] == 4: | |
| self.SegSort(segments, "end") | |
| elif self.seglistSort[0] == 5: | |
| self.SegSort(segments, "quantize") | |
| elif self.seglistSort[0] == 6: | |
| self.SegSort(segments, "transpose") | |
| elif self.seglistSort[0] == 7: | |
| self.SegSort(segments, "repeat") | |
| elif self.seglistSort[0] == 8: | |
| self.SegSort(segments, "mute_flags") | |
| listDataMap = [] | |
| self.currentSegmentIndex = None | |
| self.currentSegmentName = None | |
| self.segList.DeleteAllItems() | |
| self.eventList.DeleteAllItems() | |
| self.menuItems[JetDefs.MNU_UPDATE_SEG].Enable(False) | |
| self.menuItems[JetDefs.MNU_DELETE_SEG].Enable(False) | |
| self.menuItems[JetDefs.MNU_MOVE_SEG].Enable(False) | |
| self.menuItems[JetDefs.MNU_ADD_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_MOVE_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_UPDATE_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_DELETE_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_MOVE_EVENT].Enable(False) | |
| for segment in self.jet_file.GetSegments(): | |
| index = self.segList.InsertStringItem(sys.maxint, StrNoneChk(segment.segname)) | |
| self.segList.SetStringItem(index, 1, FileJustName(StrNoneChk(segment.filename))) | |
| self.segList.SetStringItem(index, 2, FileJustName(StrNoneChk(segment.dlsfile))) | |
| self.segList.SetStringItem(index, 3, mbtFct(segment.start, 1)) | |
| self.segList.SetStringItem(index, 4, mbtFct(segment.end, 1)) | |
| self.segList.SetStringItem(index, 5, StrNoneChk(segment.quantize)) | |
| self.segList.SetStringItem(index, 6, StrNoneChk(segment.transpose)) | |
| self.segList.SetStringItem(index, 7, StrNoneChk(segment.repeat)) | |
| self.segList.SetStringItem(index, 8, StrNoneChk(segment.mute_flags)) | |
| self.segList.SetItemData(index, index) | |
| listDataMap.append((getColumnText(self.segList, index, 0).upper(), getColumnText(self.segList, index, 1).upper(), getColumnText(self.segList, index, 2).upper(), MbtVal(getColumnText(self.segList, index, 3)), MbtVal(getColumnText(self.segList, index, 4)), int(getColumnText(self.segList, index, 5)), int(getColumnText(self.segList, index, 6)), int(getColumnText(self.segList, index, 7)), int(getColumnText(self.segList, index, 8)))) | |
| self.segList.itemDataMap = listDataMap | |
| self.segList.InitSorting(9) | |
| self.graph.ClearGraph() | |
| def LoadEventsForSeg(self, segName): | |
| """ Loads up the events associated with a segment """ | |
| self.currentEventIndex = None | |
| self.eventList.DeleteAllItems() | |
| self.menuItems[JetDefs.MNU_UPDATE_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_DELETE_EVENT].Enable(False) | |
| self.menuItems[JetDefs.MNU_MOVE_EVENT].Enable(False) | |
| self.eventlistSort = (IniGetValue(self.currentJetConfigFile, JetDefs.INI_EVENTSORT, JetDefs.INI_EVENTSORT_0, 'int', 0), IniGetValue(self.currentJetConfigFile, JetDefs.INI_EVENTSORT, JetDefs.INI_EVENTSORT_1, 'int', 1)) | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment is not None: | |
| if self.eventlistSort[0] == 0: | |
| self.EventSort(segment.jetevents, "event_name") | |
| elif self.eventlistSort[0] == 1: | |
| self.EventSort(segment.jetevents, "event_type") | |
| elif self.eventlistSort[0] == 2: | |
| self.EventSort(segment.jetevents, "event_start") | |
| elif self.eventlistSort[0] == 3: | |
| self.EventSort(segment.jetevents, "event_end") | |
| elif self.eventlistSort[0] == 4: | |
| self.EventSort(segment.jetevents, "track_num") | |
| elif self.eventlistSort[0] == 5: | |
| self.EventSort(segment.jetevents, "channel_num") | |
| elif self.eventlistSort[0] == 6: | |
| self.EventSort(segment.jetevents, "event_id") | |
| listDataMap = [] | |
| for jet_event in self.jet_file.GetEvents(segName): | |
| index = self.eventList.InsertStringItem(sys.maxint, StrNoneChk(jet_event.event_name)) | |
| self.eventList.SetStringItem(index, 1, StrNoneChk(jet_event.event_type)) | |
| self.eventList.SetStringItem(index, 2, mbtFct(jet_event.event_start, 1)) | |
| self.eventList.SetStringItem(index, 3, mbtFct(jet_event.event_end, 1)) | |
| self.eventList.SetStringItem(index, 4, StrNoneChk(jet_event.track_num)) | |
| self.eventList.SetStringItem(index, 5, StrNoneChk(jet_event.channel_num + 1)) | |
| self.eventList.SetStringItem(index, 6, StrNoneChk(jet_event.event_id)) | |
| self.eventList.SetItemData(index, index) | |
| listDataMap.append((getColumnText(self.eventList, index, 0).upper(), getColumnText(self.eventList, index, 1).upper(), MbtVal(getColumnText(self.eventList, index, 2)), MbtVal(getColumnText(self.eventList, index, 3)), int(getColumnText(self.eventList, index, 4)), int(getColumnText(self.eventList, index, 5)), int(getColumnText(self.eventList, index, 6)))) | |
| self.eventList.itemDataMap = listDataMap | |
| self.eventList.InitSorting(7) | |
| def OnEventListClick(self, event): | |
| """ Sets the current event variable when selecting from the list """ | |
| self.currentCtrl = "eventList" | |
| self.currentEventIndex = event.m_itemIndex | |
| self.currentEventName = getColumnText(self.eventList, event.m_itemIndex, 0) | |
| self.menuItems[JetDefs.MNU_UPDATE_EVENT].Enable(True) | |
| self.menuItems[JetDefs.MNU_DELETE_EVENT].Enable(True) | |
| self.menuItems[JetDefs.MNU_MOVE_EVENT].Enable(True) | |
| def OnSegmentChecked(self, index, checked): | |
| """ Selects the segment when checkbox clicked """ | |
| ClearRowSelections(self.segList) | |
| SetRowSelection(self.segList, index, True) | |
| def SelectSegment(self, segName): | |
| """ Selects a segment by segment name """ | |
| itm = self.segList.FindItem(-1, segName) | |
| self.segList.EnsureVisible(itm) | |
| ClearRowSelections(self.segList) | |
| SetRowSelection(self.segList, itm, True) | |
| def SelectEvent(self, eventName): | |
| """ Selects an event by event name """ | |
| itm = self.eventList.FindItem(-1, eventName) | |
| self.eventList.EnsureVisible(itm) | |
| ClearRowSelections(self.eventList) | |
| SetRowSelection(self.eventList, itm, True) | |
| def OnSegListClick(self, event): | |
| """ Loads up a segment when the list is clicked """ | |
| self.currentCtrl = "segList" | |
| self.currentSegmentIndex = event.m_itemIndex | |
| self.currentSegmentName = getColumnText(self.segList, event.m_itemIndex, 0) | |
| self.LoadEventsForSeg(getColumnText(self.segList, event.m_itemIndex, 0)) | |
| self.menuItems[JetDefs.MNU_UPDATE_SEG].Enable(True) | |
| self.menuItems[JetDefs.MNU_DELETE_SEG].Enable(True) | |
| self.menuItems[JetDefs.MNU_MOVE_SEG].Enable(True) | |
| self.menuItems[JetDefs.MNU_ADD_EVENT].Enable(True) | |
| info = self.graph.LoadSegment(self.jet_file.GetSegment(self.currentSegmentName), showLabels=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True'), showClips=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True'), showAppEvts=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| if info == None: | |
| self.log.SetValue("") | |
| else: | |
| iLength = info.iLengthInMs | |
| if iLength > 0: | |
| self.log.SetValue("%s %.2f Seconds" % (self.currentSegmentName, iLength / 1000.00)) | |
| else: | |
| self.log.SetValue("%s" % (self.currentSegmentName)) | |
| def OnSegmentAdd(self, event): | |
| """ Calls the dialog box for adding a segment """ | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| dlg = SegEdit(JetDefs.MAIN_ADDSEGTITLE, self.currentJetConfigFile) | |
| for filename in self.jet_file.GetMidiFiles(): | |
| dlg.je.ctrls[JetDefs.F_MIDIFILE].Append(filename) | |
| for library in self.jet_file.GetLibraries(): | |
| dlg.je.ctrls[JetDefs.F_DLSFILE].Append(library) | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| if len(dlg.lstReplicate) > 0: | |
| if dlg.chkReplaceMatching: | |
| self.jet_file.DeleteSegmentsMatchingPrefix(dlg.replicatePrefix) | |
| for replicate in dlg.lstReplicate: | |
| self.jet_file.AddSegment(replicate[0], dlg.GetValue(JetDefs.F_MIDIFILE), | |
| mbtFct(replicate[1],-1), mbtFct(replicate[2],-1), | |
| JetDefs.MBT_ZEROSTR, | |
| SegmentOutputFile(dlg.GetValue(JetDefs.F_SEGNAME), self.currentJetConfigFile), | |
| dlg.GetValue(JetDefs.F_QUANTIZE), | |
| [], dlg.GetValue(JetDefs.F_DLSFILE), | |
| None, | |
| dlg.GetValue(JetDefs.F_TRANSPOSE), | |
| dlg.GetValue(JetDefs.F_REPEAT), | |
| dlg.GetValue(JetDefs.F_MUTEFLAGS)) | |
| self.LoadSegList() | |
| self.SelectSegment(dlg.lstReplicate[0][0]) | |
| else: | |
| self.jet_file.AddSegment(dlg.GetValue(JetDefs.F_SEGNAME), dlg.GetValue(JetDefs.F_MIDIFILE), | |
| dlg.GetValue(JetDefs.F_START), dlg.GetValue(JetDefs.F_END), | |
| JetDefs.MBT_ZEROSTR, | |
| SegmentOutputFile(dlg.GetValue(JetDefs.F_SEGNAME), self.currentJetConfigFile), | |
| dlg.GetValue(JetDefs.F_QUANTIZE), | |
| [], dlg.GetValue(JetDefs.F_DLSFILE), | |
| None, | |
| dlg.GetValue(JetDefs.F_TRANSPOSE), | |
| dlg.GetValue(JetDefs.F_REPEAT), | |
| dlg.GetValue(JetDefs.F_MUTEFLAGS)) | |
| self.LoadSegList() | |
| self.SelectSegment(dlg.GetValue(JetDefs.F_SEGNAME)) | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def OnSegmentUpdate(self, event): | |
| """ Calls the dialog box for updating a segment """ | |
| if self.currentSegmentName is None: | |
| return | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| dlg = SegEdit(JetDefs.MAIN_REVSEGTITLE, self.currentJetConfigFile) | |
| for filename in self.jet_file.GetMidiFiles(): | |
| dlg.je.ctrls[JetDefs.F_MIDIFILE].Append(filename) | |
| for library in self.jet_file.GetLibraries(): | |
| dlg.je.ctrls[JetDefs.F_DLSFILE].Append(library) | |
| dlg.SetValue(JetDefs.F_SEGNAME, segment.segname) | |
| dlg.SetValue(JetDefs.F_MUTEFLAGS, segment.mute_flags) | |
| dlg.SetValue(JetDefs.F_MIDIFILE, segment.filename) | |
| dlg.SetValue(JetDefs.F_DLSFILE, segment.dlsfile) | |
| dlg.SetValue(JetDefs.F_START, segment.start) | |
| dlg.SetValue(JetDefs.F_END, segment.end) | |
| dlg.SetValue(JetDefs.F_QUANTIZE, segment.quantize) | |
| dlg.SetValue(JetDefs.F_TRANSPOSE, segment.transpose) | |
| dlg.SetValue(JetDefs.F_REPEAT, segment.repeat) | |
| dlg.jetevents = segment.jetevents | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| self.jet_file.UpdateSegment(self.currentSegmentName, dlg.GetValue(JetDefs.F_SEGNAME), | |
| dlg.GetValue(JetDefs.F_MIDIFILE), | |
| dlg.GetValue(JetDefs.F_START), dlg.GetValue(JetDefs.F_END), | |
| JetDefs.MBT_ZEROSTR, #dlg.GetValue(JetDefs.F_LENGTH), | |
| SegmentOutputFile(dlg.GetValue(JetDefs.F_SEGNAME), self.currentJetConfigFile), | |
| dlg.GetValue(JetDefs.F_QUANTIZE), | |
| [], dlg.GetValue(JetDefs.F_DLSFILE), | |
| None, | |
| dlg.GetValue(JetDefs.F_TRANSPOSE), | |
| dlg.GetValue(JetDefs.F_REPEAT), | |
| dlg.GetValue(JetDefs.F_MUTEFLAGS)) | |
| if len(dlg.lstReplicate) > 0: | |
| if dlg.chkReplaceMatching: | |
| self.jet_file.DeleteSegmentsMatchingPrefix(dlg.replicatePrefix) | |
| for replicate in dlg.lstReplicate: | |
| self.jet_file.AddSegment(replicate[0], dlg.GetValue(JetDefs.F_MIDIFILE), | |
| mbtFct(replicate[1],-1), mbtFct(replicate[2],-1), | |
| JetDefs.MBT_ZEROSTR, | |
| SegmentOutputFile(dlg.GetValue(JetDefs.F_SEGNAME), self.currentJetConfigFile), | |
| dlg.GetValue(JetDefs.F_QUANTIZE), | |
| [], dlg.GetValue(JetDefs.F_DLSFILE), | |
| None, | |
| dlg.GetValue(JetDefs.F_TRANSPOSE), | |
| dlg.GetValue(JetDefs.F_REPEAT), | |
| dlg.GetValue(JetDefs.F_MUTEFLAGS)) | |
| self.LoadSegList() | |
| self.SelectSegment(dlg.lstReplicate[0][0]) | |
| else: | |
| self.LoadSegList() | |
| self.SelectSegment(dlg.GetValue(JetDefs.F_SEGNAME)) | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def OnSegmentDelete(self, event): | |
| """ Confirms the deletion segment(s) by user action """ | |
| if self.currentSegmentName is None: | |
| return | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return | |
| count = 0 | |
| deleteMsg = '' | |
| item = self.segList.GetFirstSelected() | |
| while item != -1: | |
| if count == 0: | |
| deleteMsg = getColumnText(self.segList,item,0) | |
| else: | |
| if count == 40: | |
| deleteMsg = deleteMsg + "\n" + "....more" | |
| elif count < 40: | |
| deleteMsg = deleteMsg + "\n" + getColumnText(self.segList,item,0) | |
| count = count + 1 | |
| item = self.segList.GetNextSelected(item) | |
| if YesNo(JetDefs.MAIN_CONFIRM, deleteMsg + JetDefs.MAIN_CONFIRM_SEG_DLT, False): | |
| item = self.segList.GetFirstSelected() | |
| while item != -1: | |
| segName = getColumnText(self.segList,item,0) | |
| self.SegmentDelete(segName) | |
| item = self.segList.GetNextSelected(item) | |
| self.graph.ClearGraph() | |
| self.LoadSegList() | |
| def SegmentDelete(self, segName): | |
| """ Deletes a segment """ | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| self.jet_file.DeleteSegment(segName) | |
| self.UndoAdd(saveState) | |
| def OnSegmentsMove(self, event): | |
| """ Move segment(s) """ | |
| if self.currentSegmentName is None: | |
| return | |
| lstMoveItems = [] | |
| count = 0 | |
| item = self.segList.GetFirstSelected() | |
| while item != -1: | |
| max = GetMidiInfo(self.jet_file.GetSegment(getColumnText(self.segList,item,0)).filename).endMbtStr | |
| lstMoveItems.append((getColumnText(self.segList,item,0), mbtFct(getColumnText(self.segList,item,3),-1), mbtFct(getColumnText(self.segList,item,4),-1), max)) | |
| count = count + 1 | |
| item = self.segList.GetNextSelected(item) | |
| if count == 0: | |
| InfoMsg("Move", "Select one or more items to move.") | |
| return | |
| dlg = JetMove("Move Segments") | |
| dlg.lstMoveItems = lstMoveItems | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| if len(dlg.lstMoveMbt) > 0: | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| for moveitem in dlg.lstMoveMbt: | |
| self.jet_file.MoveSegment(moveitem[0], moveitem[1], moveitem[2]) | |
| self.LoadSegList() | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def UndoAdd(self, saveState): | |
| """ Adds the current state to the undo stack """ | |
| self.UndoStack.append(saveState) | |
| self.menuItems[JetDefs.MNU_UNDO].Enable(True) | |
| def RedoAdd(self, saveState): | |
| """ Adds the current state the the redo stack """ | |
| self.RedoStack.append(saveState) | |
| self.menuItems[JetDefs.MNU_REDO].Enable(True) | |
| def OnRedo(self, event): | |
| """ Redo if there's one in the stack """ | |
| if len(self.RedoStack) > 0: | |
| self.UndoAdd(JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex)) | |
| state = self.RedoStack.pop() | |
| self.jet_file = copy.deepcopy(state.jet_file) | |
| self.LoadSegList() | |
| self.currentSegmentIndex = state.currentSegmentIndex | |
| if self.currentSegmentIndex != None: | |
| SetRowSelection(self.segList, self.currentSegmentIndex, True) | |
| if len(self.RedoStack) == 0: | |
| self.menuItems[JetDefs.MNU_REDO].Enable(False) | |
| def OnUndo(self, event): | |
| """ Undo if there's one in the stack """ | |
| if len(self.UndoStack) > 0: | |
| self.RedoAdd(JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex)) | |
| state = self.UndoStack.pop() | |
| self.jet_file = copy.deepcopy(state.jet_file) | |
| self.LoadSegList() | |
| self.currentSegmentIndex = state.currentSegmentIndex | |
| if self.currentSegmentIndex != None: | |
| SetRowSelection(self.segList, self.currentSegmentIndex, True) | |
| if len(self.UndoStack) == 0: | |
| self.menuItems[JetDefs.MNU_UNDO].Enable(False) | |
| def OnEventAdd(self, event): | |
| """ Calls a dialog box to add an event to the current segment """ | |
| if self.currentSegmentName is None: | |
| return | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| dlg = EventEdit(JetDefs.MAIN_ADDEVENTTITLE, self.currentJetConfigFile) | |
| editSegment = copy.deepcopy(segment) | |
| dlg.SetSegment(editSegment) | |
| dlg.SetEventId() | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| if dlg.GetValue(JetDefs.F_ETYPE) == JetDefs.E_EOS: | |
| #check for an existing EOS event | |
| events = self.jet_file.GetEvents(self.currentSegmentName) | |
| for evt in events: | |
| if evt.event_type == JetDefs.E_EOS: | |
| self.jet_file.DeleteEvent(self.currentSegmentName, evt.event_name) | |
| dlg.SetValue(JetDefs.F_ESTART, dlg.GetValue(JetDefs.F_EEND)) | |
| if len(dlg.lstReplicate) > 0: | |
| if dlg.chkReplaceMatching: | |
| self.jet_file.DeleteEventsMatchingPrefix(self.currentSegmentName, dlg.replicatePrefix) | |
| for replicate in dlg.lstReplicate: | |
| self.jet_file.AddEvent(self.currentSegmentName, replicate[0], | |
| dlg.GetValue(JetDefs.F_ETYPE), | |
| dlg.GetValue(JetDefs.F_EEVENTID), | |
| dlg.GetValue(JetDefs.F_ETRACK), | |
| dlg.GetValue(JetDefs.F_ECHANNEL), | |
| mbtFct(replicate[1],-1), | |
| mbtFct(replicate[2],-1)) | |
| self.SelectSegment(self.currentSegmentName) | |
| self.SelectEvent(dlg.lstReplicate[0][0]) | |
| else: | |
| self.jet_file.AddEvent(self.currentSegmentName, dlg.GetValue(JetDefs.F_ENAME), | |
| dlg.GetValue(JetDefs.F_ETYPE), | |
| dlg.GetValue(JetDefs.F_EEVENTID), | |
| dlg.GetValue(JetDefs.F_ETRACK), | |
| dlg.GetValue(JetDefs.F_ECHANNEL), | |
| dlg.GetValue(JetDefs.F_ESTART), | |
| dlg.GetValue(JetDefs.F_EEND)) | |
| self.SelectSegment(self.currentSegmentName) | |
| self.SelectEvent(dlg.GetValue(JetDefs.F_ENAME)) | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def OnEventUpdate(self, event): | |
| """ Calls the dialog box to update the current event """ | |
| if self.currentSegmentName is None: | |
| return | |
| if self.currentEventName is None: | |
| return | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return | |
| curEvent = copy.deepcopy(self.jet_file.GetEvent(self.currentSegmentName, self.currentEventName)) | |
| if curEvent == None: | |
| return | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| #only want the event we are editing to show up in graph | |
| editSegment = copy.deepcopy(segment) | |
| editSegment.jetevents = [] | |
| editSegment.jetevents.append(curEvent) | |
| dlg = EventEdit(JetDefs.MAIN_REVEVENTTITLE, self.currentJetConfigFile) | |
| dlg.SetSegment(editSegment) | |
| dlg.SetValue(JetDefs.F_ENAME, curEvent.event_name) | |
| dlg.SetValue(JetDefs.F_ETYPE, curEvent.event_type) | |
| dlg.SetValue(JetDefs.F_ESTART, curEvent.event_start) | |
| dlg.SetValue(JetDefs.F_EEND, curEvent.event_end) | |
| dlg.SetValue(JetDefs.F_ETRACK, curEvent.track_num) | |
| dlg.SetValue(JetDefs.F_ECHANNEL, curEvent.channel_num) | |
| dlg.SetValue(JetDefs.F_EEVENTID, curEvent.event_id) | |
| dlg.OnEventSelect() | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| if dlg.GetValue(JetDefs.F_ETYPE) == JetDefs.E_EOS: | |
| dlg.SetValue(JetDefs.F_ESTART, dlg.GetValue(JetDefs.F_EEND)) | |
| self.jet_file.UpdateEvent(self.currentSegmentName, | |
| self.currentEventName, | |
| dlg.GetValue(JetDefs.F_ENAME), | |
| dlg.GetValue(JetDefs.F_ETYPE), | |
| dlg.GetValue(JetDefs.F_EEVENTID), | |
| dlg.GetValue(JetDefs.F_ETRACK), | |
| dlg.GetValue(JetDefs.F_ECHANNEL), | |
| dlg.GetValue(JetDefs.F_ESTART), | |
| dlg.GetValue(JetDefs.F_EEND)) | |
| if len(dlg.lstReplicate) > 0: | |
| if dlg.chkReplaceMatching: | |
| self.jet_file.DeleteEventsMatchingPrefix(self.currentSegmentName, dlg.replicatePrefix) | |
| for replicate in dlg.lstReplicate: | |
| self.jet_file.AddEvent(self.currentSegmentName, replicate[0], | |
| dlg.GetValue(JetDefs.F_ETYPE), | |
| dlg.GetValue(JetDefs.F_EEVENTID), | |
| dlg.GetValue(JetDefs.F_ETRACK), | |
| dlg.GetValue(JetDefs.F_ECHANNEL), | |
| mbtFct(replicate[1],-1), | |
| mbtFct(replicate[2],-1)) | |
| self.SelectSegment(self.currentSegmentName) | |
| self.SelectEvent(dlg.lstReplicate[0][0]) | |
| else: | |
| self.SelectSegment(self.currentSegmentName) | |
| self.SelectEvent(dlg.GetValue(JetDefs.F_ENAME)) | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def OnEventDelete(self, event): | |
| """ Confirms the deletion of event(s) """ | |
| if self.currentSegmentName is None: | |
| return | |
| if self.currentEventName is None: | |
| return | |
| curEvent = self.jet_file.GetEvent(self.currentSegmentName, self.currentEventName) | |
| if curEvent == None: | |
| return | |
| count = 0 | |
| deleteMsg = '' | |
| item = self.eventList.GetFirstSelected() | |
| while item != -1: | |
| if count == 0: | |
| deleteMsg = getColumnText(self.eventList,item,0) | |
| else: | |
| if count == 40: | |
| deleteMsg = deleteMsg + "\n" + "....more" | |
| elif count < 40: | |
| deleteMsg = deleteMsg + "\n" + getColumnText(self.eventList,item,0) | |
| count = count + 1 | |
| item = self.eventList.GetNextSelected(item) | |
| if YesNo(JetDefs.MAIN_CONFIRM, deleteMsg + JetDefs.MAIN_CONRIRM_EVT_DLT, False): | |
| item = self.eventList.GetFirstSelected() | |
| while item != -1: | |
| eventName = getColumnText(self.eventList,item,0) | |
| self.EventDelete(eventName) | |
| item = self.eventList.GetNextSelected(item) | |
| self.SelectSegment(self.currentSegmentName) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| def EventDelete(self, eventName): | |
| """ Deletes an event """ | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| self.jet_file.DeleteEvent(self.currentSegmentName, eventName) | |
| self.UndoAdd(saveState) | |
| def OnEventsMove(self, event): | |
| """ Move event(s) """ | |
| if self.currentSegmentName is None: | |
| return | |
| if self.currentEventName is None: | |
| return | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return | |
| curEvent = self.jet_file.GetEvent(self.currentSegmentName, self.currentEventName) | |
| if curEvent == None: | |
| return | |
| lstMoveItems = [] | |
| count = 0 | |
| item = self.eventList.GetFirstSelected() | |
| while item != -1: | |
| lstMoveItems.append((getColumnText(self.eventList,item,0), mbtFct(getColumnText(self.eventList,item,2),-1), mbtFct(getColumnText(self.eventList,item,3),-1), segment.end)) | |
| count = count + 1 | |
| item = self.eventList.GetNextSelected(item) | |
| if count == 0: | |
| InfoMsg("Move", "Select one or more items to move.") | |
| return | |
| dlg = JetMove("Move Events") | |
| dlg.lstMoveItems = lstMoveItems | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| if len(dlg.lstMoveMbt) > 0: | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| for moveitem in dlg.lstMoveMbt: | |
| self.jet_file.MoveEvent(self.currentSegmentName, moveitem[0], moveitem[1], moveitem[2]) | |
| self.SelectSegment(self.currentSegmentName) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| self.UndoAdd(saveState) | |
| dlg.Destroy() | |
| def OnJetOpen(self, event): | |
| """ Calls a dialog box to get a jet config file to open """ | |
| dlg = JetOpen() | |
| result = dlg.ShowModal() | |
| if result == JetDefs.ID_JET_OPEN: | |
| self.jet_file = JetFile(dlg.fileName , "") | |
| if not ValidateConfig(self.jet_file): | |
| FileKillClean(JetDefs.UNTITLED_FILE) | |
| self.currentJetConfigFile = JetDefs.UNTITLED_FILE | |
| self.jet_file = JetFile(self.currentJetConfigFile, "") | |
| else: | |
| self.SetCurrentFile(dlg.fileName) | |
| elif result == JetDefs.ID_JET_NEW: | |
| self.jet_file = JetFile("" , "") | |
| self.SetCurrentFile(JetDefs.UNTITLED_FILE) | |
| self.LoadDefaultProperties() | |
| elif result == JetDefs.ID_JET_IMPORT: | |
| self.OnJetImportArchive(event) | |
| dlg.Destroy() | |
| def OnJetSaveAs(self, event): | |
| """ Calls a dialog box to allow saving the current jet file as another name """ | |
| defDir = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.JTC_FILE_SPEC, 'str', str(os.getcwd())) | |
| dialog = wx.FileDialog(None, JetDefs.SAVE_PROMPT, defDir, "", JetDefs.JTC_FILE_SPEC, wx.SAVE | wx.OVERWRITE_PROMPT ) | |
| if dialog.ShowModal() == wx.ID_OK: | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.JTC_FILE_SPEC, str(FileJustPath(dialog.GetPath()))) | |
| self.currentJetConfigFile = FileJustRoot(dialog.GetPath()) + ".jtc" | |
| self.jet_file.config.filename = FileJustRoot(self.currentJetConfigFile) + ".jet" | |
| self.jet_file.SaveJetConfig(self.currentJetConfigFile) | |
| self.jet_file.WriteJetFileFromConfig(self.currentJetConfigFile) | |
| self.SetCurrentFile(self.currentJetConfigFile) | |
| dialog.Destroy() | |
| def OnJetSave(self, event): | |
| """ Saves the current jet file to disk """ | |
| if self.currentJetConfigFile == JetDefs.UNTITLED_FILE: | |
| self.OnJetSaveAs(event) | |
| else: | |
| self.jet_file.SaveJetConfig(self.currentJetConfigFile) | |
| self.jet_file.WriteJetFileFromConfig(self.currentJetConfigFile) | |
| def OnJetNew(self, event): | |
| """ Initializes the state to a new jet file """ | |
| self.jet_file = JetFile("" , "") | |
| self.SetCurrentFile(JetDefs.UNTITLED_FILE) | |
| self.LoadDefaultProperties() | |
| def SetCurrentFile(self, fileName): | |
| """ Sets the state for the current jet file """ | |
| self.clipBoard = None | |
| self.currentJetConfigFile = fileName | |
| self.SetTitle(JetDefs.MAIN_TITLEPREFIX + FileJustName(fileName)) | |
| AppendRecentJetFile(fileName) | |
| self.LoadSegList() | |
| self.graph.ClearGraph() | |
| self.chkGraphLabels.SetValue(IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True')) | |
| self.chkGraphClips.SetValue(IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True')) | |
| self.chkGraphAppEvts.SetValue(IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| def createMenuBar(self): | |
| """ Creates a menu bar """ | |
| self.menuItems = {} | |
| menuBar = wx.MenuBar() | |
| for eachMenuData in JetDefs.MENU_SPEC: | |
| menuLabel = eachMenuData[0] | |
| menuItems = eachMenuData[1:] | |
| menuBar.Append(self.createMenu(menuItems), menuLabel) | |
| self.SetMenuBar(menuBar) | |
| def createMenu(self, menuData): | |
| """ Creates a menu from the structure menuData in JetDefs """ | |
| menu = wx.Menu() | |
| for eachLabel, eachStatus, eachHandler, eachEnable in menuData: | |
| if not eachLabel: | |
| menu.AppendSeparator() | |
| continue | |
| self.menuItems[eachLabel] = menu.Append(-1, eachLabel, eachStatus) | |
| self.menuItems[eachLabel].Enable(eachEnable) | |
| try: | |
| self.Bind(wx.EVT_MENU, getattr(self, eachHandler) , self.menuItems[eachLabel]) | |
| except: | |
| print("def " + eachHandler + "(self, event): pass") | |
| return menu | |
| def createToolbar(self): | |
| """ Creates the toolbar """ | |
| toolbar = self.CreateToolBar() | |
| toolbar.SetToolBitmapSize((32,32)) | |
| self.toolItems = {} | |
| for eachTool in JetDefs.TOOLBAR_SPEC: | |
| if eachTool[0] == '-': | |
| toolbar.AddSeparator() | |
| else: | |
| b = __import__(eachTool[1]) | |
| bitMap = b.getBitmap() | |
| self.toolItems[eachTool[0]] = toolbar.AddLabelTool(-1, label=eachTool[0], | |
| bitmap=bitMap, | |
| shortHelp=eachTool[0], longHelp=eachTool[2]) | |
| self.Bind(wx.EVT_TOOL, getattr(self, eachTool[3]) , self.toolItems[eachTool[0]]) | |
| toolbar.Realize() | |
| def OnAudition(self, event): | |
| """ Calls the audition window for simple preview of jet file """ | |
| jet_file = CreateTempJetFile(self.jet_file) | |
| w, h = self.GetSize() | |
| w = w - 50 | |
| if w < 900: | |
| w = 900 | |
| h = h - 50 | |
| if h < 650: | |
| h = 650 | |
| dlg = Audition(jet_file, (w,h)) | |
| dlg.ShowModal() | |
| CleanupTempJetFile(jet_file) | |
| def SetKeepPlayingFlag(self, val): | |
| """ Sets a flag to communicate playing state to the play thread """ | |
| with self.playerLock: | |
| self.keepPlaying = val | |
| def GetKeepPlayingFlag(self): | |
| """ Gets the playing state flag """ | |
| with self.playerLock: | |
| return self.keepPlaying | |
| def GraphTriggerClip(self, sClipName, iEventId): | |
| """ Triggers a clip when they click on the graph """ | |
| with self.playerLock: | |
| try: | |
| self.jet.TriggerClip(iEventId) | |
| self.log.SetValue(JetDefs.PLAY_TRIGGERCLIP_MSG % (iEventId, sClipName)) | |
| return True | |
| except: | |
| return False | |
| def OnHelpJet(self, event): | |
| """ Loads the jet help file """ | |
| import webbrowser | |
| webbrowser.open(JetDefs.MAIN_HELPFILE) | |
| return | |
| def OnHelpJetGuidelines(self, event): | |
| """ Loads the authoring guidelines file """ | |
| import webbrowser | |
| webbrowser.open(JetDefs.MAIN_HELPGUIDELINESFILE) | |
| return | |
| def OnAbout(self, event): | |
| """ Loads the about dialog box """ | |
| dlg = JetAbout() | |
| result = dlg.ShowModal() | |
| dlg.Destroy() | |
| def OnJetImportArchive(self, event): | |
| """ Imports a jet archive file """ | |
| defDir = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC, 'str', str(os.getcwd())) | |
| dialog = wx.FileDialog(None, JetDefs.IMPORT_ARCHIVE_PROMPT, defDir, "", JetDefs.ARCHIVE_FILE_SPEC, wx.OPEN) | |
| if dialog.ShowModal() == wx.ID_OK: | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC, str(FileJustPath(dialog.GetPath()))) | |
| defDir = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC + "Dir", 'str', str(os.getcwd())) | |
| dlg1 = wx.DirDialog(self, JetDefs.IMPORT_ARCHIVEDIR_PROMPT, style=wx.DD_DEFAULT_STYLE, defaultPath=defDir) | |
| if dlg1.ShowModal() == wx.ID_OK: | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC + "Dir", str(FileJustPath(dlg1.GetPath()))) | |
| if YesNo(JetDefs.MAIN_IMPORTTITLE, JetDefs.MAIN_IMPORTMSG % (dialog.GetPath(),dlg1.GetPath()), False): | |
| projectPath = dlg1.GetPath() | |
| zipFile = dialog.GetPath() | |
| z = __import__('zipfile') | |
| if not z.is_zipfile(zipFile): | |
| wx.MessageBox(JetDefs.IMPORT_ARCHIVE_NO_JTC) | |
| else: | |
| zip = z.ZipFile(zipFile, 'r') | |
| jtcFile = "" | |
| fileList = zip.namelist() | |
| isArchive = False | |
| for myFile in fileList: | |
| if myFile == 'JetArchive': | |
| isArchive = True | |
| break | |
| if not isArchive: | |
| wx.MessageBox(JetDefs.IMPORT_NOT_JET_ARCHIVE) | |
| else: | |
| for myFile in fileList: | |
| if FileJustExt(myFile) == '.JTC': | |
| jtcFile = myFile | |
| break | |
| if jtcFile == "": | |
| wx.MessageBox(JetDefs.IMPORT_ARCHIVE_NO_JTC) | |
| else: | |
| for name in zip.namelist(): | |
| ext = FileJustExt(name) | |
| if ext == '.MID' or ext == '.DLS' or ext == '.JET': | |
| file(FileFixPath(projectPath + "/" + name), 'wb').write(zip.read(name)) | |
| else: | |
| if len(ext) > 0 and ext != '.DS_STORE': | |
| file(FileFixPath(projectPath + "/" + name), 'w').write(zip.read(name)) | |
| zip.close() | |
| self.currentJetConfigFile = FileFixPath(projectPath + "/") + jtcFile | |
| self.jet_file = JetFile(self.currentJetConfigFile, "") | |
| #fix paths | |
| self.jet_file.config.filename = FileJustRoot(self.currentJetConfigFile) + ".JET" | |
| for index, segment in enumerate(self.jet_file.segments): | |
| self.jet_file.segments[index].filename = FileFixPath(projectPath + "/" + segment.filename) | |
| if segment.dlsfile > "": | |
| self.jet_file.segments[index].dlsfile = FileFixPath(projectPath + "/" + segment.dlsfile) | |
| self.jet_file.segments[index].output = FileFixPath(projectPath + "/" + segment.output) | |
| for index, library in enumerate(self.jet_file.libraries): | |
| self.jet_file.libraries[index] = FileFixPath(projectPath + "/" + library) | |
| if ValidateConfig(self.jet_file): | |
| self.jet_file.SaveJetConfig(self.currentJetConfigFile) | |
| self.jet_file.WriteJetFileFromConfig(self.currentJetConfigFile) | |
| self.jet_file = JetFile(self.currentJetConfigFile , "") | |
| self.SetCurrentFile(self.currentJetConfigFile) | |
| dlg1.Destroy() | |
| dialog.Destroy() | |
| def OnJetExportArchive(self, event): | |
| """ Exports the current setup to an archive file """ | |
| self.OnJetSave(event) | |
| defDir = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC, 'str', str(os.getcwd())) | |
| dialog = wx.FileDialog(None, JetDefs.EXPORT_ARCHIVE_PROMPT, defDir, "", JetDefs.ARCHIVE_FILE_SPEC, wx.SAVE | wx.OVERWRITE_PROMPT ) | |
| if dialog.ShowModal() == wx.ID_OK: | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_DEFAULTDIRS, JetDefs.ARCHIVE_FILE_SPEC, str(FileJustPath(dialog.GetPath()))) | |
| ExportJetArchive(FileJustRoot(dialog.GetPath()) + ".zip", self.currentJetConfigFile, self.jet_file) | |
| dialog.Destroy() | |
| def OnCopy(self, event): | |
| """ Copies the current segment or event to the clipboard """ | |
| if self.currentCtrl == JetDefs.MAIN_SEGLIST: | |
| if self.currentSegmentName is None: | |
| return "" | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return "" | |
| self.clipBoard = JetCutCopy(self.currentCtrl, segment, self.currentSegmentName) | |
| return self.currentCtrl | |
| elif self.currentCtrl == JetDefs.MAIN_EVENTLIST: | |
| if self.currentSegmentName is None: | |
| return "" | |
| if self.currentEventName is None: | |
| return "" | |
| segment = self.jet_file.GetSegment(self.currentSegmentName) | |
| if segment == None: | |
| return "" | |
| curEvent = self.jet_file.GetEvent(self.currentSegmentName, self.currentEventName) | |
| if curEvent == None: | |
| return "" | |
| self.clipBoard = JetCutCopy(self.currentCtrl, curEvent, self.currentSegmentName) | |
| return self.currentCtrl | |
| def OnCut(self, event): | |
| """ Cuts the current segment or event to the clipboard """ | |
| retCopy = self.OnCopy(event) | |
| if retCopy == JetDefs.MAIN_SEGLIST: | |
| self.SegmentDelete(self.currentSegmentName) | |
| self.LoadSegList() | |
| elif retCopy == JetDefs.MAIN_EVENTLIST: | |
| self.EventDelete(self.currentEventName) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| def OnPaste(self, event): | |
| """ Pastes the current segment or event from the clipboard """ | |
| if self.clipBoard is not None: | |
| if self.currentCtrl == JetDefs.MAIN_SEGLIST and self.clipBoard.objType == JetDefs.MAIN_SEGLIST: | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| self.jet_file.segments.append(self.clipBoard.GetObj(self.jet_file.segments)) | |
| self.UndoAdd(saveState) | |
| self.LoadSegList() | |
| elif self.currentCtrl == JetDefs.MAIN_EVENTLIST and self.clipBoard.objType == JetDefs.MAIN_EVENTLIST and self.clipBoard.currentSegmentName == self.currentSegmentName: | |
| for segment in self.jet_file.segments: | |
| if segment.segname == self.currentSegmentName: | |
| saveState = JetState(self.jet_file, self.currentSegmentIndex, self.currentEventIndex) | |
| segment.jetevents.append(self.clipBoard.GetObj(segment.jetevents)) | |
| self.UndoAdd(saveState) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| self.graph.LoadSegment(self.jet_file.GetSegment(self.currentSegmentName), showLabels=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True'), showClips=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True'), showAppEvts=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| def OnJetProperties(self, event): | |
| """ Opens a dialog box for jetfile properties """ | |
| dlg = JetPropertiesDialog() | |
| dlg.SetValue(JetDefs.F_JETFILENAME, self.jet_file.config.filename) | |
| dlg.SetValue(JetDefs.F_COPYRIGHT, StrNoneChk(self.jet_file.config.copyright)) | |
| dlg.SetValue(JetDefs.F_CHASECONTROLLERS, StrNoneChk(self.jet_file.config.chase_controllers)) | |
| dlg.SetValue(JetDefs.F_DELETEEMPTYTRACKS, StrNoneChk(self.jet_file.config.delete_empty_tracks)) | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| self.jet_file.config.filename = dlg.je.ctrls[JetDefs.F_JETFILENAME].GetValue() | |
| self.jet_file.config.copyright = dlg.je.ctrls[JetDefs.F_COPYRIGHT].GetValue() | |
| self.jet_file.config.chase_controllers = dlg.je.ctrls[JetDefs.F_CHASECONTROLLERS].GetValue() | |
| self.jet_file.config.delete_empty_tracks = dlg.je.ctrls[JetDefs.F_DELETEEMPTYTRACKS].GetValue() | |
| dlg.Destroy() | |
| def OnPreferences(self, event): | |
| """ Opens a dialog box to capture preferences and saves them to a configuration file """ | |
| dlg = JetPreferences() | |
| dlg.SetValue(JetDefs.F_COPYRIGHT, IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_COPYRIGHT)) | |
| dlg.SetValue(JetDefs.F_CHASECONTROLLERS, IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_CHASECONTROLLERS, 'bool', True)) | |
| dlg.SetValue(JetDefs.F_DELETEEMPTYTRACKS, IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_DELETEEMPTYTRACKS, 'bool', False)) | |
| result = dlg.ShowModal() | |
| if result == wx.ID_OK: | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_COPYRIGHT, dlg.GetValue(JetDefs.F_COPYRIGHT)) | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_CHASECONTROLLERS, dlg.GetValue(JetDefs.F_CHASECONTROLLERS)) | |
| IniSetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_DELETEEMPTYTRACKS, dlg.GetValue(JetDefs.F_DELETEEMPTYTRACKS)) | |
| dlg.Destroy() | |
| def LoadDefaultProperties(self): | |
| """ Loads default properties from the a configuration file """ | |
| self.jet_file.config.copyright = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_COPYRIGHT) | |
| self.jet_file.config.chase_controllers = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_CHASECONTROLLERS, 'bool', True) | |
| self.jet_file.config.delete_empty_tracks = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_PREF_SECTION, JetDefs.F_DELETEEMPTYTRACKS, 'bool', False) | |
| def OnClose(self, event): | |
| """ Called upon closing the JetCreator main window """ | |
| if self.isDirty(): | |
| ret = YesNoCancel(JetDefs.MAIN_JETCREATOR, JetDefs.MAIN_SAVEBEFOREEXIT, True) | |
| if ret == wx.ID_YES: | |
| self.OnJetSave(None) | |
| if ret == wx.ID_CANCEL: | |
| return | |
| if self.jet is not None: | |
| SafeJetShutdown(self.playerLock, self.jet) | |
| self.Destroy() | |
| def OnPlay(self, event): | |
| """ Plays the currently queued segments """ | |
| if self.btnPlay.GetLabel() == JetDefs.BUT_PLAY: | |
| if not ValidateConfig(self.jet_file): | |
| return | |
| #make sure something is queued | |
| iQueued = False | |
| num = self.segList.GetItemCount() | |
| for seg_num in range(num): | |
| if self.segList.IsChecked(seg_num): | |
| iQueued = True | |
| if not iQueued: | |
| InfoMsg(JetDefs.MAIN_PLAYSEG, JetDefs.MAIN_PLAYSEGMSG) | |
| return | |
| for segment in self.jet_file.segments: | |
| if FileExists(segment.dlsfile): | |
| if not segment.dlsfile in self.jet_file.libraries: | |
| self.jet_file.libraries.append(segment.dlsfile) | |
| self.eventList.DeleteAllItems() | |
| num = self.segList.GetItemCount() | |
| for seg_num in range(num): | |
| if seg_num == 0: self.log.Clear() | |
| if self.segList.IsChecked(seg_num): | |
| segment = self.jet_file.GetSegment(getColumnText(self.segList, seg_num, 0)) | |
| if segment != None: | |
| #so we can determine which segment is playing, make these the same | |
| userID = seg_num | |
| if FileExists(segment.dlsfile): | |
| dls_num = FindDlsNum(self.jet_file.libraries, segment.dlsfile) | |
| else: | |
| dls_num = -1 | |
| self.queueSegs.append(QueueSeg(segment.segname, userID, seg_num, dls_num, segment.repeat, segment.transpose, segment.mute_flags)) | |
| if len(self.queueSegs) == 0: | |
| return | |
| self.btnPlay.SetLabel(JetDefs.BUT_STOP) | |
| thread.start_new_thread(self.PlaySegs, ()) | |
| else: | |
| with self.playerLock: | |
| self.jet.Clear_Queue() | |
| self.SetKeepPlayingFlag(False) | |
| def PlaySegs(self): | |
| """ Thread writes a temporary copy of the jet file, and calls the library to play it """ | |
| if len(self.queueSegs) == 0: | |
| return | |
| jet_file = CreateTempJetFile(self.jet_file) | |
| if not ValidateConfig(jet_file): | |
| CleanupTempJetFile(jet_file) | |
| return | |
| self.jet = JET() | |
| self.jet.eas.StartWave() | |
| self.jet.OpenFile(jet_file.config.filename) | |
| lastID = -1 | |
| # queue first segment and start playback | |
| Queue(self.jet, self.queueSegs[0]) | |
| index = 1 | |
| self.jet.Play() | |
| self.paused = False | |
| # continue playing until all segments are done | |
| self.SetKeepPlayingFlag(True) | |
| while self.GetKeepPlayingFlag(): | |
| self.jet.Render() | |
| status = self.jet.Status() | |
| if status.currentUserID <> lastID and status.currentUserID <> -1: | |
| wx.PostEvent(self, JetStatusEvent(JetDefs.PST_PLAY, status.currentUserID)) | |
| lastID = status.currentUserID | |
| # if no more segments - we're done | |
| if status.numQueuedSegments == 0: | |
| break | |
| self.jet.GetAppEvent() | |
| # if less than 2 segs queued - queue another one | |
| if (index < len(self.queueSegs)) and (status.numQueuedSegments < 2): | |
| Queue(self.jet, self.queueSegs[index]) | |
| index += 1 | |
| wx.PostEvent(self, JetStatusEvent(JetDefs.PST_UPD_LOCATION, status.location)) | |
| SafeJetShutdown(self.playerLock, self.jet) | |
| self.queueSegs = [] | |
| CleanupTempJetFile(jet_file) | |
| wx.PostEvent(self, JetStatusEvent(JetDefs.PST_DONE, None)) | |
| def OnJetStatusUpdate(self, evt): | |
| """ These are screen updates called for from within the thread. Communication | |
| is via a postevent call. | |
| """ | |
| if evt.mode == JetDefs.PST_PLAY: | |
| segName = getColumnText(self.segList, evt.data, 0) | |
| self.LoadEventsForSeg(segName) | |
| self.log.SetValue(segName) | |
| ClearRowSelections(self.segList) | |
| SetRowSelection(self.segList, evt.data, True) | |
| elif evt.mode == JetDefs.PST_UPD_LOCATION: | |
| self.graph.UpdateLocation(evt.data) | |
| elif evt.mode == 3: | |
| self.graph.UpdateLocation(0) | |
| ClearRowSelections(self.segList) | |
| self.eventList.DeleteAllItems() | |
| self.SetKeepPlayingFlag(False) | |
| self.btnPlay.SetLabel(JetDefs.BUT_PLAY) | |
| self.btnPause.SetLabel(JetDefs.BUT_PAUSE) | |
| def OnPause(self, evt): | |
| """ Pauses the playback """ | |
| if self.jet is None: | |
| return | |
| if not self.paused: | |
| self.jet.Pause() | |
| self.paused = True | |
| self.btnPause.SetLabel(JetDefs.BUT_RESUME) | |
| else: | |
| self.jet.Play() | |
| self.paused = False | |
| self.btnPause.SetLabel(JetDefs.BUT_PAUSE) | |
| def isDirty(self): | |
| if len(self.UndoStack) == 0 and len(self.RedoStack) == 0: | |
| return False | |
| else: | |
| return True | |
| def OnSetGraphOptions(self, evt): | |
| """ Sets graph options """ | |
| IniSetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, self.chkGraphLabels.GetValue()) | |
| IniSetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, self.chkGraphClips.GetValue()) | |
| IniSetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, self.chkGraphAppEvts.GetValue()) | |
| self.graph.LoadSegment(self.jet_file.GetSegment(self.currentSegmentName), showLabels=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True'), showClips=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True'), showAppEvts=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| def OnEventSortOrderChanged(self): | |
| """ Called when sort order has changed """ | |
| IniSetValue(self.currentJetConfigFile, JetDefs.INI_EVENTSORT, JetDefs.INI_EVENTSORT_0, self.eventList.GetSortState()[0]) | |
| IniSetValue(self.currentJetConfigFile, JetDefs.INI_EVENTSORT, JetDefs.INI_EVENTSORT_1, self.eventList.GetSortState()[1]) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| self.graph.LoadSegment(self.jet_file.GetSegment(self.currentSegmentName), showLabels=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True'), showClips=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True'), showAppEvts=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| def EventSortCmp(self, a, b): | |
| """ Sorts based on selected sort order """ | |
| if self.eventlistSort[0] == 0 or self.eventlistSort[0] == 1: | |
| if self.eventlistSort[1] == 1: | |
| return cmp(a[0].upper(), b[0].upper()) | |
| else: | |
| return cmp(b[0].upper(), a[0].upper()) | |
| elif self.eventlistSort[0] == 2 or self.eventlistSort[0] == 3: | |
| if self.eventlistSort[1] == 1: | |
| return cmp(MbtVal(a[0]), MbtVal(b[0])) | |
| else: | |
| return cmp(MbtVal(b[0]), MbtVal(a[0])) | |
| else: | |
| return cmp(a[0], b[0]) | |
| def EventSort2(self, seq, attr): | |
| """ Does Sorting """ | |
| intermed = map(None, map(getattr, seq, (attr,)*len(seq)), xrange(len(seq)), seq) | |
| intermed.sort(self.EventSortCmp) | |
| return map(operator.getitem, intermed, (-1,) * len(intermed)) | |
| def EventSort(self, lst, attr): | |
| """ Does Sorting """ | |
| lst[:] = self.EventSort2(lst, attr) | |
| def OnSegSortOrderChanged(self): | |
| """ Called when sort order has changed """ | |
| IniSetValue(self.currentJetConfigFile, JetDefs.INI_SEGSORT, JetDefs.INI_SEGSORT_0, self.segList.GetSortState()[0]) | |
| IniSetValue(self.currentJetConfigFile, JetDefs.INI_SEGSORT, JetDefs.INI_SEGSORT_1, self.segList.GetSortState()[1]) | |
| self.LoadEventsForSeg(self.currentSegmentName) | |
| self.graph.LoadSegment(self.jet_file.GetSegment(self.currentSegmentName), showLabels=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHLABELS, JetDefs.F_GRAPHLABELS, 'bool', 'True'), showClips=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHCLIPS, JetDefs.F_GRAPHCLIPS, 'bool', 'True'), showAppEvts=IniGetValue(self.currentJetConfigFile, JetDefs.F_GRAPHAPPEVTS, JetDefs.F_GRAPHAPPEVTS, 'bool', 'True')) | |
| def SegSortCmp(self, a, b): | |
| """ Sorts based on selected sort order """ | |
| if self.seglistSort[0] == 0: | |
| if self.seglistSort[1] == 1: | |
| return cmp(a[0].upper(), b[0].upper()) | |
| else: | |
| return cmp(b[0].upper(), a[0].upper()) | |
| elif self.seglistSort[0] == 1 or self.seglistSort[0] == 2: | |
| if self.seglistSort[1] == 1: | |
| return cmp(FileJustName(a[0]).upper(), FileJustName(b[0]).upper()) | |
| else: | |
| return cmp(FileJustName(b[0]).upper(), FileJustName(a[0]).upper()) | |
| elif self.seglistSort[0] == 3 or self.seglistSort[0] == 4: | |
| if self.seglistSort[1] == 1: | |
| return cmp(MbtVal(a[0]), MbtVal(b[0])) | |
| else: | |
| return cmp(MbtVal(b[0]), MbtVal(a[0])) | |
| else: | |
| return cmp(a[0], b[0]) | |
| def SegSort2(self, seq, attr): | |
| """ Does Sorting """ | |
| intermed = map(None, map(getattr, seq, (attr,)*len(seq)), xrange(len(seq)), seq) | |
| intermed.sort(self.SegSortCmp) | |
| return map(operator.getitem, intermed, (-1,) * len(intermed)) | |
| def SegSort(self, lst, attr): | |
| """ Does Sorting """ | |
| lst[:] = self.SegSort2(lst, attr) | |
| if __name__ == '__main__': | |
| """ Sets the logging level, then calls the open dialog box before initializing main window""" | |
| logLevel = IniGetValue(JetDefs.JETCREATOR_INI, JetDefs.INI_LOGGING, JetDefs.INI_LOGGING) | |
| if logLevel == 'DEBUG': | |
| logging.basicConfig(level=logging.DEBUG, format='%(funcName)s[%(lineno)d]: %(message)s') | |
| elif logLevel == 'INFO': | |
| logging.basicConfig(level=logging.INFO, format='%(funcName)s[%(lineno)d]: %(message)s') | |
| elif logLevel == 'ERROR': | |
| logging.basicConfig(level=logging.ERROR, format='%(funcName)s[%(lineno)d]: %(message)s') | |
| elif logLevel == 'WARNING': | |
| logging.basicConfig(level=logging.WARNING, format='%(funcName)s[%(lineno)d]: %(message)s') | |
| else: | |
| install_release_loggers() | |
| app = wx.App(None) | |
| if not os.path.isdir(JetDefs.TEMP_JET_DIR): | |
| os.mkdir(JetDefs.TEMP_JET_DIR) | |
| openFile = "" | |
| dlg = JetOpen() | |
| result = dlg.ShowModal() | |
| if result == wx.ID_CANCEL: | |
| dlg.Destroy() | |
| elif result == JetDefs.ID_JET_IMPORT: | |
| dlg.Destroy() | |
| au = JetCreator(None, -1, "", importFlag=True) | |
| app.MainLoop() | |
| else: | |
| openFile = dlg.fileName | |
| dlg.Destroy() | |
| au = JetCreator(None, -1, openFile) | |
| app.MainLoop() | |