test: improve flag files
[nikiroo-utils.git] / src / be / nikiroo / fanfix / reader / ui / GuiReader.java
1 package be.nikiroo.fanfix.reader.ui;
2
3 import java.awt.Desktop;
4 import java.awt.EventQueue;
5 import java.awt.event.WindowAdapter;
6 import java.awt.event.WindowEvent;
7 import java.io.File;
8 import java.io.IOException;
9 import java.net.URISyntaxException;
10
11 import javax.swing.JEditorPane;
12 import javax.swing.JFrame;
13 import javax.swing.JLabel;
14 import javax.swing.JOptionPane;
15 import javax.swing.event.HyperlinkEvent;
16 import javax.swing.event.HyperlinkListener;
17
18 import be.nikiroo.fanfix.Instance;
19 import be.nikiroo.fanfix.VersionCheck;
20 import be.nikiroo.fanfix.bundles.StringIdGui;
21 import be.nikiroo.fanfix.bundles.UiConfig;
22 import be.nikiroo.fanfix.data.MetaData;
23 import be.nikiroo.fanfix.data.Story;
24 import be.nikiroo.fanfix.library.BasicLibrary;
25 import be.nikiroo.fanfix.library.CacheLibrary;
26 import be.nikiroo.fanfix.reader.BasicReader;
27 import be.nikiroo.fanfix.reader.Reader;
28 import be.nikiroo.fanfix.searchable.BasicSearchable;
29 import be.nikiroo.fanfix.searchable.SearchableTag;
30 import be.nikiroo.fanfix.supported.SupportType;
31 import be.nikiroo.utils.Progress;
32 import be.nikiroo.utils.Version;
33 import be.nikiroo.utils.ui.UIUtils;
34
35 /**
36 * This class implements a graphical {@link Reader} using the Swing library from
37 * Java.
38 * <p>
39 * It can thus be themed to look native-like, or metal-like, or use any other
40 * theme you may want to try.
41 * <p>
42 * We actually try to enable native look-alike mode on start.
43 *
44 * @author niki
45 */
46 class GuiReader extends BasicReader {
47 static private boolean nativeLookLoaded;
48
49 private CacheLibrary cacheLib;
50
51 private File cacheDir;
52
53 /**
54 * Create a new graphical {@link Reader}.
55 *
56 * @throws IOException
57 * in case of I/O errors
58 */
59 public GuiReader() throws IOException {
60 // TODO: allow different themes?
61 if (!nativeLookLoaded) {
62 UIUtils.setLookAndFeel();
63 nativeLookLoaded = true;
64 }
65
66 cacheDir = Instance.getReaderDir();
67 cacheDir.mkdirs();
68 if (!cacheDir.exists()) {
69 throw new IOException(
70 "Cannote create cache directory for local reader: "
71 + cacheDir);
72 }
73 }
74
75 @Override
76 public synchronized BasicLibrary getLibrary() {
77 if (cacheLib == null) {
78 BasicLibrary lib = super.getLibrary();
79 if (lib instanceof CacheLibrary) {
80 cacheLib = (CacheLibrary) lib;
81 } else {
82 cacheLib = new CacheLibrary(cacheDir, lib);
83 }
84 }
85
86 return cacheLib;
87 }
88
89 @Override
90 public void read(boolean sync) throws IOException {
91 MetaData meta = getMeta();
92
93 if (meta == null) {
94 throw new IOException("No story to read");
95 }
96
97 read(meta.getLuid(), sync, null);
98 }
99
100 /**
101 * Check if the {@link Story} denoted by this Library UID is present in the
102 * {@link GuiReader} cache.
103 *
104 * @param luid
105 * the Library UID
106 *
107 * @return TRUE if it is
108 */
109 public boolean isCached(String luid) {
110 return cacheLib.isCached(luid);
111 }
112
113 @Override
114 public void browse(String type) {
115 final Boolean[] done = new Boolean[] { false };
116
117 // TODO: improve presentation of update message
118 final VersionCheck updates = VersionCheck.check();
119 StringBuilder builder = new StringBuilder();
120
121 final JEditorPane updateMessage = new JEditorPane("text/html", "");
122 if (updates.isNewVersionAvailable()) {
123 builder.append(trans(StringIdGui.NEW_VERSION_AVAILABLE,
124 "<span style='color: blue;'>https://github.com/nikiroo/fanfix/releases</span>"));
125 builder.append("<br>");
126 builder.append("<br>");
127 for (Version v : updates.getNewer()) {
128 builder.append("\t<b>"
129 + trans(StringIdGui.NEW_VERSION_VERSION, v.toString())
130 + "</b>");
131 builder.append("<br>");
132 builder.append("<ul>");
133 for (String item : updates.getChanges().get(v)) {
134 builder.append("<li>" + item + "</li>");
135 }
136 builder.append("</ul>");
137 }
138
139 // html content
140 updateMessage.setText("<html><body>" //
141 + builder//
142 + "</body></html>");
143
144 // handle link events
145 updateMessage.addHyperlinkListener(new HyperlinkListener() {
146 @Override
147 public void hyperlinkUpdate(HyperlinkEvent e) {
148 if (e.getEventType().equals(
149 HyperlinkEvent.EventType.ACTIVATED))
150 try {
151 Desktop.getDesktop().browse(e.getURL().toURI());
152 } catch (IOException ee) {
153 Instance.getTraceHandler().error(ee);
154 } catch (URISyntaxException ee) {
155 Instance.getTraceHandler().error(ee);
156 }
157 }
158 });
159 updateMessage.setEditable(false);
160 updateMessage.setBackground(new JLabel().getBackground());
161 }
162
163 final String typeFinal = type;
164 EventQueue.invokeLater(new Runnable() {
165 @Override
166 public void run() {
167 if (updates.isNewVersionAvailable()) {
168 int rep = JOptionPane.showConfirmDialog(null,
169 updateMessage,
170 trans(StringIdGui.NEW_VERSION_TITLE),
171 JOptionPane.OK_CANCEL_OPTION);
172 if (rep == JOptionPane.OK_OPTION) {
173 updates.ok();
174 } else {
175 updates.ignore();
176 }
177 }
178
179 new Thread(new Runnable() {
180 @Override
181 public void run() {
182 try {
183 GuiReaderFrame gui = new GuiReaderFrame(
184 GuiReader.this, typeFinal);
185 sync(gui);
186 } catch (Exception e) {
187 Instance.getTraceHandler().error(e);
188 } finally {
189 done[0] = true;
190 }
191
192 }
193 }).start();
194 }
195 });
196
197 // This action must be synchronous, so wait until the frame is closed
198 while (!done[0]) {
199 try {
200 Thread.sleep(100);
201 } catch (InterruptedException e) {
202 }
203 }
204 }
205
206 @Override
207 public void start(File target, String program, boolean sync)
208 throws IOException {
209
210 boolean handled = false;
211 if (program == null && !sync) {
212 try {
213 Desktop.getDesktop().browse(target.toURI());
214 handled = true;
215 } catch (UnsupportedOperationException e) {
216 }
217 }
218
219 if (!handled) {
220 super.start(target, program, sync);
221 }
222 }
223
224 @Override
225 public void search(boolean sync) throws IOException {
226 GuiReaderSearchFrame search = new GuiReaderSearchFrame(this);
227 if (sync) {
228 sync(search);
229 } else {
230 search.setVisible(true);
231 }
232 }
233
234 @Override
235 public void search(SupportType searchOn, String keywords, int page,
236 int item, boolean sync) {
237 GuiReaderSearchFrame search = new GuiReaderSearchFrame(this);
238 search.search(searchOn, keywords, page, item);
239 if (sync) {
240 sync(search);
241 } else {
242 search.setVisible(true);
243 }
244 }
245
246 @Override
247 public void searchTag(final SupportType searchOn, final int page,
248 final int item, final boolean sync, final Integer... tags) {
249
250 final GuiReaderSearchFrame search = new GuiReaderSearchFrame(this);
251
252 final BasicSearchable searchable = BasicSearchable
253 .getSearchable(searchOn);
254
255 Runnable action = new Runnable() {
256 @Override
257 public void run() {
258 SearchableTag tag = null;
259 try {
260 tag = searchable.getTag(tags);
261 } catch (IOException e) {
262 Instance.getTraceHandler().error(e);
263 }
264
265 search.searchTag(searchOn, page, item, tag);
266
267 if (sync) {
268 sync(search);
269 } else {
270 search.setVisible(true);
271 }
272 }
273 };
274
275 if (sync) {
276 action.run();
277 } else {
278 new Thread(action).start();
279 }
280 }
281
282 /**
283 * Delete the {@link Story} from the cache if it is present, but <b>NOT</b>
284 * from the main library.
285 * <p>
286 * The next time we try to retrieve the {@link Story}, it may be required to
287 * cache it again.
288 *
289 * @param luid
290 * the luid of the {@link Story}
291 */
292 void clearLocalReaderCache(String luid) {
293 try {
294 cacheLib.clearFromCache(luid);
295 } catch (IOException e) {
296 Instance.getTraceHandler().error(e);
297 }
298 }
299
300 /**
301 * Forward the delete operation to the main library.
302 * <p>
303 * The {@link Story} will be deleted from the main library as well as the
304 * cache if present.
305 *
306 * @param luid
307 * the {@link Story} to delete
308 */
309 void delete(String luid) {
310 try {
311 cacheLib.delete(luid);
312 } catch (IOException e) {
313 Instance.getTraceHandler().error(e);
314 }
315 }
316
317 /**
318 * "Open" the given {@link Story}. It usually involves starting an external
319 * program adapted to the given file type.
320 * <p>
321 * Asynchronous method.
322 *
323 * @param luid
324 * the luid of the {@link Story} to open
325 * @param sync
326 * execute the process synchronously (wait until it is terminated
327 * before returning)
328 * @param pg
329 * the optional progress (we may need to prepare the
330 * {@link Story} for reading
331 *
332 * @throws IOException
333 * in case of I/O errors
334 */
335 void read(String luid, boolean sync, Progress pg) throws IOException {
336 MetaData meta = cacheLib.getInfo(luid);
337
338 boolean textInternal = Instance.getUiConfig().getBoolean(
339 UiConfig.NON_IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
340 boolean imageInternal = Instance.getUiConfig().getBoolean(
341 UiConfig.IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
342
343 boolean useInternalViewer = true;
344 if (meta.isImageDocument() && !imageInternal) {
345 useInternalViewer = false;
346 }
347 if (!meta.isImageDocument() && !textInternal) {
348 useInternalViewer = false;
349 }
350
351 if (useInternalViewer) {
352 GuiReaderViewer viewer = new GuiReaderViewer(cacheLib,
353 cacheLib.getStory(luid, null));
354 if (sync) {
355 sync(viewer);
356 } else {
357 viewer.setVisible(true);
358 }
359 } else {
360 File file = cacheLib.getFile(luid, pg);
361 openExternal(meta, file, sync);
362 }
363 }
364
365 /**
366 * Change the source of the given {@link Story} (the source is the main
367 * information used to group the stories together).
368 * <p>
369 * In other words, <b>move</b> the {@link Story} into other source.
370 * <p>
371 * The source can be a new one, it needs not exist before hand.
372 *
373 * @param luid
374 * the luid of the {@link Story} to move
375 * @param newSource
376 * the new source
377 */
378 void changeSource(String luid, String newSource) {
379 try {
380 cacheLib.changeSource(luid, newSource, null);
381 } catch (IOException e) {
382 Instance.getTraceHandler().error(e);
383 }
384 }
385
386 /**
387 * Change the title of the given {@link Story}.
388 *
389 * @param luid
390 * the luid of the {@link Story} to change
391 * @param newTitle
392 * the new title
393 */
394 void changeTitle(String luid, String newTitle) {
395 try {
396 cacheLib.changeTitle(luid, newTitle, null);
397 } catch (IOException e) {
398 Instance.getTraceHandler().error(e);
399 }
400 }
401
402 /**
403 * Change the author of the given {@link Story}.
404 * <p>
405 * The author can be a new one, it needs not exist before hand.
406 *
407 * @param luid
408 * the luid of the {@link Story} to change
409 * @param newAuthor
410 * the new author
411 */
412 void changeAuthor(String luid, String newAuthor) {
413 try {
414 cacheLib.changeAuthor(luid, newAuthor, null);
415 } catch (IOException e) {
416 Instance.getTraceHandler().error(e);
417 }
418 }
419
420 /**
421 * Simple shortcut method to call {link Instance#getTransGui()#getString()}.
422 *
423 * @param id
424 * the ID to translate
425 *
426 * @return the translated result
427 */
428 static String trans(StringIdGui id, Object... params) {
429 return Instance.getTransGui().getString(id, params);
430 }
431
432 /**
433 * Start a frame and wait until it is closed before returning.
434 *
435 * @param frame
436 * the frame to start
437 */
438 static private void sync(final JFrame frame) {
439 if (EventQueue.isDispatchThread()) {
440 throw new IllegalStateException(
441 "Cannot call a sync method in the dispatch thread");
442 }
443
444 final Boolean[] done = new Boolean[] { false };
445 try {
446 Runnable run = new Runnable() {
447 @Override
448 public void run() {
449 try {
450 frame.addWindowListener(new WindowAdapter() {
451 @Override
452 public void windowClosing(WindowEvent e) {
453 super.windowClosing(e);
454 done[0] = true;
455 }
456 });
457
458 frame.setVisible(true);
459 } catch (Exception e) {
460 done[0] = true;
461 }
462 }
463 };
464
465 if (EventQueue.isDispatchThread()) {
466 run.run();
467 } else {
468 EventQueue.invokeLater(run);
469 }
470 } catch (Exception e) {
471 Instance.getTraceHandler().error(e);
472 done[0] = true;
473 }
474
475 // This action must be synchronous, so wait until the frame is closed
476 while (!done[0]) {
477 try {
478 Thread.sleep(100);
479 } catch (InterruptedException e) {
480 }
481 }
482 }
483 }