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.getInstance().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, Instance.getInstance().getUiConfig());
  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.getInstance().getTraceHandler().error(ee);
 154                                                 } catch (URISyntaxException ee) {
 155                                                         Instance.getInstance().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.getInstance().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                 GuiReaderSearchFrame search = new GuiReaderSearchFrame(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                 GuiReaderSearchFrame search = new GuiReaderSearchFrame(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 GuiReaderSearchFrame search = new GuiReaderSearchFrame(this);
 251
 252                 final BasicSearchable searchable = BasicSearchable
 253                                 .getSearchable(searchOn);
 254
 255                 Runnable action = new Runnable() {
 256                         @Override
 257                         public void run() {
 258                                 SearchableTag tag = null;
 259                                 try {
 260                                         tag = searchable.getTag(tags);
 261                                 } catch (IOException e) {
 262                                         Instance.getInstance().getTraceHandler().error(e);
 263                                 }
 264
 265                                 search.searchTag(searchOn, page, item, tag);
 266
 267                                 if (sync) {
 268                                         sync(search);
 269                                 } else {
 270                                         search.setVisible(true);
 271                                 }
 272                         }
 273                 };
 274
 275                 if (sync) {
 276                         action.run();
 277                 } else {
 278                         new Thread(action).start();
 279                 }
 280         }
 281
 282         /**
 283          * Delete the {@link Story} from the cache if it is present, but <b>NOT</b>
 284          * from the main library.
 285          * <p>
 286          * The next time we try to retrieve the {@link Story}, it may be required to
 287          * cache it again.
 288          *
 289          * @param luid
 290          *            the luid of the {@link Story}
 291          */
 292         void clearLocalReaderCache(String luid) {
 293                 try {
 294                         cacheLib.clearFromCache(luid);
 295                 } catch (IOException e) {
 296                         Instance.getInstance().getTraceHandler().error(e);
 297                 }
 298         }
 299
 300         /**
 301          * Forward the delete operation to the main library.
 302          * <p>
 303          * The {@link Story} will be deleted from the main library as well as the
 304          * cache if present.
 305          *
 306          * @param luid
 307          *            the {@link Story} to delete
 308          */
 309         void delete(String luid) {
 310                 try {
 311                         cacheLib.delete(luid);
 312                 } catch (IOException e) {
 313                         Instance.getInstance().getTraceHandler().error(e);
 314                 }
 315         }
 316
 317         /**
 318          * "Open" the given {@link Story}. It usually involves starting an external
 319          * program adapted to the given file type.
 320          *
 321          * @param luid
 322          *            the luid of the {@link Story} to open
 323          * @param sync
 324          *            execute the process synchronously (wait until it is terminated
 325          *            before returning)
 326          * @param pg
 327          *            the optional progress (we may need to prepare the
 328          *            {@link Story} for reading
 329          *
 330          * @throws IOException
 331          *             in case of I/O errors
 332          */
 333         void read(String luid, boolean sync, Progress pg) throws IOException {
 334                 MetaData meta = cacheLib.getInfo(luid);
 335
 336                 boolean textInternal = Instance.getInstance().getUiConfig()
 337                                 .getBoolean(UiConfig.NON_IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
 338                 boolean imageInternal = Instance.getInstance().getUiConfig()
 339                                 .getBoolean(UiConfig.IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
 340
 341                 boolean useInternalViewer = true;
 342                 if (meta.isImageDocument() && !imageInternal) {
 343                         useInternalViewer = false;
 344                 }
 345                 if (!meta.isImageDocument() && !textInternal) {
 346                         useInternalViewer = false;
 347                 }
 348
 349                 if (useInternalViewer) {
 350                         GuiReaderViewer viewer = new GuiReaderViewer(cacheLib,
 351                                         cacheLib.getStory(luid, null));
 352                         if (sync) {
 353                                 sync(viewer);
 354                         } else {
 355                                 viewer.setVisible(true);
 356                         }
 357                 } else {
 358                         File file = cacheLib.getFile(luid, pg);
 359                         openExternal(meta, file, sync);
 360                 }
 361         }
 362
 363
 364         /**
 365          * "Prefetch" the given {@link Story}.
 366          * <p>
 367          * Synchronous method.
 368          *
 369          * @param luid
 370          *            the luid of the {@link Story} to prefetch
 371          * @param pg
 372          *            the optional progress (we may need to prepare the
 373          *            {@link Story} for reading
 374          *
 375          * @throws IOException
 376          *             in case of I/O errors
 377          */
 378         void prefetch(String luid, Progress pg) throws IOException {
 379                 cacheLib.getFile(luid, pg);
 380         }
 381         /**
 382          * Change the source of the given {@link Story} (the source is the main
 383          * information used to group the stories together).
 384          * <p>
 385          * In other words, <b>move</b> the {@link Story} into other source.
 386          * <p>
 387          * The source can be a new one, it needs not exist before hand.
 388          *
 389          * @param luid
 390          *            the luid of the {@link Story} to move
 391          * @param newSource
 392          *            the new source
 393          */
 394         void changeSource(String luid, String newSource) {
 395                 try {
 396                         cacheLib.changeSource(luid, newSource, null);
 397                 } catch (IOException e) {
 398                         Instance.getInstance().getTraceHandler().error(e);
 399                 }
 400         }
 401
 402         /**
 403          * Change the title of the given {@link Story}.
 404          *
 405          * @param luid
 406          *            the luid of the {@link Story} to change
 407          * @param newTitle
 408          *            the new title
 409          */
 410         void changeTitle(String luid, String newTitle) {
 411                 try {
 412                         cacheLib.changeTitle(luid, newTitle, null);
 413                 } catch (IOException e) {
 414                         Instance.getInstance().getTraceHandler().error(e);
 415                 }
 416         }
 417
 418         /**
 419          * Change the author of the given {@link Story}.
 420          * <p>
 421          * The author can be a new one, it needs not exist before hand.
 422          *
 423          * @param luid
 424          *            the luid of the {@link Story} to change
 425          * @param newAuthor
 426          *            the new author
 427          */
 428         void changeAuthor(String luid, String newAuthor) {
 429                 try {
 430                         cacheLib.changeAuthor(luid, newAuthor, null);
 431                 } catch (IOException e) {
 432                         Instance.getInstance().getTraceHandler().error(e);
 433                 }
 434         }
 435
 436         /**
 437          * Simple shortcut method to call {link Instance#getTransGui()#getString()}.
 438          *
 439          * @param id
 440          *            the ID to translate
 441          *
 442          * @return the translated result
 443          */
 444         static String trans(StringIdGui id, Object... params) {
 445                 return Instance.getInstance().getTransGui().getString(id, params);
 446         }
 447
 448         /**
 449          * Start a frame and wait until it is closed before returning.
 450          *
 451          * @param frame
 452          *            the frame to start
 453          */
 454         static private void sync(final JFrame frame) {
 455                 if (EventQueue.isDispatchThread()) {
 456                         throw new IllegalStateException(
 457                                         "Cannot call a sync method in the dispatch thread");
 458                 }
 459
 460                 final Boolean[] done = new Boolean[] { false };
 461                 try {
 462                         Runnable run = new Runnable() {
 463                                 @Override
 464                                 public void run() {
 465                                         try {
 466                                                 frame.addWindowListener(new WindowAdapter() {
 467                                                         @Override
 468                                                         public void windowClosing(WindowEvent e) {
 469                                                                 super.windowClosing(e);
 470                                                                 done[0] = true;
 471                                                         }
 472                                                 });
 473
 474                                                 frame.setVisible(true);
 475                                         } catch (Exception e) {
 476                                                 done[0] = true;
 477                                         }
 478                                 }
 479                         };
 480
 481                         if (EventQueue.isDispatchThread()) {
 482                                 run.run();
 483                         } else {
 484                                 EventQueue.invokeLater(run);
 485                         }
 486                 } catch (Exception e) {
 487                         Instance.getInstance().getTraceHandler().error(e);
 488                         done[0] = true;
 489                 }
 490
 491                 // This action must be synchronous, so wait until the frame is closed
 492                 while (!done[0]) {
 493                         try {
 494                                 Thread.sleep(100);
 495                         } catch (InterruptedException e) {
 496                         }
 497                 }
 498         }
 499 }