Commit b78268503291bcdef8c2294ea8748bf113855a52 - sugar-read-activity

Pep8 & pyflakes fixes Also rewrite the js code using python multiline strings to improve readability. Gonzalo Odiard 8 years ago

5 changed file(s) with 118 addition(s) and 114 deletion(s). Raw diff Collapse all Expand all

-4

epubview/epub.py less more

55	55
56	56	def _unzip(self):
57	57	# This is broken upto python 2.7
58		#self._zobject.extractall(path = self._tempdir)
	58	# self._zobject.extractall(path = self._tempdir)
59	59	orig_cwd = os.getcwd()
60	60	os.chdir(self._tempdir)
61	61	for name in self._zobject.namelist():

78	78	tree = etree.parse(containerfile)
79	79	root = tree.getroot()
80	80
81		for element in root.iterfind(
82		'.//{urn:oasis:names:tc:opendocument:xmlns:container}rootfile'):
	81	r_id = './/{urn:oasis:names:tc:opendocument:xmlns:container}rootfile'
	82	for element in root.iterfind(r_id):
83	83	if element.get('media-type') == 'application/oebps-package+xml':
84	84	self._opfpath = element.get('full-path')
85	85

116	116
117	117	self._zobject = zipfile.ZipFile(self._file)
118	118
119		if not 'mimetype' in self._zobject.namelist():
	119	if 'mimetype' not in self._zobject.namelist():
120	120	return False
121	121
122	122	mtypefile = self._zobject.open('mimetype')

+50

-53

epubview/epubview.py less more

23	23	import os.path
24	24	import math
25	25	import shutil
26		import BeautifulSoup
27
28		from epub import _Epub
	26
29	27	from jobs import _JobPaginator as _Paginator
30	28
31	29	LOADING_HTML = '''

39	37
40	38	__gproperties__ = {
41	39	'scale': (GObject.TYPE_FLOAT, 'the zoom level',
42		'the zoom level of the widget',
43		0.5, 4.0, 1.0, GObject.PARAM_READWRITE),
	40	'the zoom level of the widget',
	41	0.5, 4.0, 1.0, GObject.PARAM_READWRITE),
44	42	}
45	43	__gsignals__ = {
46	44	'page-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
47		([int, int])),
	45	([int, int])),
48	46	'selection-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
49	47	([])),
50	48	}

59	57	self._paginator = None
60	58	self._loaded_page = -1
61	59	self._file_loaded = True
62		#self._old_scrollval = -1
	60	# self._old_scrollval = -1
63	61	self._loaded_filename = None
64	62	self._pagecount = -1
65	63	self.__going_fwd = True

85	83	self._view.connect('scroll-event', self._view_scroll_event_cb)
86	84	self._view.connect('key-press-event', self._view_keypress_event_cb)
87	85	self._view.connect('selection-changed',
88		self._view_selection_changed_cb)
	86	self._view_selection_changed_cb)
89	87	self._view.connect_after('populate-popup',
90		self._view_populate_popup_cb)
	88	self._view_populate_popup_cb)
91	89	self._view.connect('touch-change-page', self.__touch_page_changed_cb)
92	90
93	91	self._sw.add(self._view)
94	92	self._v_vscrollbar = self._sw.get_vscrollbar()
95		self._v_scrollbar_value_changed_cb_id = \
96		self._v_vscrollbar.connect('value-changed', \
97		self._v_scrollbar_value_changed_cb)
	93	self._v_scrollbar_value_changed_cb_id = self._v_vscrollbar.connect(
	94	'value-changed', self._v_scrollbar_value_changed_cb)
98	95	self._scrollbar = Gtk.VScrollbar()
99		self._scrollbar_change_value_cb_id = \
100		self._scrollbar.connect('change-value', \
101		self._scrollbar_change_value_cb)
	96	self._scrollbar_change_value_cb_id = self._scrollbar.connect(
	97	'change-value', self._scrollbar_change_value_cb)
102	98
103	99	overlay = Gtk.Overlay()
104	100	hbox = Gtk.HBox()

237	233	'''
238	234	Returns the currently loaded XML file
239	235	'''
240		#return self._loaded_filename
	236	# return self._loaded_filename
241	237	if self._paginator:
242	238	return self._paginator.get_file_for_pageno(self._loaded_page)
243	239	else:

339	335	self._view.grab_focus()
340	336
341	337	if self._view.search_text(self._findjob.get_search_text(),
342		self._findjob.get_case_sensitive(),
343		True, False):
	338	self._findjob.get_case_sensitive(),
	339	True, False):
344	340	return
345	341	else:
346	342	path = os.path.join(self._epub.get_basedir(),
347		self._findjob.get_next_file())
	343	self._findjob.get_next_file())
348	344	self.__in_search = True
349	345	self.__search_fwd = True
350	346	self._load_file(path)

356	352	self._view.grab_focus()
357	353
358	354	if self._view.search_text(self._findjob.get_search_text(),
359		self._findjob.get_case_sensitive(),
360		False, False):
	355	self._findjob.get_case_sensitive(),
	356	False, False):
361	357	return
362	358	else:
363	359	path = os.path.join(self._epub.get_basedir(),
364		self._findjob.get_prev_file())
	360	self._findjob.get_prev_file())
365	361	self.__in_search = True
366	362	self.__search_fwd = False
367	363	self._load_file(path)

374	370
375	371	def _mark_found_text(self):
376	372	self._view.unmark_text_matches()
377		self._view.mark_text_matches(self._findjob.get_search_text(),
378		case_sensitive=self._findjob.get_case_sensitive(), limit=0)
	373	self._view.mark_text_matches(
	374	self._findjob.get_search_text(),
	375	case_sensitive=self._findjob.get_case_sensitive(), limit=0)
379	376	self._view.set_highlight_text_matches(True)
380	377
381	378	def __set_zoom(self, value):

435	432
436	433	filename = filename.split('#')[0] # Get rid of anchors
437	434
438		if self._loaded_page < 1 or filename == None:
	435	if self._loaded_page < 1 or filename is None:
439	436	return False
440	437
441	438	self._loaded_filename = filename
442	439
443	440	remfactor = self._paginator.get_remfactor_for_file(filename)
444	441	pages = self._paginator.get_pagecount_for_file(filename)
445		extra = int(math.ceil(remfactor *
446		self._view.get_page_height() / (pages - remfactor)))
	442	extra = int(math.ceil(
	443	remfactor * self._view.get_page_height() / (pages - remfactor)))
447	444	if extra > 0:
448	445	self._view.add_bottom_padding(extra)
449	446
450	447	if self.__in_search:
451	448	self._mark_found_text()
452		self._view.search_text(self._findjob.get_search_text(), \
453		self._findjob.get_case_sensitive(), \
454		self.__search_fwd, False)
	449	self._view.search_text(self._findjob.get_search_text(),
	450	self._findjob.get_case_sensitive(),
	451	self.__search_fwd, False)
455	452	self.__in_search = False
456	453	else:
457	454	if self.__going_back:

460	457	else:
461	458	self._scroll_page()
462	459
463		process_file = True
	460	# process_file = True
464	461	if self._internal_link is not None:
465	462	self._view.go_to_link(self._internal_link)
466	463	vertical_pos = \
467	464	self._view.get_vertical_position_element(self._internal_link)
468	465	# set the page number based in the vertical position
469	466	initial_page = self._paginator.get_base_pageno_for_file(filename)
470		self._loaded_page = initial_page + int(vertical_pos /
471		self._paginator.get_single_page_height())
	467	self._loaded_page = initial_page + int(
	468	vertical_pos / self._paginator.get_single_page_height())
472	469
473	470	# There are epub files, created with Calibre,
474	471	# where the link in the index points to the end of the previos

483	480	logging.error('load next file %s', next_file)
484	481	self.__in_search = False
485	482	self.__going_back = False
486		process_file = False
	483	# process_file = False
487	484	GObject.idle_add(self._load_file, next_file)
488	485
489	486	# if process_file:

501	498	word_begin = 0
502	499	word_end = 0
503	500	ignore_chars = [' ', '\n', u'\r', '_', '[', '{', ']', '}', '\|',
504		'<', '>', '*', '+', '/', '\\']
	501	'<', '>', '*', '+', '/', '\\']
505	502	ignore_set = set(ignore_chars)
506	503	self.word_tuples = []
507	504	len_page_text = len(page_text)

509	506	if page_text[i] not in ignore_set:
510	507	word_begin = i
511	508	j = i
512		while j < len_page_text and page_text[j] not in ignore_set:
	509	while j < len_page_text and page_text[j] not in ignore_set:
513	510	j = j + 1
514	511	word_end = j
515	512	i = j
516	513	word_tuple = (word_begin, word_end,
517		page_text[word_begin: word_end])
	514	page_text[word_begin: word_end])
518	515	if word_tuple[2] != u'\r':
519	516	self.word_tuples.append(word_tuple)
520	517	i = i + 1
521	518
522	519	def _scroll_page_end(self):
523	520	v_upper = self._v_vscrollbar.props.adjustment.props.upper
524		v_page_size = self._v_vscrollbar.props.adjustment.props.page_size
	521	# v_page_size = self._v_vscrollbar.props.adjustment.props.page_size
525	522	self._v_vscrollbar.set_value(v_upper)
526	523
527	524	def _scroll_page(self):

561	558	scroll_upper = self._v_vscrollbar.props.adjustment.props.upper
562	559	scroll_page_size = self._v_vscrollbar.props.adjustment.props.page_size
563	560
564		if self.__going_fwd == True and \
565		not self._loaded_page == self._pagecount:
	561	if self.__going_fwd and not self._loaded_page == self._pagecount:
566	562	if self._paginator.get_file_for_pageno(self._loaded_page) != \
567		self._paginator.get_file_for_pageno(self._loaded_page + 1):
	563	self._paginator.get_file_for_pageno(self._loaded_page + 1):
568	564	# We don't need this if the next page is in another file
569	565	return
570	566
571	567	scrollfactor_next = \
572		self._paginator.get_scrollfactor_pos_for_pageno(
	568	self._paginator.get_scrollfactor_pos_for_pageno(
573	569	self._loaded_page + 1)
574	570	if scrollval > 0:
575	571	scrollfactor = scrollval / (scroll_upper - scroll_page_size)

577	573	scrollfactor = 0
578	574	if scrollfactor >= scrollfactor_next:
579	575	self._on_page_changed(self._loaded_page, self._loaded_page + 1)
580		elif self.__going_back == True and self._loaded_page > 1:
	576	elif self.__going_back and self._loaded_page > 1:
581	577	if self._paginator.get_file_for_pageno(self._loaded_page) != \
582		self._paginator.get_file_for_pageno(
583		self._loaded_page - 1):
	578	self._paginator.get_file_for_pageno(self._loaded_page - 1):
584	579	return
585	580
586	581	scrollfactor_cur = \
587		self._paginator.get_scrollfactor_pos_for_pageno(
	582	self._paginator.get_scrollfactor_pos_for_pageno(
588	583	self._loaded_page)
589	584	if scrollval > 0:
590	585	scrollfactor = scrollval / (scroll_upper - scroll_page_size)

607	602
608	603	def _load_page(self, pageno):
609	604	if pageno > self._pagecount or pageno < 1:
610		#TODO: Cause an exception
	605	# TODO: Cause an exception
611	606	return
612	607	if self._loaded_page == pageno:
613	608	return

630	625	shutil.copy('./epubview/highlight_words.js', destpath)
631	626	self._insert_js_reference(filename.replace('file://', ''),
632	627	destpath)
	628	IMPORTANT: Find a way to do this without modify the files
	629	now text highlight is implemented and the epub file is saved
633	630	"""
634	631
635	632	if filename.endswith('xml'):

646	643
647	644	def _insert_js_reference(self, file_name, path):
648	645	js_reference = '<script type="text/javascript" ' + \
649		'src="./highlight_words.js"></script>'
	646	'src="./highlight_words.js"></script>'
650	647	o = open(file_name + '.tmp', 'a')
651	648	for line in open(file_name):
652	649	line = line.replace('</head>', js_reference + '</head>')

665	662	self._view.load_uri('file://' + filepath)
666	663	oldpage = self._loaded_page
667	664	self._loaded_page = \
668		self._paginator.get_base_pageno_for_file(filepath)
	665	self._paginator.get_base_pageno_for_file(filepath)
669	666	self._scroll_page()
670	667	self._on_page_changed(oldpage, self._loaded_page)
671	668	break

690	687	self._load_page(round(value))
691	688	else:
692	689	print 'Warning: unknown scrolltype %s with value %f' \
693		% (str(scrolltype), value)
694
695		#FIXME: This should not be needed here
	690	% (str(scrolltype), value)
	691
	692	# FIXME: This should not be needed here
696	693	self._scrollbar.set_value(self._loaded_page)
697	694
698		if self.__page_changed == True:
	695	if self.__page_changed:
699	696	self.__page_changed = False
700	697	return False
701	698	else:

+10

-13

epubview/jobs.py less more

18	18	from gi.repository import GObject
19	19	from gi.repository import Gtk
20	20	import widgets
21		import cairo
22	21	import math
23	22	import os.path
24	23	import BeautifulSoup
25
26		import epub
27	24
28	25	import threading
29	26

68	65	body = soup.find('body')
69	66	tags = body.findChildren(True)
70	67	for tag in tags:
71		if not tag.string is None:
	68	if tag.string is not None:
72	69	if tag.string.find(self.obj._text) > -1:
73	70	return True
74	71

98	95	self._count = 0
99	96	self._pagecount = 0
100	97
101		#TODO
	98	# TODO
102	99	"""
103	100	self._screen = Gdk.Screen.get_default()
104	101	self._old_fontoptions = self._screen.get_font_options()

119	116	settings.props.serif_font_family = 'DejaVu LGC Serif'
120	117	settings.props.monospace_font_family = 'DejaVu LGC Sans Mono'
121	118	settings.props.enforce_96_dpi = True
122		#FIXME: This does not seem to work
123		#settings.props.auto_shrink_images = False
	119	# FIXME: This does not seem to work
	120	# settings.props.auto_shrink_images = False
124	121	settings.props.enable_plugins = False
125	122	settings.props.default_font_size = 12
126	123	settings.props.default_monospace_font_size = 10

131	128	self._dpi = 96
132	129	self._single_page_height = _mm_to_pixel(PAGE_HEIGHT, self._dpi)
133	130	sw.set_size_request(_mm_to_pixel(PAGE_WIDTH, self._dpi),
134		self._single_page_height)
	131	self._single_page_height)
135	132	sw.add(self._temp_view)
136	133	self._temp_win.add(sw)
137	134	self._temp_view.connect('load-finished', self._page_load_finished_cb)

169	166	else:
170	167	pagelen = 1 / pages
171	168	self._pagemap[float(self._pagecount + i)] = \
172		(f.props.uri, (i - 1) / math.ceil(pages), pagelen)
	169	(f.props.uri, (i - 1) / math.ceil(pages), pagelen)
173	170
174	171	self._pagecount += int(math.ceil(pages))
175	172	self._filedict[f.props.uri.replace('file://', '')] = \
176		(math.ceil(pages), math.ceil(pages) - pages)
	173	(math.ceil(pages), math.ceil(pages) - pages)
177	174	self._bookheight += pageheight
178	175
179	176	if self._count + 1 >= len(self._filelist):
180	177	# TODO
181		#self._screen.set_font_options(self._old_fontoptions)
	178	# self._screen.set_font_options(self._old_fontoptions)
182	179	self.emit('paginated')
183	180	GObject.idle_add(self._cleanup)
184	181	else:

217	214	Returns the pageno which begins in filename
218	215	'''
219	216	for key in self._pagemap.keys():
220		if self._pagemap[key][0].replace('file://', '') == filename:
	217	if self._pagemap[key][0].replace('file://', '') == filename:
221	218	return key
222	219
223	220	return None

248	245	}
249	246
250	247	def __init__(self, document, start_page, n_pages, text,
251		case_sensitive=False):
	248	case_sensitive=False):
252	249	GObject.GObject.__init__(self)
253	250
254	251	self._finished = False

-11

epubview/navmap.py less more

0	0	import xml.etree.ElementTree as etree
1	1	from gi.repository import Gtk
2		import logging
3	2
4	3
5	4	class NavPoint(object):

50	49
51	50	def _populate_toc(self):
52	51	navmap = self._root.find(
53		'{http://www.daisy.org/z3986/2005/ncx/}navMap')
	52	'{http://www.daisy.org/z3986/2005/ncx/}navMap')
54	53	for navpoint in navmap.iterfind(
55	54	'./{http://www.daisy.org/z3986/2005/ncx/}navPoint'):
56	55	self._process_navpoint(navpoint)
57	56
58	57	def _gettitle(self, navpoint):
59		text = navpoint.find('./{http://www.daisy.org/z3986/2005/ncx/}' +
60		'navLabel/{http://www.daisy.org/z3986/2005/ncx/}text')
	58	text = navpoint.find(
	59	'./{http://www.daisy.org/z3986/2005/ncx/}' +
	60	'navLabel/{http://www.daisy.org/z3986/2005/ncx/}text')
61	61	return text.text
62	62
63	63	def _getcontent(self, navpoint):
64	64	text = navpoint.find(
65		'./{http://www.daisy.org/z3986/2005/ncx/}content')
66		if text is not None:
	65	'./{http://www.daisy.org/z3986/2005/ncx/}content')
	66	if text is not None:
67	67	return self._basepath + text.get('src')
68	68	else:
69	69	return ""

72	72	title = self._gettitle(navpoint)
73	73	content = self._getcontent(navpoint)
74	74
75		#print title, content
	75	# print title, content
76	76
77	77	iter = self._gtktreestore.append(parent, [title, content])
78		#self._flattoc.append((title, content))
	78	# self._flattoc.append((title, content))
79	79
80	80	childnavpointlist = list(navpoint.iterfind(
81		'./{http://www.daisy.org/z3986/2005/ncx/}navPoint'))
	81	'./{http://www.daisy.org/z3986/2005/ncx/}navPoint'))
82	82
83	83	if len(childnavpointlist):
84	84	for childnavpoint in childnavpointlist:

99	99	rendered.
100	100	'''
101	101	return self._flattoc
102
103		#t = TocParser('/home/sayamindu/Desktop/Test/OPS/fb.ncx')

+45

-33

epubview/widgets.py less more

	0	import logging
	1
0	2	from gi.repository import WebKit
1	3	from gi.repository import Gdk
2	4	from gi.repository import GObject

6	8
7	9	__gsignals__ = {
8	10	'touch-change-page': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
9		([bool])),
10		}
	11	([bool])), }
11	12
12	13	def __init__(self, only_to_measure=False):
13	14	WebKit.WebView.__init__(self)
14	15	self._only_to_measure = only_to_measure
15	16
16	17	def setup_touch(self):
17		self.get_window().set_events(self.get_window().get_events() \|
18		Gdk.EventMask.TOUCH_MASK)
	18	self.get_window().set_events(
	19	self.get_window().get_events() \| Gdk.EventMask.TOUCH_MASK)
19	20	self.connect('event', self.__event_cb)
20	21
21	22	def __event_cb(self, widget, event):

35	36	hide_scrollbar_js = ''
36	37	if self._only_to_measure:
37	38	hide_scrollbar_js = \
38		'document.documentElement.style.overflow = "hidden";'
	39	'document.documentElement.style.overflow = "hidden";'
39	40
40		js = 'document.documentElement.style.margin = "50px";' + \
41		'oldtitle=document.title;' + \
42		'if (document.body == null) {' + \
43		'document.title = 0} else {' + \
44		hide_scrollbar_js + \
45		'document.title=Math.max(document.body.scrollHeight, ' + \
46		'document.body.offsetHeight,document.documentElement.clientHeight,' + \
47		'document.documentElement.scrollHeight, ' + \
48		'document.documentElement.offsetHeight)};'
	41	oldtitle = self.get_main_frame().get_title()
	42
	43	js = """
	44	document.documentElement.style.margin = "50px";
	45	if (document.body == null) {
	46	document.title = 0;
	47	} else {
	48	%s
	49	document.title=Math.max(document.body.scrollHeight,
	50	document.body.offsetHeight,
	51	document.documentElement.clientHeight,
	52	document.documentElement.scrollHeight,
	53	document.documentElement.offsetHeight);
	54	};
	55	""" % hide_scrollbar_js
49	56	self.execute_script(js)
50	57	ret = self.get_main_frame().get_title()
51		js = 'document.title=oldtitle;'
52		self.execute_script(js)
	58	logging.error('get_page_height %s', ret)
	59	self.execute_script('document.title=%s;' % oldtitle)
53	60	try:
54	61	return int(ret)
55	62	except ValueError:

60	67	Adds incr pixels of padding to the end of the loaded (X)HTML page.
61	68	This is done via javascript at the moment
62	69	'''
63		js = ('var newdiv = document.createElement("div");' + \
64		'newdiv.style.height = "%dpx";document.body.appendChild(newdiv);' \
65		% incr)
	70	js = """
	71	var newdiv = document.createElement("div");
	72	newdiv.style.height = "%dpx";
	73	document.body.appendChild(newdiv);
	74	""" % incr
66	75	self.execute_script(js)
67	76
68	77	def highlight_next_word(self):

80	89	'''
81	90	# remove the first '#' char
82	91	id_link = id_link[1:]
83		js = "oldtitle = document.title;" \
84		"obj = document.getElementById('%s');" \
85		"var top = 0;" \
86		"if(obj.offsetParent) {" \
87		" while(1) {" \
88		" top += obj.offsetTop;" \
89		" if(!obj.offsetParent) {break;};" \
90		" obj = obj.offsetParent;" \
91		" };" \
92		"}" \
93		"else if(obj.y) { top += obj.y; };" \
94		"document.title=top;" % id_link
	92	oldtitle = self.get_main_frame().get_title()
	93	js = """
	94	obj = document.getElementById('%s');
	95	var top = 0;
	96	if(obj.offsetParent) {
	97	while(1) {
	98	top += obj.offsetTop;
	99	if(!obj.offsetParent) {
	100	break;
	101	};
	102	obj = obj.offsetParent;
	103	};
	104	} else if(obj.y) {
	105	top += obj.y;
	106	};
	107	document.title=top;""" % id_link
95	108	self.execute_script(js)
96	109	ret = self.get_main_frame().get_title()
97		js = 'document.title=oldtitle;'
98		self.execute_script(js)
	110	self.execute_script('document.title=%s;' % oldtitle)
99	111	try:
100	112	return int(ret)
101	113	except ValueError: