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

   1 package be.nikiroo.fanfix.reader.ui;
   2
   3 import java.awt.BorderLayout;
   4 import java.awt.Color;
   5 import java.awt.Component;
   6 import java.awt.EventQueue;
   7 import java.awt.event.ActionEvent;
   8 import java.awt.event.ActionListener;
   9 import java.io.IOException;
  10 import java.lang.reflect.InvocationTargetException;
  11 import java.util.ArrayList;
  12 import java.util.List;
  13
  14 import javax.swing.BoxLayout;
  15 import javax.swing.JButton;
  16 import javax.swing.JComboBox;
  17 import javax.swing.JFrame;
  18 import javax.swing.JLabel;
  19 import javax.swing.JList;
  20 import javax.swing.JPanel;
  21 import javax.swing.JScrollPane;
  22 import javax.swing.JTabbedPane;
  23 import javax.swing.JTextField;
  24 import javax.swing.ListCellRenderer;
  25
  26 import be.nikiroo.fanfix.Instance;
  27 import be.nikiroo.fanfix.data.MetaData;
  28 import be.nikiroo.fanfix.reader.ui.GuiReaderBook.BookActionListener;
  29 import be.nikiroo.fanfix.searchable.BasicSearchable;
  30 import be.nikiroo.fanfix.searchable.SearchableTag;
  31 import be.nikiroo.fanfix.supported.SupportType;
  32
  33 /**
  34  * This frame will allow you to search through the supported websites for new
  35  * stories/comics.
  36  *
  37  * @author niki
  38  */
  39 public class GuiReaderSearch extends JFrame {
  40         private static final long serialVersionUID = 1L;
  41
  42         private List<SupportType> supportTypes;
  43         private SupportType supportType;
  44         private boolean searchByTags;
  45         private List<SearchableTag> tags;
  46         private String keywords;
  47         private int page;
  48         private int maxPage;
  49
  50         private JPanel tagBars;
  51
  52         private JComboBox comboSupportTypes;
  53         private JTabbedPane searchTabs;
  54         private JTextField keywordsField;
  55         private JButton submitKeywords;
  56
  57         private boolean seeWordcount;
  58         private GuiReaderGroup books;
  59
  60         public GuiReaderSearch(final GuiReader reader) {
  61                 super("Browse stories");
  62                 setLayout(new BorderLayout());
  63                 setSize(800, 600);
  64
  65                 tags = new ArrayList<SearchableTag>();
  66                 page = 1; // TODO
  67                 maxPage = -1;
  68                 searchByTags = false;
  69
  70                 supportTypes = new ArrayList<SupportType>();
  71                 for (SupportType type : SupportType.values()) {
  72                         if (BasicSearchable.getSearchable(type) != null) {
  73                                 supportTypes.add(type);
  74                         }
  75                 }
  76                 supportType = supportTypes.isEmpty() ? null : supportTypes.get(0);
  77
  78                 comboSupportTypes = new JComboBox(
  79                                 supportTypes.toArray(new SupportType[] {}));
  80                 comboSupportTypes.addActionListener(new ActionListener() {
  81                         @Override
  82                         public void actionPerformed(ActionEvent e) {
  83                                 updateSupportType((SupportType) comboSupportTypes
  84                                                 .getSelectedItem());
  85                         }
  86                 });
  87                 JPanel searchSites = new JPanel(new BorderLayout());
  88                 searchSites.add(comboSupportTypes, BorderLayout.CENTER);
  89                 searchSites.add(new JLabel(" " + "Website : "), BorderLayout.WEST);
  90
  91                 searchTabs = new JTabbedPane();
  92                 searchTabs.addTab("By name", createByNameSearchPanel());
  93                 searchTabs.addTab("By tags", createByTagSearchPanel());
  94
  95                 JPanel top = new JPanel(new BorderLayout());
  96                 top.add(searchSites, BorderLayout.NORTH);
  97                 top.add(searchTabs, BorderLayout.CENTER);
  98
  99                 add(top, BorderLayout.NORTH);
 100
 101                 books = new GuiReaderGroup(reader, null, null);
 102                 books.setActionListener(new BookActionListener() {
 103                         @Override
 104                         public void select(GuiReaderBook book) {
 105                         }
 106
 107                         @Override
 108                         public void popupRequested(GuiReaderBook book, Component target,
 109                                         int x, int y) {
 110                         }
 111
 112                         @Override
 113                         public void action(GuiReaderBook book) {
 114                                 new GuiReaderSearchAction(reader.getLibrary(), book.getInfo())
 115                                                 .setVisible(true);
 116                         }
 117                 });
 118                 JScrollPane scroll = new JScrollPane(books);
 119                 scroll.getVerticalScrollBar().setUnitIncrement(16);
 120                 add(scroll, BorderLayout.CENTER);
 121
 122                 updateTags(null);
 123         }
 124
 125         private JPanel createByNameSearchPanel() {
 126                 JPanel byName = new JPanel(new BorderLayout());
 127
 128                 keywordsField = new JTextField();
 129                 byName.add(keywordsField, BorderLayout.CENTER);
 130
 131                 submitKeywords = new JButton("Search");
 132                 byName.add(submitKeywords, BorderLayout.EAST);
 133
 134                 // TODO: ENTER -> search
 135
 136                 submitKeywords.addActionListener(new ActionListener() {
 137                         @Override
 138                         public void actionPerformed(ActionEvent e) {
 139                                 search(supportType, keywordsField.getText(), page, 0);
 140                         }
 141                 });
 142
 143                 return byName;
 144         }
 145
 146         private JPanel createByTagSearchPanel() {
 147                 JPanel byTag = new JPanel();
 148                 tagBars = new JPanel();
 149                 tagBars.setLayout(new BoxLayout(tagBars, BoxLayout.Y_AXIS));
 150                 byTag.add(tagBars, BorderLayout.NORTH);
 151
 152                 return byTag;
 153         }
 154
 155         private void updateSupportType(SupportType supportType) {
 156                 if (supportType != this.supportType) {
 157                         this.supportType = supportType;
 158                         comboSupportTypes.setSelectedItem(supportType);
 159                         books.clear();
 160                         updateTags(null);
 161                 }
 162         }
 163
 164         private void updateSearchBy(final boolean byTag) {
 165                 if (byTag != this.searchByTags) {
 166                         inUi(new Runnable() {
 167                                 @Override
 168                                 public void run() {
 169                                         if (!byTag) {
 170                                                 searchTabs.setSelectedIndex(0);
 171                                         } else {
 172                                                 searchTabs.setSelectedIndex(1);
 173                                         }
 174                                 }
 175                         });
 176                 }
 177         }
 178
 179         private void updatePages(final int page, final Integer maxPage) {
 180                 inUi(new Runnable() {
 181                         @Override
 182                         public void run() {
 183                                 GuiReaderSearch.this.page = page;
 184                                 GuiReaderSearch.this.maxPage = maxPage;
 185                                 // TODO: gui
 186                                 System.out.println("page: " + page);
 187                                 System.out.println("max page: " + maxPage);
 188                         }
 189                 });
 190         }
 191
 192         // cannot be NULL
 193         private void updateKeywords(final String keywords) {
 194                 if (!keywords.equals(this.keywords)) {
 195                         inUi(new Runnable() {
 196                                 @Override
 197                                 public void run() {
 198                                         GuiReaderSearch.this.keywords = keywords;
 199                                         keywordsField.setText(keywords);
 200                                 }
 201                         });
 202                 }
 203         }
 204
 205         // update and reset the tagsbar
 206         // can be NULL, for base tags
 207         private void updateTags(final SearchableTag tag) {
 208                 final List<SearchableTag> parents = new ArrayList<SearchableTag>();
 209                 SearchableTag parent = (tag == null) ? null : tag;
 210                 while (parent != null) {
 211                         parents.add(parent);
 212                         parent = parent.getParent();
 213                 }
 214
 215                 inUi(new Runnable() {
 216                         @Override
 217                         public void run() {
 218                                 tagBars.invalidate();
 219                                 tagBars.removeAll();
 220
 221                                 // TODO: Slow UI
 222                                 // TODO: select the right one
 223                                 try {
 224                                         SearchableTag selectedChild = parents.isEmpty() ? null
 225                                                         : parents.get(parents.size() - 1);
 226                                         addTagBar(BasicSearchable.getSearchable(supportType)
 227                                                         .getTags(), selectedChild);
 228                                 } catch (IOException e) {
 229                                         error(e);
 230                                 }
 231
 232                                 for (int i = parents.size() - 1; i >= 0; i--) {
 233                                         SearchableTag selectedChild = null;
 234                                         if (i > 0) {
 235                                                 selectedChild = parents.get(i - 1);
 236                                         }
 237                                         SearchableTag parent = parents.get(i);
 238                                         addTagBar(parent.getChildren(), selectedChild);
 239                                 }
 240
 241                                 tagBars.validate();
 242                         }
 243                 });
 244         }
 245
 246         private void updateBooks(final List<GuiReaderBookInfo> infos) {
 247                 setWaitingScreen(true);
 248                 inUi(new Runnable() {
 249                         @Override
 250                         public void run() {
 251                                 books.refreshBooks(infos, seeWordcount);
 252                                 setWaitingScreen(false);
 253                         }
 254                 });
 255         }
 256
 257         // not 1.6 compatible
 258         @SuppressWarnings({ "unchecked", "rawtypes" })
 259         private void addTagBar(List<SearchableTag> tags,
 260                         final SearchableTag selected) {
 261                 tags.add(0, null);
 262
 263                 final JComboBox combo = new JComboBox(
 264                                 tags.toArray(new SearchableTag[] {}));
 265                 combo.setSelectedItem(selected);
 266
 267                 final ListCellRenderer basic = combo.getRenderer();
 268
 269                 combo.setRenderer(new ListCellRenderer() {
 270                         @Override
 271                         public Component getListCellRendererComponent(JList list,
 272                                         Object value, int index, boolean isSelected,
 273                                         boolean cellHasFocus) {
 274
 275                                 Object displayValue = value;
 276                                 if (value instanceof SearchableTag) {
 277                                         displayValue = ((SearchableTag) value).getName();
 278                                 } else {
 279                                         displayValue = "Select a tag...";
 280                                         cellHasFocus = false;
 281                                         isSelected = false;
 282                                 }
 283
 284                                 Component rep = basic.getListCellRendererComponent(list,
 285                                                 displayValue, index, isSelected, cellHasFocus);
 286
 287                                 if (value == null) {
 288                                         rep.setForeground(Color.GRAY);
 289                                 }
 290
 291                                 return rep;
 292                         }
 293                 });
 294
 295                 combo.addActionListener(new ActionListener() {
 296                         @Override
 297                         public void actionPerformed(ActionEvent e) {
 298                                 final SearchableTag tag = (SearchableTag) combo
 299                                                 .getSelectedItem();
 300                                 if (tag != null) {
 301                                         addTagBar(tag, new Runnable() {
 302                                                 @Override
 303                                                 public void run() {
 304                                                         // TODO: stories if needed
 305                                                         setWaitingScreen(false);
 306                                                 }
 307                                         });
 308                                 }
 309                         }
 310                 });
 311
 312                 tagBars.add(combo);
 313         }
 314
 315         // async, add children of tag, NULL = base tags
 316         private void addTagBar(final SearchableTag tag, final Runnable inUi) {
 317                 new Thread(new Runnable() {
 318                         @Override
 319                         public void run() {
 320                                 BasicSearchable searchable = BasicSearchable
 321                                                 .getSearchable(supportType);
 322
 323                                 List<SearchableTag> children = new ArrayList<SearchableTag>();
 324                                 if (tag == null) {
 325                                         try {
 326                                                 List<SearchableTag> baseTags = searchable.getTags();
 327                                                 children = baseTags;
 328                                         } catch (IOException e) {
 329                                                 error(e);
 330                                         }
 331                                 } else {
 332                                         try {
 333                                                 searchable.fillTag(tag);
 334                                         } catch (IOException e) {
 335                                                 error(e);
 336                                         }
 337
 338                                         if (!tag.isLeaf()) {
 339                                                 children = tag.getChildren();
 340                                         } else {
 341                                                 children = null;
 342                                                 // TODO: stories
 343                                         }
 344                                 }
 345
 346                                 final List<SearchableTag> fchildren = children;
 347                                 inUi(new Runnable() {
 348                                         @Override
 349                                         public void run() {
 350                                                 if (fchildren != null) {
 351                                                         addTagBar(fchildren, tag);
 352                                                 }
 353
 354                                                 if (inUi != null) {
 355                                                         inUi.run();
 356                                                 }
 357                                         }
 358                                 });
 359                         }
 360                 }).start();
 361         }
 362
 363         // item 0 = no selection, else = default selection
 364         public void search(final SupportType searchOn, final String keywords,
 365                         final int page, final int item) {
 366
 367                 setWaitingScreen(true);
 368
 369                 updateSupportType(searchOn);
 370                 updateSearchBy(false);
 371                 updateKeywords(keywords);
 372                 updatePages(page, maxPage);
 373
 374                 new Thread(new Runnable() {
 375                         @Override
 376                         public void run() {
 377                                 BasicSearchable search = BasicSearchable
 378                                                 .getSearchable(searchOn);
 379
 380                                 int maxPage = -1;
 381                                 try {
 382                                         maxPage = search.searchPages(keywords);
 383                                 } catch (IOException e) {
 384                                         error(e);
 385                                 }
 386
 387                                 if (page <= 0) {
 388                                         updateBooks(new ArrayList<GuiReaderBookInfo>());
 389                                         updatePages(0, maxPage);
 390                                 } else {
 391                                         List<MetaData> results;
 392                                         try {
 393                                                 results = search.search(keywords, page);
 394                                         } catch (IOException e) {
 395                                                 error(e);
 396                                                 results = new ArrayList<MetaData>();
 397                                         }
 398
 399                                         search(results, page, maxPage, item);
 400
 401                                         // ! 1-based index !
 402                                         if (item > 0 && item <= books.getBooksCount()) {
 403                                                 // TODO: "click" on item ITEM
 404                                         }
 405                                 }
 406
 407                                 setWaitingScreen(false);
 408                         }
 409                 }).start();
 410         }
 411
 412         // tag: must be filled (or NULL for base tags)
 413         public void searchTag(final SupportType searchOn, final int page,
 414                         final int item, final SearchableTag tag) {
 415
 416                 setWaitingScreen(true);
 417
 418                 updateSupportType(searchOn);
 419                 updateSearchBy(true);
 420                 updateTags(tag);
 421                 updatePages(page, maxPage);
 422
 423                 new Thread(new Runnable() {
 424                         @Override
 425                         public void run() {
 426                                 BasicSearchable search = BasicSearchable
 427                                                 .getSearchable(searchOn);
 428
 429                                 if (tag != null) {
 430                                         int maxPage = 0;
 431                                         try {
 432                                                 maxPage = search.searchPages(tag);
 433                                         } catch (IOException e) {
 434                                                 error(e);
 435                                         }
 436
 437                                         updatePages(page, maxPage);
 438
 439                                         if (page > 0) {
 440                                                 List<MetaData> metas = new ArrayList<MetaData>();
 441
 442                                                 if (tag.isLeaf()) {
 443                                                         try {
 444                                                                 metas = search.search(tag, page);
 445                                                         } catch (IOException e) {
 446                                                                 error(e);
 447                                                         }
 448                                                 } else {
 449                                                         List<SearchableTag> subtags = tag.getChildren();
 450                                                         if (item > 0 && item <= subtags.size()) {
 451                                                                 SearchableTag subtag = subtags.get(item - 1);
 452                                                                 try {
 453                                                                         metas = search.search(subtag, page);
 454                                                                         maxPage = subtag.getPages();
 455                                                                 } catch (IOException e) {
 456                                                                         error(e);
 457                                                                 }
 458                                                         }
 459                                                 }
 460
 461                                                 updatePages(page, maxPage);
 462                                                 search(metas, page, maxPage, item);
 463                                         }
 464                                 }
 465
 466                                 setWaitingScreen(false);
 467                         }
 468                 }).start();
 469         }
 470
 471         // item 0 = no selection, else = default selection
 472         public void search(final List<MetaData> results, final int page,
 473                         final int maxPage, final int item) {
 474
 475                 updatePages(page, maxPage);
 476
 477                 if (page <= 0) {
 478                         updateBooks(new ArrayList<GuiReaderBookInfo>());
 479                         updatePages(0, maxPage);
 480                 } else {
 481                         List<GuiReaderBookInfo> infos = new ArrayList<GuiReaderBookInfo>();
 482                         for (MetaData meta : results) {
 483                                 infos.add(GuiReaderBookInfo.fromMeta(meta));
 484                         }
 485
 486                         updateBooks(infos);
 487
 488                         // ! 1-based index !
 489                         if (item > 0 && item <= books.getBooksCount()) {
 490                                 // TODO: "click" on item ITEM
 491                         }
 492                 }
 493         }
 494
 495         /**
 496          * Process the given action in the main Swing UI thread.
 497          * <p>
 498          * The code will make sure the current thread is the main UI thread and, if
 499          * not, will switch to it before executing the runnable.
 500          * <p>
 501          * Synchronous operation.
 502          *
 503          * @param run
 504          *            the action to run
 505          */
 506         private void inUi(final Runnable run) {
 507                 if (EventQueue.isDispatchThread()) {
 508                         run.run();
 509                 } else {
 510                         try {
 511                                 EventQueue.invokeAndWait(run);
 512                         } catch (InterruptedException e) {
 513                                 error(e);
 514                         } catch (InvocationTargetException e) {
 515                                 error(e);
 516                         }
 517                 }
 518         }
 519
 520         private void error(Exception e) {
 521                 Instance.getTraceHandler().error(e);
 522         }
 523
 524         private void setWaitingScreen(final boolean waiting) {
 525                 inUi(new Runnable() {
 526                         @Override
 527                         public void run() {
 528                                 GuiReaderSearch.this.setEnabled(!waiting);
 529                                 books.setEnabled(!waiting);
 530                                 submitKeywords.setEnabled(!waiting);
 531                         }
 532                 });
 533         }
 534 }