""" | |
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() | |