-import threading, gtk, gio, gobject
-import lib
+import threading, gtk, gobject
+import lib, profile
class notdone(Exception): pass
try:
val = self.value()
except Exception as e:
- with gtk.gdk.lock:
- self._exc = e
- for cb in self._notlist:
- cb()
- self._notlist = []
+ self._exc = e
+ gobject.idle_add(self._callcbs, True)
else:
- with gtk.gdk.lock:
- self._val = [val]
- for cb in self._notlist:
- cb()
- self._notlist = []
+ self._val = [val]
+ gobject.idle_add(self._callcbs, True)
+
+ def _callcbs(self, final):
+ nls = []
+ for cb in self._notlist:
+ if cb():
+ nls.append(cb)
+ self._notlist = [] if final else nls
# Caller must hold GDK lock
def notify(self, cb):
cb()
def progcb(self):
- with gtk.gdk.lock:
- nls = []
- for cb in self._notlist:
- if cb():
- nls.append(cb)
- self._notlist = nls
+ gobject.idle_add(self._callcbs, False)
@property
def val(self):
self.start()
def value(self):
- buf = bytearray()
- with self.page.open() as st:
- self.p = 0
- self.st = st
- while True:
- read = st.read(1024)
- if read == "":
- break
- self.p += len(read)
- buf.extend(read)
- self.progcb()
- self.st = None
- return gtk.gdk.pixbuf_new_from_stream(gio.memory_input_stream_new_from_data(str(buf)))
+ buf = gtk.gdk.PixbufLoader()
+ try:
+ with self.page.open() as st:
+ self.p = 0
+ self.st = st
+ while True:
+ read = st.read(1024)
+ if read == "":
+ break
+ self.p += len(read)
+ buf.write(read)
+ self.progcb()
+ self.st = None
+ finally:
+ buf.close()
+ return buf.get_pixbuf()
@property
def prog(self):
f = imgload(page)
self.bk.append((idl, f))
if len(self.bk) > self.sz:
- self.bk = self.bk[-sz:]
+ self.bk = self.bk[-self.sz:]
return f
+ def __delitem__(self, page):
+ idl = page.idlist()
+ for i, (ol, f) in enumerate(self.bk):
+ if ol == idl:
+ del self.bk[i]
+ return
+ raise KeyError(idl)
+
class relpageget(future):
def __init__(self, cur, prev, cache=None):
super(relpageget, self).__init__()
self.cache[page]
return page
+class idpageget(future):
+ def __init__(self, base, idlist):
+ super(idpageget, self).__init__()
+ self.bnode = base
+ self.idlist = idlist
+
+ def value(self):
+ return lib.cursor(self.bnode.byidlist(self.idlist)).cur
+
class pageget(future):
def __init__(self, fnode):
super(pageget, self).__init__()
self.window.set_user_data(None)
def do_size_request(self, req):
- req.width, req.height = self.get_osize()
+ w, h = self.get_osize()
+ req.width, req.height = max(min(w, 4096), 0), max(min(h, 4096), 0)
def fitzoom(self):
w, h = self.get_osize()
self.cur = None
raise
+class plistget(future):
+ def __init__(self, node):
+ super(plistget, self).__init__()
+ self.node = node
+
+ def value(self):
+ return list(self.node)
+
+class loadplist(object):
+ def __init__(self, pnode):
+ self.pnode = pnode
+ self.flist = plistget(self.pnode)
+
+ def attach(self, sbox):
+ self.sbox = sbox
+ self.flist.notify(self.haslist)
+
+ def haslist(self):
+ if self.sbox.loadlist.cur != self: return False
+ if not self.flist.done: return True
+ self.sbox.setlist(self.flist.val)
+
+class sbox(gtk.ComboBox):
+ def __init__(self, reader, ptnode):
+ super(sbox, self).__init__()
+ self.rd = reader
+ self.node = ptnode
+ self.pnode, self.pidx = self.node.stack[-1]
+
+ self.bk = gtk.ListStore(str)
+ self.set_model(self.bk)
+ cell = gtk.CellRendererText()
+ self.pack_start(cell, True)
+ self.add_attribute(cell, "text", 0)
+ self.set_active(0)
+
+ self.set_sensitive(False)
+ self.set_focus_on_click(False)
+ self.bk.append([ptnode.name])
+ self.loadlist = procslot(self)
+ self.loadlist.set(loadplist(self.pnode))
+
+ def setlist(self, ls):
+ self.bk.clear()
+ for i, ch in enumerate(ls):
+ self.bk.append(["%i/%i: %s" % (i + 1, len(ls), ch.name)])
+ self.set_active(self.pidx)
+ self.set_sensitive(True)
+ self.connect("changed", self.changed_cb)
+
+ def changed_cb(self, wdg, data=None):
+ self.rd.fetchpage(pageget(self.pnode[self.get_active()]))
+
+class profprop(object):
+ def __init__(self, key, default=None):
+ self.key = key
+ self.default = default
+
+ def __get__(self, ins, cls):
+ return ins.profile.props.get(self.key, self.default)
+
+ def __set__(self, ins, val):
+ ins.profile.props[self.key] = val
+ ins.profile.save()
+
+ def __delete__(self, ins):
+ del ins.profile.props[self.key]
+ ins.profile.save()
+
class reader(gtk.Window):
- def __init__(self, manga):
+ def __init__(self, manga, prof=None):
super(reader, self).__init__(gtk.WINDOW_TOPLEVEL)
self.connect("delete_event", lambda wdg, ev, data=None: False)
self.connect("destroy", lambda wdg, data=None: self.quit())
self.pagefetch = procslot(self)
self.imgfetch = procslot(self)
self.preload = procslot(self)
+ self.profile = prof if prof else profile.memmanga(None, None, manga.id)
+
+ self.manga = manga
+ self.page = None
+ self.sboxes = []
+ self.point = None
vlay = gtk.VBox()
self.pfr = gtk.Frame(None)
self.pfr.set_shadow_type(gtk.SHADOW_NONE)
vlay.pack_start(self.pfr)
self.pfr.show()
+ self.sboxbar = gtk.HBox()
+ algn = gtk.Alignment(0, 0.5, 0, 0)
+ sboxlbl = gtk.Label(self.manga.name + u": ")
+ algn.add(sboxlbl)
+ sboxlbl.show()
+ self.sboxbar.pack_start(algn, False)
+ algn.show()
+ vlay.pack_start(self.sboxbar, False)
+ self.sboxbar.show()
self.sbar = gtk.HBox()
self.pagelbl = gtk.Label("")
algn = gtk.Alignment(0, 0.5, 0, 0)
self.add(vlay)
vlay.show()
- self.manga = manga
- self.page = None
- self.fetchpage(pageget(self.manga))
+ if self.curpage is not None:
+ self.fetchpage(idpageget(self.manga, self.curpage))
+ else:
+ self.fetchpage(pageget(self.manga))
self.updtitle()
- self.point = None
+
+ zmode = profprop("zmode", "fit")
+ curpage = profprop("curpage")
def updpagelbl(self):
if self.page is None:
w, h = self.page.get_osize()
self.pagelbl.set_text(u"%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
+ def updsboxes(self, page):
+ nodes = [node for node, idx in page.stack[1:]] + [page]
+ l = min(len(self.sboxes), len(nodes))
+ for i, (pbox, node) in enumerate(zip(self.sboxes, nodes)):
+ if pbox.node != node:
+ l = i
+ break
+ for i in xrange(l, len(self.sboxes)):
+ self.sboxbar.remove(self.sboxes[i])
+ self.sboxes = self.sboxes[:l]
+ for i in xrange(l, len(nodes)):
+ new = sbox(self, nodes[i])
+ self.sboxbar.pack_start(new, False, padding=5)
+ self.sboxes.append(new)
+ new.show()
+
def setimg(self, img):
if self.page is not None:
self.pfr.remove(self.page)
self.page = None
if img is not None:
self.page = pageview(img)
+ if self.zmode == "1":
+ self.page.set_zoom(1)
+ self.page.set_off((0, 0))
self.pfr.add(self.page)
self.page.show()
self.updpagelbl()
if self.point is not None:
self.point = None
if page is not None:
+ self.curpage = page.idlist()
self.point = ccursor(page, self.cache)
self.imgfetch.set(imgfetch(self.cache[page]))
else:
self.setimg(None)
+ self.updsboxes(page)
def fetchpage(self, fpage, setcb=None):
self.imgfetch.set(None)
if self.page is not None:
if ev.keyval in [ord('O'), ord('o')]:
self.zoom = 1.0
+ self.zmode = "1"
elif ev.keyval in [ord('P'), ord('p')]:
self.zoom = None
+ self.zmode = "fit"
elif ev.keyval in [ord('[')]:
self.zoom = min(self.zoom * 1.25, 3)
elif ev.keyval in [ord(']')]:
self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
elif ev.keyval in [65288]:
self.fetchpage(self.point.prev, lambda page: self.preload.set(preload(relpageget(page, True, self.cache))))
+ elif ev.keyval in [ord('R'), ord('r')]:
+ page = self.point.cur.cur
+ del self.cache[page]
+ self.imgfetch.set(imgfetch(self.cache[page]))
def quit(self):
self.hide()
Dolda2000 GitWeb / automanga.git / blobdiff