Raise a well-defined error for directories that are probably invalid.
[automanga.git] / manga / reader.py
1 import threading, gtk, gio, gobject
2 import lib
3
4 class notdone(Exception): pass
5
6 class future(threading.Thread):
7     prog = None
8
9     def __init__(self):
10         super(future, self).__init__()
11         self._val = None
12         self._exc = None
13         self._notlist = []
14         self._started = False
15         self.setDaemon(True)
16
17     def start(self):
18         if not self._started:
19             super(future, self).start()
20             self._started = True
21
22     def run(self):
23         try:
24             val = self.value()
25         except Exception as e:
26             self._exc = e
27             gobject.idle_add(self._callcbs, True)
28         else:
29             self._val = [val]
30             gobject.idle_add(self._callcbs, True)
31
32     def _callcbs(self, final):
33         nls = []
34         for cb in self._notlist:
35             if cb():
36                 nls.append(cb)
37         self._notlist = [] if final else nls
38
39     # Caller must hold GDK lock
40     def notify(self, cb):
41         self.start()
42         if not self.done:
43             self._notlist.append(cb)
44         else:
45             cb()
46
47     def progcb(self):
48         gobject.idle_add(self._callcbs, False)
49
50     @property
51     def val(self):
52         self.start()
53         if self._exc is not None:
54             raise self._exc
55         if self._val is None:
56             raise notdone()
57         return self._val[0]
58
59     @property
60     def done(self):
61         self.start()
62         return self._exc != None or self._val != None
63
64     def wait(self):
65         self.start()
66         while self.is_alive():
67             self.join()
68         return self.val
69
70 class imgload(future):
71     def __init__(self, page):
72         super(imgload, self).__init__()
73         self.page = page
74         self.st = None
75         self.start()
76
77     def value(self):
78         buf = bytearray()
79         with self.page.open() as st:
80             self.p = 0
81             self.st = st
82             while True:
83                 read = st.read(1024)
84                 if read == "":
85                     break
86                 self.p += len(read)
87                 buf.extend(read)
88                 self.progcb()
89         self.st = None
90         with gtk.gdk.lock:
91             try:
92                 return gtk.gdk.pixbuf_new_from_stream(gio.memory_input_stream_new_from_data(str(buf)))
93             finally:
94                 gtk.gdk.flush()
95
96     @property
97     def prog(self):
98         if self.st is None or self.st.clen is None:
99             return None
100         return float(self.p) / float(self.st.clen)
101
102 class pagecache(object):
103     def __init__(self, sz=50):
104         self.sz = sz
105         self.bk = []
106
107     def __getitem__(self, page):
108         idl = page.idlist()
109         for ol, f in self.bk:
110             if ol == idl:
111                 return f
112         f = imgload(page)
113         self.bk.append((idl, f))
114         if len(self.bk) > self.sz:
115             self.bk = self.bk[-self.sz:]
116         return f
117
118 class relpageget(future):
119     def __init__(self, cur, prev, cache=None):
120         super(relpageget, self).__init__()
121         self.cur = lib.cursor(cur)
122         self.prev = prev
123         self.cache = cache
124         self.start()
125
126     def value(self):
127         try:
128             if self.prev:
129                 page = self.cur.prev()
130             else:
131                 page = self.cur.next()
132         except StopIteration:
133             page = None
134         else:
135             if self.cache:
136                 self.cache[page]
137         return page
138
139 class idpageget(future):
140     def __init__(self, base, idlist):
141         super(idpageget, self).__init__()
142         self.bnode = base
143         self.idlist = idlist
144
145     def value(self):
146         return lib.cursor(self.bnode.byidlist(self.idlist)).cur
147
148 class pageget(future):
149     def __init__(self, fnode):
150         super(pageget, self).__init__()
151         self.fnode = fnode
152         self.start()
153
154     def value(self):
155         return lib.cursor(self.fnode).cur
156
157 class ccursor(object):
158     def __init__(self, ob, cache=None):
159         self.cur = lib.cursor(ob)
160         self.prev = relpageget(self.cur, True, cache)
161         self.next = relpageget(self.cur, False, cache)
162
163 class pageview(gtk.Widget):
164     def __init__(self, pixbuf):
165         super(pageview, self).__init__()
166         self.pixbuf = pixbuf
167         self.zoomed = None, None
168         self.fit = True
169         self.zoom = 1.0
170         self.interp = gtk.gdk.INTERP_HYPER
171         self.off = 0, 0
172
173     def get_osize(self):
174         return self.pixbuf.get_width(), self.pixbuf.get_height()
175
176     def get_asize(self):
177         return self.allocation.width, self.allocation.height
178
179     def do_realize(self):
180         self.set_flags(self.flags() | gtk.REALIZED)
181         alloc = self.allocation
182         self.window = gtk.gdk.Window(self.get_parent_window(),
183                                      width=alloc.width, height=alloc.height,
184                                      window_type = gtk.gdk.WINDOW_CHILD,
185                                      wclass = gtk.gdk.INPUT_OUTPUT,
186                                      event_mask = self.get_events() | gtk.gdk.EXPOSURE_MASK
187                                      )
188         self.window.set_user_data(self)
189         self.style.attach(self.window)
190         self.style.set_background(self.window, gtk.STATE_NORMAL)
191         self.window.move_resize(*alloc)
192
193     def do_unrealize(self):
194         self.window.set_user_data(None)
195
196     def do_size_request(self, req):
197         w, h = self.get_osize()
198         req.width, req.height = max(min(w, 4096), 0), max(min(h, 4096), 0)
199
200     def fitzoom(self):
201         w, h = self.get_osize()
202         alloc = self.allocation
203         return min(float(alloc.width) / float(w), float(alloc.height) / float(h))
204
205     def do_size_allocate(self, alloc):
206         self.allocation = alloc
207         if self.fit:
208             self.zoom = self.fitzoom()
209         if self.flags() & gtk.REALIZED:
210             self.window.move_resize(*alloc)
211
212     def get_zoomed(self):
213         zoom = self.zoom
214         pz, zbuf = self.zoomed
215         if pz != zoom:
216             w, h = self.get_osize()
217             zbuf = self.pixbuf.scale_simple(int(w * zoom), int(h * zoom), self.interp)
218             self.zoomed = zoom, zbuf
219         return zbuf
220
221     def get_zsize(self):
222         zbuf = self.get_zoomed()
223         return zbuf.get_width(), zbuf.get_height()
224
225     def do_expose_event(self, event):
226         aw, ah = self.get_asize()
227         dw, dh = aw, ah
228         zbuf = self.get_zoomed()
229         zw, zh = self.get_zsize()
230         ox, oy = self.off
231         dx, dy = 0, 0
232         if zw < aw:
233             dx = (aw - zw) / 2
234             dw = zw
235         if zh < ah:
236             dy = (ah - zh) / 2
237             dh = zh
238         gc = self.style.fg_gc[gtk.STATE_NORMAL]
239         self.window.draw_pixbuf(gc, zbuf, ox, oy, dx, dy, dw, dh)
240
241     def set_off(self, off):
242         aw, ah = self.get_asize()
243         zw, zh = self.get_zsize()
244         ox, oy = off
245         ox, oy = int(ox), int(oy)
246         if ox > zw - aw: ox = zw - aw
247         if oy > zh - ah: oy = zh - ah
248         if ox < 0: ox = 0
249         if oy < 0: oy = 0
250         self.off = ox, oy
251         self.queue_draw()
252
253     def set_zoom(self, zoom):
254         if zoom is not None: zoom = float(zoom)
255         aw, ah = self.get_asize()
256         zw, zh = self.get_zsize()
257         dw, dh = zw - aw, zh - ah
258         ox, oy = self.off
259         xa = float(ox) / float(dw) if dw > 0 else 0.5
260         ya = float(oy) / float(dh) if dh > 0 else 0.5
261
262         if zoom is None:
263             self.fit = True
264             self.zoom = self.fitzoom()
265         else:
266             self.fit = False
267             self.zoom = zoom
268
269         zw, zh = self.get_zsize()
270         dw, dh = zw - aw, zh - ah
271         ox = int(xa * dw) if dw > 0 else 0
272         oy = int(ya * dh) if dh > 0 else 0
273         self.set_off((ox, oy))
274 gobject.type_register(pageview)
275
276 class msgproc(object):
277     def attach(self, reader):
278         self.rd = reader
279         self.msg = gtk.Alignment(0, 0.5, 0, 0)
280         self.hlay = gtk.HBox()
281         self.lbl = gtk.Label("")
282         self.hlay.pack_start(self.lbl)
283         self.lbl.show()
284         self.msg.add(self.hlay)
285         self.hlay.show()
286         self.rd.sbar.pack_start(self.msg)
287         self.msg.show()
288         self._prog = None
289
290     def prog(self, p):
291         if p is not None and self._prog is None:
292             self._prog = gtk.ProgressBar()
293             self._prog.set_fraction(p)
294             self.hlay.pack_start(self._prog, padding=5)
295             self._prog.show()
296         elif p is None and self._prog is not None:
297             self.hlay.remove(self._prog)
298             self._prog = None
299
300     def abort(self):
301         self.rd.sbar.remove(self.msg)
302
303 class pagefetch(msgproc):
304     def __init__(self, fpage, setcb=None):
305         self.pg = fpage
306         self.setcb = setcb
307
308     def attach(self, reader):
309         super(pagefetch, self).attach(reader)
310         self.lbl.set_text("Fetching page...")
311         self.pg.notify(self.haspage)
312
313     def haspage(self):
314         if self.rd.pagefetch.cur != self: return False
315         if not self.pg.done:
316             return True
317         if self.pg.val is not None:
318             self.rd.setpage(self.pg.val)
319             if self.setcb is not None:
320                 self.setcb(self.pg.val)
321         self.rd.pagefetch.set(None)
322
323 class imgfetch(msgproc):
324     def __init__(self, fimage):
325         self.img = fimage
326         self.upd = False
327         self.error = None
328
329     def attach(self, reader):
330         super(imgfetch, self).attach(reader)
331         self.lbl.set_text("Fetching image...")
332         self.img.notify(self.imgprog)
333
334     def imgprog(self):
335         if self.rd.imgfetch.cur != self: return False
336         if self.img.done:
337             try:
338                 img = self.img.val
339             except Exception as e:
340                 self.error = str(e)
341             else:
342                 self.rd.setimg(img)
343                 self.upd = True
344             self.rd.imgfetch.set(None)
345         else:
346             self.prog(self.img.prog)
347             return True
348
349     def abort(self):
350         self.rd.sbar.remove(self.msg)
351         if not self.upd:
352             self.rd.setimg(None)
353             if self.error is not None:
354                 self.rd.pagelbl.set_text("Error fetching image: " + self.error)
355
356 class preload(msgproc):
357     def __init__(self, fpage):
358         self.pg = fpage
359
360     def attach(self, reader):
361         super(preload, self).attach(reader)
362         self.lbl.set_text("Fetching next page...")
363         self.pg.notify(self.haspage)
364
365     def haspage(self):
366         if self.rd.preload.cur != self: return False
367         if not self.pg.done: return True
368         if self.pg.val is not None:
369             self.img = self.rd.cache[self.pg.val]
370             self.lbl.set_text("Loading next page...")
371             self.img.notify(self.imgprog)
372         else:
373             self.rd.preload.set(None)
374
375     def imgprog(self):
376         if self.rd.preload.cur != self: return False
377         if self.img.done:
378             self.rd.preload.set(None)
379         else:
380             self.prog(self.img.prog)
381             return True
382
383     def abort(self):
384         self.rd.sbar.remove(self.msg)
385
386 class procslot(object):
387     __slots__ = ["cur", "p"]
388     def __init__(self, p):
389         self.cur = None
390         self.p = p
391
392     def set(self, proc):
393         if self.cur is not None:
394             self.cur.abort()
395             self.cur = None
396         if proc is not None:
397             self.cur = proc
398             try:
399                 proc.attach(self.p)
400             except:
401                 self.cur = None
402                 raise
403
404 class plistget(future):
405     def __init__(self, node):
406         super(plistget, self).__init__()
407         self.node = node
408
409     def value(self):
410         return list(self.node)
411
412 class loadplist(object):
413     def __init__(self, pnode):
414         self.pnode = pnode
415         self.flist = plistget(self.pnode)
416
417     def attach(self, sbox):
418         self.sbox = sbox
419         self.flist.notify(self.haslist)
420
421     def haslist(self):
422         if self.sbox.loadlist.cur != self: return False
423         if not self.flist.done: return True
424         self.sbox.setlist(self.flist.val)
425
426 class sbox(gtk.ComboBox):
427     def __init__(self, reader, ptnode):
428         super(sbox, self).__init__()
429         self.rd = reader
430         self.node = ptnode
431         self.pnode, self.pidx = self.node.stack[-1]
432
433         self.bk = gtk.ListStore(str)
434         self.set_model(self.bk)
435         cell = gtk.CellRendererText()
436         self.pack_start(cell, True)
437         self.add_attribute(cell, "text", 0)
438         self.set_active(0)
439
440         self.set_sensitive(False)
441         self.set_focus_on_click(False)
442         self.bk.append([ptnode.name])
443         self.loadlist = procslot(self)
444         self.loadlist.set(loadplist(self.pnode))
445
446     def setlist(self, ls):
447         self.bk.clear()
448         for i, ch in enumerate(ls):
449             self.bk.append(["%i/%i: %s" % (i + 1, len(ls), ch.name)])
450         self.set_active(self.pidx)
451         self.set_sensitive(True)
452         self.connect("changed", self.changed_cb)
453
454     def changed_cb(self, wdg, data=None):
455         self.rd.fetchpage(pageget(self.pnode[self.get_active()]))
456
457 class reader(gtk.Window):
458     def __init__(self, manga, profile=None):
459         super(reader, self).__init__(gtk.WINDOW_TOPLEVEL)
460         self.connect("delete_event",    lambda wdg, ev, data=None: False)
461         self.connect("destroy",         lambda wdg, data=None:     self.quit())
462         self.connect("key_press_event", self.key)
463         self.cache = pagecache()
464         self.pagefetch = procslot(self)
465         self.imgfetch = procslot(self)
466         self.preload = procslot(self)
467         self.profile = profile
468
469         self.manga = manga
470         self.page = None
471         self.sboxes = []
472         self.point = None
473
474         vlay = gtk.VBox()
475         self.pfr = gtk.Frame(None)
476         self.pfr.set_shadow_type(gtk.SHADOW_NONE)
477         vlay.pack_start(self.pfr)
478         self.pfr.show()
479         self.sboxbar = gtk.HBox()
480         algn = gtk.Alignment(0, 0.5, 0, 0)
481         sboxlbl = gtk.Label(self.manga.name + u": ")
482         algn.add(sboxlbl)
483         sboxlbl.show()
484         self.sboxbar.pack_start(algn, False)
485         algn.show()
486         vlay.pack_start(self.sboxbar, False)
487         self.sboxbar.show()
488         self.sbar = gtk.HBox()
489         self.pagelbl = gtk.Label("")
490         algn = gtk.Alignment(0, 0.5, 0, 0)
491         algn.add(self.pagelbl)
492         self.pagelbl.show()
493         self.sbar.pack_start(algn)
494         algn.show()
495         vlay.pack_end(self.sbar, False)
496         self.sbar.show()
497         self.add(vlay)
498         vlay.show()
499
500         if self.profile and "curpage" in self.profile:
501             self.fetchpage(idpageget(self.manga, self.profile["curpage"]))
502         else:
503             self.fetchpage(pageget(self.manga))
504         self.updtitle()
505
506     def updpagelbl(self):
507         if self.page is None:
508             self.pagelbl.set_text("")
509         else:
510             w, h = self.page.get_osize()
511             self.pagelbl.set_text(u"%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
512
513     def updsboxes(self, page):
514         nodes = [node for node, idx in page.stack[1:]] + [page]
515         l = min(len(self.sboxes), len(nodes))
516         for i, (pbox, node) in enumerate(zip(self.sboxes, nodes)):
517             if pbox.node != node:
518                 l = i
519                 break
520         for i in xrange(l, len(self.sboxes)):
521             self.sboxbar.remove(self.sboxes[i])
522         self.sboxes = self.sboxes[:l]
523         for i in xrange(l, len(nodes)):
524             new = sbox(self, nodes[i])
525             self.sboxbar.pack_start(new, False, padding=5)
526             self.sboxes.append(new)
527             new.show()
528
529     def setimg(self, img):
530         if self.page is not None:
531             self.pfr.remove(self.page)
532             self.page = None
533         if img is not None:
534             self.page = pageview(img)
535             self.pfr.add(self.page)
536             self.page.show()
537         self.updpagelbl()
538
539     def setpage(self, page):
540         if self.point is not None:
541             self.point = None
542         if page is not None:
543             if self.profile:
544                 self.profile.setprop("curpage", page.idlist())
545                 self.profile.saveprops()
546             self.point = ccursor(page, self.cache)
547             self.imgfetch.set(imgfetch(self.cache[page]))
548         else:
549             self.setimg(None)
550         self.updsboxes(page)
551
552     def fetchpage(self, fpage, setcb=None):
553         self.imgfetch.set(None)
554         proc = pagefetch(fpage, setcb)
555         self.pagefetch.set(proc)
556         return proc
557
558     def updtitle(self):
559         self.set_title(u"Automanga \u2013 " + self.manga.name)
560
561     @property
562     def zoom(self):
563         return self.page.zoom
564     @zoom.setter
565     def zoom(self, zoom):
566         self.page.set_zoom(zoom)
567         self.updpagelbl()
568
569     def pan(self, off):
570         ox, oy = self.page.off
571         px, py = off
572         self.page.set_off((ox + px, oy + py))
573
574     def key(self, wdg, ev, data=None):
575         if ev.keyval in [ord('Q'), ord('q')]:
576             self.quit()
577         elif ev.keyval in [65307]:
578             if self.page is not None:
579                 self.pagefetch.set(None)
580             self.imgfetch.set(None)
581         if self.page is not None:
582             if ev.keyval in [ord('O'), ord('o')]:
583                 self.zoom = 1.0
584             elif ev.keyval in [ord('P'), ord('p')]:
585                 self.zoom = None
586             elif ev.keyval in [ord('[')]:
587                 self.zoom = min(self.zoom * 1.25, 3)
588             elif ev.keyval in [ord(']')]:
589                 self.zoom /= 1.25
590             elif ev.keyval in [ord('h')]:
591                 self.pan((-100, 0))
592             elif ev.keyval in [ord('j')]:
593                 self.pan((0, 100))
594             elif ev.keyval in [ord('k')]:
595                 self.pan((0, -100))
596             elif ev.keyval in [ord('l')]:
597                 self.pan((100, 0))
598             elif ev.keyval in [ord('H')]:
599                 self.page.set_off((0, self.page.off[1]))
600             elif ev.keyval in [ord('J')]:
601                 self.page.set_off((self.page.off[0], self.page.get_asize()[1]))
602             elif ev.keyval in [ord('K')]:
603                 self.page.set_off((self.page.off[1], 0))
604             elif ev.keyval in [ord('L')]:
605                 self.page.set_off((self.page.get_asize()[0], self.page.off[1]))
606         if self.point is not None:
607             if ev.keyval in [ord(' ')]:
608                 self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
609             elif ev.keyval in [65288]:
610                 self.fetchpage(self.point.prev, lambda page: self.preload.set(preload(relpageget(page, True, self.cache))))
611
612     def quit(self):
613         self.hide()
614         gtk.main_quit()
615 gobject.type_register(reader)