# Copyright Max Kolosov 2009-2013 pyirrlicht@gmail.com
# http://pybass.sf.net
# BSD license

import sys

import pybass
try:
	import pybassmidi
except:
	pybassmidi = None
from io import StringIO

try:
	from exe import wx
except:
	import wx
from wx.lib.ticker import Ticker

def print_error():
	exc, err, traceback = sys.exc_info()
	print('%s %s ERROR ON LINE %d %s\n' % (exc, traceback.tb_frame.f_code.co_filename, traceback.tb_lineno, err))
	del exc, err, traceback

class memory_stream:
	def __init__(self, data, name = 'memory_stream'):
		self.name = name
		self.current_position = 0
		self.data = data
		self.end_position = len(self.data) - 1
		self.decode_length = 0
		self.seconds = 0
	def read(self, size = 1024):
		result = ''
		if self.current_position is not self.end_position and size > 0:
			last_index = self.current_position + size
			if last_index > self.end_position:
				last_index = self.end_position
			result = self.data[self.current_position : last_index]
			self.current_position = last_index
		return result
	def write(self, value = ''):
		self.data += value
	def seek(self, position, whence = 0):
		if whence is 0:
			if position <= self.end_position:
				self.current_position = position
		elif whence is 1:
			if position + self.current_position <= self.end_position:
				self.current_position += position
		elif whence is 2:
			if position < 0:
				position *= -1
			if self.end_position - position > 0:
				self.current_position = self.end_position - position
	def tell(self):
		return self.current_position
	def isatty(self):
		return 1
	def flush(self):
		pass
	def is_eof(self):
		return self.current_position == self.end_position

class slider_ctrl(wx.Slider):
	def __init__(self, *args, **kwargs):
		self.timer_interval = 500
		self.player_ctrl = args[0]
		wx.Slider.__init__(self, *args, **kwargs)
		self.timer = wx.Timer(self)
		self.Bind(wx.EVT_LEFT_DOWN, self.event_left_down)
		self.Bind(wx.EVT_LEFT_UP, self.event_left_up)
		self.Bind(wx.EVT_TIMER, self.event_timer)
	def __del__(self):
		if hasattr(self, 'timer'):
			self.timer.Stop()
	def timer_start(self):
		if not self.timer.IsRunning():
			self.timer.Start(self.timer_interval)
	def timer_stop(self):
		if self.timer.IsRunning():
			self.timer.Stop()
	def event_timer(self, event):
		if self.player_ctrl.method_get_position() < self.player_ctrl.method_get_length() - 1:
			self.SetValue(self.player_ctrl.method_get_position())
		else:
			self.player_ctrl.method_stop_audio()
	def event_left_down(self, event):
		self.timer_stop()
		event.Skip()
	def event_left_up(self, event):
		self.player_ctrl.method_set_position(self.GetValue())
		self.timer_start()
		event.Skip()

class player_ctrl(wx.Panel):
	def __init__(self, *args, **kwargs):

		self.stream = kwargs.pop('stream', None)
		self.name_stream = kwargs.pop('name_stream', 'memory_stream')
		self.bass_handle = 0
		self.sound_font = 0

		result = pybass.BASS_Init(-1, 44100, 0, 0, 0)
		if not result:
			bass_error_code = pybass.BASS_ErrorGetCode()
			if bass_error_code != pybass.BASS_ERROR_ALREADY:
				self.slider.Enable(False)
				self.btn_play.Enable(False)
				self.btn_stop.Enable(False)
				print('BASS_Init error %s' % pybass.get_error_description(bass_error_code))
		self.plugins = {}
		self.plugins['aac'] = (pybass.BASS_PluginLoad(b'bass_aac.dll', 0), '|AAC|*.aac')
		self.plugins['ac3'] = (pybass.BASS_PluginLoad(b'bass_ac3.dll', 0), '|AC3|*.ac3')
		self.plugins['aix'] = (pybass.BASS_PluginLoad(b'bass_aix.dll', 0), '|AIX|*.aix')
		self.plugins['ape'] = (pybass.BASS_PluginLoad(b'bass_ape.dll', 0), '|APE|*.ape')
		self.plugins['mpc'] = (pybass.BASS_PluginLoad(b'bass_mpc.dll', 0), '|MPC|*.mpc')
		self.plugins['ofr'] = (pybass.BASS_PluginLoad(b'bass_ofr.dll', 0), '|OFR|*.ofr')
		self.plugins['spx'] = (pybass.BASS_PluginLoad(b'bass_spx.dll', 0), '|SPX|*.spx')
		self.plugins['tta'] = (pybass.BASS_PluginLoad(b'bass_tta.dll', 0), '|TTA|*.tta')
		self.plugins['cda'] = (pybass.BASS_PluginLoad(b'basscd.dll', 0), '|CDA|*.cda')
		self.plugins['flac'] = (pybass.BASS_PluginLoad(b'bassflac.dll', 0), '|FLAC|*.flac')
		self.plugins['wma'] = (pybass.BASS_PluginLoad(b'basswma.dll', 0), '|WMA, WMV|*.wma;*.wmv')
		if pybassmidi:
			sound_font_file_name = 'CT4MGM.SF2'
			self.sound_font = pybassmidi.BASS_MIDI_FontInit(sound_font_file_name, 0)
			if self.sound_font == 0:
				print('BASS_MIDI_FontInit error %s (sound font file must be %s)' % (pybass.get_error_description(pybass.BASS_ErrorGetCode()), sound_font_file_name))
			else:
				self.plugins['midi'] = (pybass.BASS_PluginLoad('bassmidi.dll', 0), '|MID|*.mid')
		else:
			print('pybassmidi module not accessible')

		wx.Panel.__init__(self, *args, **kwargs)

		sizer_h = wx.BoxSizer(wx.HORIZONTAL)

		self.btn_play = wx.Button(self, wx.ID_ANY, _('Play'), style = wx.NO_BORDER)
		self.btn_play.SetToolTip(_('Play media data'))
		self.Bind(wx.EVT_BUTTON, self.event_play, self.btn_play)
		sizer_h.Add(self.btn_play)

		self.btn_stop = wx.Button(self, wx.ID_ANY, _('Stop'), style = wx.NO_BORDER)
		self.Bind(wx.EVT_BUTTON, self.event_stop, self.btn_stop)
		sizer_h.Add(self.btn_stop)

		self.btn_open = wx.Button(self, wx.ID_OPEN, _('Open'), style = wx.NO_BORDER)
		self.Bind(wx.EVT_BUTTON, self.event_open, self.btn_open)
		sizer_h.Add(self.btn_open)

		sizer_v = wx.BoxSizer(wx.VERTICAL)

		self.status_line = Ticker(self, fgcolor = '#000062', bgcolor = '#7F7F8F', start = False, ppf = 1, fps = 50, direction = 'ltr')
		sizer_v.Add(self.status_line, 0, wx.EXPAND)

		self.slider = slider_ctrl(self, wx.ID_ANY, 0, 0, 1)
		sizer_v.Add(self.slider, 0, wx.EXPAND)

		sizer_v.Add(sizer_h)

		self.SetSizer(sizer_v)
		self.SetAutoLayout(True)

		self.volume_slider = wx.Slider(self, wx.ID_ANY, pybass.BASS_GetVolume() * 100, 0, 100)
		self.Bind(wx.EVT_SCROLL, self.event_volume_slider, self.volume_slider)
		sizer_h.Add(self.volume_slider, 0, wx.EXPAND)

		self.method_check_controls()

	def method_load_file(self):
		import os
		wildcard = 'music sounds (MO3, IT, XM, S3M, MTM, MOD, UMX)|*.mo3;*.it;*.xm;*.s3m;*.mtm;*.mod;*.umx'
		wildcard += '|stream sounds (MP3, MP2, MP1, OGG, WAV, AIFF)|*.mp3;*.mp2;*.mp1;*.ogg;*.wav;*.aiff'
		for plugin in self.plugins.values():
			if plugin[0] > 0:
				wildcard += plugin[1]
		wildcard += '|All files (*.*)|*.*'
		dlg = wx.FileDialog(self, message = _('Choose a file'), defaultDir = os.getcwd(),  defaultFile = '', wildcard = wildcard, style = wx.FD_OPEN|wx.FD_CHANGE_DIR)
		if dlg.ShowModal() == wx.ID_OK:
			self.name_stream = file_name = dlg.GetPath()
			if os.path.isfile(file_name):
				flags = 0
				if isinstance(file_name, str):                #flags |= pybass.BASS_UNICODE
					try:
					    pybass.BASS_CHANNELINFO._fields_.remove(('filename', pybass.ctypes.c_char_p))
					except:
						pass
					else:
						pybass.BASS_CHANNELINFO._fields_.append(('filename', pybass.ctypes.c_wchar_p))
				error_msg = 'BASS_StreamCreateFile error %s'
				new_bass_handle = 0
				if dlg.GetFilterIndex() == 0:#BASS_CTYPE_MUSIC_MOD
					flags |= pybass.BASS_MUSIC_PRESCAN
					new_bass_handle = pybass.BASS_MusicLoad(False, file_name.encode(), 0, 0, flags, 0)
					error_msg = 'BASS_MusicLoad error %s'
				else:#other sound types
					new_bass_handle = pybass.BASS_StreamCreateFile(False, file_name.encode(), 0, 0, flags)
				if new_bass_handle == 0:
					print(error_msg % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.method_stop_audio()
					self.bass_handle = new_bass_handle
					self.stream = None
					self.method_slider_set_range()
					self.method_check_controls()

	def method_load_wav_file(self):
		import os
		wildcard = 'wav (*.wav)|*.wav|All files (*.*)|*.*'
		dlg = wx.FileDialog(self, message = _('Choose a file'), defaultDir = os.getcwd(),  defaultFile = '', wildcard = wildcard, style = wx.OPEN|wx.CHANGE_DIR)
		if dlg.ShowModal() == wx.ID_OK:
			self.name_stream = file_name = dlg.GetPath()
			if os.path.isfile(file_name):
				flags = 0
				#if isinstance(file_name, unicode):
				#	flags |= pybass.BASS_UNICODE
				#	try:
				#		pybass.BASS_CHANNELINFO._fields_.remove(('filename', pybass.ctypes.c_char_p))
				#	except:
				#		pass
				#	else:
				#		pybass.BASS_CHANNELINFO._fields_.append(('filename', pybass.ctypes.c_wchar_p))
				def stream_callback(handle, buffer, length, user):
					b = pybass.ctypes.cast(buffer, pybass.ctypes.c_char_p)
					pybass.ctypes.memset(b, 0, length)
					data = pybass.ctypes.c_char_p(self.stream.read(length))
					pybass.ctypes.memmove(b, data, length)
					if self.stream.is_eof():
						length |= pybass.BASS_STREAMPROC_END
						self.stream.current_position = 0
					return length
				self.stream_callback = stream_callback
				self.user_func = pybass.STREAMPROC(self.stream_callback)
				self.stream = memory_stream(open(file_name, 'rb').read(), file_name)
				new_bass_handle = pybass.BASS_StreamCreate(44100, 2, flags, self.user_func, 0)
				if new_bass_handle == 0:
					print('BASS_StreamCreate error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.method_stop_audio()
					self.bass_handle = new_bass_handle
					self.stream = None
					self.method_slider_set_range()
					self.method_check_controls()

	def method_load_data(self, stream, name_stream = 'memory_stream'):
		if stream is not None:
			if isinstance(stream, (str, list, tuple, buffer)):
				self.stream = memory_stream(stream, name_stream)
			else:
				self.stream = stream
			if isinstance(self.stream, memory_stream):
				system = pybass.STREAMFILE_BUFFER
				flags = 0
				def callback_close(user):
					self.stream.current_position = 0
				self.callback_close = callback_close
				def callback_length(user):
					return len(self.stream.data)
				self.callback_length = callback_length
				def callback_read(buffer, length, user):
					b = pybass.ctypes.cast(buffer, pybass.ctypes.c_char_p)
					pybass.ctypes.memset(b, 0, length)
					data = pybass.ctypes.c_char_p(self.stream.read(length))
					pybass.ctypes.memmove(b, data, length)
					return length
				self.callback_read = callback_read
				def callback_seek(offset, user):
					self.stream.seek(offset)
					return True
				self.callback_seek = callback_seek
				self.bass_file_procs = pybass.BASS_FILEPROCS()
				self.bass_file_procs.close = pybass.FILECLOSEPROC(self.callback_close)
				self.bass_file_procs.length = pybass.FILELENPROC(self.callback_length)
				self.bass_file_procs.read = pybass.FILEREADPROC(self.callback_read)
				self.bass_file_procs.seek = pybass.FILESEEKPROC(self.callback_seek)
				new_bass_handle = pybass.BASS_StreamCreateFileUser(system, flags, self.bass_file_procs, id(self.stream.data))
				if new_bass_handle == 0:
					print('BASS_StreamCreateFileUser error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.method_stop_audio()
					self.bass_handle = new_bass_handle
					channel_info = self.method_get_channel_info()
					if channel_info.ctype == pybass.BASS_CTYPE_STREAM_OGG:
						import pyogginfo
						ogg_info = pyogginfo.VorbisStreamInfo()
						stream = pyogginfo.SimpleDemultiplexer(ogg_info)
						if isinstance(self.stream.data, str):
							stream.process(self.stream.data)
						else:
							stream.process(str(self.stream.data))
						self.stream.decode_length = ogg_info.lastPosition
						self.stream.seconds = ogg_info.stop
						try:
							for key, value in ogg_info.comments.comments:
								if key == 'TITLE':
									if value.strip() > '':
										self.stream.name = value
						except:
							pass
					self.method_slider_set_range()
					self.method_check_controls()

	def method_get_channel_info(self):
		channel_info = pybass.BASS_CHANNELINFO()
		if not pybass.BASS_ChannelGetInfo(self.bass_handle, channel_info):
			print('BASS_ChannelGetInfo error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
		return channel_info

	def method_get_state(self):
		return pybass.BASS_ChannelIsActive(self.bass_handle)

	def method_get_length(self):
		result = pybass.BASS_ChannelGetLength(self.bass_handle, pybass.BASS_POS_BYTE)
		if result <= 0 and isinstance(self.stream, memory_stream):
			result = self.stream.decode_length
		return result

	def method_get_position(self):
		return pybass.BASS_ChannelGetPosition(self.bass_handle, pybass.BASS_POS_BYTE)

	def method_set_position(self, value):
		if not pybass.BASS_ChannelSetPosition(self.bass_handle, value, pybass.BASS_POS_BYTE):
			print('BASS_ChannelSetPosition error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))

	def method_slider_set_range(self):
		self.slider.SetRange(0, self.method_get_length())

	def method_check_controls(self):
		if self.bass_handle:
			self.slider.Enable(True)
			self.btn_play.Enable(True)
			if self.method_get_state() == pybass.BASS_ACTIVE_STOPPED:
				self.btn_stop.Enable(False)
			else:
				self.btn_stop.Enable(True)
			test = ''
			if hasattr(self.stream, 'name'):
				text = self.stream.name + ' (' + pybass.seconds_to_string(self.stream.seconds) + ')'
			else:
				#~ channel_info = self.method_get_channel_info()
				#~ text = channel_info.filename
				text = self.name_stream + ' (' + pybass.stream_length_as_hms(self.bass_handle) + ')'
			self.status_line.SetText(text)
			if self.status_line.GetText() != '':
				self.status_line.Start()
		else:
			self.slider.Enable(False)
			self.btn_play.Enable(False)
			self.btn_stop.Enable(False)
			if self.status_line.GetText() == '':
				if self.status_line.IsTicking():
					self.status_line.Stop()

	def method_is_end(self):
		return self.method_get_state() == pybass.BASS_ACTIVE_STOPPED and self.method_get_position() == 0

	def method_play(self):
		if self.bass_handle:
			if self.method_get_state() in (pybass.BASS_ACTIVE_STOPPED, pybass.BASS_ACTIVE_PAUSED):
				if not pybass.BASS_ChannelPlay(self.bass_handle, False):
					print('BASS_ChannelPlay error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.slider.timer_start()
					self.btn_play.SetLabel(_('Pause'))
					self.btn_stop.Enable(True)
			else:
				if not pybass.BASS_ChannelPause(self.bass_handle):
					print('BASS_ChannelPause error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.slider.timer_stop()
					self.btn_play.SetLabel(_('Unpause'))

	def event_volume_slider(self, event):
		pybass.BASS_SetVolume(event.GetPosition() / 100.0)

	def event_play(self, event):
		self.method_play()

	def event_open(self, event):
		self.method_load_file()

	def event_stop(self, event):
		self.method_stop_audio()

	def method_stop_audio(self):
		self.method_stop_audio_stream()
		self.btn_play.SetLabel(_('Play'))
		self.slider.SetValue(0)
		self.btn_stop.Enable(False)

	def method_stop_audio_stream(self):
		self.slider.timer_stop()
		if self.bass_handle:
			if not pybass.BASS_ChannelStop(self.bass_handle):
				print('BASS_ChannelStop error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
			else:
				self.method_set_position(0)

	def method_free_handle(self):
		if self.bass_handle:
			channel_info = self.method_get_channel_info()
			if channel_info.ctype >= pybass.BASS_CTYPE_MUSIC_MOD:
				if not pybass.BASS_MusicFree(self.bass_handle):
					print('BASS_MusicFree error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.bass_handle = 0
			elif channel_info.ctype >= pybass.BASS_CTYPE_STREAM:
				if not pybass.BASS_StreamFree(self.bass_handle):
					print('BASS_StreamFree error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
				else:
					self.bass_handle = 0

	def method_reset(self):
		self.method_free_handle()
		self.status_line.SetText('')
		self.method_check_controls()

	def __del__(self):
		self.method_free_handle()
		if self.sound_font != 0 and pybassmidi:
			if pybassmidi.BASS_MIDI_FontFree(self.sound_font):
				print('BASS_MIDI_FontFree error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))
		for plugin in self.plugins.values():
			if plugin[0] > 0:
				if pybass.BASS_PluginFree(plugin[0]):
					print('BASS_PluginFree error %s' % pybass.get_error_description(pybass.BASS_ErrorGetCode()))


if __name__ == "__main__":
	import os, gettext
	from locale import getdefaultlocale, setlocale, LC_ALL
	from wx.lib.agw.aui import AuiManager, AuiPaneInfo, AuiToolBar, AUI_TB_DEFAULT_STYLE, AUI_TB_OVERFLOW
	from wx.html import HtmlHelpController
	setlocale(LC_ALL, '')

	class log_ctrl(wx.TextCtrl):
		def __init__(self, *args, **kwargs):
			self.file_name = kwargs.pop('file_name', 'log.txt')
			self.main_frame = kwargs.pop('main_frame', None)
			self.add_to_file = kwargs.pop('add_to_file', False)
			if self.main_frame is None:
				self.main_frame = args[0]
			super(log_ctrl, self).__init__(*args, **kwargs)
		def __write__(self, content):
			self.WriteText(content)
		def show_control(self, ctrl_name = 'log_ctrl'):
			if self.main_frame is not None:
				if hasattr(self.main_frame,'aui_manager'):
					self.main_frame.show_aui_pane_info(ctrl_name)
			self.SetInsertionPointEnd()
			if self.add_to_file: self.flush()
		def write(self, content):
			self.show_control()
			self.__write__(content)
		def writelines(self, l):
			self.show_control()
			map(self.__write__, l)
		def flush(self):
			self.SaveFile(self.file_name)

	class main_frame(wx.Frame):
		def __init__(self, *args, **kwargs):
			print("b0")
			self.app = kwargs.pop('app', None)
			wx.Frame.__init__(self, *args, **kwargs)
			# =============== Logging Text Control ================
			print("b1")
			self.log_ctrl = log_ctrl(self, style = wx.TE_MULTILINE, add_to_file = True)
			#sys.stdout = self.log_ctrl
			#sys.stderr = self.log_ctrl
			print("b2")
			self.log = wx.LogTextCtrl(self.log_ctrl)
			self.log.SetLogLevel(wx.LOG_Error)
			#~ wx.Log_SetActiveTarget(self.log)
			# =============== player Control ================
			self.player = player_ctrl(self)
			# =============== StatusBar ================
			statusbar = self.CreateStatusBar(2)
			statusbar.SetStatusWidths([-1, -1])
			statusbar.SetStatusText(_('Welcome into application!'), 0)
			print("b3")
			# =============== AuiManager ================
			self.aui_manager = AuiManager()
			self.aui_manager.SetManagedWindow(self)
			self.aui_manager.AddPane(self.player, AuiPaneInfo().Name('player').CenterPane())
			self.aui_manager.AddPane(self.log_ctrl, AuiPaneInfo().Name('log_ctrl').Bottom().Layer(0).BestSize((100, 100)).Hide())
			print("b4")
			if self.log_ctrl.GetValue() != '':
				self.aui_manager.GetPane('log_ctrl').Show()
			self.aui_manager.Update()
		def DoUpdate(self):
			self.aui_manager.Update()
		def show_aui_pane_info(self, name):
			if not self.aui_manager.GetPane(name).IsShown():
				self.aui_manager.GetPane(name).Show()
			self.aui_manager.Update()
		def show_hide_aui_pane_info(self, name):
			if self.aui_manager.GetPane(name).IsShown():
				self.aui_manager.GetPane(name).Hide()
			else:
				self.aui_manager.GetPane(name).Show()
			self.aui_manager.Update()

	#~ class application(wx.PySimpleApp):
	class application(wx.App):
		app_version = '0.4'
		app_path = os.getcwd()
		app_name = os.path.basename(sys.argv[0].split('.')[0])
		help_file = app_path + '/' + app_name + '.htb'
		settings_name = app_path + '/' + app_name + '.cfg'
		def start(self):
			result = True
			print(5)
			self.help_file = self.app_name + '.htb'
			#SETUP LANGUAGE
			lang_catalog = getdefaultlocale()[0]
			list_trans = []
			current_trans = -1
			i = 0
			print(6)
			if os.path.exists('lang/%s'%lang_catalog):
				for dir_name in os.listdir('lang'):
					if os.path.exists('lang/%s/%s.mo'%(dir_name, self.app_name)):
						if dir_name == lang_catalog:
							current_trans = i
							self.help_file = 'lang/' + dir_name + '/'+ self.help_file
						list_trans.append(gettext.GNUTranslations(open('lang/%s/%s.mo'%(dir_name, self.app_name), 'rb')))
						i += 1
				if len(list_trans) > 0:
					try:
						list_trans[current_trans].install()
					except:
						print_error()
			print(7)
			if current_trans == -1:
				trans = gettext.NullTranslations()
				trans.install()
			# SETUP WX LANGUAGE TRANSLATION TO OS DEFAULT LANGUAGE
			# WX DIRECTORY MUST BE TO CONTAIN LANG DIRECTORY
			self.locale = wx.Locale(wx.LANGUAGE_DEFAULT)
			print(8)
			# CHECK EXISTS INSTANCE
			name_user = wx.GetUserId()
			name_instance = self.app_name + '::'
			self.instance_checker = wx.SingleInstanceChecker(name_instance + name_user)
			print(9)
			if self.instance_checker.IsAnotherRunning():
				wx.MessageBox(_('Software is already running.'), _('Warning'))
				return False
			# CREATE HTML HELP CONTROLLER
			#~ wx.FileSystem.AddHandler(wx.ZipFSHandler())
			self.help_controller = HtmlHelpController()
			print(10)
			if os.path.exists(self.help_file):
				self.help_controller.AddBook(self.help_file)
			#ABOUT APPLICATION
			self.developers = [_('Maxim Kolosov')]
			self.copyright = _('(C) 2013 Max Kolosov')
			self.web_site = ('http://pybass.sf.net', _('Home page'))
			self.email = ('mailto:pyirrlicht@gmail.com', _('email for feedback'))
			self.license = _('BSD license')
			self.about_description = _('wxPython bass music player.')
			#CREATE MAIN FRAME
			print(11)
			self.main_frame = main_frame(None, wx.ID_ANY, self.app_name, app = self)
			print(12)
			self.SetTopWindow(self.main_frame)
			print(13)
			self.main_frame.Show()
			print(14)
			return result

		def OnExit(self):
			try:
				del self.instance_checker
			except:
				print_error()

	print(1)
	app = application(0)
	print(2)
	if app.start():
		print(3)
		app.MainLoop()
	else:
		print(4)
		app.OnExit()