[nikiroo-utils.git] / src / be / nikiroo / fanfix / reader / ui / GuiReader.java

package be.nikiroo.fanfix.reader.ui;

import java.awt.Desktop;
import java.awt.EventQueue;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;

import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.VersionCheck;
import be.nikiroo.fanfix.bundles.StringIdGui;
import be.nikiroo.fanfix.bundles.UiConfig;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.fanfix.library.BasicLibrary;
import be.nikiroo.fanfix.library.CacheLibrary;
import be.nikiroo.fanfix.reader.BasicReader;
import be.nikiroo.fanfix.reader.Reader;
import be.nikiroo.fanfix.supported.SupportType;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.Version;
import be.nikiroo.utils.ui.UIUtils;

/**
 * This class implements a graphical {@link Reader} using the Swing library from
 * Java.
 * <p>
 * It can thus be themed to look native-like, or metal-like, or use any other
 * theme you may want to try.
 * <p>
 * We actually try to enable native look-alike mode on start.
 * 
 * @author niki
 */
class GuiReader extends BasicReader {
	static private boolean nativeLookLoaded;

	private CacheLibrary cacheLib;

	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;
		}

		cacheDir = Instance.getReaderDir();
		cacheDir.mkdirs();
		if (!cacheDir.exists()) {
			throw new IOException(
					"Cannote create cache directory for local reader: "
							+ cacheDir);
		}
	}

	@Override
	public synchronized BasicLibrary getLibrary() {
		if (cacheLib == null) {
			BasicLibrary lib = super.getLibrary();
			if (lib instanceof CacheLibrary) {
				cacheLib = (CacheLibrary) lib;
			} else {
				cacheLib = new CacheLibrary(cacheDir, lib);
			}
		}

		return cacheLib;
	}

	@Override
	public void read(boolean sync) throws IOException {
		MetaData meta = getMeta();

		if (meta == null) {
			throw new IOException("No story to read");
		}

		read(meta.getLuid(), sync, null);
	}

	/**
	 * Check if the {@link Story} denoted by this Library UID is present in the
	 * {@link GuiReader} cache.
	 * 
	 * @param luid
	 *            the Library UID
	 * 
	 * @return TRUE if it is
	 */
	public boolean isCached(String luid) {
		return cacheLib.isCached(luid);
	}

	@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();

		final JEditorPane updateMessage = new JEditorPane("text/html", "");
		if (updates.isNewVersionAvailable()) {
			builder.append(trans(StringIdGui.NEW_VERSION_AVAILABLE,
					"<span style='color: blue;'>https://github.com/nikiroo/fanfix/releases</span>"));
			builder.append("<br>");
			builder.append("<br>");
			for (Version v : updates.getNewer()) {
				builder.append("\t<b>"
						+ trans(StringIdGui.NEW_VERSION_VERSION, v.toString())
						+ "</b>");
				builder.append("<br>");
				builder.append("<ul>");
				for (String item : updates.getChanges().get(v)) {
					builder.append("<li>" + item + "</li>");
				}
				builder.append("</ul>");
			}

			// html content
			updateMessage.setText("<html><body>" //
					+ builder//
					+ "</body></html>");

			// handle link events
			updateMessage.addHyperlinkListener(new HyperlinkListener() {
				@Override
				public void hyperlinkUpdate(HyperlinkEvent e) {
					if (e.getEventType().equals(
							HyperlinkEvent.EventType.ACTIVATED))
						try {
							Desktop.getDesktop().browse(e.getURL().toURI());
						} catch (IOException ee) {
							Instance.getTraceHandler().error(ee);
						} catch (URISyntaxException ee) {
							Instance.getTraceHandler().error(ee);
						}
				}
			});
			updateMessage.setEditable(false);
			updateMessage.setBackground(new JLabel().getBackground());
		}

		final String typeFinal = type;
		EventQueue.invokeLater(new Runnable() {
			@Override
			public void run() {
				if (updates.isNewVersionAvailable()) {
					int rep = JOptionPane.showConfirmDialog(null,
							updateMessage,
							trans(StringIdGui.NEW_VERSION_TITLE),
							JOptionPane.OK_CANCEL_OPTION);
					if (rep == JOptionPane.OK_OPTION) {
						updates.ok();
					} else {
						updates.ignore();
					}
				}

				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, boolean sync)
			throws IOException {

		boolean handled = false;
		if (program == null && !sync) {
			try {
				Desktop.getDesktop().browse(target.toURI());
				handled = true;
			} catch (UnsupportedOperationException e) {
			}
		}

		if (!handled) {
			super.start(target, program, sync);
		}
	}

	@Override
	public void search(boolean sync) throws IOException {
		// TODO
		if (sync) {
			throw new java.lang.IllegalStateException("Not implemented yet.");
		}
	}

	@Override
	public void search(SupportType searchOn, String keywords, int page,
			int item, boolean sync) {
		// TODO: add parameters!
		GuiReaderSearch search = new GuiReaderSearch(this);
		if (sync) {
			sync(search);
		} else {
			search.setVisible(true);
		}
	}

	@Override
	public void searchTag(SupportType searchOn, int page, int item,
			boolean sync, Integer... tags) {
		// TODO
		if (sync) {
			throw new java.lang.IllegalStateException("Not implemented yet.");
		}
	}

	/**
	 * Delete the {@link Story} from the cache if it is present, but <b>NOT</b>
	 * from the main library.
	 * <p>
	 * 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);
		} catch (IOException e) {
			Instance.getTraceHandler().error(e);
		}
	}

	/**
	 * Forward the delete operation to the main library.
	 * <p>
	 * 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);
		} catch (IOException e) {
			Instance.getTraceHandler().error(e);
		}
	}

	/**
	 * "Open" the given {@link Story}. It usually involves starting an external
	 * program adapted to the given file type.
	 * <p>
	 * 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 {
		MetaData meta = cacheLib.getInfo(luid);

		boolean textInternal = Instance.getUiConfig().getBoolean(
				UiConfig.NON_IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
		boolean imageInternal = Instance.getUiConfig().getBoolean(
				UiConfig.IMAGES_DOCUMENT_USE_INTERNAL_READER, true);

		boolean useInternalViewer = true;
		if (meta.isImageDocument() && !imageInternal) {
			useInternalViewer = false;
		}
		if (!meta.isImageDocument() && !textInternal) {
			useInternalViewer = false;
		}

		if (useInternalViewer) {
			GuiReaderViewer viewer = new GuiReaderViewer(cacheLib,
					cacheLib.getStory(luid, null));
			if (sync) {
				sync(viewer);
			} else {
				viewer.setVisible(true);
			}
		} else {
			File file = cacheLib.getFile(luid, pg);
			openExternal(meta, file, sync);
		}
	}

	/**
	 * Change the source of the given {@link Story} (the source is the main
	 * information used to group the stories together).
	 * <p>
	 * In other words, <b>move</b> the {@link Story} into other source.
	 * <p>
	 * 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}.
	 * <p>
	 * 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);
		}
	}

	/**
	 * Simple shortcut method to call {link Instance#getTransGui()#getString()}.
	 * 
	 * @param id
	 *            the ID to translate
	 * 
	 * @return the translated result
	 */
	static String trans(StringIdGui id, Object... params) {
		return Instance.getTransGui().getString(id, params);
	}

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