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