[nikiroo-utils.git] / src / be / nikiroo / fanfix / reader / ui / GuiReaderGroup.java

package be.nikiroo.fanfix.reader.ui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JLabel;
import javax.swing.JPanel;

import be.nikiroo.fanfix.bundles.StringIdGui;
import be.nikiroo.fanfix.reader.ui.GuiReaderBook.BookActionListener;
import be.nikiroo.utils.ui.WrapLayout;

/**
 * A group of {@link GuiReaderBook}s for display.
 * 
 * @author niki
 */
public class GuiReaderGroup extends JPanel {
	private static final long serialVersionUID = 1L;
	private BookActionListener action;
	private Color backgroundColor;
	private GuiReader reader;
	private List<GuiReaderBookInfo> infos;
	private List<GuiReaderBook> books;
	private JPanel pane;
	private boolean words; // words or authors (secondary info on books)
	private int itemsPerLine;

	/**
	 * Create a new {@link GuiReaderGroup}.
	 * 
	 * @param reader
	 *            the {@link GuiReaderBook} used to probe some information about
	 *            the stories
	 * @param title
	 *            the title of this group
	 * @param backgroundColor
	 *            the background colour to use (or NULL for default)
	 */
	public GuiReaderGroup(GuiReader reader, String title, Color backgroundColor) {
		this.reader = reader;
		this.backgroundColor = backgroundColor;

		this.pane = new JPanel();

		pane.setLayout(new WrapLayout(WrapLayout.LEADING, 5, 5));
		if (backgroundColor != null) {
			pane.setBackground(backgroundColor);
			setBackground(backgroundColor);
		}

		setLayout(new BorderLayout(0, 10));

		// Make it focusable:
		setFocusable(true);
		setEnabled(true);
		setVisible(true);

		add(pane, BorderLayout.CENTER);

		if (title != null) {
			if (title.isEmpty()) {
				title = GuiReader.trans(StringIdGui.MENU_AUTHORS_UNKNOWN);
			}

			JLabel label = new JLabel();
			label.setText(String.format("<html>"
					+ "<body style='text-align: center; color: gray;'><br><b>"
					+ "%s" + "</b></body>" + "</html>", title));
			label.setHorizontalAlignment(JLabel.CENTER);
			add(label, BorderLayout.NORTH);
		}

		// Compute the number of items per line at each resize
		addComponentListener(new ComponentAdapter() {
			@Override
			public void componentResized(ComponentEvent e) {
				super.componentResized(e);
				computeItemsPerLine();
			}
		});
		computeItemsPerLine();

		addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				onKeyPressed(e);
			}

			@Override
			public void keyTyped(KeyEvent e) {
				onKeyTyped(e);
			}
		});

		addFocusListener(new FocusAdapter() {
			@Override
			public void focusGained(FocusEvent e) {
				if (getSelectedBookIndex() < 0) {
					setSelectedBook(0, true);
				}
			}

			@Override
			public void focusLost(FocusEvent e) {
				setBackground(null);
				setSelectedBook(-1, false);
			}
		});
	}

	/**
	 * Compute how many items can fit in a line so UP and DOWN can be used to go
	 * up/down one line at a time.
	 */
	private void computeItemsPerLine() {
		// TODO
		itemsPerLine = 5;
	}

	/**
	 * Set the {@link ActionListener} that will be fired on each
	 * {@link GuiReaderBook} action.
	 * 
	 * @param action
	 *            the action
	 */
	public void setActionListener(BookActionListener action) {
		this.action = action;
		refreshBooks(infos, words);
	}

	/**
	 * Refresh the list of {@link GuiReaderBook}s displayed in the control.
	 * 
	 * @param infos
	 *            the new list of infos
	 * @param seeWordcount
	 *            TRUE to see word counts, FALSE to see authors
	 */
	public void refreshBooks(List<GuiReaderBookInfo> infos, boolean seeWordcount) {
		this.infos = infos;
		refreshBooks(seeWordcount);
	}

	/**
	 * Refresh the list of {@link GuiReaderBook}s displayed in the control.
	 * <p>
	 * Will not change the current stories.
	 * 
	 * @param seeWordcount
	 *            TRUE to see word counts, FALSE to see authors
	 */
	public void refreshBooks(boolean seeWordcount) {
		this.words = seeWordcount;

		books = new ArrayList<GuiReaderBook>();
		invalidate();
		pane.invalidate();
		pane.removeAll();

		if (infos != null) {
			for (GuiReaderBookInfo info : infos) {
				boolean isCached = false;
				if (info.getMeta() != null) {
					isCached = reader.isCached(info.getMeta().getLuid());
				}

				GuiReaderBook book = new GuiReaderBook(reader, info, isCached,
						words);
				if (backgroundColor != null) {
					book.setBackground(backgroundColor);
				}

				books.add(book);

				book.addActionListener(new BookActionListener() {
					@Override
					public void select(GuiReaderBook book) {
						GuiReaderGroup.this.requestFocusInWindow();
						for (GuiReaderBook abook : books) {
							abook.setSelected(abook == book);
						}
					}

					@Override
					public void popupRequested(GuiReaderBook book,
							Component target, int x, int y) {
					}

					@Override
					public void action(GuiReaderBook book) {
					}
				});

				if (action != null) {
					book.addActionListener(action);
				}

				pane.add(book);
			}
		}

		pane.validate();
		pane.repaint();
		validate();
		repaint();
	}

	/**
	 * Enables or disables this component, depending on the value of the
	 * parameter <code>b</code>. An enabled component can respond to user input
	 * and generate events. Components are enabled initially by default.
	 * <p>
	 * Disabling this component will also affect its children.
	 * 
	 * @param b
	 *            If <code>true</code>, this component is enabled; otherwise
	 *            this component is disabled
	 */
	@Override
	public void setEnabled(boolean b) {
		if (books != null) {
			for (GuiReaderBook book : books) {
				book.setEnabled(b);
				book.repaint();
			}
		}

		pane.setEnabled(b);
		super.setEnabled(b);
		repaint();
	}

	/**
	 * Return the index of the currently selected book if any, -1 if none.
	 * 
	 * @return the index or -1
	 */
	private int getSelectedBookIndex() {
		int index = -1;
		for (int i = 0; i < books.size(); i++) {
			if (books.get(i).isSelected()) {
				index = i;
				break;
			}
		}
		return index;
	}

	/**
	 * Select the given book, or unselect all items.
	 * 
	 * @param index
	 *            the index of the book to select, can be outside the bounds
	 *            (either all the items will be unselected or the first or last
	 *            book will then be selected, see <tt>forceRange>/tt>)
	 * @param forceRange
	 *            TRUE to constraint the index to the first/last element, FALSE
	 *            to unselect when outside the range
	 */
	private void setSelectedBook(int index, boolean forceRange) {
		int previousIndex = getSelectedBookIndex();

		if (index >= books.size()) {
			if (forceRange) {
				index = books.size() - 1;
			} else {
				index = -1;
			}
		}

		if (index < 0 && forceRange) {
			index = 0;
		}

		if (previousIndex >= 0) {
			books.get(previousIndex).setSelected(false);
		}

		if (index >= 0) {
			books.get(index).setSelected(true);
		}
	}

	/**
	 * The action to execute when a key is typed.
	 * 
	 * @param e
	 *            the key event
	 */
	private void onKeyTyped(KeyEvent e) {
		boolean consumed = false;
		boolean action = e.getKeyChar() == '\n';
		boolean popup = e.getKeyChar() == ' ';
		if (action || popup) {
			consumed = true;

			int index = getSelectedBookIndex();
			if (index >= 0) {
				GuiReaderBook book = books.get(index);
				if (action) {
					book.action();
				} else if (popup) {
					book.popup(book, book.getWidth() / 2, book.getHeight() / 2);
				}
			}
		}

		if (consumed) {
			e.consume();
		}
	}

	/**
	 * The action to execute when a key is pressed.
	 * 
	 * @param e
	 *            the key event
	 */
	private void onKeyPressed(KeyEvent e) {
		boolean consumed = false;
		if (e.isActionKey()) {
			int offset = 0;
			switch (e.getKeyCode()) {
			case KeyEvent.VK_LEFT:
				offset = -1;
				break;
			case KeyEvent.VK_RIGHT:
				offset = 1;
				break;
			case KeyEvent.VK_UP:
				offset = -itemsPerLine;
				break;
			case KeyEvent.VK_DOWN:
				offset = itemsPerLine;
				break;
			}

			if (offset != 0) {
				consumed = true;

				int previousIndex = getSelectedBookIndex();
				if (previousIndex >= 0) {
					setSelectedBook(previousIndex + offset, true);
				}
			}
		}

		if (consumed) {
			e.consume();
		}
	}
}
Commit	Line	Data
	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.event.ActionListener;
	7	import java.awt.event.ComponentAdapter;
	8	import java.awt.event.ComponentEvent;
	9	import java.awt.event.FocusAdapter;
	10	import java.awt.event.FocusEvent;
	11	import java.awt.event.KeyAdapter;
	12	import java.awt.event.KeyEvent;
	13	import java.util.ArrayList;
	14	import java.util.List;
	15
	16	import javax.swing.JLabel;
	17	import javax.swing.JPanel;
	18
	19	import be.nikiroo.fanfix.bundles.StringIdGui;
	20	import be.nikiroo.fanfix.reader.ui.GuiReaderBook.BookActionListener;
	21	import be.nikiroo.utils.ui.WrapLayout;
	22
	23	/**
	24	* A group of {@link GuiReaderBook}s for display.
	25	*
	26	* @author niki
	27	*/
	28	public class GuiReaderGroup extends JPanel {
	29	private static final long serialVersionUID = 1L;
	30	private BookActionListener action;
	31	private Color backgroundColor;
	32	private GuiReader reader;
	33	private List<GuiReaderBookInfo> infos;
	34	private List<GuiReaderBook> books;
	35	private JPanel pane;
	36	private boolean words; // words or authors (secondary info on books)
	37	private int itemsPerLine;
	38
	39	/**
	40	* Create a new {@link GuiReaderGroup}.
	41	*
	42	* @param reader
	43	* the {@link GuiReaderBook} used to probe some information about
	44	* the stories
	45	* @param title
	46	* the title of this group
	47	* @param backgroundColor
	48	* the background colour to use (or NULL for default)
	49	*/
	50	public GuiReaderGroup(GuiReader reader, String title, Color backgroundColor) {
	51	this.reader = reader;
	52	this.backgroundColor = backgroundColor;
	53
	54	this.pane = new JPanel();
	55
	56	pane.setLayout(new WrapLayout(WrapLayout.LEADING, 5, 5));
	57	if (backgroundColor != null) {
	58	pane.setBackground(backgroundColor);
	59	setBackground(backgroundColor);
	60	}
	61
	62	setLayout(new BorderLayout(0, 10));
	63
	64	// Make it focusable:
	65	setFocusable(true);
	66	setEnabled(true);
	67	setVisible(true);
	68
	69	add(pane, BorderLayout.CENTER);
	70
	71	if (title != null) {
	72	if (title.isEmpty()) {
	73	title = GuiReader.trans(StringIdGui.MENU_AUTHORS_UNKNOWN);
	74	}
	75
	76	JLabel label = new JLabel();
	77	label.setText(String.format("<html>"
	78	+ "<body style='text-align: center; color: gray;'><br><b>"
	79	+ "%s" + "</b></body>" + "</html>", title));
	80	label.setHorizontalAlignment(JLabel.CENTER);
	81	add(label, BorderLayout.NORTH);
	82	}
	83
	84	// Compute the number of items per line at each resize
	85	addComponentListener(new ComponentAdapter() {
	86	@Override
	87	public void componentResized(ComponentEvent e) {
	88	super.componentResized(e);
	89	computeItemsPerLine();
	90	}
	91	});
	92	computeItemsPerLine();
	93
	94	addKeyListener(new KeyAdapter() {
	95	@Override
	96	public void keyPressed(KeyEvent e) {
	97	onKeyPressed(e);
	98	}
	99
	100	@Override
	101	public void keyTyped(KeyEvent e) {
	102	onKeyTyped(e);
	103	}
	104	});
	105
	106	addFocusListener(new FocusAdapter() {
	107	@Override
	108	public void focusGained(FocusEvent e) {
	109	if (getSelectedBookIndex() < 0) {
	110	setSelectedBook(0, true);
	111	}
	112	}
	113
	114	@Override
	115	public void focusLost(FocusEvent e) {
	116	setBackground(null);
	117	setSelectedBook(-1, false);
	118	}
	119	});
	120	}
	121
	122	/**
	123	* Compute how many items can fit in a line so UP and DOWN can be used to go
	124	* up/down one line at a time.
	125	*/
	126	private void computeItemsPerLine() {
	127	// TODO
	128	itemsPerLine = 5;
	129	}
	130
	131	/**
	132	* Set the {@link ActionListener} that will be fired on each
	133	* {@link GuiReaderBook} action.
	134	*
	135	* @param action
	136	* the action
	137	*/
	138	public void setActionListener(BookActionListener action) {
	139	this.action = action;
	140	refreshBooks(infos, words);
	141	}
	142
	143	/**
	144	* Refresh the list of {@link GuiReaderBook}s displayed in the control.
	145	*
	146	* @param infos
	147	* the new list of infos
	148	* @param seeWordcount
	149	* TRUE to see word counts, FALSE to see authors
	150	*/
	151	public void refreshBooks(List<GuiReaderBookInfo> infos, boolean seeWordcount) {
	152	this.infos = infos;
	153	refreshBooks(seeWordcount);
	154	}
	155
	156	/**
	157	* Refresh the list of {@link GuiReaderBook}s displayed in the control.
	158	* <p>
	159	* Will not change the current stories.
	160	*
	161	* @param seeWordcount
	162	* TRUE to see word counts, FALSE to see authors
	163	*/
	164	public void refreshBooks(boolean seeWordcount) {
	165	this.words = seeWordcount;
	166
	167	books = new ArrayList<GuiReaderBook>();
	168	invalidate();
	169	pane.invalidate();
	170	pane.removeAll();
	171
	172	if (infos != null) {
	173	for (GuiReaderBookInfo info : infos) {
	174	boolean isCached = false;
	175	if (info.getMeta() != null) {
	176	isCached = reader.isCached(info.getMeta().getLuid());
	177	}
	178
	179	GuiReaderBook book = new GuiReaderBook(reader, info, isCached,
	180	words);
	181	if (backgroundColor != null) {
	182	book.setBackground(backgroundColor);
	183	}
	184
	185	books.add(book);
	186
	187	book.addActionListener(new BookActionListener() {
	188	@Override
	189	public void select(GuiReaderBook book) {
	190	GuiReaderGroup.this.requestFocusInWindow();
	191	for (GuiReaderBook abook : books) {
	192	abook.setSelected(abook == book);
	193	}
	194	}
	195
	196	@Override
	197	public void popupRequested(GuiReaderBook book,
	198	Component target, int x, int y) {
	199	}
	200
	201	@Override
	202	public void action(GuiReaderBook book) {
	203	}
	204	});
	205
	206	if (action != null) {
	207	book.addActionListener(action);
	208	}
	209
	210	pane.add(book);
	211	}
	212	}
	213
	214	pane.validate();
	215	pane.repaint();
	216	validate();
	217	repaint();
	218	}
	219
	220	/**
	221	* Enables or disables this component, depending on the value of the
	222	* parameter <code>b</code>. An enabled component can respond to user input
	223	* and generate events. Components are enabled initially by default.
	224	* <p>
	225	* Disabling this component will also affect its children.
	226	*
	227	* @param b
	228	* If <code>true</code>, this component is enabled; otherwise
	229	* this component is disabled
	230	*/
	231	@Override
	232	public void setEnabled(boolean b) {
	233	if (books != null) {
	234	for (GuiReaderBook book : books) {
	235	book.setEnabled(b);
	236	book.repaint();
	237	}
	238	}
	239
	240	pane.setEnabled(b);
	241	super.setEnabled(b);
	242	repaint();
	243	}
	244
	245	/**
	246	* Return the index of the currently selected book if any, -1 if none.
	247	*
	248	* @return the index or -1
	249	*/
	250	private int getSelectedBookIndex() {
	251	int index = -1;
	252	for (int i = 0; i < books.size(); i++) {
	253	if (books.get(i).isSelected()) {
	254	index = i;
	255	break;
	256	}
	257	}
	258	return index;
	259	}
	260
	261	/**
	262	* Select the given book, or unselect all items.
	263	*
	264	* @param index
	265	* the index of the book to select, can be outside the bounds
	266	* (either all the items will be unselected or the first or last
	267	* book will then be selected, see <tt>forceRange>/tt>)
	268	* @param forceRange
	269	* TRUE to constraint the index to the first/last element, FALSE
	270	* to unselect when outside the range
	271	*/
	272	private void setSelectedBook(int index, boolean forceRange) {
	273	int previousIndex = getSelectedBookIndex();
	274
	275	if (index >= books.size()) {
	276	if (forceRange) {
	277	index = books.size() - 1;
	278	} else {
	279	index = -1;
	280	}
	281	}
	282
	283	if (index < 0 && forceRange) {
	284	index = 0;
	285	}
	286
	287	if (previousIndex >= 0) {
	288	books.get(previousIndex).setSelected(false);
	289	}
	290
	291	if (index >= 0) {
	292	books.get(index).setSelected(true);
	293	}
	294	}
	295
	296	/**
	297	* The action to execute when a key is typed.
	298	*
	299	* @param e
	300	* the key event
	301	*/
	302	private void onKeyTyped(KeyEvent e) {
	303	boolean consumed = false;
	304	boolean action = e.getKeyChar() == '\n';
	305	boolean popup = e.getKeyChar() == ' ';
	306	if (action \|\| popup) {
	307	consumed = true;
	308
	309	int index = getSelectedBookIndex();
	310	if (index >= 0) {
	311	GuiReaderBook book = books.get(index);
	312	if (action) {
	313	book.action();
	314	} else if (popup) {
	315	book.popup(book, book.getWidth() / 2, book.getHeight() / 2);
	316	}
	317	}
	318	}
	319
	320	if (consumed) {
	321	e.consume();
	322	}
	323	}
	324
	325	/**
	326	* The action to execute when a key is pressed.
	327	*
	328	* @param e
	329	* the key event
	330	*/
	331	private void onKeyPressed(KeyEvent e) {
	332	boolean consumed = false;
	333	if (e.isActionKey()) {
	334	int offset = 0;
	335	switch (e.getKeyCode()) {
	336	case KeyEvent.VK_LEFT:
	337	offset = -1;
	338	break;
	339	case KeyEvent.VK_RIGHT:
	340	offset = 1;
	341	break;
	342	case KeyEvent.VK_UP:
	343	offset = -itemsPerLine;
	344	break;
	345	case KeyEvent.VK_DOWN:
	346	offset = itemsPerLine;
	347	break;
	348	}
	349
	350	if (offset != 0) {
	351	consumed = true;
	352
	353	int previousIndex = getSelectedBookIndex();
	354	if (previousIndex >= 0) {
	355	setSelectedBook(previousIndex + offset, true);
	356	}
	357	}
	358	}
	359
	360	if (consumed) {
	361	e.consume();
	362	}
	363	}
	364	}