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