[fanfix.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.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.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("A new version of the program is available at <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>Version " + v + "</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, "Updates available",
							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);
		}
	}

	/**
	 * 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 {
		File file = cacheLib.getFile(luid, pg);

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

	/**
	 * 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);
		}
	}

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