src/be/nikiroo/fanfix/reader/ui/GuiReader.java

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