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                 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.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.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.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          * <p>
 321          * Asynchronous method.
 322          *
 323          * @param luid
 324          *            the luid of the {@link Story} to open
 325          * @param sync
 326          *            execute the process synchronously (wait until it is terminated
 327          *            before returning)
 328          * @param pg
 329          *            the optional progress (we may need to prepare the
 330          *            {@link Story} for reading
 331          *
 332          * @throws IOException
 333          *             in case of I/O errors
 334          */
 335         void read(String luid, boolean sync, Progress pg) throws IOException {
 336                 MetaData meta = cacheLib.getInfo(luid);
 337
 338                 boolean textInternal = Instance.getUiConfig().getBoolean(
 339                                 UiConfig.NON_IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
 340                 boolean imageInternal = Instance.getUiConfig().getBoolean(
 341                                 UiConfig.IMAGES_DOCUMENT_USE_INTERNAL_READER, true);
 342
 343                 boolean useInternalViewer = true;
 344                 if (meta.isImageDocument() && !imageInternal) {
 345                         useInternalViewer = false;
 346                 }
 347                 if (!meta.isImageDocument() && !textInternal) {
 348                         useInternalViewer = false;
 349                 }
 350
 351                 if (useInternalViewer) {
 352                         GuiReaderViewer viewer = new GuiReaderViewer(cacheLib,
 353                                         cacheLib.getStory(luid, null));
 354                         if (sync) {
 355                                 sync(viewer);
 356                         } else {
 357                                 viewer.setVisible(true);
 358                         }
 359                 } else {
 360                         File file = cacheLib.getFile(luid, pg);
 361                         openExternal(meta, file, sync);
 362                 }
 363         }
 364
 365         /**
 366          * Change the source of the given {@link Story} (the source is the main
 367          * information used to group the stories together).
 368          * <p>
 369          * In other words, <b>move</b> the {@link Story} into other source.
 370          * <p>
 371          * The source can be a new one, it needs not exist before hand.
 372          *
 373          * @param luid
 374          *            the luid of the {@link Story} to move
 375          * @param newSource
 376          *            the new source
 377          */
 378         void changeSource(String luid, String newSource) {
 379                 try {
 380                         cacheLib.changeSource(luid, newSource, null);
 381                 } catch (IOException e) {
 382                         Instance.getTraceHandler().error(e);
 383                 }
 384         }
 385
 386         /**
 387          * Change the title of the given {@link Story}.
 388          *
 389          * @param luid
 390          *            the luid of the {@link Story} to change
 391          * @param newTitle
 392          *            the new title
 393          */
 394         void changeTitle(String luid, String newTitle) {
 395                 try {
 396                         cacheLib.changeTitle(luid, newTitle, null);
 397                 } catch (IOException e) {
 398                         Instance.getTraceHandler().error(e);
 399                 }
 400         }
 401
 402         /**
 403          * Change the author of the given {@link Story}.
 404          * <p>
 405          * The author can be a new one, it needs not exist before hand.
 406          *
 407          * @param luid
 408          *            the luid of the {@link Story} to change
 409          * @param newAuthor
 410          *            the new author
 411          */
 412         void changeAuthor(String luid, String newAuthor) {
 413                 try {
 414                         cacheLib.changeAuthor(luid, newAuthor, null);
 415                 } catch (IOException e) {
 416                         Instance.getTraceHandler().error(e);
 417                 }
 418         }
 419
 420         /**
 421          * Simple shortcut method to call {link Instance#getTransGui()#getString()}.
 422          *
 423          * @param id
 424          *            the ID to translate
 425          *
 426          * @return the translated result
 427          */
 428         static String trans(StringIdGui id, Object... params) {
 429                 return Instance.getTransGui().getString(id, params);
 430         }
 431
 432         /**
 433          * Start a frame and wait until it is closed before returning.
 434          *
 435          * @param frame
 436          *            the frame to start
 437          */
 438         static private void sync(final JFrame frame) {
 439                 if (EventQueue.isDispatchThread()) {
 440                         throw new IllegalStateException(
 441                                         "Cannot call a sync method in the dispatch thread");
 442                 }
 443
 444                 final Boolean[] done = new Boolean[] { false };
 445                 try {
 446                         Runnable run = new Runnable() {
 447                                 @Override
 448                                 public void run() {
 449                                         try {
 450                                                 frame.addWindowListener(new WindowAdapter() {
 451                                                         @Override
 452                                                         public void windowClosing(WindowEvent e) {
 453                                                                 super.windowClosing(e);
 454                                                                 done[0] = true;
 455                                                         }
 456                                                 });
 457
 458                                                 frame.setVisible(true);
 459                                         } catch (Exception e) {
 460                                                 done[0] = true;
 461                                         }
 462                                 }
 463                         };
 464
 465                         if (EventQueue.isDispatchThread()) {
 466                                 run.run();
 467                         } else {
 468                                 EventQueue.invokeLater(run);
 469                         }
 470                 } catch (Exception e) {
 471                         Instance.getTraceHandler().error(e);
 472                         done[0] = true;
 473                 }
 474
 475                 // This action must be synchronous, so wait until the frame is closed
 476                 while (!done[0]) {
 477                         try {
 478                                 Thread.sleep(100);
 479                         } catch (InterruptedException e) {
 480                         }
 481                 }
 482         }
 483 }