3 gi.require_version("Gtk", "3.0")
4 from gi.repository import Gtk as gtk, GdkPixbuf as gdkpix, Gdk as gdk, GObject as gobject
5 from . import lib, profile
7 class notdone(Exception): pass
9 class future(threading.Thread):
13 super(future, self).__init__()
17 self._tstarted = False
21 if not self._tstarted:
22 super(future, self).start()
28 except Exception as e:
30 gobject.idle_add(self._callcbs, True)
33 gobject.idle_add(self._callcbs, True)
35 def _callcbs(self, final):
37 for cb in self._notlist:
40 self._notlist = [] if final else nls
42 # Caller must hold GDK lock
46 self._notlist.append(cb)
51 gobject.idle_add(self._callcbs, False)
56 if self._exc is not None:
65 return self._exc != None or self._val != None
69 while self.is_alive():
73 class imgload(future):
74 def __init__(self, page):
75 super(imgload, self).__init__()
81 buf = gdkpix.PixbufLoader()
84 with self.page.open() as st:
102 return buf.get_pixbuf()
106 if self.st is None or self.st.clen is None:
108 return float(self.p) / float(self.st.clen)
110 class pagecache(object):
111 def __init__(self, sz=50):
115 def __getitem__(self, page):
117 for ol, f in self.bk:
121 self.bk.append((idl, f))
122 if len(self.bk) > self.sz:
123 self.bk = self.bk[-self.sz:]
126 def __delitem__(self, page):
128 for i, (ol, f) in enumerate(self.bk):
134 class relpageget(future):
135 def __init__(self, cur, prev, cache=None):
136 super(relpageget, self).__init__()
137 self.cur = lib.cursor(cur)
145 page = self.cur.prev()
147 page = self.cur.next()
148 except StopIteration:
155 class idpageget(future):
156 def __init__(self, base, idlist):
157 super(idpageget, self).__init__()
163 return lib.cursor(self.bnode.byidlist(self.idlist)).cur
165 raise KeyError("could not find last read page: " + repr(self.idlist))
167 class pageget(future):
168 def __init__(self, fnode):
169 super(pageget, self).__init__()
174 return lib.cursor(self.fnode).cur
176 class ccursor(object):
177 def __init__(self, ob, cache=None):
178 self.cur = lib.cursor(ob)
179 self.prev = relpageget(self.cur, True, cache)
180 self.next = relpageget(self.cur, False, cache)
182 class pageview(gtk.Widget):
183 def __init__(self, pixbuf):
184 super(pageview, self).__init__()
186 self.zoomed = None, None
189 self.interp = gdkpix.InterpType.HYPER
193 return self.pixbuf.get_width(), self.pixbuf.get_height()
196 alloc = self.get_allocation()
197 return alloc.width, alloc.height
199 def do_realize(self):
200 alloc = self.get_allocation()
201 attr = gdk.WindowAttr()
202 attr.window_type = gdk.WindowType.CHILD
205 attr.width = alloc.width
206 attr.height = alloc.height
207 attr.visual = self.get_visual()
208 attr.event_mask = self.get_events() | gdk.EventMask.EXPOSURE_MASK
209 a = gdk.WindowAttributesType
210 wnd = gdk.Window(self.get_parent_window(), attr, a.X | a.Y | a.VISUAL)
211 wnd.set_background_pattern(None)
213 self.register_window(wnd)
214 self.set_realized(True)
216 # XXX: Why don't these actually get called?
217 def get_preferred_width(self):
218 return 0, max(min(self.get_osize()[0], 4096), 0)
219 def get_preferred_height(self):
220 return 0, max(min(self.get_osize()[1], 4096), 0)
223 w, h = self.get_osize()
224 alloc = self.get_allocation()
225 return min(float(alloc.width) / float(w), float(alloc.height) / float(h))
227 def do_size_allocate(self, alloc):
228 self.set_allocation(alloc)
230 self.zoom = self.fitzoom()
232 aw, ah = self.get_asize()
233 zw, zh = self.get_zsize()
235 if zw >= aw and ox + aw > zw:
237 if zh >= ah and oy + ah > zh:
240 if self.get_realized():
241 self.get_window().move_resize(alloc.x, alloc.y, alloc.width, alloc.height)
243 def get_zoomed(self):
245 pz, zbuf = self.zoomed
247 w, h = self.get_osize()
248 zbuf = self.pixbuf.scale_simple(int(w * zoom), int(h * zoom), self.interp)
249 self.zoomed = zoom, zbuf
253 zbuf = self.get_zoomed()
254 return zbuf.get_width(), zbuf.get_height()
256 def do_draw(self, cr):
257 aw, ah = self.get_asize()
259 zbuf = self.get_zoomed()
260 zw, zh = self.get_zsize()
269 gdk.cairo_set_source_pixbuf(cr, zbuf, dx - ox, dy - oy)
272 def set_off(self, off):
273 aw, ah = self.get_asize()
274 zw, zh = self.get_zsize()
276 ox, oy = int(ox), int(oy)
277 if ox > zw - aw: ox = zw - aw
278 if oy > zh - ah: oy = zh - ah
284 def set_zoom(self, zoom):
285 if zoom is not None: zoom = float(zoom)
286 aw, ah = self.get_asize()
287 zw, zh = self.get_zsize()
288 dw, dh = zw - aw, zh - ah
290 xa = float(ox) / float(dw) if dw > 0 else 0.5
291 ya = float(oy) / float(dh) if dh > 0 else 0.5
295 self.zoom = self.fitzoom()
300 zw, zh = self.get_zsize()
301 dw, dh = zw - aw, zh - ah
302 ox = int(xa * dw) if dw > 0 else 0
303 oy = int(ya * dh) if dh > 0 else 0
304 self.set_off((ox, oy))
306 class msgproc(object):
307 def attach(self, reader):
309 self.msg = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
310 self.hlay = gtk.HBox()
311 self.lbl = gtk.Label("")
312 self.hlay.pack_start(self.lbl, True, True, 0)
314 self.msg.add(self.hlay)
316 self.rd.sbar.pack_start(self.msg, True, True, 0)
322 if self._prog is None:
323 self._prog = gtk.ProgressBar()
324 self.hlay.pack_start(self._prog, True, True, 5)
326 self._prog.set_fraction(p)
327 elif p is None and self._prog is not None:
328 self.hlay.remove(self._prog)
332 self.rd.sbar.remove(self.msg)
334 class pagefetch(msgproc):
335 def __init__(self, fpage, setcb=None):
339 def attach(self, reader):
340 super(pagefetch, self).attach(reader)
341 self.lbl.set_text("Fetching page...")
342 self.pg.notify(self.haspage)
345 if self.rd.pagefetch.cur != self: return False
348 if self.pg.val is not None:
349 self.rd.setpage(self.pg.val)
350 if self.setcb is not None:
351 self.setcb(self.pg.val)
352 self.rd.pagefetch.set(None)
354 class imgfetch(msgproc):
355 def __init__(self, fimage):
360 def attach(self, reader):
361 super(imgfetch, self).attach(reader)
362 self.lbl.set_text("Fetching image...")
363 self.img.notify(self.imgprog)
366 if self.rd.imgfetch.cur != self: return False
370 except Exception as e:
375 self.rd.imgfetch.set(None)
377 self.prog(self.img.prog)
381 self.rd.sbar.remove(self.msg)
384 if self.error is not None:
385 self.rd.pagelbl.set_text("Error fetching image: " + self.error)
387 class preload(msgproc):
388 def __init__(self, fpage):
391 def attach(self, reader):
392 super(preload, self).attach(reader)
393 self.lbl.set_text("Fetching next page...")
394 self.pg.notify(self.haspage)
397 if self.rd.preload.cur != self: return False
398 if not self.pg.done: return True
399 if self.pg.val is not None:
400 self.img = self.rd.cache[self.pg.val]
401 self.lbl.set_text("Loading next page...")
402 self.img.notify(self.imgprog)
404 self.rd.preload.set(None)
407 if self.rd.preload.cur != self: return False
409 self.rd.preload.set(None)
411 self.prog(self.img.prog)
415 self.rd.sbar.remove(self.msg)
417 class procslot(object):
418 __slots__ = ["cur", "p"]
419 def __init__(self, p):
424 if self.cur is not None:
435 class plistget(future):
436 def __init__(self, node):
437 super(plistget, self).__init__()
441 return list(self.node)
443 class loadplist(object):
444 def __init__(self, pnode):
446 self.flist = plistget(self.pnode)
448 def attach(self, sbox):
450 self.flist.notify(self.haslist)
453 if self.sbox.loadlist.cur != self: return False
454 if not self.flist.done: return True
455 self.sbox.setlist(self.flist.val)
457 class sbox(gtk.ComboBox):
458 def __init__(self, reader, ptnode):
459 super(sbox, self).__init__()
462 self.pnode, self.pidx = self.node.stack[-1]
464 self.bk = gtk.ListStore(str)
465 self.set_model(self.bk)
466 cell = gtk.CellRendererText()
467 self.pack_start(cell, True)
468 self.add_attribute(cell, "text", 0)
471 self.set_sensitive(False)
472 self.set_focus_on_click(False)
473 self.bk.append([ptnode.name])
474 self.loadlist = procslot(self)
475 self.loadlist.set(loadplist(self.pnode))
477 def setlist(self, ls):
479 for i, ch in enumerate(ls):
480 self.bk.append(["%i/%i: %s" % (i + 1, len(ls), ch.name)])
481 self.set_active(self.pidx)
482 self.set_sensitive(True)
483 self.connect("changed", self.changed_cb)
485 def changed_cb(self, wdg, data=None):
486 self.rd.fetchpage(pageget(self.pnode[self.get_active()]))
488 class profprop(object):
489 def __init__(self, key, default=None):
491 self.default = default
493 def __get__(self, ins, cls):
494 return ins.profile.props.get(self.key, self.default)
496 def __set__(self, ins, val):
497 ins.profile.props[self.key] = val
500 def __delete__(self, ins):
501 del ins.profile.props[self.key]
504 class reader(gtk.Window):
505 def __init__(self, manga, prof=None):
506 super(reader, self).__init__()
507 self.connect("delete_event", lambda wdg, ev, data=None: False)
508 self.connect("destroy", lambda wdg, data=None: self.quit())
509 self.connect("key_press_event", self.key)
510 self.cache = pagecache()
511 self.pagefetch = procslot(self)
512 self.imgfetch = procslot(self)
513 self.preload = procslot(self)
514 self.profile = prof if prof else profile.memmanga(None, None, manga.id)
522 self.pfr = gtk.Frame()
523 self.pfr.set_shadow_type(gtk.ShadowType.NONE)
524 vlay.pack_start(self.pfr, True, True, 0)
526 self.sboxbar = gtk.HBox()
527 algn = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
528 sboxlbl = gtk.Label(self.manga.name + ": ")
531 self.sboxbar.pack_start(algn, False, True, 0)
533 vlay.pack_start(self.sboxbar, False, True, 0)
535 self.sbar = gtk.HBox()
536 self.pagelbl = gtk.Label("")
537 algn = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
538 algn.add(self.pagelbl)
540 self.sbar.pack_start(algn, True, True, 0)
542 vlay.pack_end(self.sbar, False, True, 0)
547 if self.curpage is not None:
548 self.fetchpage(idpageget(self.manga, self.curpage))
550 self.fetchpage(pageget(self.manga))
553 zmode = profprop("zmode", "fit")
554 curpage = profprop("curpage")
556 def updpagelbl(self):
557 if self.page is None:
558 self.pagelbl.set_text("")
560 w, h = self.page.get_osize()
561 self.pagelbl.set_text("%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
563 def updsboxes(self, page):
564 nodes = [node for node, idx in page.stack[1:]] + [page]
565 l = min(len(self.sboxes), len(nodes))
566 for i, (pbox, node) in enumerate(zip(self.sboxes, nodes)):
567 if pbox.node != node:
570 for i in range(l, len(self.sboxes)):
571 self.sboxbar.remove(self.sboxes[i])
572 self.sboxes = self.sboxes[:l]
573 for i in range(l, len(nodes)):
574 new = sbox(self, nodes[i])
575 self.sboxbar.pack_start(new, False, True, 5)
576 self.sboxes.append(new)
579 def setimg(self, img):
580 if self.page is not None:
581 self.pfr.remove(self.page)
584 self.page = pageview(img)
585 if self.zmode == "1":
586 self.page.set_zoom(1)
587 self.page.set_off((0, 0))
588 self.pfr.add(self.page)
592 def setpage(self, page):
593 if self.point is not None:
596 self.curpage = page.idlist()
597 self.point = ccursor(page, self.cache)
598 self.imgfetch.set(imgfetch(self.cache[page]))
603 def fetchpage(self, fpage, setcb=None):
604 self.imgfetch.set(None)
605 proc = pagefetch(fpage, setcb)
606 self.pagefetch.set(proc)
610 self.set_title("Automanga \u2013 " + self.manga.name)
614 return self.page.zoom
616 def zoom(self, zoom):
617 self.page.set_zoom(zoom)
621 ox, oy = self.page.off
623 self.page.set_off((ox + px, oy + py))
625 def key(self, wdg, ev, data=None):
626 if ev.keyval in [ord('Q'), ord('q')]:
628 elif ev.keyval in [65307]:
629 if self.page is not None:
630 self.pagefetch.set(None)
631 self.imgfetch.set(None)
632 if self.page is not None:
633 if ev.keyval in [ord('O'), ord('o')]:
636 elif ev.keyval in [ord('P'), ord('p')]:
639 elif ev.keyval in [ord('[')]:
640 self.zoom = min(self.zoom * 1.25, 3)
641 elif ev.keyval in [ord(']')]:
643 elif ev.keyval in [ord('h')]:
645 elif ev.keyval in [ord('j')]:
647 elif ev.keyval in [ord('k')]:
649 elif ev.keyval in [ord('l')]:
651 elif ev.keyval in [ord('H')]:
652 self.page.set_off((0, self.page.off[1]))
653 elif ev.keyval in [ord('J')]:
654 self.page.set_off((self.page.off[0], self.page.get_asize()[1]))
655 elif ev.keyval in [ord('K')]:
656 self.page.set_off((self.page.off[1], 0))
657 elif ev.keyval in [ord('L')]:
658 self.page.set_off((self.page.get_asize()[0], self.page.off[1]))
659 if self.point is not None:
660 if ev.keyval in [ord(' ')]:
661 if self.page and self.page.off[1] + self.page.get_asize()[1] < self.page.get_zsize()[1]:
662 self.pan((0, self.page.get_asize()[1] - 50))
664 self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
665 elif ev.keyval in [65288]:
666 if self.page and self.page.off[1] > 0:
667 self.pan((0, -(self.page.get_asize()[1] - 50)))
669 self.fetchpage(self.point.prev, lambda page: self.preload.set(preload(relpageget(page, True, self.cache))))
670 elif ev.keyval in [ord('R'), ord('r')]:
671 page = self.point.cur.cur
673 self.imgfetch.set(imgfetch(self.cache[page]))
678 gobject.type_register(reader)