-import threading, gtk, gio, gobject
-import lib
+import threading
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk as gtk, GdkPixbuf as gdkpix, Gdk as gdk, GObject as gobject
+from . import lib, profile
class notdone(Exception): pass
self._val = None
self._exc = None
self._notlist = []
- self._started = False
+ self._tstarted = False
self.setDaemon(True)
def start(self):
- if not self._started:
+ if not self._tstarted:
super(future, self).start()
- self._started = True
+ self._tstarted = True
def run(self):
try:
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
- with gtk.gdk.lock:
+ buf = gdkpix.PixbufLoader()
+ done = False
+ try:
+ with self.page.open() as st:
+ self.p = 0
+ self.st = st
+ while True:
+ read = st.read(1024)
+ if read == b"":
+ break
+ self.p += len(read)
+ buf.write(read)
+ self.progcb()
+ self.st = None
+ done = True
+ finally:
try:
- return gtk.gdk.pixbuf_new_from_stream(gio.memory_input_stream_new_from_data(str(buf)))
- finally:
- gtk.gdk.flush()
+ buf.close()
+ except:
+ if done:
+ raise
+ return buf.get_pixbuf()
@property
def prog(self):
self.idlist = idlist
def value(self):
- return lib.cursor(self.bnode.byidlist(self.idlist)).cur
+ try:
+ return lib.cursor(self.bnode.byidlist(self.idlist)).cur
+ except KeyError:
+ raise KeyError("could not find last read page: " + repr(self.idlist))
class pageget(future):
def __init__(self, fnode):
self.zoomed = None, None
self.fit = True
self.zoom = 1.0
- self.interp = gtk.gdk.INTERP_HYPER
+ self.interp = gdkpix.InterpType.HYPER
self.off = 0, 0
def get_osize(self):
return self.pixbuf.get_width(), self.pixbuf.get_height()
def get_asize(self):
- return self.allocation.width, self.allocation.height
+ alloc = self.get_allocation()
+ return alloc.width, alloc.height
def do_realize(self):
- self.set_flags(self.flags() | gtk.REALIZED)
- alloc = self.allocation
- self.window = gtk.gdk.Window(self.get_parent_window(),
- width=alloc.width, height=alloc.height,
- window_type = gtk.gdk.WINDOW_CHILD,
- wclass = gtk.gdk.INPUT_OUTPUT,
- event_mask = self.get_events() | gtk.gdk.EXPOSURE_MASK
- )
- self.window.set_user_data(self)
- self.style.attach(self.window)
- self.style.set_background(self.window, gtk.STATE_NORMAL)
- self.window.move_resize(*alloc)
-
- def do_unrealize(self):
- self.window.set_user_data(None)
-
- def do_size_request(self, req):
- w, h = self.get_osize()
- req.width, req.height = max(min(w, 4096), 0), max(min(h, 4096), 0)
+ alloc = self.get_allocation()
+ attr = gdk.WindowAttr()
+ attr.window_type = gdk.WindowType.CHILD
+ attr.x = alloc.x
+ attr.y = alloc.y
+ attr.width = alloc.width
+ attr.height = alloc.height
+ attr.visual = self.get_visual()
+ attr.event_mask = self.get_events() | gdk.EventMask.EXPOSURE_MASK
+ a = gdk.WindowAttributesType
+ wnd = gdk.Window(self.get_parent_window(), attr, a.X | a.Y | a.VISUAL)
+ wnd.set_background_pattern(None)
+ self.set_window(wnd)
+ self.register_window(wnd)
+ self.set_realized(True)
+
+ # XXX: Why don't these actually get called?
+ def get_preferred_width(self):
+ return 0, max(min(self.get_osize()[0], 4096), 0)
+ def get_preferred_height(self):
+ return 0, max(min(self.get_osize()[1], 4096), 0)
def fitzoom(self):
w, h = self.get_osize()
- alloc = self.allocation
+ alloc = self.get_allocation()
return min(float(alloc.width) / float(w), float(alloc.height) / float(h))
def do_size_allocate(self, alloc):
- self.allocation = alloc
+ self.set_allocation(alloc)
if self.fit:
self.zoom = self.fitzoom()
- if self.flags() & gtk.REALIZED:
- self.window.move_resize(*alloc)
+ else:
+ aw, ah = self.get_asize()
+ zw, zh = self.get_zsize()
+ ox, oy = self.off
+ if zw >= aw and ox + aw > zw:
+ ox = zw - aw
+ if zh >= ah and oy + ah > zh:
+ oy = zh - ah
+ self.off = ox, oy
+ if self.get_realized():
+ self.get_window().move_resize(alloc.x, alloc.y, alloc.width, alloc.height)
def get_zoomed(self):
zoom = self.zoom
zbuf = self.get_zoomed()
return zbuf.get_width(), zbuf.get_height()
- def do_expose_event(self, event):
+ def do_draw(self, cr):
aw, ah = self.get_asize()
dw, dh = aw, ah
zbuf = self.get_zoomed()
if zh < ah:
dy = (ah - zh) / 2
dh = zh
- gc = self.style.fg_gc[gtk.STATE_NORMAL]
- self.window.draw_pixbuf(gc, zbuf, ox, oy, dx, dy, dw, dh)
+ gdk.cairo_set_source_pixbuf(cr, zbuf, dx - ox, dy - oy)
+ cr.paint()
def set_off(self, off):
aw, ah = self.get_asize()
ox = int(xa * dw) if dw > 0 else 0
oy = int(ya * dh) if dh > 0 else 0
self.set_off((ox, oy))
-gobject.type_register(pageview)
class msgproc(object):
def attach(self, reader):
self.rd = reader
- self.msg = gtk.Alignment(0, 0.5, 0, 0)
+ self.msg = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
self.hlay = gtk.HBox()
self.lbl = gtk.Label("")
- self.hlay.pack_start(self.lbl)
+ self.hlay.pack_start(self.lbl, True, True, 0)
self.lbl.show()
self.msg.add(self.hlay)
self.hlay.show()
- self.rd.sbar.pack_start(self.msg)
+ self.rd.sbar.pack_start(self.msg, True, True, 0)
self.msg.show()
self._prog = None
def prog(self, p):
- if p is not None and self._prog is None:
- self._prog = gtk.ProgressBar()
+ if p is not None:
+ if self._prog is None:
+ self._prog = gtk.ProgressBar()
+ self.hlay.pack_start(self._prog, True, True, 5)
+ self._prog.show()
self._prog.set_fraction(p)
- self.hlay.pack_start(self._prog, padding=5)
- self._prog.show()
elif p is None and self._prog is not None:
self.hlay.remove(self._prog)
self._prog = None
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, profile=None):
- super(reader, self).__init__(gtk.WINDOW_TOPLEVEL)
+ def __init__(self, manga, prof=None):
+ super(reader, self).__init__()
self.connect("delete_event", lambda wdg, ev, data=None: False)
self.connect("destroy", lambda wdg, data=None: self.quit())
self.connect("key_press_event", self.key)
self.pagefetch = procslot(self)
self.imgfetch = procslot(self)
self.preload = procslot(self)
- self.profile = profile
+ self.profile = prof if prof else profile.memmanga(None, None, manga.id)
self.manga = manga
self.page = None
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 = gtk.Frame()
+ self.pfr.set_shadow_type(gtk.ShadowType.NONE)
+ vlay.pack_start(self.pfr, True, True, 0)
self.pfr.show()
self.sboxbar = gtk.HBox()
- algn = gtk.Alignment(0, 0.5, 0, 0)
- sboxlbl = gtk.Label(self.manga.name + u": ")
+ algn = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
+ sboxlbl = gtk.Label(self.manga.name + ": ")
algn.add(sboxlbl)
sboxlbl.show()
- self.sboxbar.pack_start(algn, False)
+ self.sboxbar.pack_start(algn, False, True, 0)
algn.show()
- vlay.pack_start(self.sboxbar, False)
+ vlay.pack_start(self.sboxbar, False, True, 0)
self.sboxbar.show()
self.sbar = gtk.HBox()
self.pagelbl = gtk.Label("")
- algn = gtk.Alignment(0, 0.5, 0, 0)
+ algn = gtk.Alignment(xalign=0.0, yalign=0.5, xscale=0.0, yscale=0.0)
algn.add(self.pagelbl)
self.pagelbl.show()
- self.sbar.pack_start(algn)
+ self.sbar.pack_start(algn, True, True, 0)
algn.show()
- vlay.pack_end(self.sbar, False)
+ vlay.pack_end(self.sbar, False, True, 0)
self.sbar.show()
self.add(vlay)
vlay.show()
- if self.profile and "curpage" in self.profile:
- self.fetchpage(idpageget(self.manga, self.profile["curpage"]))
+ if self.curpage is not None:
+ self.fetchpage(idpageget(self.manga, self.curpage))
else:
self.fetchpage(pageget(self.manga))
self.updtitle()
+ zmode = profprop("zmode", "fit")
+ curpage = profprop("curpage")
+
def updpagelbl(self):
if self.page is None:
self.pagelbl.set_text("")
else:
w, h = self.page.get_osize()
- self.pagelbl.set_text(u"%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
+ self.pagelbl.set_text("%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]
if pbox.node != node:
l = i
break
- for i in xrange(l, len(self.sboxes)):
+ for i in range(l, len(self.sboxes)):
self.sboxbar.remove(self.sboxes[i])
self.sboxes = self.sboxes[:l]
- for i in xrange(l, len(nodes)):
+ for i in range(l, len(nodes)):
new = sbox(self, nodes[i])
- self.sboxbar.pack_start(new, False, padding=5)
+ self.sboxbar.pack_start(new, False, True, 5)
self.sboxes.append(new)
new.show()
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:
- if self.profile:
- self.profile.setprop("curpage", page.idlist())
- self.profile.saveprops()
+ self.curpage = page.idlist()
self.point = ccursor(page, self.cache)
self.imgfetch.set(imgfetch(self.cache[page]))
else:
return proc
def updtitle(self):
- self.set_title(u"Automanga \u2013 " + self.manga.name)
+ self.set_title("Automanga \u2013 " + self.manga.name)
@property
def zoom(self):
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.page.set_off((self.page.get_asize()[0], self.page.off[1]))
if self.point is not None:
if ev.keyval in [ord(' ')]:
- self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
+ if self.page and self.page.off[1] + self.page.get_asize()[1] < self.page.get_zsize()[1]:
+ self.pan((0, self.page.get_asize()[1] - 50))
+ else:
+ 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))))
+ if self.page and self.page.off[1] > 0:
+ self.pan((0, -(self.page.get_asize()[1] - 50)))
+ else:
+ 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]
Dolda2000 GitWeb / automanga.git / blobdiff