from basemodel import Stage, ListStage, NotifyStage, YesNoStage, OkNoStage, EntryStage, SymbolSelectionStage
import baseui
import runtime, config, utils, uiconfig
from setting import setting
from model import StorageShortStage
import status
import os
#MMW
import stat
#end of MMW

class VideoNotifyStage(NotifyStage):
	def __init__(self, message, cb=None):
		icon = uiconfig.baloon_video_icon
		NotifyStage.__init__(self, message, icon, cb)

class SortStage(ListStage):
	icon = uiconfig.image_image_sound_video_icon
	def __init__(self):
		self.title = _('SORT')
		self.choice = _('By name'), _('By size')

		ListStage.__init__(self)
		self.ui.set_focus(setting.video_sort_rule)

	def activate(self, index):
		setting.video_sort_rule = index
		stage = runtime.manager.find_stage('video gallery')
		stage.sort()
		runtime.manager.back_stage('video gallery')

class RenameStage(EntryStage):
	def __init__(self):
		EntryStage.__init__(self, _('File name'), _('RENAME'))
		gallery = runtime.manager.find_stage('video gallery')
		self.ui.entry.ascii_mode_case3 = True
		name = gallery.get_current_name()
		#if len(name) > 16:
		#	name = name[:16]
		self.ui.set_text(name)
		self.ui.set_max(16)
		#self.ui.set_fixed_automata(None, False)
		# shchun : global automata change
		if setting.lang == 'Korean':
			self.ui.set_automata('hangul', False)
		else:
			self.ui.set_automata('multitap', 'lower')
		# end shchun
	def activate_menu1(self):
		new_name = self.ui.get_text()
		if not new_name:
			stage = VideoNotifyStage(_('Empty image name'))
			runtime.manager.change_stage(stage)
			return

		stage = runtime.manager.find_stage('video gallery')

		old_name= stage.get_current_name()
		if old_name == new_name:
			runtime.manager.change_stage(VideoNotifyStage(_('No change')))
			return

		if stage:
			if not stage.rename_is_ok(new_name):
				runtime.manager.stack_stage(VideoNotifyStage(_('There exists same name')))
				return
				
			for ch in new_name:
				if ch in '\/:*?"<>':
					#runtime.manager.stack_stage(NotifyStage(_('Please, do not use \/:*?"<> characters to make file name'),  uiconfig.baloon_photo_icon))
					msg = runtime.evas.pre_parse(_('Please, do not use %s characters to make file name')%('\/:*?"<>',))
					runtime.manager.stack_stage(NotifyStage(msg,  uiconfig.baloon_photo_icon))
					return
		def cb():
			runtime.manager.back_stage('video gallery')
			runtime.manager.stage.rename(new_name)
		utils.player.play_effect(config.SETTING_SUCCEEDED)
		stage = VideoNotifyStage(_('Renamed!'), cb)
		runtime.manager.change_stage(stage)

	def handle_key(self, key):
#ka...hangul 2007.02.05 modify
#		if key == '*':
#			if self.ui.entry.ascii_mode_case3:
#				runtime.manager.stack_stage(SymbolSelectionStage(self, case=3))
#				return True
#		elif key == '#':
#		if key == 'SOFT4':
#			# vpark 2006.08.28 automata		
#			self.automata_idx = utils.get_automata_idx(*self.ui.automata)		
#			if setting.lang == 'Korean':			
#				self.ui.automata_idx = (self.ui.automata_idx + 1) % len(config.automata_list_hangul)	
#				self.ui.automata = config.automata_list_hangul[self.ui.automata_idx]		
#			else:	
#				self.ui.automata_idx = (self.ui.automata_idx + 1) % len(config.automata_list)
#				self.ui.automata = config.automata_list[self.ui.automata_idx]	
#				self.ui.set_automata(*self.ui.automata)
#			return True
		if key == config.Menu4:
			runtime.manager.back_stage()
			return True
		return EntryStage.handle_key(self, key)

class VideoDetailUI(baseui.LargeWindowUI):
	def __init__(self, file, date, filesize):
		baseui.LargeWindowUI.__init__(self, '','',_('DETAILS'),_('DETAILS'),'',_('BACK'))

		pos = uiconfig.large_window_pos
		font = uiconfig.large_window_text_font

		def get_multiline_filename(file, width, font):
			buf_text = ''
			filename = []

			for i in range(len(file)):
				buf_text += file[i]

				t = runtime.evas.text(text=buf_text, font=font)
				w = t.geometry[2]
				if w >= width: # cut line
					filename.append(buf_text)
					buf_text = ''

				t.free()

			if len(buf_text) > 0:
				filename.append(buf_text)

			return filename

		file = _('File')+ ': ' + file
		detail_list = get_multiline_filename(file, uiconfig.large_window_text_width, font)
		detail_list.append(_('Date')+ ': ' + date)
		detail_list.append(_('File size')+ ': ' + filesize)

		for i, text in enumerate(detail_list):
			x = pos[0] + uiconfig.large_window_text_pos_x
			y = pos[1] + uiconfig.large_window_text_pos_y[i]
			t = runtime.evas.text(text=text, pos=(x, y), \
				color=uiconfig.large_window_text_color, \
				font=font)
			self.add(t)

# KT DEMO 20080125
class VideoPlayStage(ListStage):
	name = 'videoplaystage'
	icon = uiconfig.image_sound_icon
	def __init__(self):
		self.direc = '/usr/local/lgvp/audios/mp4/'
		self.title = _('PLAYING MOVIES')
		self.choice = self.get_flist()
		ListStage.__init__(self, choice=self.choice, title=self.title, icon=self.icon)
		self.audio_index = 0
		self.player_pid = None
	
	def get_flist(self):
		choice = []
		all_list = os.listdir(self.direc)
		for i in range(len(all_list)):
			if all_list[i].lower().endswith('.mp4'): #or all_list[i].lower().endswith('.wav'):
				choice.append(all_list[i])
		choice.sort()
		return choice

	def get_current_file(self):
		return self.direc + self.choice[self.audio_index]

	def play_audio(self):
		if status.phone_status != status.Disconnected:
			return
		if len(self.choice) == 0:
			return
		audio_file = self.get_current_file()
#		if audio_file.lower().startswith(config.sdmmc_dir):
#			audio_file = audio_file.replace(config.sdmmc_dir, '/mfs/sd/')
		self.player_pid = utils.player.play(audio_file)

	def stop_audio(self):
		if status.phone_status != status.Disconnected:
			return
		if not self.player_pid:
			return 
		utils.player.stop(self.player_pid)

	def show(self):
		os.system('fb0top 0')
		self.play_audio()
		ListStage.show(self)

	def hide(self):
		self.stop_audio()
		ListStage.hide(self)

	def destroy(self):
		os.system('fb0top 1')
		self.stop_audio()
		ListStage.destroy(self)

	def handle_key(self, key):
		ret = ListStage.handle_key(self, key)
		if key in ('Up', 'Down'):
			new_audio_index = self.ui.get_focus()
			runtime.evas.render_now()
			if self.audio_index != new_audio_index:
				self.audio_index = new_audio_index
				self.stop_audio()
				self.play_audio()
		return ret


# KT DEMO 20080125==
class VideoDetailStage(Stage):
	def __init__(self):
		gallery = runtime.manager.find_stage('video gallery')
		detail = gallery.get_detail()
		self.ui = VideoDetailUI(*detail)
	def handle_key(self, key):
		if key == config.Menu4 or key == 'CLR':
			runtime.manager.back_stage()
			return True
		return False


class VideoGalleryOptionStage(ListStage):
	#icon = uiconfig.image_image_sound_video_icon
# eicho add 06.11.23
	name = 'videogalleryoptionstage'
	
	def __init__(self):
		self.title = _('OPTIONS')

		choice1 = _('Play'),_('Send'), _('Delete'), _('Rename'), _('Sort'), _('Details')
		#choice2 = _('Play'),_('Delete'), _('Rename'), _('Sort'), _('Details')
		choice2 = _('Play'),_('Delete'), _('Rename'), _('Details')

		from profile import profile
		if profile.get_profile() == 0:
			self.choice = choice1
		else:
			self.choice = choice2
		ListStage.__init__(self)

	def activate(self, index):
		gallery_stage = runtime.manager.find_stage('video gallery')
		if self.choice[index] == _('Play'):
			runtime.manager.change_stage(PlayStage(gallery_stage.get_current_file()))
		if self.choice[index] == _('Send'):
			from mmscomposestage import MMSCreateStage, MMSSize_excess
			import mmsconfig
			from mmsmanager import mmsmgr
			if mmsmgr.setmedia(mmsconfig.MEDIA_VIDEO, gallery_stage.get_current_file()):
				runtime.manager.stack_stage(MMSCreateStage(addmedia_type=mmsconfig.MEDIA_VIDEO))
			else:
				MMSSize_excess()
		if self.choice[index] == _('Delete'):
			def yes():
				gallery_stage.delete()
				def delete_done():
					runtime.manager.back_stage('video gallery')
				utils.player.play_effect(config.SETTING_SUCCEEDED)
				stage = VideoNotifyStage(_('Movie deleted'), delete_done)
				runtime.manager.change_stage(stage)
			def no():
				runtime.manager.back_stage()
			stage = YesNoStage(_('Do you want to delete movie?'), yes, no, '', uiconfig.baloon_video_icon)
			runtime.manager.stack_stage(stage)
		if self.choice[index] == _('Rename'):
			# KA: [20070831] hangul lvp-2000
			try:
				gallery = runtime.manager.find_stage('video gallery')	
				unicode(gallery.get_current_name(),'utf-8')			
				stage = RenameStage		
			except:
				utils.player.play_effect(config.SETTING_FAILED)
				stage = NotifyStage(_('No change'), uiconfig.baloon_photo_icon)	
			runtime.manager.stack_stage(stage)
			# KA: [20070831] hangul lvp-2000 ==
		if self.choice[index] == _('Sort'):
			runtime.manager.stack_stage(SortStage)
		if self.choice[index] == _('Details'):
			runtime.manager.stack_stage(VideoDetailStage)

def get_video_gallery_list(type):
	dirname, thumb_dirname = utils.get_video_dir(type)
	import os.path
	if not os.path.exists(config.video_dir):
		utils.make_dir(config.video_dir)
	if not os.path.exists(config.video_recorded_dir):
		utils.make_dir(config.video_recorded_dir)
	if not os.path.exists(config.video_received_dir):
		utils.make_dir(config.video_received_dir)
	if not os.path.exists(config.video_recorded_thumnail_dir):
		utils.make_dir(config.video_recorded_thumnail_dir)
	if not os.path.exists(config.video_received_thumnail_dir):
		utils.make_dir(config.video_received_thumnail_dir)
	_list = utils.get_file_lists(dirname)
	return dirname, thumb_dirname, _list

def VideoGalleryStage(video_type, mmsmessage=None, ipemailMessage=None, isshow=True):
	#status.supervision_not_allowed = 1
	dirname, thumb_dirname, lists = get_video_gallery_list(video_type)
	if len(lists) == 0:
		utils.player.play_effect(config.SETTING_FAILED)
		return NotifyStage(_('Gallery empty!'), uiconfig.baloon_video_icon)
	stage = _VideoGalleryStage(video_type, dirname, thumb_dirname, lists, mmsmessage, ipemailMessage, isshow)
	return stage

class _VideoGalleryStage(Stage):
	# Phase2 123
	def __init__(self, video_type, dirname, thumb_dirname, lists, mmsmessage, ipemailMessage, isshow=True):
		#status.supervision_not_allowed = 1
		self.video_thumb_dir = thumb_dirname
		self.ipemailMessage = ipemailMessage
		self.mmsmessage = mmsmessage
		self.video_type = video_type
		self.video_dir = dirname
		if self.mmsmessage or self.ipemailMessage:
			self.ui = baseui.GalleryUI(_('OK'),_('PLAY'),'', _('BACK'))
		else:
			self.ui = baseui.GalleryUI(_('MENU'),_('PLAY'),'',_('BACK'))
		self.init_list(lists, isshow)
		self.set_name('video gallery')

	def set_file(self, file):
		for i, f in enumerate(self.lists):
			if f[0] == file:
				self.video_index = i
				self.ui.set_video_preview(self.get_current_file())
				return

	def show(self):
		if len(self.lists) == 0:
			if config.mm_debug:
				print 'FIXME: list len = 0 in video Gallery'
			runtime.manager.back_stage()
			return
		# 이미지가 하나만 있을 경우에는 arrow 표시 안함
#		self.ui.show_arrow(len(self.lists) > 1)

		Stage.show(self)
		self.ui.large_arrow_left.hide()
		self.ui.large_arrow_right.hide()
		runtime.evas.render_now()
		self.ui.set_video_preview(self.get_current_file(), isshow=True)



	def init_list(self, lists, isshow=True):
		self.video_index = 0
		self.video_number = len(lists)
		self.lists = lists
		self.sort(isshow)

	def change_video(self, delta):
		self.video_index += delta
		if self.video_index < 0:
			self.video_index = self.video_number - 1
		elif self.video_index >= self.video_number:
			self.video_index = 0
		self.ui.set_video_preview(self.get_current_file())

	def sort(self, isshow=True):
		'''
		if setting.video_sort_rule == 0:
			def sort_func(x,y):
				return cmp(x[0].lower(), y[0].lower())
		elif setting.video_sort_rule == 1:
			def sort_func(x,y,sort_col=setting.video_sort_rule):
				return cmp(x[sort_col], y[sort_col])
		else:
			def sort_func(x,y,sort_col=setting.photo_sort_rule):
				return -(cmp(x[sort_col], y[sort_col]))
		'''
		def sort_func(x, y):
			return cmp(y[2], x[2])

		self.lists.sort(sort_func)

		self.video_index = 0
		if isshow:
			self.ui.set_video_preview(self.get_current_file())

	def get_current_name(self):
		name = self.lists[self.video_index][0]
		ext = ''
		dot = name.rfind('.')
		if dot >= 0:
			ext = name[dot:]
			name = name[:dot]
			try:
				name = unicode(name , 'euc-kr').encode('utf-8')
			except:
				pass
		return name

	def rename_is_ok(self, name):
		old = self.get_current_file()
		ext = utils.get_ext(old)
		name = name + '.' + ext
		new_name = self.video_dir + name
		try:
			new_name = unicode(new_name , 'utf-8').encode('euc-kr')
		except:
			pass
		import os.path
		if os.path.exists(new_name):
			return False
		return True

	def rename(self, name):
		old = self.get_current_file()
		ext = utils.get_ext(old)
		old_image_file = old.split('/')[-1]
		dot = old_image_file.rfind('.')
		if dot >=0:
			old_image_file = self.video_thumb_dir+old_image_file[:dot]+'.png'
		else:
			old_image_file = self.video_thumb_dir+old_image_file+'.png'
		image_name = name + '.png'
		name = name + '.' + ext
		new_name = self.video_dir + name
		new_image_name = self.video_thumb_dir + image_name

		try:
			old = unicode(old , 'utf-8').encode('euc-kr')
		except:
			pass
		try:
			new_name = unicode(new_name , 'utf-8').encode('euc-kr')
		except:
			pass
		try:
			old_image_file = unicode(old_image_file , 'utf-8').encode('euc-kr')
		except:
			pass
		try:
			new_image_name = unicode(new_image_name , 'utf-8').encode('euc-kr')
		except:
			pass
			
		if utils.rename(old, new_name):
			self.lists[self.video_index] = (name,) + self.lists[self.video_index][1:]
			utils.rename(old_image_file, new_image_name)
			self.ui.set_video_preview(self.get_current_file())
		else:
			if config.mm_debug:
				print 'Rename failed'
		if config.mm_debug:
			print 'FIXME: Do vidoe Rename: current index = ', self.video_index

	def delete(self):
		name = self.get_current_file()
		try:
			name = unicode(name, 'utf-8').encode('euc-kr')
		except:
			pass
			
		if utils.remove(name):
			image_file = name.split('/')[-1]
			dot = image_file.rfind('.')
			if dot >=0:
				image_file = self.video_thumb_dir+image_file[:dot]+'.png'
			else:
				image_file = self.video_thumb_dir+image_file+'.png'

			try:
				image_file = unicode(image_file, 'utf-8').encode('euc-kr')
			except:
				pass
			utils.remove(image_file)
			del self.lists[self.video_index]
			self.video_number = len(self.lists)
			if self.video_number > 0:
				if self.video_index >= self.video_number:
					self.video_index = self.video_number - 1
				self.ui.set_video_preview(self.get_current_file())
			else:
				pass
		if config.mm_debug:
			print 'FIXME: Do video Delete: current index = ', self.video_index

	def delete_all(self):
		print 'video_number =', self.video_number
		for i in range(self.video_number):
			name = self.video_dir + self.lists[i][0]

			try:
				name = unicode(name, 'utf-8').encode('euc-kr')
			except:
				pass

			print 'i =', i, 'name =', name
			utils.remove(name)
		del self.lists[:]
		self.video_number = 0

	def get_current_file(self):
		return self.video_dir + self.lists[self.video_index][0]

	def get_detail(self):
		video_file = self.get_current_file()
		try:
			video_file = unicode(video_file, 'utf-8').encode('euc-kr')
		except:
			pass
		import time, ntptime
		stat_video = os.stat(video_file)
#MMW		
		atime = os.stat(video_file)[stat.ST_ATIME]
		mtime = os.stat(video_file)[stat.ST_MTIME]	
#		print 'atime++', atime
#		print 'mtime++', mtime
		ctime = time.localtime(atime)
#		print 'atime', ctime
		ctime = time.localtime(mtime)
#		print 'mtime', ctime

#end of MMW
		date = '%02d/%02d/%03d' % (ctime[2], ctime[1], ctime[0])
		size = (stat_video[6] + 1023)/ 1024

		name = video_file.split('/')[-1]
		try:
			name = unicode(name, 'euc-kr').encode('utf-8')
		except:
			pass

		return (name, date, '%dKB' % size)

	def handle_key(self, key):
		if key == config.Menu1:
			if self.mmsmessage:
				from mmsmanager import mmsmgr
				from mmscomposestage import MMSMessageNotify, MMSMessageNotify_cb, MMSSize_excess
				from mmsconfig import MEDIA_VIDEO

				if mmsmgr.setmedia(MEDIA_VIDEO, self.get_current_file()):
					runtime.manager.change_stage(MMSMessageNotify(self.mmsmessage, MMSMessageNotify_cb))
				else:
					MMSSize_excess()
			elif self.ipemailMessage:
				from ipemailstage import IpEmailAttachNotify
				runtime.manager.stack_stage(IpEmailAttachNotify(_('Recorded video attached'), \
					unicode(self.get_current_file())))
			else:
				runtime.manager.stack_stage(VideoGalleryOptionStage)
		elif key == config.Menu2 or key == 'OK':
			if self.ui.delete_thumb():
				import time, ntptime
				time.sleep(1.5)
			runtime.manager.stack_stage(PlayStage(self.get_current_file()))
		elif key == config.Menu3:
			pass
		elif key in (config.Menu4, 'CLR'):
			runtime.manager.back_stage()
		elif key in ('Up', 'Left'):
			self.change_video(-1)
		elif key in ('Down', 'Right'):
			self.change_video(+1)

class PlayStage(Stage):
# eicho add 06.11.22
	name = 'videoplaystage'
	
	def __init__(self, fname, _title=_('VIDEO GALLERY')):
		self.player_pid = None
		self.fname = fname
		self.ui = baseui.GalleryUI('','','',_('BACK'))
		# self.ui = baseui.GalleryUI('',_('BACK'), _title)
		self.ui.set_video_preview(self.fname, False)

		if setting.screen_saver_enabled:
			status.not_screen_saver = True

		self.player_view = None
		self.player_view = runtime.evas.rectangle()
		self.player_view.layer = 1
		self.player_view.color = (255, 255, 254, 255)

		self.player_view.geometry = (0,0,0,0)


	def show(self):
		if setting.screen_saver_enabled:
			status.not_screen_saver = True
		Stage.show(self)
		self.ui.small_arrow_left.hide()
		self.ui.small_arrow_right.hide()
		self.ui.large_arrow_left.hide()
		self.ui.large_arrow_right.hide()
		#os.system('fb0top 0')
# eicho add 06.11.23
		if status.flag_state_incoming_ss:
			print '#### @PLAYStage: flag is still S|S # status.flag_state_incoming_ss=', status.flag_state_incoming_ss
		else:
			# self.player_pid = utils.player.play(self.fname, loop=False)
			'''
			pos = (uiconfig.gallery_pos[1], uiconfig.gallery_pos[0], uiconfig.gallery_pos[1]+uiconfig.gallery_size[1], uiconfig.gallery_pos[0]+uiconfig.gallery_size[0])
			self.player_pid = utils.player.play(self.fname, loop=False, videopos=pos)
			'''
			xres,yres = uiconfig.gallery_size
			xpos,ypos = uiconfig.gallery_pos

			self.player_view.geometry = (xpos, ypos, xres, yres)
			runtime.evas.use_transparency(True)
			self.player_view.show()
			
			runtime.mmedia.unload()
			try:
				play_fname = unicode(self.fname, 'utf-8').encode('euc-kr')
			except:
				play_fname = self.fname
			
			utils.player.play_video(play_fname, xres, yres, xpos, ypos, gallery=True)
			#os.system('fb0top 0')
			

# eicho add 06.11.22
	def stop_play(self):
		#os.system('fb0top 1')
		#utils.player.stop(self.player_pid)
		utils.player.stop_video()
		self.player_view.hide()
		runtime.evas.use_transparency(False)
		self.player_pid = None

	def destroy(self):
		#os.system('fb0top 1')
		#utils.player.stop(self.player_pid)
		utils.player.stop_video()
		self.player_view.hide()
		runtime.evas.use_transparency(False)
		self.player_pid = None
		Stage.destroy(self)

		status.not_screen_saver = False
		if setting.screen_saver_enabled:
			setting.reset_screen_saver_timer()
			status.screensaver_activated = False

	def hide(self):
		runtime.manager.back_stage(isshow=False)
		return

	def handle_key(self, key):
		if key == config.Menu4 or key == 'CLR':
			runtime.manager.back_stage()
			return True
		else:
			Stage.handle_key(self, key)

class RecordedVideoStage(ListStage):
	name = 'recordevideo'
	icon = uiconfig.image_image_sound_video_icon
	def __init__(self, mmsmessage=None):
		self.title = _('RECORDED VIDEOS')
		self.choice = _('Add new'), _('Video gallery')

		ListStage.__init__(self)
		self.mmsmessage = mmsmessage
		status.supervision_not_allowed = 1

	def activate(self, index):
		if index == 0:
			dirname, thumb_dirname, lists = get_video_gallery_list('recorded')
			# 남은 공간 체크
			if not utils.check_free_storage():
				runtime.manager.stack_stage(StorageShortStage(uiconfig.baloon_video_icon))
			elif config.video_record_max <= len(lists):
				runtime.manager.stack_stage(VideoNotifyStage(_('Video gallery is full!')))
			else:
				import mmtools
				stage = mmtools.VideoPreviewStage(self.mmsmessage)
				runtime.manager.stack_stage(stage)
		elif index == 1:
			stage = VideoGalleryStage('recorded', self.mmsmessage)
			runtime.manager.stack_stage(stage)

	def destroy(self):
		ListStage.destroy(self)
		status.supervision_not_allowed = 0

class VideosStage(ListStage):
	icon = uiconfig.image_image_sound_video_icon
	def __init__(self):
		self.title = _('VIDEOS')
		self.choice = _('Recorded videos'),

		ListStage.__init__(self, self.choice, self.title, self.icon)
		status.supervision_not_allowed = 1

	def activate(self, index):
		if index == 0:
			stage = RecordedVideoStage()
		elif index == 1:
			stage = VideoGalleryStage('received')
		runtime.manager.stack_stage(stage)

	def destroy(self):
		ListStage.destroy(self)
		status.supervision_not_allowed = 0
	
class VideoDeleteStage(ListStage):
	icon = uiconfig.image_image_sound_video_delete_icon

	def __init__(self):
		self.title = _('DELETE')
		self.choice = _('Recorded videos'), _('All videos')
	
		ListStage.__init__(self)
	

	def activate(self, index):
		if index == 0:
			dirname, thumb_dirname, lists = get_video_gallery_list('recorded')
			if len(lists) == 0:
				runtime.manager.stack_stage(VideoNotifyStage(_('No recorded videos')))
				return
			message = _('Delete all recorded videos?')
			notify_message = _('All recorded videos deleted')
#ka...3800 malaga 2007.04.02
#		elif index == 1:
#			dirname, thumb_dirname, lists = get_video_gallery_list('received')
#			if len(lists) == 0:
#				runtime.manager.stack_stage(VideoNotifyStage(_('No received videos')))
#				return
#			message = _('Delete all received videos?')
#			notify_message = _('All received videos deleted')
		else:
			dirname, thumb_dirname, lists1 = get_video_gallery_list('recorded')
			dirname, thumb_dirname, lists2 = get_video_gallery_list('received')
			if len(lists1)+len(lists2) == 0:
				runtime.manager.stack_stage(VideoNotifyStage(_('No videos')))
				return
			message = _('Delete all videos?')
			notify_message = _('All videos deleted')
		def yes():
			stage = NotifyStage(notify_message, uiconfig.baloon_video_delete_icon)
			runtime.manager.change_stage(stage)
			if index == 0:
				utils.remove_dir(config.video_recorded_dir)
				utils.remove_dir(config.video_recorded_thumnail_dir)
			elif index == 1:
				utils.remove_dir(config.video_received_dir)
				utils.remove_dir(config.video_received_thumnail_dir)
			else:
				utils.remove_dir(config.video_recorded_dir)
				utils.remove_dir(config.video_received_dir)
				utils.remove_dir(config.video_recorded_thumnail_dir)
				utils.remove_dir(config.video_received_thumnail_dir)
		def no():
			runtime.manager.back_stage()
		stage = OkNoStage(message, yes, no, '', uiconfig.baloon_video_delete_icon)
		runtime.manager.stack_stage(stage)