1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
import gobject
import logging
import gtk
import evince
_logger = logging.getLogger('read-activity')
class EvinceViewer():
def __init__(self):
self._view_notify_zoom_handler = None
self._view = evince.View()
def setup(self, activity):
self._view.connect('selection-changed',
activity._view_selection_changed_cb)
activity._scrolled = gtk.ScrolledWindow()
activity._scrolled.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
activity._scrolled.props.shadow_type = gtk.SHADOW_NONE
activity._scrolled.add(self._view)
self._view.show()
activity._hbox.pack_start(activity._scrolled, expand=True, fill=True)
activity._scrolled.show()
self.dpi = activity.dpi
def load_document(self, file_path):
try:
self._document = evince.document_factory_get_document(file_path)
except gobject.GError, e:
_logger.error('Can not load document: %s', e)
return
else:
self._model = evince.DocumentModel()
self._model.set_document(self._document)
self._view.set_model(self._model)
# set dpi
min_scale = self._model.get_min_scale()
max_scale = self._model.get_max_scale()
self._model.set_min_scale(min_scale * self.dpi / 72.0)
self._model.set_max_scale(max_scale * self.dpi / 72.0)
def get_current_page(self):
return self._model.props.page
def set_current_page(self, page):
if page >= self._document.get_n_pages():
page = self._document.get_n_pages() - 1
elif page < 0:
page = 0
self._model.props.page = page
def get_pagecount(self):
'''
Returns the pagecount of the loaded file
'''
return self._document.get_n_pages()
def load_metadata(self, activity):
self.metadata = activity.metadata
if not self.metadata['title_set_by_user'] == '1':
title = self._document.get_title()
if title:
self.metadata['title'] = title
sizing_mode = self.metadata.get('Read_sizing_mode', 'fit-width')
_logger.debug('Found sizing mode: %s', sizing_mode)
if sizing_mode == "best-fit":
self._model.props.sizing_mode = evince.SIZING_BEST_FIT
if hasattr(self._view, 'update_view_size'):
self._view.update_view_size(self._scrolled)
elif sizing_mode == "free":
self._model.props.sizing_mode = evince.SIZING_FREE
self._model.props.scale = \
float(self.metadata.get('Read_zoom', '1.0'))
_logger.debug('Set zoom to %f', self._model.props.scale)
elif sizing_mode == "fit-width":
self._model.props.sizing_mode = evince.SIZING_FIT_WIDTH
if hasattr(self._view, 'update_view_size'):
self._view.update_view_size(self._scrolled)
else:
# this may happen when we get a document from a buddy with a later
# version of Read, for example.
_logger.warning("Unknown sizing_mode state '%s'", sizing_mode)
if self.metadata.get('Read_zoom', None) is not None:
self._model.props.scale = float(self.metadata['Read_zoom'])
def update_metadata(self, activity):
self.metadata = activity.metadata
self.metadata['Read_zoom'] = str(self._model.props.scale)
if self._model.props.sizing_mode == evince.SIZING_BEST_FIT:
self.metadata['Read_sizing_mode'] = "best-fit"
elif self._model.props.sizing_mode == evince.SIZING_FREE:
self.metadata['Read_sizing_mode'] = "free"
elif self._model.props.sizing_mode == evince.SIZING_FIT_WIDTH:
self.metadata['Read_sizing_mode'] = "fit-width"
else:
_logger.error("Don't know how to save sizing_mode state '%s'" %
self._model.props.sizing_mode)
self.metadata['Read_sizing_mode'] = "fit-width"
def can_highlight(self):
return False
def can_do_text_to_speech(self):
return False
def get_zoom(self):
'''
Returns the current zoom level
'''
return self._model.props.scale * 100
def set_zoom(self, value):
'''
Sets the current zoom level
'''
self._model.props.sizing_mode = evince.SIZING_FREE
if not self._view_notify_zoom_handler:
return
self._model.disconnect(self._view_notify_zoom_handler)
try:
self._model.props.scale = value / 100.0
finally:
self._view_notify_zoom_handler = self._model.connect(
'notify::scale', self._zoom_handler)
def zoom_in(self):
'''
Zooms in (increases zoom level by 0.1)
'''
self._model.props.sizing_mode = evince.SIZING_FREE
self._view.zoom_in()
def zoom_out(self):
'''
Zooms out (decreases zoom level by 0.1)
'''
self._model.props.sizing_mode = evince.SIZING_FREE
self._view.zoom_out()
def zoom_to_width(self):
self._model.props.sizing_mode = evince.SIZING_FIT_WIDTH
def can_zoom_in(self):
'''
Returns True if it is possible to zoom in further
'''
return self._view.can_zoom_in()
def can_zoom_out(self):
'''
Returns True if it is possible to zoom out further
'''
return self._view.can_zoom_out()
def can_zoom_to_width(self):
return True
def zoom_to_best_fit(self):
self._model.props.sizing_mode = evince.SIZING_BEST_FIT
def zoom_to_actual_size(self):
self._model.props.sizing_mode = evince.SIZING_FREE
self._model.props.scale = 1.0
def connect_zoom_handler(self, handler):
self._zoom_handler = handler
self._view_notify_zoom_handler = \
self._model.connect('notify::scale', handler)
return self._view_notify_zoom_handler
def setup_find_job(self, text, updated_cb):
self._find_job = evince.JobFind(document=self._document, start_page=0,
n_pages=self._document.get_n_pages(),
text=text, case_sensitive=False)
self._find_updated_handler = self._find_job.connect('updated',
updated_cb)
evince.Job.scheduler_push_job(self._find_job,
evince.JOB_PRIORITY_NONE)
return self._find_job, self._find_updated_handler
def connect_page_changed_handler(self, handler):
self._model.connect('page-changed', handler)
def update_toc(self, activity):
return False
def find_set_highlight_search(self, set_highlight_search):
self._view.find_set_highlight_search(set_highlight_search)
def find_next(self):
'''
Highlights the next matching item for current search
'''
self._view.find_next()
def find_previous(self):
'''
Highlights the previous matching item for current search
'''
self._view.find_previous()
def find_changed(self, job, page=None):
self._view.find_changed(job, page)
def scroll(self, scrolltype, horizontal):
'''
Scrolls through the pages.
Scrolling is horizontal if horizontal is set to True
Valid scrolltypes are:
gtk.SCROLL_PAGE_BACKWARD and gtk.SCROLL_PAGE_FORWARD
'''
if scrolltype == gtk.SCROLL_PAGE_BACKWARD:
self._view.scroll(gtk.SCROLL_PAGE_BACKWARD, -1)
elif scrolltype == gtk.SCROLL_PAGE_FORWARD:
self._view.scroll(gtk.SCROLL_PAGE_FORWARD, 1)
else:
print ('Got unsupported scrolltype %s' % str(scrolltype))
def copy(self):
self._view.copy()
|
