|
1 # Copyright (c) 2005 Nokia Corporation |
|
2 # |
|
3 # Licensed under the Apache License, Version 2.0 (the "License"); |
|
4 # you may not use this file except in compliance with the License. |
|
5 # You may obtain a copy of the License at |
|
6 # |
|
7 # http://www.apache.org/licenses/LICENSE-2.0 |
|
8 # |
|
9 # Unless required by applicable law or agreed to in writing, software |
|
10 # distributed under the License is distributed on an "AS IS" BASIS, |
|
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
12 # See the License for the specific language governing permissions and |
|
13 # limitations under the License. |
|
14 |
|
15 |
|
16 import appuifw, e32, os |
|
17 from graphics import * |
|
18 import key_codes |
|
19 |
|
20 appuifw.app.screen='full' |
|
21 appuifw.app.body=canvas=appuifw.Canvas() |
|
22 backup_image=Image.new(canvas.size) |
|
23 canvas.clear(0) |
|
24 center=[0,0] |
|
25 zoom=1 |
|
26 zoomstepindex=0 |
|
27 screensize=canvas.size |
|
28 screenrect=(0,0,screensize[0],screensize[1]) |
|
29 step=30 |
|
30 textloc=(screensize[0]*0.3,screensize[1]*.5) |
|
31 |
|
32 if e32.in_emulator(): |
|
33 imagedir=u'c:\\images' |
|
34 else: |
|
35 imagedir=u'e:\\images' |
|
36 files=map(unicode,os.listdir(imagedir)) |
|
37 |
|
38 index=appuifw.selection_list(files) |
|
39 |
|
40 lock=e32.Ao_lock() |
|
41 |
|
42 def fullupdate(): |
|
43 backup_image.clear(bgcolor) |
|
44 update() |
|
45 |
|
46 def nextpic(): |
|
47 global index,finished |
|
48 index=(index+1)%len(files) |
|
49 finished=1 |
|
50 loaded_image.stop() |
|
51 lock.signal() |
|
52 |
|
53 def prevpic(): |
|
54 global index,finished |
|
55 index=(index-1)%len(files) |
|
56 finished=1 |
|
57 loaded_image.stop() |
|
58 lock.signal() |
|
59 |
|
60 def zoomin(): |
|
61 global zoomstepindex,zoom |
|
62 if zoomstepindex < (len(zoomsteps)-1): |
|
63 zoomstepindex+=1 |
|
64 zoom=zoomsteps[zoomstepindex] |
|
65 fullupdate() |
|
66 |
|
67 def zoomout(): |
|
68 global zoomstepindex |
|
69 if zoomstepindex > 0: |
|
70 zoomstepindex-=1 |
|
71 zoom=zoomsteps[zoomstepindex] |
|
72 backup_image.clear(bgcolor) |
|
73 fullupdate() |
|
74 |
|
75 |
|
76 def isvalidcenter(c): |
|
77 iw,ih=(loaded_image.size[0],loaded_image.size[1]) |
|
78 srcsize=(int(screensize[0]/zoom),int(screensize[1]/zoom)) |
|
79 vw,vh=(srcsize[0]/2,srcsize[1]/2) |
|
80 return (c[0]+vw<iw and c[0]-vw>=0 and |
|
81 c[1]+vh<ih and c[1]-vh>=0) |
|
82 def move(delta): |
|
83 global center |
|
84 c=center |
|
85 for k in range(1,4): |
|
86 t=[c[0]+int(delta[0]*k*20/zoom), |
|
87 c[1]+int(delta[1]*k*20/zoom)] |
|
88 center=t |
|
89 update() |
|
90 |
|
91 bgcolor=0 |
|
92 |
|
93 canvas.bind(key_codes.EKey3,nextpic) |
|
94 canvas.bind(key_codes.EKey1,prevpic) |
|
95 canvas.bind(key_codes.EKey5,zoomin) |
|
96 canvas.bind(key_codes.EKey0,zoomout) |
|
97 canvas.bind(key_codes.EKeyLeftArrow,lambda:move((-1,0))) |
|
98 canvas.bind(key_codes.EKeyRightArrow,lambda:move((1,0))) |
|
99 canvas.bind(key_codes.EKeyUpArrow,lambda:move((0,-1))) |
|
100 canvas.bind(key_codes.EKeyDownArrow,lambda:move((0,1))) |
|
101 |
|
102 def rect_intersection(r1,r2): |
|
103 return (max(r1[0],r2[0]),max(r1[1],r2[1]), |
|
104 min(r1[2],r2[2]),min(r1[3],r2[3])) |
|
105 |
|
106 def update(): |
|
107 global zoom |
|
108 zoom=zoomsteps[zoomstepindex] |
|
109 # We convert the screen rect into image coordinates, compute its |
|
110 # intersection with the image rect and transform it back to screen |
|
111 # coordinates. |
|
112 imgrect=(0,0,loaded_image.size[0],loaded_image.size[1]) |
|
113 ss=(int(screensize[0]/zoom),int(screensize[1]/zoom)) |
|
114 screenrect_imgcoords=(center[0]-ss[0]/2,center[1]-ss[1]/2, |
|
115 center[0]+ss[0]/2,center[1]+ss[1]/2) |
|
116 sourcerect=rect_intersection(screenrect_imgcoords,imgrect) |
|
117 targetrect=(int((sourcerect[0]-center[0])*zoom+screensize[0]/2), |
|
118 int((sourcerect[1]-center[1])*zoom+screensize[1]/2), |
|
119 int((sourcerect[2]-center[0])*zoom+screensize[0]/2), |
|
120 int((sourcerect[3]-center[1])*zoom+screensize[1]/2)) |
|
121 backup_image.clear(bgcolor) |
|
122 backup_image.blit(loaded_image,source=sourcerect,target=targetrect,scale=1) |
|
123 if not finished: |
|
124 backup_image.text(textloc,u'Loading....',(255,255,0)) |
|
125 backup_image.text((0,10),files[index],(0,255,0)) |
|
126 canvas.blit(backup_image) |
|
127 |
|
128 global finished |
|
129 finished=0 |
|
130 def finishload(err): |
|
131 global finished |
|
132 finished=1 |
|
133 |
|
134 running=1 |
|
135 def quit(): |
|
136 global running,lock |
|
137 running=0 |
|
138 lock.signal() |
|
139 |
|
140 appuifw.app.exit_key_handler=quit |
|
141 backup_image.clear(bgcolor) |
|
142 |
|
143 selected_file=imagedir+"\\"+files[index] |
|
144 imginfo=Image.inspect(selected_file) |
|
145 imgsize=imginfo['size'] |
|
146 loaded_image=Image.new(imgsize) |
|
147 |
|
148 im=None |
|
149 while running: |
|
150 selected_file=imagedir+"\\"+files[index] |
|
151 imgsize=Image.inspect(selected_file)['size'] |
|
152 backup_image.text(textloc,u'Loading.',(255,255,0)) |
|
153 finished=0 |
|
154 if imgsize != loaded_image.size: |
|
155 loaded_image=Image.new(imgsize) |
|
156 loaded_image.load(selected_file, callback=finishload) |
|
157 backup_image.text(textloc,u'Loading..',(255,255,0)) |
|
158 zoomsteps=[1.*screensize[0]/loaded_image.size[0],.25,.5,1] |
|
159 zoomstepindex=0 |
|
160 center=[loaded_image.size[0]/2,loaded_image.size[1]/2] |
|
161 backup_image.text(textloc,u'Loading...',(255,255,0)) |
|
162 while not finished: |
|
163 update() |
|
164 e32.ao_sleep(0.5) |
|
165 fullupdate() |
|
166 lock.wait() |
|
167 loaded_image=None |
|
168 backup_image=None |