src/be/nikiroo/fanfix/reader/GuiReaderFrame.java

   1 package be.nikiroo.fanfix.reader;
   2
   3 import java.awt.BorderLayout;
   4 import java.awt.Color;
   5 import java.awt.Frame;
   6 import java.awt.Toolkit;
   7 import java.awt.datatransfer.DataFlavor;
   8 import java.awt.event.ActionEvent;
   9 import java.awt.event.ActionListener;
  10 import java.awt.event.KeyEvent;
  11 import java.awt.event.MouseEvent;
  12 import java.awt.event.WindowEvent;
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.net.URL;
  16 import java.util.ArrayList;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Map.Entry;
  21
  22 import javax.swing.BoxLayout;
  23 import javax.swing.JFileChooser;
  24 import javax.swing.JFrame;
  25 import javax.swing.JMenu;
  26 import javax.swing.JMenuBar;
  27 import javax.swing.JMenuItem;
  28 import javax.swing.JOptionPane;
  29 import javax.swing.JPanel;
  30 import javax.swing.JPopupMenu;
  31 import javax.swing.JScrollPane;
  32 import javax.swing.SwingUtilities;
  33 import javax.swing.filechooser.FileFilter;
  34 import javax.swing.filechooser.FileNameExtensionFilter;
  35
  36 import be.nikiroo.fanfix.Instance;
  37 import be.nikiroo.fanfix.bundles.Config;
  38 import be.nikiroo.fanfix.bundles.UiConfig;
  39 import be.nikiroo.fanfix.data.MetaData;
  40 import be.nikiroo.fanfix.data.Story;
  41 import be.nikiroo.fanfix.library.LocalLibrary;
  42 import be.nikiroo.fanfix.output.BasicOutput.OutputType;
  43 import be.nikiroo.fanfix.reader.GuiReaderBook.BookActionListener;
  44 import be.nikiroo.utils.Progress;
  45 import be.nikiroo.utils.Version;
  46 import be.nikiroo.utils.ui.ConfigEditor;
  47 import be.nikiroo.utils.ui.ProgressBar;
  48
  49 /**
  50  * A {@link Frame} that will show a {@link GuiReaderBook} item for each
  51  * {@link Story} in the main cache ({@link Instance#getCache()}), and offer a
  52  * way to copy them to the {@link GuiReader} cache (
  53  * {@link BasicReader#getLibrary()}), read them, delete them...
  54  *
  55  * @author niki
  56  */
  57 class GuiReaderFrame extends JFrame {
  58         private static final long serialVersionUID = 1L;
  59         private GuiReader reader;
  60         private Map<GuiReaderGroup, String> booksByType;
  61         private Map<GuiReaderGroup, String> booksByAuthor;
  62         private JPanel pane;
  63         private Color color;
  64         private ProgressBar pgBar;
  65         private JMenuBar bar;
  66         private GuiReaderBook selectedBook;
  67         private boolean words; // words or authors (secondary info on books)
  68
  69         /**
  70          * A {@link Runnable} with a {@link Story} parameter.
  71          *
  72          * @author niki
  73          */
  74         private interface StoryRunnable {
  75                 /**
  76                  * Run the action.
  77                  *
  78                  * @param story
  79                  *            the story
  80                  */
  81                 public void run(Story story);
  82         }
  83
  84         /**
  85          * Create a new {@link GuiReaderFrame}.
  86          *
  87          * @param reader
  88          *            the associated {@link GuiReader} to forward some commands and
  89          *            access its {@link LocalLibrary}
  90          * @param type
  91          *            the type of {@link Story} to load, or NULL for all types
  92          */
  93         public GuiReaderFrame(GuiReader reader, String type) {
  94                 super(String.format("Fanfix %s Library", Version.getCurrentVersion()));
  95
  96                 this.reader = reader;
  97
  98                 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  99                 setSize(800, 600);
 100                 setLayout(new BorderLayout());
 101
 102                 pane = new JPanel();
 103                 pane.setLayout(new BoxLayout(pane, BoxLayout.PAGE_AXIS));
 104
 105                 color = Instance.getUiConfig().getColor(UiConfig.BACKGROUND_COLOR);
 106                 if (color != null) {
 107                         setBackground(color);
 108                         pane.setBackground(color);
 109                 }
 110
 111                 JScrollPane scroll = new JScrollPane(pane);
 112                 scroll.getVerticalScrollBar().setUnitIncrement(16);
 113                 add(scroll, BorderLayout.CENTER);
 114
 115                 pgBar = new ProgressBar();
 116                 add(pgBar, BorderLayout.SOUTH);
 117
 118                 pgBar.addActionListener(new ActionListener() {
 119                         @Override
 120                         public void actionPerformed(ActionEvent e) {
 121                                 invalidate();
 122                                 pgBar.setProgress(null);
 123                                 validate();
 124                                 setEnabled(true);
 125                         }
 126                 });
 127
 128                 pgBar.addUpdateListener(new ActionListener() {
 129                         @Override
 130                         public void actionPerformed(ActionEvent e) {
 131                                 invalidate();
 132                                 validate();
 133                                 repaint();
 134                         }
 135                 });
 136
 137                 booksByType = new HashMap<GuiReaderGroup, String>();
 138                 booksByAuthor = new HashMap<GuiReaderGroup, String>();
 139
 140                 pane.setVisible(false);
 141                 final Progress pg = new Progress();
 142                 final String typeF = type;
 143                 outOfUi(pg, new Runnable() {
 144                         @Override
 145                         public void run() {
 146                                 GuiReaderFrame.this.reader.getLibrary().refresh(false, pg);
 147                                 invalidate();
 148                                 setJMenuBar(createMenu());
 149                                 addBookPane(typeF, true);
 150                                 refreshBooks();
 151                                 validate();
 152                                 pane.setVisible(true);
 153                         }
 154                 });
 155
 156                 setVisible(true);
 157         }
 158
 159         private void addSourcePanes() {
 160                 // Sources -> i18n
 161                 GuiReaderGroup bookPane = new GuiReaderGroup(reader, "Sources", color);
 162
 163                 List<MetaData> sources = new ArrayList<MetaData>();
 164                 for (String source : reader.getLibrary().getSources()) {
 165                         MetaData mSource = new MetaData();
 166                         mSource.setLuid(null);
 167                         mSource.setTitle(source);
 168                         mSource.setSource(source);
 169                         sources.add(mSource);
 170                 }
 171
 172                 bookPane.refreshBooks(sources, false);
 173
 174                 this.invalidate();
 175                 pane.invalidate();
 176                 pane.add(bookPane);
 177                 pane.validate();
 178                 this.validate();
 179
 180                 bookPane.setActionListener(new BookActionListener() {
 181                         @Override
 182                         public void select(GuiReaderBook book) {
 183                                 selectedBook = book;
 184                         }
 185
 186                         @Override
 187                         public void popupRequested(GuiReaderBook book, MouseEvent e) {
 188                                 JPopupMenu popup = new JPopupMenu();
 189                                 popup.add(createMenuItemOpenBook());
 190                                 popup.show(e.getComponent(), e.getX(), e.getY());
 191                         }
 192
 193                         @Override
 194                         public void action(final GuiReaderBook book) {
 195                                 removeBookPanes();
 196                                 addBookPane(book.getMeta().getSource(), true);
 197                                 refreshBooks();
 198                         }
 199                 });
 200         }
 201
 202         /**
 203          * Add a new {@link GuiReaderGroup} on the frame to display the books of the
 204          * selected type or author.
 205          *
 206          * @param value
 207          *            the author or the type, or NULL to get all the
 208          *            authors-or-types
 209          * @param type
 210          *            TRUE for type, FALSE for author
 211          */
 212         private void addBookPane(String value, boolean type) {
 213                 if (value == null) {
 214                         if (type) {
 215                                 if (Instance.getUiConfig().getBoolean(UiConfig.SOURCE_PAGE,
 216                                                 false)) {
 217                                         addSourcePanes();
 218                                 } else {
 219                                         for (String tt : reader.getLibrary().getSources()) {
 220                                                 if (tt != null) {
 221                                                         addBookPane(tt, type);
 222                                                 }
 223                                         }
 224                                 }
 225                         } else {
 226                                 for (String tt : reader.getLibrary().getAuthors()) {
 227                                         if (tt != null) {
 228                                                 addBookPane(tt, type);
 229                                         }
 230                                 }
 231                         }
 232
 233                         return;
 234                 }
 235
 236                 GuiReaderGroup bookPane = new GuiReaderGroup(reader, value, color);
 237                 if (type) {
 238                         booksByType.put(bookPane, value);
 239                 } else {
 240                         booksByAuthor.put(bookPane, value);
 241                 }
 242
 243                 this.invalidate();
 244                 pane.invalidate();
 245                 pane.add(bookPane);
 246                 pane.validate();
 247                 this.validate();
 248
 249                 bookPane.setActionListener(new BookActionListener() {
 250                         @Override
 251                         public void select(GuiReaderBook book) {
 252                                 selectedBook = book;
 253                         }
 254
 255                         @Override
 256                         public void popupRequested(GuiReaderBook book, MouseEvent e) {
 257                                 JPopupMenu popup = new JPopupMenu();
 258                                 popup.add(createMenuItemOpenBook());
 259                                 popup.addSeparator();
 260                                 popup.add(createMenuItemExport());
 261                                 popup.add(createMenuItemMove());
 262                                 popup.add(createMenuItemSetCover());
 263                                 popup.add(createMenuItemClearCache());
 264                                 popup.add(createMenuItemRedownload());
 265                                 popup.addSeparator();
 266                                 popup.add(createMenuItemDelete());
 267                                 popup.show(e.getComponent(), e.getX(), e.getY());
 268                         }
 269
 270                         @Override
 271                         public void action(final GuiReaderBook book) {
 272                                 openBook(book);
 273                         }
 274                 });
 275         }
 276
 277         private void removeBookPanes() {
 278                 booksByType.clear();
 279                 booksByAuthor.clear();
 280                 pane.invalidate();
 281                 this.invalidate();
 282                 pane.removeAll();
 283                 pane.validate();
 284                 this.validate();
 285         }
 286
 287         /**
 288          * Refresh the list of {@link GuiReaderBook}s from disk.
 289          *
 290          */
 291         private void refreshBooks() {
 292                 for (GuiReaderGroup group : booksByType.keySet()) {
 293                         List<MetaData> stories = reader.getLibrary().getListBySource(
 294                                         booksByType.get(group));
 295                         group.refreshBooks(stories, words);
 296                 }
 297
 298                 for (GuiReaderGroup group : booksByAuthor.keySet()) {
 299                         List<MetaData> stories = reader.getLibrary().getListByAuthor(
 300                                         booksByAuthor.get(group));
 301                         group.refreshBooks(stories, words);
 302                 }
 303
 304                 pane.repaint();
 305                 this.repaint();
 306         }
 307
 308         /**
 309          * Create the main menu bar.
 310          *
 311          * @return the bar
 312          */
 313         private JMenuBar createMenu() {
 314                 bar = new JMenuBar();
 315
 316                 JMenu file = new JMenu("File");
 317                 file.setMnemonic(KeyEvent.VK_F);
 318
 319                 JMenuItem imprt = new JMenuItem("Import URL...", KeyEvent.VK_U);
 320                 imprt.addActionListener(new ActionListener() {
 321                         @Override
 322                         public void actionPerformed(ActionEvent e) {
 323                                 imprt(true);
 324                         }
 325                 });
 326                 JMenuItem imprtF = new JMenuItem("Import File...", KeyEvent.VK_F);
 327                 imprtF.addActionListener(new ActionListener() {
 328                         @Override
 329                         public void actionPerformed(ActionEvent e) {
 330                                 imprt(false);
 331                         }
 332                 });
 333                 JMenuItem exit = new JMenuItem("Exit", KeyEvent.VK_X);
 334                 exit.addActionListener(new ActionListener() {
 335                         @Override
 336                         public void actionPerformed(ActionEvent e) {
 337                                 GuiReaderFrame.this.dispatchEvent(new WindowEvent(
 338                                                 GuiReaderFrame.this, WindowEvent.WINDOW_CLOSING));
 339                         }
 340                 });
 341
 342                 file.add(createMenuItemOpenBook());
 343                 file.add(createMenuItemExport());
 344                 file.add(createMenuItemMove());
 345                 file.addSeparator();
 346                 file.add(imprt);
 347                 file.add(imprtF);
 348                 file.addSeparator();
 349                 file.add(exit);
 350
 351                 bar.add(file);
 352
 353                 JMenu edit = new JMenu("Edit");
 354                 edit.setMnemonic(KeyEvent.VK_E);
 355
 356                 edit.add(createMenuItemClearCache());
 357                 edit.add(createMenuItemRedownload());
 358                 edit.addSeparator();
 359                 edit.add(createMenuItemDelete());
 360
 361                 bar.add(edit);
 362
 363                 JMenu view = new JMenu("View");
 364                 view.setMnemonic(KeyEvent.VK_V);
 365                 JMenuItem vauthors = new JMenuItem("Author");
 366                 vauthors.setMnemonic(KeyEvent.VK_A);
 367                 vauthors.addActionListener(new ActionListener() {
 368                         @Override
 369                         public void actionPerformed(ActionEvent e) {
 370                                 words = false;
 371                                 refreshBooks();
 372                         }
 373                 });
 374                 view.add(vauthors);
 375                 JMenuItem vwords = new JMenuItem("Word count");
 376                 vwords.setMnemonic(KeyEvent.VK_W);
 377                 vwords.addActionListener(new ActionListener() {
 378                         @Override
 379                         public void actionPerformed(ActionEvent e) {
 380                                 words = true;
 381                                 refreshBooks();
 382                         }
 383                 });
 384                 view.add(vwords);
 385                 bar.add(view);
 386
 387                 JMenu sources = new JMenu("Sources");
 388                 sources.setMnemonic(KeyEvent.VK_S);
 389
 390                 List<String> tt = reader.getLibrary().getSources();
 391                 tt.add(0, null);
 392                 for (final String type : tt) {
 393                         JMenuItem item = new JMenuItem(type == null ? "All" : type);
 394                         item.addActionListener(new ActionListener() {
 395                                 @Override
 396                                 public void actionPerformed(ActionEvent e) {
 397                                         removeBookPanes();
 398                                         addBookPane(type, true);
 399                                         refreshBooks();
 400                                 }
 401                         });
 402                         sources.add(item);
 403
 404                         if (type == null) {
 405                                 sources.addSeparator();
 406                         }
 407                 }
 408
 409                 bar.add(sources);
 410
 411                 JMenu authors = new JMenu("Authors");
 412                 authors.setMnemonic(KeyEvent.VK_A);
 413
 414                 List<String> aa = reader.getLibrary().getAuthors();
 415                 aa.add(0, null);
 416                 for (final String author : aa) {
 417                         JMenuItem item = new JMenuItem(author == null ? "All"
 418                                         : author.isEmpty() ? "[unknown]" : author);
 419                         item.addActionListener(new ActionListener() {
 420                                 @Override
 421                                 public void actionPerformed(ActionEvent e) {
 422                                         removeBookPanes();
 423                                         addBookPane(author, false);
 424                                         refreshBooks();
 425                                 }
 426                         });
 427                         authors.add(item);
 428
 429                         if (author == null || author.isEmpty()) {
 430                                 authors.addSeparator();
 431                         }
 432                 }
 433
 434                 bar.add(authors);
 435
 436                 JMenu options = new JMenu("Options");
 437                 options.setMnemonic(KeyEvent.VK_O);
 438                 options.add(createMenuItemConfig());
 439                 options.add(createMenuItemUiConfig());
 440                 bar.add(options);
 441
 442                 return bar;
 443         }
 444
 445         /**
 446          * Create the Fanfix Configuration menu item.
 447          *
 448          * @return the item
 449          */
 450         private JMenuItem createMenuItemConfig() {
 451                 final String title = "Fanfix Configuration";
 452                 JMenuItem item = new JMenuItem(title);
 453                 item.setMnemonic(KeyEvent.VK_F);
 454
 455                 item.addActionListener(new ActionListener() {
 456                         @Override
 457                         public void actionPerformed(ActionEvent e) {
 458                                 ConfigEditor<Config> ed = new ConfigEditor<Config>(
 459                                                 Config.class, Instance.getConfig(),
 460                                                 "This is where you configure the options of the program.");
 461                                 JFrame frame = new JFrame(title);
 462                                 frame.add(ed);
 463                                 frame.setSize(800, 600);
 464                                 frame.setVisible(true);
 465                         }
 466                 });
 467
 468                 return item;
 469         }
 470
 471         /**
 472          * Create the UI Configuration menu item.
 473          *
 474          * @return the item
 475          */
 476         private JMenuItem createMenuItemUiConfig() {
 477                 final String title = "UI Configuration";
 478                 JMenuItem item = new JMenuItem(title);
 479                 item.setMnemonic(KeyEvent.VK_U);
 480
 481                 item.addActionListener(new ActionListener() {
 482                         @Override
 483                         public void actionPerformed(ActionEvent e) {
 484                                 ConfigEditor<UiConfig> ed = new ConfigEditor<UiConfig>(
 485                                                 UiConfig.class, Instance.getUiConfig(),
 486                                                 "This is where you configure the graphical appearence of the program.");
 487                                 JFrame frame = new JFrame(title);
 488                                 frame.add(ed);
 489                                 frame.setSize(800, 600);
 490                                 frame.setVisible(true);
 491                         }
 492                 });
 493
 494                 return item;
 495         }
 496
 497         /**
 498          * Create the export menu item.
 499          *
 500          * @return the item
 501          */
 502         private JMenuItem createMenuItemExport() {
 503                 final JFileChooser fc = new JFileChooser();
 504                 fc.setAcceptAllFileFilterUsed(false);
 505
 506                 final Map<FileFilter, OutputType> filters = new HashMap<FileFilter, OutputType>();
 507                 for (OutputType type : OutputType.values()) {
 508                         String ext = type.getDefaultExtension(false);
 509                         String desc = type.getDesc(false);
 510
 511                         if (ext == null || ext.isEmpty()) {
 512                                 filters.put(createAllFilter(desc), type);
 513                         } else {
 514                                 filters.put(new FileNameExtensionFilter(desc, ext), type);
 515                         }
 516                 }
 517
 518                 // First the "ALL" filters, then, the extension filters
 519                 for (Entry<FileFilter, OutputType> entry : filters.entrySet()) {
 520                         if (!(entry.getKey() instanceof FileNameExtensionFilter)) {
 521                                 fc.addChoosableFileFilter(entry.getKey());
 522                         }
 523                 }
 524                 for (Entry<FileFilter, OutputType> entry : filters.entrySet()) {
 525                         if (entry.getKey() instanceof FileNameExtensionFilter) {
 526                                 fc.addChoosableFileFilter(entry.getKey());
 527                         }
 528                 }
 529                 //
 530
 531                 JMenuItem export = new JMenuItem("Save as...", KeyEvent.VK_S);
 532                 export.addActionListener(new ActionListener() {
 533                         @Override
 534                         public void actionPerformed(ActionEvent e) {
 535                                 if (selectedBook != null) {
 536                                         fc.showDialog(GuiReaderFrame.this, "Save");
 537                                         if (fc.getSelectedFile() != null) {
 538                                                 final OutputType type = filters.get(fc.getFileFilter());
 539                                                 final String path = fc.getSelectedFile()
 540                                                                 .getAbsolutePath()
 541                                                                 + type.getDefaultExtension(false);
 542                                                 final Progress pg = new Progress();
 543                                                 outOfUi(pg, new Runnable() {
 544                                                         @Override
 545                                                         public void run() {
 546                                                                 try {
 547                                                                         reader.getLibrary().export(
 548                                                                                         selectedBook.getMeta().getLuid(),
 549                                                                                         type, path, pg);
 550                                                                 } catch (IOException e) {
 551                                                                         Instance.syserr(e);
 552                                                                 }
 553                                                         }
 554                                                 });
 555                                         }
 556                                 }
 557                         }
 558                 });
 559
 560                 return export;
 561         }
 562
 563         /**
 564          * Create a {@link FileFilter} that accepts all files and return the given
 565          * description.
 566          *
 567          * @param desc
 568          *            the description
 569          *
 570          * @return the filter
 571          */
 572         private FileFilter createAllFilter(final String desc) {
 573                 return new FileFilter() {
 574                         @Override
 575                         public String getDescription() {
 576                                 return desc;
 577                         }
 578
 579                         @Override
 580                         public boolean accept(File f) {
 581                                 return true;
 582                         }
 583                 };
 584         }
 585
 586         /**
 587          * Create the refresh (delete cache) menu item.
 588          *
 589          * @return the item
 590          */
 591         private JMenuItem createMenuItemClearCache() {
 592                 JMenuItem refresh = new JMenuItem("Clear cache", KeyEvent.VK_C);
 593                 refresh.addActionListener(new ActionListener() {
 594                         @Override
 595                         public void actionPerformed(ActionEvent e) {
 596                                 if (selectedBook != null) {
 597                                         outOfUi(null, new Runnable() {
 598                                                 @Override
 599                                                 public void run() {
 600                                                         reader.clearLocalReaderCache(selectedBook.getMeta()
 601                                                                         .getLuid());
 602                                                         selectedBook.setCached(false);
 603                                                         SwingUtilities.invokeLater(new Runnable() {
 604                                                                 @Override
 605                                                                 public void run() {
 606                                                                         selectedBook.repaint();
 607                                                                 }
 608                                                         });
 609                                                 }
 610                                         });
 611                                 }
 612                         }
 613                 });
 614
 615                 return refresh;
 616         }
 617
 618         /**
 619          * Create the delete menu item.
 620          *
 621          * @return the item
 622          */
 623         private JMenuItem createMenuItemMove() {
 624                 JMenu moveTo = new JMenu("Move to...");
 625                 moveTo.setMnemonic(KeyEvent.VK_M);
 626
 627                 List<String> types = new ArrayList<String>();
 628                 types.add(null);
 629                 types.addAll(reader.getLibrary().getSources());
 630
 631                 for (String type : types) {
 632                         JMenuItem item = new JMenuItem(type == null ? "New type..." : type);
 633
 634                         moveTo.add(item);
 635                         if (type == null) {
 636                                 moveTo.addSeparator();
 637                         }
 638
 639                         final String ftype = type;
 640                         item.addActionListener(new ActionListener() {
 641                                 @Override
 642                                 public void actionPerformed(ActionEvent e) {
 643                                         if (selectedBook != null) {
 644                                                 String type = ftype;
 645                                                 if (type == null) {
 646                                                         Object rep = JOptionPane.showInputDialog(
 647                                                                         GuiReaderFrame.this, "Move to:",
 648                                                                         "Moving story",
 649                                                                         JOptionPane.QUESTION_MESSAGE, null, null,
 650                                                                         selectedBook.getMeta().getSource());
 651
 652                                                         if (rep == null) {
 653                                                                 return;
 654                                                         }
 655
 656                                                         type = rep.toString();
 657                                                 }
 658
 659                                                 final String ftype = type;
 660                                                 outOfUi(null, new Runnable() {
 661                                                         @Override
 662                                                         public void run() {
 663                                                                 reader.changeType(selectedBook.getMeta()
 664                                                                                 .getLuid(), ftype);
 665
 666                                                                 selectedBook = null;
 667
 668                                                                 SwingUtilities.invokeLater(new Runnable() {
 669                                                                         @Override
 670                                                                         public void run() {
 671                                                                                 setJMenuBar(createMenu());
 672                                                                         }
 673                                                                 });
 674                                                         }
 675                                                 });
 676                                         }
 677                                 }
 678                         });
 679                 }
 680
 681                 return moveTo;
 682         }
 683
 684         /**
 685          * Create the redownload (then delete original) menu item.
 686          *
 687          * @return the item
 688          */
 689         private JMenuItem createMenuItemRedownload() {
 690                 JMenuItem refresh = new JMenuItem("Redownload", KeyEvent.VK_R);
 691                 refresh.addActionListener(new ActionListener() {
 692                         @Override
 693                         public void actionPerformed(ActionEvent e) {
 694                                 if (selectedBook != null) {
 695                                         final MetaData meta = selectedBook.getMeta();
 696                                         imprt(meta.getUrl(), new StoryRunnable() {
 697                                                 @Override
 698                                                 public void run(Story story) {
 699                                                         reader.delete(meta.getLuid());
 700                                                         GuiReaderFrame.this.selectedBook = null;
 701                                                         MetaData newMeta = story.getMeta();
 702                                                         if (!newMeta.getSource().equals(meta.getSource())) {
 703                                                                 reader.changeType(newMeta.getLuid(),
 704                                                                                 meta.getSource());
 705                                                         }
 706                                                 }
 707                                         }, "Removing old copy");
 708                                 }
 709                         }
 710                 });
 711
 712                 return refresh;
 713         }
 714
 715         /**
 716          * Create the delete menu item.
 717          *
 718          * @return the item
 719          */
 720         private JMenuItem createMenuItemDelete() {
 721                 JMenuItem delete = new JMenuItem("Delete", KeyEvent.VK_D);
 722                 delete.addActionListener(new ActionListener() {
 723                         @Override
 724                         public void actionPerformed(ActionEvent e) {
 725                                 if (selectedBook != null) {
 726                                         outOfUi(null, new Runnable() {
 727                                                 @Override
 728                                                 public void run() {
 729                                                         reader.delete(selectedBook.getMeta().getLuid());
 730                                                         selectedBook = null;
 731                                                 }
 732                                         });
 733                                 }
 734                         }
 735                 });
 736
 737                 return delete;
 738         }
 739
 740         /**
 741          * Create the open menu item for a book or a source (no LUID).
 742          *
 743          * @return the item
 744          */
 745         private JMenuItem createMenuItemOpenBook() {
 746                 JMenuItem open = new JMenuItem("Open", KeyEvent.VK_O);
 747                 open.addActionListener(new ActionListener() {
 748                         @Override
 749                         public void actionPerformed(ActionEvent e) {
 750                                 if (selectedBook != null) {
 751                                         if (selectedBook.getMeta().getLuid() == null) {
 752                                                 removeBookPanes();
 753                                                 addBookPane(selectedBook.getMeta().getSource(), true);
 754                                                 refreshBooks();
 755                                         } else {
 756                                                 openBook(selectedBook);
 757                                         }
 758                                 }
 759                         }
 760                 });
 761
 762                 return open;
 763         }
 764
 765         /**
 766          * Create the SetCover menu item for a book to change the linked source
 767          * cover.
 768          *
 769          * @return the item
 770          */
 771         private JMenuItem createMenuItemSetCover() {
 772                 JMenuItem open = new JMenuItem("Set as cover for source", KeyEvent.VK_C);
 773                 open.addActionListener(new ActionListener() {
 774                         @Override
 775                         public void actionPerformed(ActionEvent e) {
 776                                 if (selectedBook != null) {
 777                                         reader.getLibrary().setSourceCover(
 778                                                         selectedBook.getMeta().getSource(),
 779                                                         selectedBook.getMeta().getLuid());
 780                                 }
 781                         }
 782                 });
 783
 784                 return open;
 785         }
 786
 787         /**
 788          * Open a {@link GuiReaderBook} item.
 789          *
 790          * @param book
 791          *            the {@link GuiReaderBook} to open
 792          */
 793         private void openBook(final GuiReaderBook book) {
 794                 final Progress pg = new Progress();
 795                 outOfUi(pg, new Runnable() {
 796                         @Override
 797                         public void run() {
 798                                 try {
 799                                         reader.read(book.getMeta().getLuid(), pg);
 800                                         SwingUtilities.invokeLater(new Runnable() {
 801                                                 @Override
 802                                                 public void run() {
 803                                                         book.setCached(true);
 804                                                 }
 805                                         });
 806                                 } catch (IOException e) {
 807                                         // TODO: error message?
 808                                         Instance.syserr(e);
 809                                 }
 810                         }
 811                 });
 812         }
 813
 814         /**
 815          * Process the given action out of the Swing UI thread and link the given
 816          * {@link ProgressBar} to the action.
 817          * <p>
 818          * The code will make sure that the {@link ProgressBar} (if not NULL) is set
 819          * to done when the action is done.
 820          *
 821          * @param progress
 822          *            the {@link ProgressBar} or NULL
 823          * @param run
 824          *            the action to run
 825          */
 826         private void outOfUi(Progress progress, final Runnable run) {
 827                 final Progress pg = new Progress();
 828                 final Progress reload = new Progress("Reload books");
 829                 if (progress == null) {
 830                         progress = new Progress();
 831                 }
 832
 833                 pg.addProgress(progress, 90);
 834                 pg.addProgress(reload, 10);
 835
 836                 invalidate();
 837                 pgBar.setProgress(pg);
 838                 validate();
 839                 setEnabled(false);
 840
 841                 new Thread(new Runnable() {
 842                         @Override
 843                         public void run() {
 844                                 run.run();
 845                                 refreshBooks();
 846                                 reload.done();
 847                                 if (!pg.isDone()) {
 848                                         // will trigger pgBar ActionListener:
 849                                         pg.done();
 850                                 }
 851                         }
 852                 }, "outOfUi thread").start();
 853         }
 854
 855         /**
 856          * Import a {@link Story} into the main {@link LocalLibrary}.
 857          * <p>
 858          * Should be called inside the UI thread.
 859          *
 860          * @param askUrl
 861          *            TRUE for an {@link URL}, false for a {@link File}
 862          */
 863         private void imprt(boolean askUrl) {
 864                 JFileChooser fc = new JFileChooser();
 865
 866                 Object url;
 867                 if (askUrl) {
 868                         String clipboard = "";
 869                         try {
 870                                 clipboard = ("" + Toolkit.getDefaultToolkit()
 871                                                 .getSystemClipboard().getData(DataFlavor.stringFlavor))
 872                                                 .trim();
 873                         } catch (Exception e) {
 874                                 // No data will be handled
 875                         }
 876
 877                         if (clipboard == null || !clipboard.startsWith("http")) {
 878                                 clipboard = "";
 879                         }
 880
 881                         url = JOptionPane.showInputDialog(GuiReaderFrame.this,
 882                                         "url of the story to import?", "Importing from URL",
 883                                         JOptionPane.QUESTION_MESSAGE, null, null, clipboard);
 884                 } else if (fc.showOpenDialog(this) != JFileChooser.CANCEL_OPTION) {
 885                         url = fc.getSelectedFile().getAbsolutePath();
 886                 } else {
 887                         url = null;
 888                 }
 889
 890                 if (url != null && !url.toString().isEmpty()) {
 891                         imprt(url.toString(), null, null);
 892                 }
 893         }
 894
 895         /**
 896          * Actually import the {@link Story} into the main {@link LocalLibrary}.
 897          * <p>
 898          * Should be called inside the UI thread.
 899          *
 900          * @param url
 901          *            the {@link Story} to import by {@link URL}
 902          * @param onSuccess
 903          *            Action to execute on success
 904          */
 905         private void imprt(final String url, final StoryRunnable onSuccess,
 906                         String onSuccessPgName) {
 907                 final Progress pg = new Progress();
 908                 final Progress pgImprt = new Progress();
 909                 final Progress pgOnSuccess = new Progress(onSuccessPgName);
 910                 pg.addProgress(pgImprt, 95);
 911                 pg.addProgress(pgOnSuccess, 5);
 912
 913                 outOfUi(pg, new Runnable() {
 914                         @Override
 915                         public void run() {
 916                                 Exception ex = null;
 917                                 Story story = null;
 918                                 try {
 919                                         story = reader.getLibrary().imprt(BasicReader.getUrl(url),
 920                                                         pgImprt);
 921                                 } catch (IOException e) {
 922                                         ex = e;
 923                                 }
 924
 925                                 final Exception e = ex;
 926
 927                                 final boolean ok = (e == null);
 928
 929                                 pgOnSuccess.setProgress(0);
 930                                 if (!ok) {
 931                                         Instance.syserr(e);
 932                                         SwingUtilities.invokeLater(new Runnable() {
 933                                                 @Override
 934                                                 public void run() {
 935                                                         JOptionPane.showMessageDialog(GuiReaderFrame.this,
 936                                                                         "Cannot import: " + url, e.getMessage(),
 937                                                                         JOptionPane.ERROR_MESSAGE);
 938                                                 }
 939                                         });
 940                                 } else {
 941                                         if (onSuccess != null) {
 942                                                 onSuccess.run(story);
 943                                         }
 944                                 }
 945                                 pgOnSuccess.done();
 946                         }
 947                 });
 948         }
 949
 950         /**
 951          * Enables or disables this component, depending on the value of the
 952          * parameter <code>b</code>. An enabled component can respond to user input
 953          * and generate events. Components are enabled initially by default.
 954          * <p>
 955          * Disabling this component will also affect its children.
 956          *
 957          * @param b
 958          *            If <code>true</code>, this component is enabled; otherwise
 959          *            this component is disabled
 960          */
 961         @Override
 962         public void setEnabled(boolean b) {
 963                 if (bar != null) {
 964                         bar.setEnabled(b);
 965                 }
 966
 967                 for (GuiReaderGroup group : booksByType.keySet()) {
 968                         group.setEnabled(b);
 969                 }
 970                 for (GuiReaderGroup group : booksByAuthor.keySet()) {
 971                         group.setEnabled(b);
 972                 }
 973                 super.setEnabled(b);
 974                 repaint();
 975         }
 976 }