IMG Puzzle v2

# IMAGE Puzzle v2
# joe, 03/01/2015
import appuifw as A
import graphics as G

class SwapIMG:
 def __init__(self):
  self.state=''
  self.run,self.finished,self.swap,self.hint=0,0,0,0
  self.pos,self.old_pos,self.match=[],[],[]
  self.num=4
  self.mov=[None,None]
  self.gb=[None,None]
  self.cur=[0,0]
  self.cur_m=0
  self.cur_index=[(x,y) for y in range(self.num) for x in range(self.num)]
  self.x0,self.y0=4,4
  self.w=(min(size)-(self.x0*2))/self.num
  self.h=(min(size)-(self.y0*2))/self.num
  self.cur_f,self.page,self.offset,self.fs=0,0,12,0
  self.files=[]
  A.app.screen='full'
  self.c=A.Canvas(redraw_callback=self._redraw,event_callback=self._event)
  A.app.body=self.c
  A.app.exit_key_handler=lambda:None
  self.play()

 def exit(self):
  self.run=0

 def _redraw(self,rect):
  if img:self.c.blit(img)

 def _event(self,sc):
  k=sc['scancode']
  self.hint=0
  if self.state=='':
   if sc['type']==3 and k==164:
    self.state,self.cur_m='menu',0
   if sc['type'] is not A.EEventKey:return
   if not self.finished:
    if k in (0xf,0x36):
     self.cur[0]+=1
     if self.cur[0]>self.num-1:
      self.cur[0]=0
      self.cur[1]+=1
      if self.cur[1]>self.num-1:
       self.cur[1]=0
       self.cur[0]=0
    elif k in (0xe,0x34):
     self.cur[0]-=1
     if self.cur[0]<0:
      self.cur[0]=self.num-1
      self.cur[1]-=1
      if self.cur[1]<0:
       self.cur[1]=self.num-1
       self.cur[0]=self.num-1
    elif k in (0x10,0x32):
     self.cur[1]-=1
     if self.cur[1]<0:
      self.cur[1]=self.num-1
    elif k in (0x11,0x38):
     self.cur[1]+=1
     if self.cur[1]>self.num-1:
      self.cur[1]=0
    elif k==0x37:
     self.hint=1
    elif k==0x30:
     self.replay()
    elif k in (0xa7,0x35):
     if self.mov[0] is None:
      self.mov[0]=self.cur[0] + self.cur[1]*self.num
     else:
      if self.mov[0]!=None:
       self.mov[1],self.swap=self.cur[0] + self.cur[1]*self.num,1
  elif self.state=='menu':
   if sc['type']==3 and k in (164,165):
    self.state=''
   if sc['type'] is not A.EEventKey:return
   lem=len(self.list_menu)-1
   if k in (0x10,0x32):
    self.cur_m-=1
    if self.cur_m<0:
     self.cur_m=lem
   elif k in (0x11,0x38):
    self.cur_m+=1
    if self.cur_m>lem:
     self.cur_m=0
   elif k in (0xa7,0x35):
    if callable(self.list_menu[self.cur_m][1]):
     self.state=''
     self.list_menu[self.cur_m][1]()
  elif self.state=='fman':
   if sc['type']==3 and k==165:
    self.state,self.fs='',0
    self.gb[0]=self.gb[1]
   if sc['type'] is not A.EEventKey:return
   if k in (0x11,0x38):
    self.cur_f+=1
    if self.cur_f>self.offset-1:
     self.page+=1
     self.cur_f=0
    if self.page*self.offset+self.cur_f>=len(self.files):
      self.page=0
      self.cur_f=0
   elif k in (0x10,0x32):
    self.cur_f-=1
    if self.cur_f<0:
     self.page-=1
     self.cur_f=self.offset-1
    if self.page<0:
     self.page=len(self.files)/self.offset
     self.cur_f=(len(self.files)-1)-self.page*self.offset
   elif k==0x2a:
    self.page-=1
    self.cur_f=0
    if self.page<0:
     self.page=len(self.files)/self.offset
     self.cur_f=0
   elif k==0x7f:
    self.page+=1
    if self.page<len(self.files)/self.offset:
     self.cur_f=self.offset-1
    else:
     self.cur_f = (len(self.files)-1)-self.page*self.offset
    if self.page > len(self.files)/self.offset:
     self.page=0
     self.cur_f=self.offset-1
   elif k in (0xa7,0x35):
    if self.fs:
     p=os.path.join(img_dir,self.files[self.page*self.offset+self.cur_f])
     try:
      self.gb[0]=None
      self.gb[0]=G.Image.open(p)
      sz=(min(size)-(self.x0),min(size)-(self.y0))
      if self.gb[0].size!=sz:
       self.gb[0]=self.gb[0].resize(sz)
     except:
      self.gb=[None,None]
     self.state=''
     self.replay()

 def _get_pos(self):
  for i in xrange(self.num*self.num):
   x=self.x0+((i%self.num)*self.w)
   y=self.y0+((i/self.num)*self.h)
   self.pos.append((x,y,x+self.w,y+self.h))
  self.old_pos=[i for i in self.pos]
  random.shuffle(self.pos)

 def select_pic(self):
  if not len(self.files):
   self.files=map(dec,filter(lambda f:os.path.isfile(os.path.join(img_dir,f)),os.listdir(img_dir)))
  self.gb[1]=self.gb[0]
  self.state='fman'

 def replay(self):
  self.pos=self.old_pos=[]
  self.match,self.finished=[],0
  self._get_pos()

 def _checkpos(self):
  for i in range(len(self.pos)):
   if self.old_pos[i]==self.pos[i]:
    if i not in self.match:
     self.match.append(i)

 def _checkall(self):
  if len(self.match)==len(self.pos):
   self.match,self.finished=[],1

 def _swaplist(self):
  self.pos[self.mov[0]],self.pos[self.mov[1]]=self.pos[self.mov[1]],self.pos[self.mov[0]]
  self.swap,self.mov=0,[None,None]

 def _draw_f(self):
  self.gb[0],self.fs=None,1
  x,y,th=5,30,14
  if len(self.files)-self.page*self.offset<self.offset:mx=len(self.files)-self.page*self.offset
  else:mx=self.offset
  img.rectangle((x-3,y+3+((self.cur_f-1)*th),size[0]-2,y+3+((self.cur_f-1)*th+th)),fill=h_color)
  for i in range(0,mx):
   col=(txt_color,foc_color)[i==self.cur_f]
   img.text((x,y+i*th),self.files[i+self.page*self.offset],col)
  img.text((x,y-15),u'%s' %img_dir,txt_color,'legend')
  img.text((size[0]-35,size[1]-5),u'Back',txt_color,'legend')

 def _draw_m(self):
  menu=[(u'Select Image',self.select_pic),(u'Replay (0)',self.replay),(u'Show Match (7)',lambda:None),(u'About',lambda:None),(u'Exit',self.exit)]
  if not self.gb[0]:
   menu.pop(1)
   menu.pop(1)
  self.list_menu=menu
  lem=len(menu)
  x,y,th=1,size[1]-1,16
  rw,rh=100,lem*th+(th/2)
  img.rectangle((x,y-rh,x+rw,y),b_color,win_color)
  img.rectangle((x+2,y-rh+3+(self.cur_m*th),x+rw-3,y-rh+3+(self.cur_m*th+th)),fill=h_color)
  for i in range(len(menu)):
   col=(txt_color,foc_color)[i==self.cur_m]
   img.text((x+5,y-rh+th+(i*th)),u'%s' %menu[i][0],col,'legend')

 def _tsize(self,text,fnt):
  if not isinstance(text,unicode):
   text=unicode(text)
  m=img.measure_text(text,font=fnt)[0]
  w,h=(m[2]-m[0],m[3]-m[1])
  return (w,h)

 def play(self):
  self.run=1
  while self.run:
   img.clear(bg_color)
   if self.gb[0]:
    img.rectangle((self.x0-2,self.y0-2,self.x0+2+(self.num*self.w),self.y0+2+(self.num*self.h)),b_color)
    for i in range(len(self.pos)):
     cx,cy=(i%self.num),(i/self.num)
     img.blit(self.gb[0],target=(self.x0+cx*self.w,self.y0+cy*self.h),source=self.pos[i])

     if self.old_pos[i]==self.pos[i]:
      if not self.finished:
       if self.hint:
        img.rectangle( (self.old_pos[i][0]+1,self.old_pos[i][1]+1,self.old_pos[i][0]+12,self.old_pos[i][1]+12),b_color,win_color)
        img.line((self.old_pos[i][0]+3,self.old_pos[i][1]+6,self.old_pos[i][0]+4,self.old_pos[i][1]+8,self.old_pos[i][0]+8,self.old_pos[i][1]+3),b_color,width=2)

    if not self.finished:
     dx=self.x0+(self.cur[0]*self.w)
     dy=self.y0+(self.cur[1]*self.h)
     img.rectangle((dx,dy,dx+self.w,dy+self.h),cur_color,width=2)

    if self.mov[0]!=None:
     dx=self.x0+(self.cur_index[self.mov[0]][0]*self.w)
     dy=self.y0+(self.cur_index[self.mov[0]][1]*self.h)
     img.rectangle((dx,dy,dx+self.w,dy+self.h),sel_color,width=2)
    p=len(self.match)*100.0/len(self.pos)
    txt,fnt=(u'%d match (%.0f %%)' %(len(self.match),p),u'Complete')[self.finished],'legend'
    img.text((size[0]/2-self._tsize(txt,fnt)[0]/2,size[1]-14),txt,txt_color,fnt)

    self._checkpos()
    self._checkall()
    if self.swap:self._swaplist()
   else:
    if not self.state:
     txt,fnt=u'No Image Selected','legend'
     img.text((size[0]/2-self._tsize(txt,fnt)[0]/2,size[1]/2),txt,txt_color,fnt)

   if self.state=='menu':self._draw_m()
   if self.state=='fman':self._draw_f()
   self._redraw(())
   A.e32.ao_sleep(1e-04)


size=G.sysinfo.display_pixels()
img=G.Image.new(size)
import powlite_fm
fm=powlite_fm.manager()
import random

bg_color=0
txt_color=0xcccccc
foc_color=0xffffff
b_color=0xffffff
win_color=0x111111
cur_color=0xef0000
sel_color=0x00ef00
h_color=0xfff

img_dir=u'e:\\images\\'
def dec(x):
 if len(x)>30:
  x=x[:25]+'...'
 return x.decode('u8')

A.e32.ao_sleep(0)
import os
SwapIMG()