├── BookReaderPlugin.php
├── LICENSE
├── README.md
├── build.xml
├── controllers
├── IndexController.php
└── ViewerController.php
├── languages
├── fr.mo
├── fr.po
├── template.base.pot
└── template.pot
├── libraries
└── BookReader
│ ├── Creator.php
│ └── Creator
│ ├── Default.php
│ ├── ExtractOCR.php
│ ├── RefnumOCR.php
│ └── Simple.php
├── models
└── BookReader.php
├── plugin.ini
├── routes.ini
└── views
├── admin
├── forms
│ └── bookreader-batch-edit.php
└── plugins
│ └── bookreader-config-form.php
├── helpers
└── GetBookReader.php
├── public
├── index
│ ├── fulltext.php
│ └── image-proxy.php
└── viewer
│ ├── show.php
│ └── view.php
└── shared
├── css
├── BookReader.css
├── BookReaderEmbed.css
└── BookReaderLending.css
├── images
├── BRicons.png
├── back_cover.png
├── back_pages.png
├── blank.png
├── book_bottom_icon.png
├── book_down_icon.png
├── book_left_icon.png
├── book_leftmost_icon.png
├── book_right_icon.png
├── book_rightmost_icon.png
├── book_top_icon.png
├── book_up_icon.png
├── booksplit.png
├── control_pause_icon.png
├── control_play_icon.png
├── down_arrow.png
├── down_arrow_wt.png
├── embed_icon.png
├── icon_OL-logo-xs.png
├── icon_alert-xs.png
├── icon_close-pop.png
├── icon_home.png
├── icon_indicator.png
├── icon_zoomer.png
├── left_edges.png
├── logo_icon.png
├── marker_chap-off.png
├── marker_chap-on.png
├── marker_srch-off.png
├── marker_srch-on.png
├── marker_srchchap-off.png
├── marker_srchchap-on.png
├── nav_control-dn.png
├── nav_control-lt.png
├── nav_control-rt.png
├── nav_control-up.png
├── nav_control.png
├── one_page_mode_icon.png
├── print_icon.png
├── progressbar.gif
├── right_arrow.png
├── right_arrow_wt.png
├── right_edges.png
├── slider.png
├── thumbnail_mode_icon.png
├── transparent.png
├── two_page_mode_icon.png
├── zoom_in_icon.png
└── zoom_out_icon.png
└── javascripts
├── BookReader.js
├── ToCmenu.js
├── dragscrollable.js
├── excanvas.compiled.js
├── jquery-1.4.2.min.js
├── jquery-ui-1.8.1.custom.min.js
├── jquery-ui-1.8.5.custom.min.js
├── jquery.bt.min.js
├── jquery.colorbox-min.js
├── jquery.ui.ipad.js
└── touch
├── BookReaderTouch.css
└── images
├── book_bottom_icon.png
├── book_down_icon.png
├── book_left_icon.png
├── book_leftmost_icon.png
├── book_right_icon.png
├── book_rightmost_icon.png
├── book_top_icon.png
├── book_up_icon.png
├── control_pause_icon.png
├── control_play_icon.png
├── embed_icon.png
├── logo_icon.png
├── one_page_mode_icon.png
├── print_icon.png
├── thumbnail_mode_icon.png
├── two_page_mode_icon.png
├── zoom_in_icon.png
└── zoom_out_icon.png
/BookReaderPlugin.php:
--------------------------------------------------------------------------------
1 | 'BookReader_Creator_Default',
50 | 'bookreader_sorting_mode' => false,
51 | 'bookreader_mode_page' => '1',
52 | 'bookreader_append_items_show' => true,
53 | 'bookreader_embed_functions' => '0',
54 | 'bookreader_class' => '',
55 | 'bookreader_width' => '100%',
56 | 'bookreader_height' => '480',
57 | );
58 |
59 | /**
60 | * Installs the plugin.
61 | */
62 | public function hookInstall()
63 | {
64 | $this->_installOptions();
65 | }
66 |
67 | /**
68 | * Upgrade the plugin.
69 | */
70 | public function hookUpgrade($args)
71 | {
72 | $oldVersion = $args['old_version'];
73 | $newVersion = $args['new_version'];
74 |
75 | if (version_compare($oldVersion, '2.1', '<=')) {
76 | set_option('bookreader_custom_css', WEB_PLUGIN . '/BookReader/' . $this->_options['bookreader_custom_css']);
77 | delete_option('bookreader_logo_url');
78 | delete_option('bookreader_toolbar_color');
79 | }
80 |
81 | if (version_compare($oldVersion, '2.6', '<=')) {
82 | delete_option('bookreader_custom_library');
83 | set_option('bookreader_creator', $this->_options['bookreader_creator']);
84 | set_option('bookreader_append_items_show', $this->_options['bookreader_append_items_show']);
85 | }
86 |
87 | if (version_compare($oldVersion, '2.7', '<')) {
88 | delete_option('bookreader_custom_css');
89 | delete_option('bookreader_favicon_url');
90 | }
91 | }
92 |
93 | /**
94 | * Uninstalls the plugin.
95 | */
96 | public function hookUninstall()
97 | {
98 | $this->_uninstallOptions();
99 | }
100 |
101 | /**
102 | * Initialize the plugin.
103 | */
104 | public function hookInitialize()
105 | {
106 | add_translation_source(dirname(__FILE__) . '/languages');
107 | add_shortcode('bookreader', array($this, 'shortcodeBookReader'));
108 | }
109 |
110 | /**
111 | * Shows plugin configuration page.
112 | *
113 | * @return void
114 | */
115 | public function hookConfigForm($args)
116 | {
117 | $view = get_view();
118 | echo $view->partial('plugins/bookreader-config-form.php');
119 | }
120 |
121 | /**
122 | * Processes the configuration form.
123 | *
124 | * @return void
125 | */
126 | public function hookConfig($args)
127 | {
128 | $post = $args['post'];
129 | foreach ($this->_options as $optionKey => $optionValue) {
130 | if (isset($post[$optionKey])) {
131 | set_option($optionKey, $post[$optionKey]);
132 | }
133 | }
134 | }
135 |
136 | /**
137 | * Defines public routes.
138 | *
139 | * @return void
140 | */
141 | public function hookDefineRoutes($args)
142 | {
143 | if (is_admin_theme()) {
144 | return;
145 | }
146 |
147 | $args['router']->addConfig(new Zend_Config_Ini(dirname(__FILE__) . '/routes.ini', 'routes'));
148 | }
149 |
150 | /**
151 | * Manages data when an item is saved.
152 | */
153 | public function hookAfterSaveItem($args)
154 | {
155 | $item = $args['record'];
156 |
157 | // This is done after insert, update or post and only if a function exists
158 | // in the custom library.
159 | $bookreader = new BookReader($item);
160 | $bookreader->saveData();
161 | }
162 |
163 | /**
164 | * Add a partial batch edit form.
165 | *
166 | * @return void
167 | */
168 | public function hookAdminItemsBatchEditForm($args)
169 | {
170 | $view = $args['view'];
171 | echo $view->partial(
172 | 'forms/bookreader-batch-edit.php'
173 | );
174 | }
175 |
176 | /**
177 | * Process the partial batch edit form.
178 | *
179 | * @return void
180 | */
181 | public function hookItemsBatchEditCustom($args)
182 | {
183 | $item = $args['item'];
184 | $orderByFilename = $args['custom']['bookreader']['orderByFilename'];
185 | $mixFileTypes = $args['custom']['bookreader']['mixFileTypes'];
186 | $checkImageSize = $args['custom']['bookreader']['checkImageSize'];
187 |
188 | if ($orderByFilename) {
189 | $this->_sortFiles($item, (boolean) $mixFileTypes);
190 | }
191 |
192 | if ($checkImageSize) {
193 | $this->_checkImageSize($item);
194 | }
195 | }
196 |
197 | /**
198 | * Sort all files of an item by name.
199 | *
200 | * @param Item $item
201 | * @param boolean $mixFileTypes
202 | *
203 | * @return void
204 | */
205 | protected function _sortFiles($item, $mixFileTypes = false)
206 | {
207 | if ($item->fileCount() < 2) {
208 | return;
209 | }
210 |
211 | if ($mixFileTypes) {
212 | $list = $item->Files;
213 | BookReader_Creator::sortFilesByOriginalName($list, false);
214 | }
215 | else {
216 | $bookreader = new BookReader($item);
217 | // Get leaves and remove blank ones.
218 | $leaves = array_filter($bookreader->getLeaves());
219 | $non_leaves = array_filter($bookreader->getNonLeaves());
220 | // Manage the case where there is no BookReader data.
221 | if (empty($leaves) && empty($non_leaves)) {
222 | $list = $item->Files;
223 | BookReader_Creator::sortFilesByOriginalName($list, false);
224 | }
225 | else {
226 | // Order them separately.
227 | BookReader_Creator::sortFilesByOriginalName($leaves, false);
228 | BookReader_Creator::sortFilesByOriginalName($non_leaves, false);
229 | // Finally, merge them.
230 | $list = array_merge($leaves, $non_leaves);
231 | }
232 | }
233 |
234 | // To avoid issues with unique index when updating (order should be
235 | // unique for each file of an item), all orders are reset to null before
236 | // true process.
237 | $db = $this->_db;
238 | $bind = array(
239 | $item->id,
240 | );
241 | $sql = "
242 | UPDATE `$db->File` files
243 | SET files.order = NULL
244 | WHERE files.item_id = ?
245 | ";
246 | $db->query($sql, $bind);
247 |
248 | // To avoid multiple updates, a single query is used.
249 | foreach ($list as &$file) {
250 | $file = $file->id;
251 | }
252 | // The array is made unique, because a leaf can be repeated.
253 | $list = implode(',', array_unique($list));
254 | $sql = "
255 | UPDATE `$db->File` files
256 | SET files.order = FIND_IN_SET(files.id, '$list')
257 | WHERE files.id in ($list)
258 | ";
259 | $db->query($sql);
260 | }
261 |
262 | /**
263 | * Rebuild missing metadata of files.
264 | *
265 | * @param Item $item
266 | * @return void
267 | */
268 | protected function _checkImageSize($item)
269 | {
270 | foreach ($item->Files as $file) {
271 | if (!$file->hasThumbnail() || strpos($file->mime_type, 'image/') !== 0) {
272 | continue;
273 | }
274 | $metadata = json_decode($file->metadata, true);
275 | if (empty($metadata)) {
276 | $metadata = array();
277 | }
278 | // Check if resolution is set.
279 | elseif (!empty($metadata['video']['resolution_x']) && !empty($metadata['video']['resolution_y'])) {
280 | continue;
281 | }
282 |
283 | // Set the resolution directly.
284 | $imageType = 'original';
285 | // The storage adapter should be checked for external storage.
286 | $storageAdapter = $file->getStorage()->getAdapter();
287 | $filepath = get_class($storageAdapter) == 'Omeka_Storage_Adapter_Filesystem'
288 | ? FILES_DIR . DIRECTORY_SEPARATOR . $file->getStoragePath($imageType)
289 | : $file->getWebPath($imageType);
290 | list($width, $height, $type, $attr) = getimagesize($filepath);
291 | $metadata['video']['resolution_x'] = $width;
292 | $metadata['video']['resolution_y'] = $height;
293 | $file->metadata = version_compare(phpversion(), '5.4.0', '<')
294 | ? json_encode($metadata)
295 | : json_encode($metadata, JSON_UNESCAPED_SLASHES);
296 | $file->save();
297 | }
298 | }
299 |
300 | /**
301 | * Hook to display viewer.
302 | *
303 | * @param array $args
304 | *
305 | * @return void
306 | */
307 | public function hookPublicItemsShow($args)
308 | {
309 | if (!get_option('bookreader_append_items_show') && empty($args['direct'])) {
310 | return;
311 | }
312 |
313 | $view = empty($args['view']) ? get_view() : $args['view'];
314 | echo $view->getBookReader($args);
315 | }
316 |
317 | /**
318 | * Shortcode to display viewer.
319 | *
320 | * @param array $args
321 | * @param Omeka_View $view
322 | * @return string
323 | */
324 | public static function shortcodeBookReader($args, $view)
325 | {
326 | $args['view'] = $view;
327 | return $view->getBookReader($args);
328 | }
329 | }
330 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | BookReader (plugin for Omeka)
2 | =============================
3 |
4 | [BookReader] is a plugin for [Omeka] that adds [Internet Archive BookReader].
5 | The IA BookReader is used to view books from the Internet Archive online and can
6 | also be used to view other books.
7 |
8 | So you can create online flip book from image files constituting an item or from
9 | files listed in a gDoc spreadsheet.
10 |
11 | See demo of the [embedded version] of [Mines ParisTech] or in [fullscreen mode]
12 | with highlighted results of a search in the OCR text ([Université Rennes 2]).
13 |
14 | For the spreasheet use, see [gDoc explanation]. The javascript included comes
15 | from [BookReader spreadsheet] via [Dušan Ranđelović fork]. Main benefit is that item
16 | doesn't need to have all pages/images uploaded to Omeka and that there is no
17 | need for composit PDF, so presentation is completely parted from metadata.
18 |
19 |
20 | Installation
21 | ------------
22 |
23 | - Upload the BookReader plugin folder into your plugins folder on the server;
24 | - Activate it from the admin dashboad > Settings > Plugins page
25 | - Click the Configure link to add the following
26 | - Name of to custom class (default is `BookReader_Creator_Default`)
27 | - Sorting mode for the viewer (omeka default order or original filename order)
28 | - Number of pages in Embed mode (1 or 2)
29 | - Embed all functions (0 for none or 1 for all)
30 | - The width of the inline frame (Embedded Simple Viewer)
31 | - The height of the inline frame (Embedded Simple Viewer)
32 |
33 | If you want to change more options, copy the file `views/public/viewer/show.php`
34 | in the subdirectory `book-reader/viewer/`of your theme and update it.
35 |
36 | See below the notes for more info.
37 |
38 |
39 | Usage
40 | -----
41 |
42 | The viewer is always available at `http://www.example.com/items/viewer/{item id}`.
43 | Furthermore, it is automatically embedded in items/show page. This can be
44 | disabled in the config of the plugin.
45 |
46 | The url for the default page `items/viewer/:id` can be replaced by the old one
47 | `viewer/show/:id` or any other url via the file `routes.ini`.
48 |
49 | To embed the BookReader with more control, three mechanisms are provided. So,
50 | according to your needs, you may add this code in the `items/show.php` file of
51 | your theme or anywhere else, as long as the item is defined (as variable or as
52 | current record 'item').
53 |
54 | * Helper (recommended)
55 | - With no option:
56 |
57 | ```
58 | echo $this->getBookReader();
59 | ```
60 |
61 | * Shortcode
62 | - In a field that can be shortcoded: `[bookreader]`.
63 | - Default in theme: `shortcodes('[bookreader]'); ?>`
64 | - With all options:
65 |
66 | ```
67 | shortcodes('[bookreader item=1 page=0 embed_functions=0 mode_page=1]');
69 | ?>
70 | ```
71 |
72 | * Hook
73 | - With all options:
74 |
75 | ```
76 | true,
79 | 'view' => $this,
80 | 'item' => $item,
81 | 'page' => '0',
82 | 'embed_functions' => false,
83 | 'mode_page' => 1,
84 | ));
85 | ?>
86 | ```
87 |
88 | All options are optional. If one is not defined, the parameters set in the
89 | config page will be used.
90 | The image number starts from '0' with default functions.
91 |
92 |
93 | Notes
94 | -----
95 |
96 | - A batch edit is provided to sort images before other files (pdf, xml...) that
97 | are associated to an item (Items > check box items > edit button).
98 |
99 | *Warning*
100 |
101 | PHP should be installed with the extension "exif" in order to get the size of
102 | images. This is the case for all major distributions and providers.
103 |
104 | If technical metadata are missing for some images, in particular when the
105 | extension "exif" is not installed or when images are not fully compliant with
106 | the standards, they should be rebuilt. A notice is added in the error log.
107 | A form in the batch edit can be used to process them automatically: check the
108 | items in the "admin/items/browse" view, then click the button "Edit", then the
109 | checkbox "Rebuild metadata when missing". The viewer will work without these
110 | metadata, but the display will be slower.
111 |
112 |
113 | Customing
114 | ---------
115 |
116 | There are several ways to store data about items in Omeka, so the BookReader can
117 | be customized via a class that extends `BookReader_Creator`.
118 |
119 | BookReader uses several arrays to get images and infos about them. Take a
120 | document of twelve pages as an example. In Javascript, we have these arrays:
121 | - br.leafMap : mapping of pages, as [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
122 | - br.pageNums : number of pages, as [,, "i", "ii", "iii", "iv", 1, 2, 3, 4, 5,]
123 | - br.pageLabels : label of pages, as ["Cover", "Blank",,,,, "Page 1 (unnumbered)",,,,, "Back cover"]
124 | - br.pageWidths : width of each image, as [500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500]
125 | - br.pageHeights : height of each image, as [800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800]
126 |
127 | With the default files of BookReader, all images of an item are displayed, so
128 | the leafMap indexes are always a simple list of numbers like above (starting
129 | from 0 when the first page is a right page, else from 1). Page numbers and/or
130 | page labels can be empty, so in that case the index is used. When the user
131 | leafs through the document, the viewer sends a request with index + 1 as image
132 | parameter. So the controller can send the index - 1 to select image in the
133 | ordered list of images files.
134 |
135 | Some functions of php are used to make relation with this index and to provide
136 | images. They are used in the beginning and via Ajax. During creation of the
137 | viewer, php should provide mapping, numbers and labels via BookReader custom
138 | functions (`getPageIndexes()`, `getPageNumbers()` and `getPageLabels()`). These
139 | functions use one main method, `getLeaves()`, that provides the ordered
140 | list of all images that should be displayed as leaves (saved by default as a
141 | static variable in php). This list is used too to get the selected image when
142 | needed via the index. The `getNonLeaves()` method is used to get links to other
143 | files to share. So,The list of leaves files is a simple array as [File 1, File 2, File 3, File 4...].
144 |
145 | In case of a non-digitalized blank or forgotten page, in order to keep the
146 | left/right succession of leafs, the mapping and the page numbers and labels
147 | should be the same, and the list of leaves files should be [File 1, null, File 3, File 4...].
148 | The `transparent.png` image will be displayed if an image is missing, with the
149 | width and the height of the first page.
150 |
151 | In case of multiple files for the same page, for example with a pop-up or with
152 | and without a tracing paper, the mapping can be: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 12, 11].
153 | Other arrays should be set in accordance: number of pages as [,, "i", "ii", "iii", "iv", 1, 2, 3, 4, 5, 4, 5,],
154 | labels as ["Cover", "Blank",,,,, "Page 1 (unnumbered)",,,, "Page 5 with tracing paper", "Back cover"]
155 | and files as [File 1, null, File 3, File 4..., File 10, File 11a, File 10, File 11b, File 12].
156 | Any other arrangements can be used.
157 |
158 | To avoid to calculate these data each time an item is displayed, it's
159 | recommanded to save them either in a xml file, or in the database. It's
160 | specially important for widths and heights data, as all of them should be got
161 | before first display.
162 | A batch can be launched in the admin/items/show page if needed. The function
163 | `saveData()` should be customized to your needs. Of course, other functions
164 | should check if these data are available and use them. This function can be used
165 | too the first time a viewer is displayed for an item.
166 |
167 |
168 | Spreadsheet use
169 | ---------------
170 |
171 | To test it, create an item with this value in Dublin Core : Relation:
172 | `https://spreadsheets.google.com/feeds/list/0Ag7PrlWT3aWadDdVODJLVUs0a1AtUVlUWlhnXzdwcGc/od6/public/values`.
173 | This is the public Atom feed of a Google Spreadsheet with five columns. These
174 | columns are `image`, `height`, `width`,`num` and `label`. Only the first one,
175 | that is the url to the image, is required. See [gDoc explanation] for more info.
176 | Then go to `http://example.org/items/view/{item id}`.
177 |
178 | Remarks:
179 |
180 | - Because data are not in the local database, the build of the Book Reader can
181 | take some seconds when the page is loaded.
182 | - Thumbs are not set because files are not in database but on custom server
183 | place listed in gDoc.
184 | - In the default example, the image 182 is set in the spreadsheet, but is empty.
185 |
186 |
187 | Optional plugins
188 | ----------------
189 |
190 | The extract ocr and pdfToc plugins are highly recommended.
191 |
192 | - [Extract ocr] allows fulltext searching inside a flip book. To enable it in
193 | BookReader, you need to overwrite Bookreader/libraries/BookReader/Creator/Default.php
194 | using Bookreader/libraries/BookReader/Creator/ExtractOCR.php or to set the path
195 | in configuration panel of the extension.
196 | - [PDF Toc] retrieves table of contents from pdf file associated to an item.
197 |
198 |
199 | Troubleshooting
200 | ---------------
201 |
202 | See online issues on the [plugin issues] page on GitHub.
203 |
204 |
205 | License
206 | -------
207 |
208 | This plugin is published under [GNU/GPL].
209 |
210 | This program is free software; you can redistribute it and/or modify it under
211 | the terms of the GNU General Public License as published by the Free Software
212 | Foundation; either version 3 of the License, or (at your option) any later
213 | version.
214 |
215 | This program is distributed in the hope that it will be useful, but WITHOUT
216 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
217 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
218 | details.
219 |
220 | You should have received a copy of the GNU General Public License along with
221 | this program; if not, write to the Free Software Foundation, Inc.,
222 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
223 |
224 |
225 | Contact
226 | -------
227 |
228 | See developer documentation on [Internet Archive BookReader] and [source of IA BookReader]
229 | on GitHub.
230 |
231 | Current maintainers:
232 | * [Julien Sicot]
233 | * [Daniel Berthereau]
234 |
235 | First version has been built by Julien Sicot for [Université Rennes 2].
236 | The upgrade for Omeka 2.0 has been built for [Mines ParisTech].
237 |
238 |
239 | Copyright
240 | ---------
241 |
242 | The source code of [Internet Archive BookReader] is licensed under AGPL v3, as
243 | described in the LICENSE file.
244 |
245 | * Copyright Internet Archive, 2008-2009
246 |
247 | BookReader Omeka plugin:
248 |
249 | * Copyright Julien Sicot, 2011-2013
250 | * Copyright Daniel Berthereau, 2013-2015 (upgrade for Omeka 2.0)
251 |
252 | BookReader Spreadsheet:
253 |
254 | * Copyright Doug Reside, 2013
255 | * Copyright Dušan Ranđelović, 2013
256 |
257 |
258 | [BookReader]: https://github.com/Daniel-KM/BookReader
259 | [Omeka]: https://omeka.org
260 | [Internet Archive BookReader]: http://openlibrary.org/dev/docs/bookreader
261 | [BookReader spreadsheet]: https://github.com/dougreside/bookreaderspreadsheet
262 | [Dušan Ranđelović fork]: https://github.com/duxan/BookReader-PDF
263 | [gDoc explanation]: http://www.nypl.org/blog/2013/06/25/binding-your-own-ebooks-pt-1-bookreader
264 | [source of IA BookReader]: https://github.com/openlibrary/bookreader
265 | [embedded version]: https://patrimoine.mines-paristech.fr/document/Brochant_MS_39
266 | [fullscreen mode]: http://bibnum.univ-rennes2.fr/viewer/show/566#page/5/mode/1up
267 | [Extract ocr]: https://github.com/symac/Plugin-Extractocr
268 | [PDF Toc]: https://github.com/symac/Plugin-PdfToc
269 | [plugin issues]: https://github.com/jsicot/BookReader/issues
270 | [GNU/GPL]: https://www.gnu.org/licenses/gpl-3.0.html
271 | [Daniel Berthereau]: https://github.com/Daniel-KM
272 | [Julien Sicot]: https://github.com/jsicot
273 | [Université Rennes 2]: http://bibnum.univ-rennes2.fr
274 | [Mines ParisTech]: http://bib.mines-paristech.fr
275 |
--------------------------------------------------------------------------------
/build.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
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 |
--------------------------------------------------------------------------------
/controllers/IndexController.php:
--------------------------------------------------------------------------------
1 | _helper->viewRenderer->setNoRender();
16 | }
17 |
18 | /**
19 | * Returns the answer to a query in order to highlight it via javascript.
20 | *
21 | * A result can contain multiple words, multiple matches, multiple pars and
22 | * multiple boxes, for example when the answer is on two lines or pages.
23 | *
24 | * The resulted javascript/json is echoed and sent via Ajax.
25 | *
26 | * The structure of the json object is:
27 | * ->ia = item id
28 | * ->q = query
29 | * ->page_count = page count (useless)
30 | * ->body_length = body lenght (useless)
31 | * ->leaf0_missing = generally empty
32 | * ->matches = results as array of objects
33 | * ->text = few words to contextualize the result, used in nav bar
34 | * ->par = array of parallel images (currently, only the [0] is used)
35 | * ->t = top limit of global zone
36 | * ->l = left limit of global zone
37 | * ->b = bottom limit of global zone
38 | * ->r = right limit of global zone
39 | * ->page = page number
40 | * ->index = page index
41 | * ->boxes = array of coordinates of boxes to highlight
42 | * ->t = top limit of word zone
43 | * ->l = left limit of word zone
44 | * ->b = bottom limit of word zone
45 | * ->r = right limit of word zone
46 | * ->page = page number
47 | * ->index = page index
48 | * Note that only one of "page" or "index" is needed. Index is prefered,
49 | * because it's generally simpler to manage and more efficient.
50 | */
51 | public function fulltextAction()
52 | {
53 | $request = $this->getRequest();
54 | $item_id = $request->getParam('item_id');
55 | $item = get_record_by_id('Item', $item_id);
56 | if (empty($item)) {
57 | throw new Omeka_Controller_Exception_404;
58 | }
59 |
60 | $part = $request->getParam('part');
61 | $query = $request->getParam('q');
62 | $query = utf8_encode($query);
63 | $callback = $request->getParam('callback');
64 |
65 | $output = array();
66 |
67 | // Check if there are data for search.
68 | $bookreader = new BookReader($item);
69 | if ($bookreader->hasDataForSearch()) {
70 | $output['id'] = $item_id;
71 | $output['part'] = $part;
72 | $output['q'] = $query;
73 | // TODO Check if these keys are really needed.
74 | // $output['page_count'] = 200;
75 | // $output['body_length'] = 140000;
76 | // TODO Kezako ?
77 | // $output['leaf0_missing'] = false;
78 |
79 | $answer = $bookreader->searchFulltext($query);
80 | $output['matches'] = $bookreader->highlightFiles($answer);
81 | }
82 |
83 | // Send answer.
84 | $this->getResponse()->clearBody();
85 | $this->getResponse()->setHeader('Content-Type', 'text/html');
86 | // header('Content-Type: text/javascript; charset=utf8');
87 | // header('Access-Control-Allow-Methods: GET, POST');
88 | $tab_json = json_encode($output);
89 | echo $callback . '(' . $tab_json . ')';
90 | }
91 |
92 | /**
93 | * Returns sized image for the current image.
94 | */
95 | public function imageProxyAction()
96 | {
97 | $this->_sendImage();
98 | }
99 |
100 | /**
101 | * Returns thumbnail image of the current image.
102 | */
103 | public function thumbProxyAction()
104 | {
105 | $this->_sendImage('thumbnail');
106 | }
107 |
108 | /**
109 | * Helper to return image of the current image.
110 | *
111 | * @param string $type Derivative type of the image.
112 | * @return void
113 | */
114 | protected function _sendImage($type = null)
115 | {
116 | $request = $this->getRequest();
117 | $itemId = $request->getParam('id');
118 | $item = get_record_by_id('item', $itemId);
119 | if (empty($item)) {
120 | throw new Omeka_Controller_Exception_404;
121 | }
122 |
123 | $index = $request->getParam('image');
124 | // Get the index.
125 | if ($index != '000') {
126 | $index = preg_replace('`^[0]*`', '', $index);
127 | $index--;
128 | }
129 | else {
130 | $index = 0;
131 | }
132 |
133 | $bookreader = new BookReader($item);
134 |
135 | $part = $request->getParam('part');
136 | $bookreader->setPart($part);
137 |
138 | if (is_null($type)) {
139 | $scale = $request->getParam('scale');
140 | $type = $bookreader->getSizeType($scale);
141 | // Set a default, even it's normally useless.
142 | $type = $type ?: 'fullsize';
143 | }
144 |
145 | $imagesFiles = $bookreader->getLeaves();
146 | $file = $imagesFiles[$index];
147 | // No file, so a blank image
148 | if (empty($file)) {
149 | $filepath = 'images/blank.png';
150 | $image = file_get_contents(physical_path_to($filepath));
151 | $this->getResponse()->clearBody();
152 | $this->getResponse()->setHeader('Content-Type', 'image/jpeg');
153 | $this->getResponse()->setBody($image);
154 | }
155 | // Else, redirect (302/307) to the url of the file.
156 | else {
157 | $this->_helper->redirector->gotoUrlAndExit($file->getWebPath($type));
158 | }
159 | }
160 | }
161 |
--------------------------------------------------------------------------------
/controllers/ViewerController.php:
--------------------------------------------------------------------------------
1 | _forward('show');
19 | }
20 |
21 | public function showAction()
22 | {
23 | $id = $this->getParam('id');
24 | $item = get_record_by_id('Item', $id);
25 | if (empty($item)) {
26 | throw new Omeka_Controller_Exception_404;
27 | }
28 |
29 | $this->_prepareViewer($item);
30 | }
31 |
32 | public function viewAction()
33 | {
34 | $id = $this->getParam('id');
35 | $item = get_record_by_id('Item', $id);
36 | if (empty($item)) {
37 | throw new Omeka_Controller_Exception_404;
38 | }
39 |
40 | $relations = metadata($item, array('Dublin Core', 'Relation'),
41 | array('all' => true, 'no_escape' => true, 'no_filter' => true));
42 |
43 | // Currently, only support gDoc urls.
44 | $tableUrl = '';
45 | $baseUrl = 'https://spreadsheets.google.com/feeds/list/';
46 | $endUrl = '/public/values';
47 | foreach ($relations as $relation) {
48 | if (strpos($relation, $baseUrl) === 0
49 | && substr_compare($relation, $endUrl, -strlen($endUrl), strlen($endUrl)) === 0
50 | ) {
51 | $tableUrl = $relation;
52 | break;
53 | }
54 | }
55 | if (empty($tableUrl)) {
56 | $this->_helper->flashMessenger(__('This item has no table of images.'), 'error');
57 | return $this->forward('show', 'items', 'default', array(
58 | 'module' => null,
59 | 'controller' => 'items',
60 | 'action' => 'show',
61 | 'id' => $item->id,
62 | ));
63 | }
64 |
65 | $this->_prepareViewer($item);
66 | $this->view->tableUrl = $tableUrl . '?alt=json-in-script&callback=spreadsheetLoaded';
67 | }
68 |
69 | /**
70 | * Helper to prepare the viewer (only the javascript differs in view).
71 | */
72 | protected function _prepareViewer($item)
73 | {
74 | $ui = $this->getParam('ui');
75 | $part = $this->getParam('part');
76 |
77 | $bookreader = new BookReader($item);
78 | $bookreader->setUI($ui);
79 | $bookreader->setPart($part);
80 |
81 | $this->view->bookreader = $bookreader;
82 | $this->view->item = $item;
83 | // Values have been checked inside BookReader.
84 | $this->view->ui = $bookreader->getUI();
85 | $this->view->part = $bookreader->getPart();
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/languages/fr.mo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsicot/BookReader/4e98fc1e7a2d86fbff63fb4bbcc8ba4e0da931a5/languages/fr.mo
--------------------------------------------------------------------------------
/languages/template.base.pot:
--------------------------------------------------------------------------------
1 | # Translation for the BookReader plugin for Omeka.
2 | # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
3 | # This file is distributed under the same license as the Omeka package.
4 | # FIRST AUTHOR , YEAR.
5 | #
6 | #, fuzzy
7 | msgid ""
8 | msgstr ""
9 | "Project-Id-Version: BookReader\n"
10 | "Report-Msgid-Bugs-To: https://github.com/Daniel-KM/BookReader/issues\n"
11 | "POT-Creation-Date: 2013-07-04 00:00+0000\n"
12 | "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
13 | "Last-Translator: FULL NAME \n"
14 | "Language-Team: LANGUAGE \n"
15 | "MIME-Version: 1.0\n"
16 | "Content-Type: text/plain; charset=UTF-8\n"
17 | "Content-Transfer-Encoding: 8bit\n"
18 |
--------------------------------------------------------------------------------
/libraries/BookReader/Creator.php:
--------------------------------------------------------------------------------
1 | setItem($item);
23 | }
24 |
25 | /**
26 | * Set item.
27 | *
28 | * @param integer|Item $item
29 | */
30 | public function setItem($item)
31 | {
32 | if (empty($item)) {
33 | $this->_item = null;
34 | }
35 | elseif ($item instanceof Item) {
36 | $this->_item = $item;
37 | }
38 | else {
39 | $this->_item = get_record_by_id('Item', (integer) $item);
40 | }
41 | }
42 |
43 | public function setUI($ui)
44 | {
45 | $this->_ui = ($ui == 'embed') ? 'embed' : '';
46 | }
47 |
48 | public function setPart($part)
49 | {
50 | $this->_part = (integer) $part;
51 | }
52 |
53 | public function getItem()
54 | {
55 | return $this->_item;
56 | }
57 |
58 | public function getUI()
59 | {
60 | return $this->_ui;
61 | }
62 |
63 | public function getPart()
64 | {
65 | return $this->_part;
66 | }
67 |
68 | /**
69 | * Get an array of all images of an item in order to display them with
70 | * BookReader.
71 | *
72 | * @return array
73 | * Array of filenames associated to original filenames.
74 | */
75 | public function getLeaves()
76 | {
77 | return $this->_get_list_of_leaves(false);
78 | }
79 |
80 | /**
81 | * Get an array of all non-images of an item in order to display them as
82 | * links.
83 | *
84 | * @return array
85 | * Array of filenames associated to original filenames.
86 | */
87 | public function getNonLeaves()
88 | {
89 | return $this->_get_list_of_leaves(true);
90 | }
91 |
92 | /**
93 | * Get an array of all leaves (or all non-leaves) of an item in order to
94 | * display them with BookReader.
95 | *
96 | * @param boolean $invert
97 | *
98 | * @return array
99 | * Array of files or nulls.
100 | */
101 | protected function _get_list_of_leaves($invert = false)
102 | {
103 | if (empty($this->_item)) {
104 | return;
105 | }
106 |
107 | if (is_null($this->_leaves)) {
108 | $this->_leaves = array();
109 | $this->_nonleaves = array();
110 |
111 | $supportedFormats = array(
112 | 'jpeg' => 'JPEG Joint Photographic Experts Group JFIF format',
113 | 'jpg' => 'Joint Photographic Experts Group JFIF format',
114 | 'png' => 'Portable Network Graphics',
115 | 'gif' => 'Graphics Interchange Format',
116 | 'tif' => 'Tagged Image File Format',
117 | 'tiff' => 'Tagged Image File Format',
118 | );
119 | // Set the regular expression to match selected/supported formats.
120 | $supportedFormatRegex = '/\.(' . implode('|', array_keys($supportedFormats)) . ')$/i';
121 |
122 | // Retrieve image files from the item.
123 | set_loop_records('files', $this->_item->getFiles());
124 | foreach (loop('files') as $file) {
125 | if ($file->hasThumbnail() && preg_match($supportedFormatRegex, $file->filename)) {
126 | $this->_leaves[] = $file;
127 | }
128 | else {
129 | $this->_nonleaves[] = $file;
130 | }
131 | }
132 |
133 | // Sorting by original filename or keep attachment order.
134 | if (get_option('bookreader_sorting_mode')) {
135 | $this->sortFilesByOriginalName($this->_leaves);
136 | $this->sortFilesByOriginalName($this->_nonleaves);
137 | }
138 | // Reset keys, because the important is to get files by order.
139 | $this->_leaves = array_values($this->_leaves);
140 | $this->_nonleaves = array_values($this->_nonleaves);
141 | }
142 |
143 | return $invert
144 | ? $this->_nonleaves
145 | : $this->_leaves;
146 | }
147 |
148 | /**
149 | * Count the number of image files attached to an item.
150 | *
151 | * @return integer
152 | * Number of images attached to an item.
153 | */
154 | public function itemLeafsCount()
155 | {
156 | if (empty($this->_item)) {
157 | return;
158 | }
159 | return count($this->getLeaves());
160 | }
161 |
162 | /**
163 | * Get the list of indexes of pages for an item.
164 | *
165 | * This function is used to get quickly all page indexes of an item. First
166 | * page should be 0 if document starts from right, and 1 if document starts
167 | * from left. Use null for a missing page.
168 | *
169 | * By default, indexes are simply a list of numbers starting from 0.
170 | *
171 | * @return array of integers
172 | */
173 | public function getPageIndexes()
174 | {
175 | if (empty($this->_item)) {
176 | return;
177 | }
178 |
179 | // Start from 0 by default.
180 | $leaves = $this->getLeaves();
181 | $indexes = array();
182 | foreach($leaves as $key => $leaf) {
183 | $indexes[] = empty($leaf) ? null : $key;
184 | }
185 | return $indexes;
186 | }
187 |
188 | /**
189 | * Get the list of numbers of pages of an item.
190 | *
191 | * The page number is the name of a page of a file, like "6" or "XIV".
192 | *
193 | * This function is used to get quickly all page numbers of an item. If the
194 | * page number is empty, the label page will be used. If there is no page
195 | * number, a null value or an empty string is used, so the label in viewer
196 | * will be the page index + 1.
197 | *
198 | * No page number by default.
199 | *
200 | * @see getPageLabels()
201 | *
202 | * @return array of strings
203 | */
204 | public function getPageNumbers()
205 | {
206 | if (empty($this->_item)) {
207 | return;
208 | }
209 |
210 | $leaves = $this->getLeaves();
211 | return array_fill(0, count($leaves), null);
212 | }
213 |
214 | /**
215 | * Get the list of labels of pages of an item.
216 | *
217 | * This function is used to get quickly all page labels of an item.
218 | *
219 | * A label is used first for pages without pagination, like cover, summary,
220 | * title page, index, inserted page, planches, etc. If there is a page
221 | * number, this label is not needed, but it can be used to add a specific
222 | * information ("Page XIV : Illustration").
223 | *
224 | * No label by default.
225 | *
226 | * @see getPageNumbers()
227 | *
228 | * @return array of strings
229 | */
230 | public function getPageLabels()
231 | {
232 | if (empty($this->_item)) {
233 | return;
234 | }
235 |
236 | $leaves = $this->getLeaves();
237 | return array_fill(0, count($leaves), '');
238 | }
239 |
240 | /**
241 | * Return the cover file of an item (the leaf to display as a thumbnail).
242 | *
243 | * This data can be saved in the base in order to speed the display.
244 | *
245 | * @return file
246 | * Object file of the cover.
247 | */
248 | public function getCoverFile()
249 | {
250 | if (empty($this->_item)) {
251 | return;
252 | }
253 |
254 | $leaves = $this->getLeaves();
255 | $index = $this->getTitleLeaf();
256 | return isset($leaves[$index]) ? $leaves[$index] : reset($leaves);
257 | }
258 |
259 | /**
260 | * Return index of the first leaf to display by BookReader.
261 | *
262 | * @return integer
263 | * Index for bookreader.
264 | */
265 | public function getTitleLeaf()
266 | {
267 | if (empty($this->_item)) {
268 | return;
269 | }
270 |
271 | return 0;
272 | }
273 |
274 | /**
275 | * Get the index of a file in the list of leaves.
276 | *
277 | * @return integer|null
278 | */
279 | public function getLeafIndex($file = null)
280 | {
281 | if (empty($file)) {
282 | $file = get_current_record('file');
283 | if (empty($file)) {
284 | return null;
285 | }
286 | }
287 |
288 | $leaves = $this->getLeaves();
289 | foreach($leaves as $key => $leaf) {
290 | if ($leaf && $leaf->id == $file->id) {
291 | return $key;
292 | }
293 | }
294 |
295 | return null;
296 | }
297 |
298 | /**
299 | * Get the page index of a file in the list of images.
300 | *
301 | * @see getPageIndexes()
302 | *
303 | * @return integer
304 | * Index of the page.
305 | */
306 | public function getPageIndex($file = null)
307 | {
308 | return $this->_getLeafData('PageIndexes', $file);
309 | }
310 |
311 | /**
312 | * Get the page number of a file.
313 | *
314 | * @see getPageNumbers()
315 | *
316 | * @return string
317 | * Number of the page, empty to use the page label, or 'null' if none.
318 | */
319 | public function getPageNumber($file = null)
320 | {
321 | return $this->_getLeafData('PageNumbers', $file);
322 | }
323 |
324 | /**
325 | * Get the page label of a file, like "4th Cover" or "Faux titre".
326 | *
327 | * @see getPageLabels()
328 | *
329 | * @return string
330 | * Label of the page, if needed.
331 | */
332 | public function getPageLabel($file = null)
333 | {
334 | return $this->_getLeafData('PageLabels', $file);
335 | }
336 |
337 | /**
338 | * Get a specific data of a file in list of leaves.
339 | *
340 | * @return integer|null
341 | */
342 | protected function _getLeafData($dataType, $file = null)
343 | {
344 | $key = $this->getLeafIndex($file);
345 | if (is_null($key)) {
346 | return null;
347 | }
348 | $callback = 'get' . $dataType;
349 | $array = $this->$callback();
350 | return isset($array[$key]) ? $array[$key] : null;
351 | }
352 |
353 | /**
354 | * Get an array of the widths and heights of each image file of an item.
355 | *
356 | * This data can be saved in the base in order to speed the display.
357 | *
358 | * @param string $imageType
359 | * @return array Array of width and height of image files of an item.
360 | */
361 | public function getImagesSizes($imageType = 'fullsize')
362 | {
363 | if (empty($this->_item)) {
364 | return;
365 | }
366 |
367 | $widths = array();
368 | $heights = array();
369 | $leaves = $this->getLeaves();
370 | foreach ($leaves as $file) {
371 | $imageSize = $this->getImageSize($file, $imageType);
372 | $widths[] = $imageSize['width'];
373 | $heights[] = $imageSize['height'];
374 | }
375 |
376 | return array(
377 | $widths,
378 | $heights,
379 | );
380 | }
381 |
382 | /**
383 | * Get an array of the width and height of the image file.
384 | *
385 | * @internal The process uses the saved constraints. It they are changed but
386 | * the derivative haven't been rebuilt, the return will be wrong (but
387 | * generally without consequences for BookReader).
388 | *
389 | * @param File $file
390 | * @param string $imageType
391 | * @return array Associative array of width and height of the image file.
392 | * If the file is not an image, the width and the height will be null.
393 | */
394 | public function getImageSize($file, $imageType = 'fullsize')
395 | {
396 | static $sizeConstraints = array();
397 |
398 | if (!isset($sizeConstraints[$imageType])) {
399 | $sizeConstraints[$imageType] = get_option($imageType . '_constraint');
400 | }
401 | $sizeConstraint = $sizeConstraints[$imageType];
402 |
403 | // Check if this is an image.
404 | if (empty($file) || strpos($file->mime_type, 'image/') !== 0) {
405 | $width = null;
406 | $height = null;
407 | }
408 |
409 | // This is an image.
410 | else {
411 | $metadata = json_decode($file->metadata, true);
412 | if (empty($metadata['video']['resolution_x']) || empty($metadata['video']['resolution_y'])) {
413 | $msg = __('The image #%d ("%s") is not stored correctly.', $file->id, $file->original_filename);
414 | _log($msg, Zend_Log::NOTICE);
415 |
416 | if (isset($metadata['video']['resolution_x']) || isset($metadata['video']['resolution_y'])) {
417 | throw new Exception($msg);
418 | }
419 |
420 | // Get the resolution directly.
421 | // The storage adapter should be checked for external storage.
422 | $storageAdapter = $file->getStorage()->getAdapter();
423 | $filepath = get_class($storageAdapter) == 'Omeka_Storage_Adapter_Filesystem'
424 | ? FILES_DIR . DIRECTORY_SEPARATOR . $file->getStoragePath($imageType)
425 | : $file->getWebPath($imageType);
426 | list($width, $height, $type, $attr) = getimagesize($filepath);
427 | if (empty($width) || empty($height)) {
428 | throw new Exception($msg);
429 | }
430 | }
431 |
432 | // Calculate the size.
433 | else {
434 | $sourceWidth = $metadata['video']['resolution_x'];
435 | $sourceHeight = $metadata['video']['resolution_y'];
436 |
437 | // Use the original size when possible.
438 | if ($imageType == 'original') {
439 | $width = $sourceWidth;
440 | $height = $sourceHeight;
441 | }
442 | // This supposes that the option has not changed before.
443 | else {
444 | // Source is landscape.
445 | if ($sourceWidth > $sourceHeight) {
446 | $width = $sizeConstraint;
447 | $height = round($sourceHeight * $sizeConstraint / $sourceWidth);
448 | }
449 | // Source is portrait.
450 | elseif ($sourceWidth < $sourceHeight) {
451 | $width = round($sourceWidth * $sizeConstraint / $sourceHeight);
452 | $height = $sizeConstraint;
453 | }
454 | // Source is square.
455 | else {
456 | $width = $sizeConstraint;
457 | $height = $sizeConstraint;
458 | }
459 | }
460 | }
461 | }
462 |
463 | return array(
464 | 'width' => $width,
465 | 'height' => $height,
466 | );
467 | }
468 |
469 | /**
470 | * Get an array of the number, label, witdh and height of each image file of
471 | * an item. Individual data are json encoded.
472 | *
473 | * @return array
474 | * Array of the json encoded index, number, label, width and height of
475 | * images (leaves) files of an item.
476 | */
477 | public function imagesData($imageType = 'fullsize')
478 | {
479 | if (empty($this->_item)) {
480 | return;
481 | }
482 |
483 | $indexes = $this->getPageIndexes();
484 | $numbers = $this->getPageNumbers();
485 | $labels = $this->getPageLabels();
486 | list($widths, $heights) = $this->getImagesSizes($imageType);
487 |
488 | return array(
489 | $indexes,
490 | $numbers,
491 | $labels,
492 | $widths,
493 | $heights,
494 | );
495 | }
496 |
497 | /**
498 | * Return the image in html format of the cover of the item.
499 | *
500 | * @todo Put it in a custom library.
501 | *
502 | * @return string
503 | * Html code of the image of the cover of the item.
504 | */
505 | public function itemCover($props = array(), $index = 0)
506 | {
507 | if (empty($this->_item)) {
508 | return;
509 | }
510 |
511 | $file = $this->getCoverFile();
512 |
513 | $img = '';
514 | if ($file) {
515 | $title = $this->_item->getElementTexts('Dublin Core', 'Title');
516 | $title = empty($title) ? '' : $title[0]->text;
517 | $defaultProps = array(
518 | 'alt' => html_escape($title),
519 | );
520 |
521 | $props = array_merge($defaultProps, $props);
522 |
523 | // TODO Currently use automatic width.
524 | $width = @$props['width'];
525 | $height = @$props['height'];
526 |
527 | $img = '_tagAttributes($props) . ' width="auto" height="120" />';
528 | }
529 |
530 | return $img;
531 | }
532 |
533 | /**
534 | * Returns the derivative size to use for the current image, depending on
535 | * the scale.
536 | *
537 | * This default is correct for all digitalized normal books.
538 | *
539 | * @return string
540 | * Derivative name of the size.
541 | */
542 | public function getSizeType($scale)
543 | {
544 | switch ($scale) {
545 | case ($scale < 1): return 'original';
546 | case ($scale < 2): return 'fullsize';
547 | case ($scale < 4): return 'fullsize';
548 | case ($scale < 8): return 'fullsize';
549 | case ($scale < 16): return 'thumbnail';
550 | case ($scale < 32): return 'thumbnail';
551 | }
552 | return 'fullsize';
553 | }
554 |
555 | /**
556 | * Get links to non-images files of the item.
557 | *
558 | * @return string
559 | * Html code of links.
560 | */
561 | public function linksToNonImages()
562 | {
563 | if (empty($this->_item)) {
564 | return;
565 | }
566 |
567 | $html = '';
568 | $nonImagesFiles = $this->getNonLeaves();
569 | foreach ($nonImagesFiles as $file) {
570 | // Set the document's absolute URL.
571 | // Note: file_download_uri($file) does not work here. It results
572 | // in the iPaper error: "Unable to reach provided URL."
573 | //$documentUrl = WEB_FILES . '/' . $file->filename;
574 | //$documentUrl = file_download_uri($file);
575 | $filesize = $this->_formatFileSize($file->size);
576 | $extension = pathinfo($file->original_filename, PATHINFO_EXTENSION);
577 | //$type = $file->mime_browser;
578 | $html .= '