X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Ffanfix%2Freader%2FBasicReader.java;h=778b6338b108f847bea745fbe8fe04c77a0454ec;hb=e0fb1417b679a2f3cb0fef4937e79b211f1ce3c4;hp=05e3e3df1124b6eae858e536e5b57adec2db78e2;hpb=b0e88ebd20f8b2950c382694e936da76ac3596b6;p=fanfix.git diff --git a/src/be/nikiroo/fanfix/reader/BasicReader.java b/src/be/nikiroo/fanfix/reader/BasicReader.java index 05e3e3d..778b633 100644 --- a/src/be/nikiroo/fanfix/reader/BasicReader.java +++ b/src/be/nikiroo/fanfix/reader/BasicReader.java @@ -1,17 +1,17 @@ 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.Instance; -import be.nikiroo.fanfix.Library; 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.library.BasicLibrary; +import be.nikiroo.fanfix.library.LocalLibrary; import be.nikiroo.fanfix.supported.BasicSupport; import be.nikiroo.utils.Progress; import be.nikiroo.utils.serial.SerialUtils; @@ -23,38 +23,14 @@ import be.nikiroo.utils.serial.SerialUtils; * * @author niki */ -public abstract class BasicReader { - public enum ReaderType { - /** Simple reader that outputs everything on the console */ - CLI, - /** Reader that starts local programs to handle the stories */ - GUI, - /** A text (UTF-8) reader with menu and text windows */ - TUI, - - ; - - 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 + "LocalReader"; - } - - return null; - } - } - - private static Library defaultLibrary = Instance.getLibrary(); +public abstract class BasicReader implements Reader { + private static BasicLibrary defaultLibrary = Instance.getLibrary(); private static ReaderType defaultType = ReaderType.GUI; - private Library lib; + private BasicLibrary lib; + private MetaData meta; private Story story; - private ReaderType type; + private int chapter; /** * Take the default reader type configuration from the config file. @@ -71,42 +47,17 @@ public abstract class BasicReader { } } - /** - * The type of this reader. - * - * @return the type - */ - public ReaderType getType() { - return type; - } - - /** - * The type of this reader. - * - * @param type - * the new type - */ - protected BasicReader setType(ReaderType type) { - this.type = type; - return this; - } + @Override + public synchronized Story getStory(Progress pg) { + if (story == null) { + story = getLibrary().getStory(meta.getLuid(), pg); + } - /** - * Return the current {@link Story}. - * - * @return the {@link Story} - */ - public Story getStory() { return story; } - /** - * The {@link Library} to load the stories from (by default, takes the - * default {@link Library}). - * - * @return the {@link Library} - */ - public Library getLibrary() { + @Override + public BasicLibrary getLibrary() { if (lib == null) { lib = defaultLibrary; } @@ -114,95 +65,58 @@ public abstract class BasicReader { return lib; } - /** - * Change the {@link Library} that will be managed by this - * {@link BasicReader}. - * - * @param lib - * the new {@link Library} - */ - public void setLibrary(Library lib) { + @Override + public void setLibrary(BasicLibrary lib) { this.lib = lib; } - /** - * Create a new {@link BasicReader} for a {@link Story} in the - * {@link Library}. - * - * @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, Progress pg) throws IOException { - story = lib.getStory(luid, pg); - if (story == null) { + @Override + public synchronized MetaData getMeta() { + return meta; + } + + @Override + public synchronized void setMeta(MetaData meta) throws IOException { + setMeta(meta == null ? null : meta.getLuid()); // must check the library + } + + @Override + public synchronized void setMeta(String luid) throws IOException { + story = null; + meta = getLibrary().getInfo(luid); + + if (meta == null) { throw new IOException("Cannot retrieve story from library: " + luid); } } - /** - * Create a new {@link BasicReader} for an external {@link Story}. - * - * @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, Progress pg) throws IOException { - BasicSupport support = BasicSupport.getSupport(source); + @Override + public synchronized void setMeta(URL url, Progress pg) + throws IOException { + BasicSupport support = BasicSupport.getSupport(url); if (support == null) { - throw new IOException("URL not supported: " + source.toString()); + throw new IOException("URL not supported: " + url.toString()); } - story = support.process(source, pg); + story = support.process(pg); if (story == null) { throw new IOException( "Cannot retrieve story from external source: " - + source.toString()); - + + url.toString()); } - } - /** - * Start the {@link Story} Reading. - * - * @throws IOException - * in case of I/O error or if the {@link Story} was not - * previously set - */ - public abstract void read() throws IOException; + meta = story.getMeta(); + } - /** - * Read the selected chapter (starting at 1). - * - * @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) throws IOException; + @Override + public int getChapter() { + return chapter; + } - /** - * Start the reader in browse mode for the given source (or pass NULL for - * all sources). - * - * @param library - * the library to browse - * - * @param source - * the type of {@link Story} to take into account, or NULL for - * all - */ - public abstract void browse(String source); + @Override + public void setChapter(int chapter) { + this.chapter = chapter; + } /** * Return a new {@link BasicReader} ready for use if one is configured. @@ -211,22 +125,23 @@ public abstract class BasicReader { * * @return a {@link BasicReader}, or NULL if none configured */ - public static BasicReader getReader() { + public static Reader getReader() { try { if (defaultType != null) { - return ((BasicReader) SerialUtils.createObject(defaultType - .getTypeName())).setType(defaultType); + return (Reader) SerialUtils.createObject(defaultType + .getTypeName()); } } catch (Exception e) { - Instance.syserr(new Exception("Cannot create a reader of type: " - + defaultType + " (Not compiled in?)", e)); + Instance.getTraceHandler().error( + new Exception("Cannot create a reader of type: " + + defaultType + " (Not compiled in?)", e)); } return null; } /** - * The default {@link ReaderType} used when calling + * The default {@link Reader.ReaderType} used when calling * {@link BasicReader#getReader()}. * * @return the default type @@ -236,7 +151,7 @@ public abstract class BasicReader { } /** - * The default {@link ReaderType} used when calling + * The default {@link Reader.ReaderType} used when calling * {@link BasicReader#getReader()}. * * @param defaultType @@ -247,12 +162,13 @@ public abstract class BasicReader { } /** - * Change the default {@link Library} to open with the {@link BasicReader}s. + * Change the default {@link LocalLibrary} to open with the + * {@link BasicReader}s. * * @param lib - * the new {@link Library} + * the new {@link LocalLibrary} */ - public static void setDefaultLibrary(Library lib) { + public static void setDefaultLibrary(BasicLibrary lib) { BasicReader.defaultLibrary = lib; } @@ -284,16 +200,39 @@ public abstract class BasicReader { return source; } - // open with external player the related file - public static void open(Library lib, String luid) throws IOException { + /** + * 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 + */ + @Override + public void openExternal(BasicLibrary lib, String luid) throws IOException { MetaData meta = lib.getInfo(luid); - File target = lib.getFile(luid); + File target = lib.getFile(luid, null); - open(meta, target); + openExternal(meta, target); } - // open with external player the related file - protected static void open(MetaData meta, File target) throws IOException { + /** + * 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 void openExternal(MetaData meta, File target) throws IOException { String program = null; if (meta.isImageDocument()) { program = Instance.getUiConfig().getString( @@ -307,15 +246,41 @@ public abstract class BasicReader { program = null; } - if (program == null) { - try { - Desktop.getDesktop().browse(target.toURI()); - } catch (UnsupportedOperationException e) { - Runtime.getRuntime().exec( - new String[] { "xdg-open", target.getAbsolutePath() }); + start(target, program); + } + /** + * Start a file and open it with the given program if given or the first + * default system starter we can find. + * + * @param target + * the target to open + * @param program + * the program to use or NULL for the default system starter + * + * @throws IOException + * in case of I/O error + */ + protected void start(File target, String program) throws IOException { + if (program == null) { + boolean ok = false; + for (String starter : new String[] { "xdg-open", "open", "see", + "start", "run" }) { + try { + Instance.getTraceHandler().trace( + "starting external program"); + Runtime.getRuntime().exec( + new String[] { starter, target.getAbsolutePath() }); + ok = true; + break; + } catch (IOException e) { + } + } + if (!ok) { + throw new IOException("Cannot find a program to start the file"); } } else { + Instance.getTraceHandler().trace("starting external program"); Runtime.getRuntime().exec( new String[] { program, target.getAbsolutePath() }); }