+ * It can thus be themed to look native-like, or metal-like, or use any other + * theme you may want to try. + *
+ * We actually try to enable native look-alike mode on start. + * + * @author niki + */ class GuiReader extends BasicReader { static private boolean nativeLookLoaded; @@ -30,7 +45,14 @@ class GuiReader extends BasicReader { private File cacheDir; + /** + * Create a new graphical {@link Reader}. + * + * @throws IOException + * in case of I/O errors + */ public GuiReader() throws IOException { + // TODO: allow different themes? if (!nativeLookLoaded) { UIUtils.setLookAndFeel(); nativeLookLoaded = true; @@ -60,14 +82,14 @@ class GuiReader extends BasicReader { } @Override - public void read() throws IOException { + public void read(boolean sync) throws IOException { MetaData meta = getMeta(); if (meta == null) { throw new IOException("No story to read"); } - read(meta.getLuid(), null); + read(meta.getLuid(), sync, null); } /** @@ -85,6 +107,8 @@ class GuiReader extends BasicReader { @Override public void browse(String type) { + final Boolean[] done = new Boolean[] { false }; + // TODO: improve presentation of update message final VersionCheck updates = VersionCheck.check(); StringBuilder builder = new StringBuilder(); @@ -143,25 +167,61 @@ class GuiReader extends BasicReader { } } - new GuiReaderFrame(GuiReader.this, typeFinal).setVisible(true); + new Thread(new Runnable() { + @Override + public void run() { + try { + GuiReaderFrame gui = new GuiReaderFrame( + GuiReader.this, typeFinal); + sync(gui); + } catch (Exception e) { + Instance.getTraceHandler().error(e); + } finally { + done[0] = true; + } + + } + }).start(); } }); + + // This action must be synchronous, so wait until the frame is closed + while (!done[0]) { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + } + } } @Override - public void start(File target, String program) throws IOException { - if (program == null) { + public void start(File target, String program, boolean sync) + throws IOException { + + boolean handled = false; + if (program == null && !sync) { try { Desktop.getDesktop().browse(target.toURI()); + handled = true; } catch (UnsupportedOperationException e) { - super.start(target, program); } - } else { - super.start(target, program); + } + + if (!handled) { + super.start(target, program, sync); } } - // delete from local reader library + /** + * Delete the {@link Story} from the cache if it is present, but NOT + * from the main library. + *
+ * The next time we try to retrieve the {@link Story}, it may be required to + * cache it again. + * + * @param luid + * the luid of the {@link Story} + */ void clearLocalReaderCache(String luid) { try { cacheLib.clearFromCache(luid); @@ -170,7 +230,15 @@ class GuiReader extends BasicReader { } } - // delete from main library + /** + * Forward the delete operation to the main library. + *
+ * The {@link Story} will be deleted from the main library as well as the + * cache if present. + * + * @param luid + * the {@link Story} to delete + */ void delete(String luid) { try { cacheLib.delete(luid); @@ -179,19 +247,146 @@ class GuiReader extends BasicReader { } } - // open the given book - void read(String luid, Progress pg) throws IOException { + /** + * "Open" the given {@link Story}. It usually involves starting an external + * program adapted to the given file type. + *
+ * Asynchronous method. + * + * @param luid + * the luid of the {@link Story} to open + * @param sync + * execute the process synchronously (wait until it is terminated + * before returning) + * @param pg + * the optional progress (we may need to prepare the + * {@link Story} for reading + * + * @throws IOException + * in case of I/O errors + */ + void read(String luid, boolean sync, Progress pg) throws IOException { File file = cacheLib.getFile(luid, pg); - // TODO: show a special page for the chapter? - openExternal(getLibrary().getInfo(luid), file); + GuiReaderTextViewer viewer = new GuiReaderTextViewer(cacheLib, + cacheLib.getStory(luid, null)); + + // TODO: testing text viewer: + if (false) { + if (sync) { + sync(viewer); + } else { + viewer.setVisible(true); + } + } + + openExternal(getLibrary().getInfo(luid), file, sync); } - void changeType(String luid, String newSource) { + /** + * Change the source of the given {@link Story} (the source is the main + * information used to group the stories together). + *
+ * In other words, move the {@link Story} into other source. + *
+ * The source can be a new one, it needs not exist before hand. + * + * @param luid + * the luid of the {@link Story} to move + * @param newSource + * the new source + */ + void changeSource(String luid, String newSource) { try { cacheLib.changeSource(luid, newSource, null); } catch (IOException e) { Instance.getTraceHandler().error(e); } } + + /** + * Change the title of the given {@link Story}. + * + * @param luid + * the luid of the {@link Story} to change + * @param newTitle + * the new title + */ + void changeTitle(String luid, String newTitle) { + try { + cacheLib.changeTitle(luid, newTitle, null); + } catch (IOException e) { + Instance.getTraceHandler().error(e); + } + } + + /** + * Change the author of the given {@link Story}. + *
+ * The author can be a new one, it needs not exist before hand. + * + * @param luid + * the luid of the {@link Story} to change + * @param newAuthor + * the new author + */ + void changeAuthor(String luid, String newAuthor) { + try { + cacheLib.changeAuthor(luid, newAuthor, null); + } catch (IOException e) { + Instance.getTraceHandler().error(e); + } + } + + /** + * Start a frame and wait until it is closed before returning. + * + * @param frame + * the frame to start + */ + static private void sync(final JFrame frame) { + if (EventQueue.isDispatchThread()) { + throw new IllegalStateException( + "Cannot call a sync method in the dispatch thread"); + } + + final Boolean[] done = new Boolean[] { false }; + try { + Runnable run = new Runnable() { + @Override + public void run() { + try { + frame.addWindowListener(new WindowAdapter() { + @Override + public void windowClosing(WindowEvent e) { + super.windowClosing(e); + done[0] = true; + } + }); + + frame.setVisible(true); + } catch (Exception e) { + done[0] = true; + } + } + }; + + if (EventQueue.isDispatchThread()) { + run.run(); + } else { + EventQueue.invokeLater(run); + } + } catch (Exception e) { + Instance.getTraceHandler().error(e); + done[0] = true; + } + + // This action must be synchronous, so wait until the frame is closed + while (!done[0]) { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + } + } + } }