package be.nikiroo.fanfix.reader;
+import java.awt.Desktop;
+import java.io.File;
import java.io.IOException;
+import java.net.MalformedURLException;
import java.net.URL;
+import be.nikiroo.fanfix.BasicLibrary;
import be.nikiroo.fanfix.Instance;
-import be.nikiroo.fanfix.Library;
+import be.nikiroo.fanfix.LocalLibrary;
import be.nikiroo.fanfix.bundles.Config;
+import be.nikiroo.fanfix.bundles.UiConfig;
+import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.fanfix.supported.BasicSupport;
+import be.nikiroo.utils.Progress;
+import be.nikiroo.utils.serial.SerialUtils;
/**
* The class that handles the different {@link Story} readers you can use.
* @author niki
*/
public abstract class BasicReader {
+ /**
+ * A type of {@link BasicReader}.
+ *
+ * @author niki
+ */
public enum ReaderType {
/** Simple reader that outputs everything on the console */
CLI,
/** Reader that starts local programs to handle the stories */
- LOCAL
+ GUI,
+ /** A text (UTF-8) reader with menu and text windows */
+ TUI,
+
+ ;
+
+ /**
+ * Return the full class name of a type that implements said
+ * {@link ReaderType}.
+ *
+ * @return the class name
+ */
+ public String getTypeName() {
+ String pkg = "be.nikiroo.fanfix.reader.";
+ switch (this) {
+ case CLI:
+ return pkg + "CliReader";
+ case TUI:
+ return pkg + "TuiReader";
+ case GUI:
+ return pkg + "GuiReader";
+ }
+
+ return null;
+ }
}
- private static ReaderType defaultType = ReaderType.CLI;
+ private static BasicLibrary defaultLibrary = Instance.getLibrary();
+ private static ReaderType defaultType = ReaderType.GUI;
+
+ private BasicLibrary lib;
private Story story;
private ReaderType type;
*
* @param type
* the new type
+ *
+ * @return the type
*/
protected BasicReader setType(ReaderType type) {
this.type = type;
return story;
}
+ /**
+ * The {@link LocalLibrary} to load the stories from (by default, takes the
+ * default {@link LocalLibrary}).
+ *
+ * @return the {@link LocalLibrary}
+ */
+ public BasicLibrary getLibrary() {
+ if (lib == null) {
+ lib = defaultLibrary;
+ }
+
+ return lib;
+ }
+
+ /**
+ * Change the {@link LocalLibrary} that will be managed by this
+ * {@link BasicReader}.
+ *
+ * @param lib
+ * the new {@link LocalLibrary}
+ */
+ public void setLibrary(LocalLibrary lib) {
+ this.lib = lib;
+ }
+
/**
* Create a new {@link BasicReader} for a {@link Story} in the
- * {@link Library} .
+ * {@link LocalLibrary}.
*
* @param luid
* the {@link Story} ID
+ * @param pg
+ * the optional progress reporter
+ *
* @throws IOException
* in case of I/O error
*/
- public void setStory(String luid) throws IOException {
- story = Instance.getLibrary().getStory(luid);
+ public void setStory(String luid, Progress pg) throws IOException {
+ story = lib.getStory(luid, pg);
if (story == null) {
- // if the LUID is wrong and < 3, pad it to 3 chars with "0" then
- // retry (since LUIDs are %03d)
- if (luid != null && luid.length() < 3) {
- while (luid.length() < 3) {
- luid = "0" + luid;
- }
- setStory(luid);
- } else {
- throw new IOException("Cannot retrieve story from library: "
- + luid);
- }
+ throw new IOException("Cannot retrieve story from library: " + luid);
}
}
*
* @param source
* the {@link Story} {@link URL}
+ * @param pg
+ * the optional progress reporter
+ *
* @throws IOException
* in case of I/O error
*/
- public void setStory(URL source) throws IOException {
+ public void setStory(URL source, Progress pg) throws IOException {
BasicSupport support = BasicSupport.getSupport(source);
if (support == null) {
throw new IOException("URL not supported: " + source.toString());
}
- story = support.process(source);
+ story = support.process(source, pg);
if (story == null) {
throw new IOException(
"Cannot retrieve story from external source: "
*
* @param chapter
* the chapter
+ *
+ * @throws IOException
+ * in case of I/O error or if the {@link Story} was not
+ * previously set
*/
- public abstract void read(int chapter);
+ public abstract void read(int chapter) throws IOException;
/**
- * Start the reader in browse mode for the given type (or pass NULL for all
- * types).
+ * Start the reader in browse mode for the given source (or pass NULL for
+ * all sources).
*
- * @param type
+ * @param source
* the type of {@link Story} to take into account, or NULL for
* all
*/
- public abstract void start(String type);
+ public abstract void browse(String source);
/**
* Return a new {@link BasicReader} ready for use if one is configured.
public static BasicReader getReader() {
try {
if (defaultType != null) {
- switch (defaultType) {
- case LOCAL:
- return new LocalReader().setType(ReaderType.LOCAL);
- case CLI:
- return new CliReader().setType(ReaderType.CLI);
- }
+ return ((BasicReader) SerialUtils.createObject(defaultType
+ .getTypeName())).setType(defaultType);
}
- } catch (IOException e) {
+ } catch (Exception e) {
Instance.syserr(new Exception("Cannot create a reader of type: "
- + defaultType, e));
+ + defaultType + " (Not compiled in?)", e));
}
return null;
public static void setDefaultReaderType(ReaderType defaultType) {
BasicReader.defaultType = defaultType;
}
+
+ /**
+ * Change the default {@link LocalLibrary} to open with the
+ * {@link BasicReader}s.
+ *
+ * @param lib
+ * the new {@link LocalLibrary}
+ */
+ public static void setDefaultLibrary(BasicLibrary lib) {
+ BasicReader.defaultLibrary = lib;
+ }
+
+ /**
+ * Return an {@link URL} from this {@link String}, be it a file path or an
+ * actual {@link URL}.
+ *
+ * @param sourceString
+ * the source
+ *
+ * @return the corresponding {@link URL}
+ *
+ * @throws MalformedURLException
+ * if this is neither a file nor a conventional {@link URL}
+ */
+ public static URL getUrl(String sourceString) throws MalformedURLException {
+ if (sourceString == null || sourceString.isEmpty()) {
+ throw new MalformedURLException("Empty url");
+ }
+
+ URL source = null;
+ try {
+ source = new URL(sourceString);
+ } catch (MalformedURLException e) {
+ File sourceFile = new File(sourceString);
+ source = sourceFile.toURI().toURL();
+ }
+
+ return source;
+ }
+
+ /**
+ * Open the {@link Story} with an external reader (the program will be
+ * passed the main file associated with this {@link Story}).
+ *
+ * @param lib
+ * the {@link BasicLibrary} to select the {@link Story} from
+ * @param luid
+ * the {@link Story} LUID
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ public static void open(BasicLibrary lib, String luid) throws IOException {
+ MetaData meta = lib.getInfo(luid);
+ File target = lib.getFile(luid);
+
+ open(meta, target);
+ }
+
+ /**
+ * Open the {@link Story} with an external reader (the program will be
+ * passed the given target file).
+ *
+ * @param meta
+ * the {@link Story} to load
+ * @param target
+ * the target {@link File}
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ protected static void open(MetaData meta, File target) throws IOException {
+ String program = null;
+ if (meta.isImageDocument()) {
+ program = Instance.getUiConfig().getString(
+ UiConfig.IMAGES_DOCUMENT_READER);
+ } else {
+ program = Instance.getUiConfig().getString(
+ UiConfig.NON_IMAGES_DOCUMENT_READER);
+ }
+
+ if (program != null && program.trim().isEmpty()) {
+ program = null;
+ }
+
+ if (program == null) {
+ try {
+ Desktop.getDesktop().browse(target.toURI());
+ } catch (UnsupportedOperationException e) {
+ Runtime.getRuntime().exec(
+ new String[] { "xdg-open", target.getAbsolutePath() });
+
+ }
+ } else {
+ Runtime.getRuntime().exec(
+ new String[] { program, target.getAbsolutePath() });
+ }
+ }
}
git://git.nikiroo.be / fanfix.git / blobdiff