from PythonQt import *

IMAGE = 0
TEXT = 1
RECT = 2

import runtime

debug = 0

class CanvasItemWrapper(object):
        item = 0

        def __init__(self,item):
            self.item = item
        
        def move(self,x,y):
                self.item.x = x
                self.item.y = y
 
        def show(self):
        	if self.item:
                    self.item.visible = 1
                
        def hide(self):
        	if self.item:
                    self.item.visible = 0

        def geometry_get(self):
                return [self.item.x,self.item.y,self.item.w,self.item.h]

	def geometry_set(self,geometry):
		self.item.x = geometry[0]
		self.item.y = geometry[1]
		self.item.w = geometry[2]
		self.item.h = geometry[3]

	geometry = property(geometry_get,geometry_set)
        
        def free(self):
                self.hide()
                self.item.deleted = 1
                self.item = None

        def getfile(self):
                return self.item.file

        def setfile(self, file):
                self.item.file = file

        file = property(getfile, setfile)
        
        def layer_get(self):
                return self.item.layer

        def layer_set(self, layer):
                self.item.layer = layer

        layer = property(layer_get, layer_set)

        def getpos(self):
                return self.item.x, self.item.y

        def setpos(self, pos):
                self.item.x = pos[0]
                self.item.y = pos[1]

        pos = property(getpos, setpos)

        def text_get(self):
                return self.item.text

        def text_set(self, text):
                self.item.text = text

        text = property(text_get, text_set)

        def size_get(self):
                return self.item.w, self.item.h

        def size_set(self, size):
                self.item.w = size[0]
                self.item.h = size[1]

        size = property(size_get, size_set)

	def color_get(self):
		return self.item.color
		
	def color_set(self,col=(0,0,0,0)):
		self.item.color = QColor(col[0],col[1],col[2],col[3])
		
	color = property(color_get, color_set)
	
        def smooth_scale_set(self,x):
		return

	def fill_set(self,x,y,w,h):
		if debug:
			print 'fill_set'
		self.item.fill_set(x,y,w,h)
		return
 
        def descent_get(self):
                return self.item.descent

        def horiz_advance_get(self):
        	return self.item.horiz_advance

        def clip_set(self,clip):
                geo = clip.geometry
                self.item.clip = QRect(geo[0], geo[1], geo[2], geo[3])

        def resize(self,w,h):
        	self.item.resize(w,h)
        	
	def getfont(self):
		f = self.item.font
		return (f.family(), f.pixelSize())
		
	def setfont(self,font=('','')):
		self.item.font = QFont(font[0],font[1])
		
	font = property(getfont,setfont)
		
	def font_set(self,fn,fs):
		self.setfont((fn,fs))
		
	def font_get(self):
		return self.getfont()


class List(object):
	def __init__(self,parent,labels,pos):
		self.labels = labels
		self.parent = parent
		self.__pos = pos
		self.focus = 0
		self.w = QListWidget(self.parent)
		for lst in self.labels:	
			netItem = QListWidgetItem(lst,self.w)
		self.w.geometry = QRect(QPoint(120,70),QSize(200,186))		
	def show(self):
		print 'show listwidget'
		self.w.show()
		self.w.setFocus()

	def hide(self):
		print 'hide listwidget'
		self.w.hide()
			
	def close(self):
		self.w.close()
	
	def get_focus(self):
		return self.w.currentRow()	


#translator = Translator()

#                if (self.__count):
#                    self.t.text = translator.translate(text)


CALLBACK_KEY_UP = 0 
CALLBACK_KEY_DOWN = 0
INPUT_READ = 0

import runtime
import config


class Evas:
	rec = ''
	test = 0
        itemList = [None,None]

	def __init__(self,x,y,w,h,r):
		if debug:
			print 'evas init'
                self.c = Canvas(x,y,w,h)
                self.c.connect('keyPressed(int)', self.keyPressed)
		self.tid = 1
		self.timer_cb_list = [ ]
		self.notifier_list = [ ]

        def keyPressed(self, key):
        	import qtkey
                if ( key == qtkey.Select or key == qtkey.Context1 or key == ord('A') ):
                    return runtime.evas.handle_key(True, config.Menu1)
                elif ( key == qtkey.Back or key == ord('B') ):
                    return runtime.evas.handle_key(True, config.Menu2)
                elif ( key == qtkey.Context2 ):
                    return runtime.evas.handle_key(True, config.Menu3)
                elif ( key == qtkey.Context3 ):
                    return runtime.evas.handle_key(True, config.Menu4)
                elif ( key == qtkey.F27 ):
                    return runtime.evas.handle_key(True, config.Video)
                elif ( key == qtkey.F28 ):
                    return runtime.evas.handle_key(True, config.Snapshot)
                elif ( key == qtkey.F29 ):
                    return runtime.evas.handle_key(True, config.key_mms)
                elif ( key == qtkey.F30 ):
                    return runtime.evas.handle_key(True, config.VideoPrivacy)
                elif ( key == qtkey.F31 ):
                    return runtime.evas.handle_key(True, config.VideoSize)
                elif ( key == qtkey.F32 ):
                    return runtime.evas.handle_key(True, config.key_favorite)
                elif ( key == qtkey.Hangup ):
                    return runtime.evas.handle_key(True, config.Red)
                elif ( key == qtkey.Call ):
                    return runtime.evas.handle_key(True, config.Green)
                elif ( key == qtkey.F1 ):
                    return runtime.evas.handle_key(True, config.OffHook)
                elif ( key == qtkey.F2 ):
                    return runtime.evas.handle_key(True, config.OnHook)
                elif ( key == qtkey.Left ):
                    return runtime.evas.handle_key(True, 'Left')
                elif ( key == qtkey.Right ):
                    return runtime.evas.handle_key(True, 'Right')
                elif ( key == qtkey.Up ):
                    return runtime.evas.handle_key(True, 'Up')
                elif ( key == qtkey.Down ):
                    return runtime.evas.handle_key(True, 'Down')
                k = chr(key)
                return runtime.evas.handle_key(True, k)

	def image_cache_set(x,y):
		if debug:
			print 'image cache set'
		return

	def font_cache_set(x,y):
		if debug:
			print 'font cache set'
		return

	def font_path_prepend(self,dir_list):
		if debug:
			print 'font_path_prepend'
		return

	def image_cache_flush(self):
		if debug:
			print 'image cache flush'
		return

        def rectangle(self,pos=(0,0),size=(0,0)):
                rect = self.c.newRect(pos[0],pos[1],size[0],size[1])
                return CanvasItemWrapper(rect)
                
	def image(self,pos=(0,0),file=''):
                img = self.c.newImage(pos[0],pos[1],file)
                return CanvasItemWrapper(img)

	def event_set_mask(self,val):
		if debug:
			print 'event_set_mask'
		return

	def event_set_callback(self,cb):
		if debug:
			print 'event_set_callback'
		return

	def timeout_add(self,x,cb):
		if debug:
			print ' ** timeout_add, ', x, ' ', cb
		for timer, c in self.timer_cb_list:
		    if (c == cb):
		    	if debug:
		        	print 'timer already exists for ', cb
		        self.timeout_remove(timer)
		        break
		timer = Timer(x)
		timer.connect('timeout(Timer*)',self.call_timeout_cb)
		self.timer_cb_list.append((timer,cb))
		return timer

	def timeout_remove(self,tid):
		for timer, cb in self.timer_cb_list:
		    if (timer == tid):
		    	if debug:
				print ' ** timeout_remove, ', cb
			self.timer_cb_list.remove((timer,cb))
			timer.stop()
			timer.deleteLater()
			timer = None
			return
			
	def call_timeout_cb(self,tid):
		for timer, cb in self.timer_cb_list:
		    if (timer == tid):
		    	if debug:
		    		print ' ** timeout, ', cb
			cb()
			return

        def text(self,text='',pos=(0,0),font=('',13),color=(255,255,255,255)):
                txt = self.c.newText(pos[0],pos[1],text,font[0],font[1],QColor(color[0],color[1],color[2],color[3]))
                return CanvasItemWrapper(txt)

        def calendar(self):
                return Calendar(self.c.qwidget_cast())

	def uiloader(self):
		return QUiLoader(0)

	def canvas(self):
		return self.c.qwidget_cast()

	def list(self,labels,pos=(119,54)):
		print 'create listwidget'
		return List(self.c.qwidget_cast(),labels,pos)

        def update(self, geo):
                self.c.update(geo[0],geo[1],geo[2],geo[3])

        def render(self):
        	if debug:
			print 'render'
                return

	def render_now(self):
		if debug:
			print 'render now'
		return

	def idle_add(self,cb):
		if debug:
			print 'idle_add'
		timer = QTimer()
		timer.setInterval(500)
		timer.setSingleShot(1)
		timer.connect('timeout()', cb)
		timer.connect('timeout()', timer.deleteLater())
		timer.start()

	def set_lang(self,lang):
		import os
                if ( lang == 'Korean' ):
                    os.environ["LANG"] = 'ko_KR'
                elif ( lang == "LAspanish" ):
                    os.environ["LANG"] = 'es_ES'
                elif ( lang == "Portuguese" ):
                    os.environ["LANG"] = 'pt_PT'
                elif ( lang == "Russian" ):
                    os.environ["LANG"] = 'ru_RU'
                elif ( lang == "English" ):
                    os.environ["LANG"] = 'C'
                elif ( lang == "Italian" ):
                    os.environ["LANG"] = 'it_IT'
                elif ( lang == "Deutsch" ):
                    os.environ["LANG"] = 'de_DE'
                elif ( lang == "Francais" ):
                    os.environ["LANG"] = 'fr_FR'
                elif ( lang == "Spain" ):
                    os.environ["LANG"] = 'es_ES'
                if debug:
                	print os.environ["LANG"]

#                translator.load()
        def use_transparency(self, flag):
        	if debug:
			print 'use transparency'
		return
       
	def loop(self):
		if debug:
			print 'loop'
		return

	def quit(self):
		if debug:
			print 'quit'
		self.c.deleteLater()
		return

	def input_add(self,fd,type,cb):
		if debug:
			print 'input add'
		for n in self.notifier_list:
		   if (n.fd() == fd):
		   	if debug:
		       		print 'socket notifier is already created for socket ', fd 
		       	return
		       
		if (type == INPUT_READ):
		    notifier = SocketNotifier(fd, 0)
		else:
		    if debug:
		        print 'type not supported - XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
		notifier.connect('activated(int,int)', cb)
		
		self.notifier_list.append(notifier)
		return notifier	

	def input_remove(self,notifier):
		self.notifier_list.remove(notifier)
		notifier.deleteLater()
		notifier = None