tui: qualify FILE menu items
[fanfix.git] / src / be / nikiroo / fanfix / reader / tui / TuiReaderApplication.java
1 package be.nikiroo.fanfix.reader.tui;
2
3 import java.awt.Toolkit;
4 import java.awt.datatransfer.DataFlavor;
5 import java.io.IOException;
6 import java.net.URL;
7 import java.net.UnknownHostException;
8
9 import jexer.TApplication;
10 import jexer.TCommand;
11 import jexer.TKeypress;
12 import jexer.TMessageBox;
13 import jexer.TMessageBox.Result;
14 import jexer.TMessageBox.Type;
15 import jexer.TStatusBar;
16 import jexer.TWidget;
17 import jexer.TWindow;
18 import jexer.event.TCommandEvent;
19 import jexer.event.TMenuEvent;
20 import jexer.menu.TMenu;
21 import be.nikiroo.fanfix.Instance;
22 import be.nikiroo.fanfix.data.MetaData;
23 import be.nikiroo.fanfix.data.Story;
24 import be.nikiroo.fanfix.library.BasicLibrary;
25 import be.nikiroo.fanfix.reader.BasicReader;
26 import be.nikiroo.fanfix.reader.Reader;
27 import be.nikiroo.fanfix.reader.tui.TuiReaderMainWindow.Mode;
28 import be.nikiroo.fanfix.supported.SupportType;
29 import be.nikiroo.utils.Progress;
30
31 /**
32 * Manages the TUI general mode and links and manages the {@link TWindow}s.
33 * <p>
34 * It will also enclose a {@link Reader} and simply handle the reading part
35 * differently (it will create the required sub-windows and display them).
36 *
37 * @author niki
38 */
39 class TuiReaderApplication extends TApplication implements Reader {
40 public static final int MENU_FILE_OPEN = 1025;
41 public static final int MENU_FILE_IMPORT_URL = 1026;
42 public static final int MENU_FILE_IMPORT_FILE = 1027;
43 public static final int MENU_FILE_EXPORT = 1028;
44 public static final int MENU_FILE_DELETE = 1029;
45 public static final int MENU_FILE_LIBRARY = 1030;
46 public static final int MENU_FILE_EXIT = 1031;
47
48 public static final TCommand CMD_EXIT = new TCommand(MENU_FILE_EXIT) {
49 };
50
51 private Reader reader;
52 private TuiReaderMainWindow main;
53
54 // start reading if meta present
55 public TuiReaderApplication(Reader reader, BackendType backend)
56 throws Exception {
57 super(backend);
58 init(reader);
59
60 if (getMeta() != null) {
61 read(false);
62 }
63 }
64
65 public TuiReaderApplication(Reader reader, String source,
66 TApplication.BackendType backend) throws Exception {
67 super(backend);
68 init(reader);
69
70 showMain();
71 main.setMode(Mode.SOURCE, source);
72 }
73
74 @Override
75 public void read(boolean sync) throws IOException {
76 read(getStory(null), sync);
77 }
78
79 @Override
80 public MetaData getMeta() {
81 return reader.getMeta();
82 }
83
84 @Override
85 public Story getStory(Progress pg) throws IOException {
86 return reader.getStory(pg);
87 }
88
89 @Override
90 public BasicLibrary getLibrary() {
91 return reader.getLibrary();
92 }
93
94 @Override
95 public void setLibrary(BasicLibrary lib) {
96 reader.setLibrary(lib);
97 }
98
99 @Override
100 public void setMeta(MetaData meta) throws IOException {
101 reader.setMeta(meta);
102 }
103
104 @Override
105 public void setMeta(String luid) throws IOException {
106 reader.setMeta(luid);
107 }
108
109 @Override
110 public void setMeta(URL source, Progress pg) throws IOException {
111 reader.setMeta(source, pg);
112 }
113
114 @Override
115 public void browse(String source) {
116 try {
117 reader.browse(source);
118 } catch (IOException e) {
119 Instance.getTraceHandler().error(e);
120 }
121 }
122
123 @Override
124 public int getChapter() {
125 return reader.getChapter();
126 }
127
128 @Override
129 public void setChapter(int chapter) {
130 reader.setChapter(chapter);
131 }
132
133 @Override
134 public void search(boolean sync) throws IOException {
135 reader.search(sync);
136 }
137
138 @Override
139 public void search(SupportType searchOn, String keywords, int page,
140 int item, boolean sync) throws IOException {
141 reader.search(searchOn, keywords, page, item, sync);
142 }
143
144 @Override
145 public void searchTag(SupportType searchOn, int page, int item,
146 boolean sync, Integer... tags) throws IOException {
147 reader.searchTag(searchOn, page, item, sync, tags);
148 }
149
150 /**
151 * Open the given {@link Story} for reading. This may or may not start an
152 * external program to read said {@link Story}.
153 *
154 * @param story
155 * the {@link Story} to read
156 * @param sync
157 * execute the process synchronously (wait until it is terminated
158 * before returning)
159 *
160 * @throws IOException
161 * in case of I/O errors
162 */
163 public void read(Story story, boolean sync) throws IOException {
164 if (story == null) {
165 throw new IOException("No story to read");
166 }
167
168 // TODO: open in editor + external option
169 if (!story.getMeta().isImageDocument()) {
170 TWindow window = new TuiReaderStoryWindow(this, story, getChapter());
171 window.maximize();
172 } else {
173 try {
174 openExternal(getLibrary(), story.getMeta().getLuid(), sync);
175 } catch (IOException e) {
176 messageBox("Error when trying to open the story",
177 e.getMessage(), TMessageBox.Type.OK);
178 }
179 }
180 }
181
182 /**
183 * Set the default status bar when this window appear.
184 * <p>
185 * Some shortcuts are always visible, and will be put here.
186 * <p>
187 * Note that shortcuts placed this way on menu won't work unless the menu
188 * also implement them.
189 *
190 * @param window
191 * the new window or menu on screen
192 * @param description
193 * the description to show on the status ba
194 */
195 public TStatusBar setStatusBar(TWindow window, String description) {
196 TStatusBar statusBar = window.newStatusBar(description);
197 statusBar.addShortcutKeypress(TKeypress.kbF10, CMD_EXIT, "Exit");
198 return statusBar;
199
200 }
201
202 private void showMain() {
203 if (main != null && main.isVisible()) {
204 main.activate();
205 } else {
206 if (main != null) {
207 main.close();
208 }
209 main = new TuiReaderMainWindow(this);
210 main.maximize();
211 }
212 }
213
214 private void init(Reader reader) {
215 this.reader = reader;
216
217 // TODO: traces/errors?
218 Instance.setTraceHandler(null);
219
220 // Add the menus TODO: i18n
221 TMenu fileMenu = addMenu("&File");
222 fileMenu.addItem(MENU_FILE_OPEN, "&Open...");
223 fileMenu.addItem(MENU_FILE_EXPORT, "&Save as...");
224 fileMenu.addItem(MENU_FILE_DELETE, "&Delete...");
225 // TODO: Move to...
226 fileMenu.addSeparator();
227 fileMenu.addItem(MENU_FILE_IMPORT_URL, "Import &URL...");
228 fileMenu.addItem(MENU_FILE_IMPORT_FILE, "Import &file...");
229 fileMenu.addSeparator();
230 fileMenu.addItem(MENU_FILE_LIBRARY, "Lib&rary");
231 fileMenu.addSeparator();
232 fileMenu.addItem(MENU_FILE_EXIT, "E&xit");
233
234 setStatusBar(fileMenu, "File-management "
235 + "commands (Open, Save, Print, etc.)");
236
237 // TODO: Edit: re-download, delete
238
239 //
240
241 addWindowMenu();
242
243 getBackend().setTitle("Fanfix");
244 }
245
246 @Override
247 protected boolean onCommand(TCommandEvent command) {
248 if (command.getCmd().equals(TuiReaderMainWindow.CMD_SEARCH)) {
249 messageBox("title", "caption");
250 return true;
251 }
252 return super.onCommand(command);
253 }
254
255 @Override
256 protected boolean onMenu(TMenuEvent menu) {
257 // TODO: i18n
258 switch (menu.getId()) {
259 case MENU_FILE_EXIT:
260 close(this);
261 return true;
262 case MENU_FILE_OPEN:
263 String openfile = null;
264 try {
265 openfile = fileOpenBox(".");
266 reader.setMeta(BasicReader.getUrl(openfile), null);
267 read(false);
268 } catch (IOException e) {
269 // TODO: i18n
270 error("Fail to open file"
271 + (openfile == null ? "" : ": " + openfile),
272 "Import error", e);
273 }
274
275 return true;
276 case MENU_FILE_DELETE:
277 String luid = null;
278 String story = null;
279 MetaData meta = null;
280 if (main != null) {
281 meta = main.getSelectedMeta();
282 }
283 if (meta != null) {
284 luid = meta.getLuid();
285 story = luid + ": " + meta.getTitle();
286 }
287
288 // TODO: i18n
289 TMessageBox mbox = messageBox("Delete story", "Delete story \""
290 + story + "\"", Type.OKCANCEL);
291 if (mbox.getResult() == Result.OK) {
292 try {
293 reader.getLibrary().delete(luid);
294 if (main != null) {
295 main.refreshStories();
296 }
297 } catch (IOException e) {
298 // TODO: i18n
299 error("Fail to delete the story: \"" + story + "\"",
300 "Error", e);
301 }
302 }
303
304 return true;
305 case MENU_FILE_IMPORT_URL:
306 String clipboard = "";
307 try {
308 clipboard = ("" + Toolkit.getDefaultToolkit()
309 .getSystemClipboard().getData(DataFlavor.stringFlavor))
310 .trim();
311 } catch (Exception e) {
312 // No data will be handled
313 }
314
315 if (clipboard == null || !clipboard.startsWith("http")) {
316 clipboard = "";
317 }
318
319 String url = inputBox("Import story", "URL to import", clipboard)
320 .getText();
321
322 try {
323 if (!imprt(url)) {
324 // TODO: i18n
325 error("URK not supported: " + url, "Import error");
326 }
327 } catch (IOException e) {
328 // TODO: i18n
329 error("Fail to import URL: " + url, "Import error", e);
330 }
331
332 return true;
333 case MENU_FILE_IMPORT_FILE:
334 String filename = null;
335 try {
336 filename = fileOpenBox(".");
337 if (!imprt(filename)) {
338 // TODO: i18n
339 error("File not supported: " + filename, "Import error");
340 }
341 } catch (IOException e) {
342 // TODO: i18n
343 error("Fail to import file"
344 + (filename == null ? "" : ": " + filename),
345 "Import error", e);
346 }
347 return true;
348 case MENU_FILE_LIBRARY:
349 showMain();
350 return true;
351 }
352
353 return super.onMenu(menu);
354 }
355
356 /**
357 * Import the given url.
358 * <p>
359 * Can fail if the host is not supported.
360 *
361 * @param url
362 *
363 * @return TRUE in case of success, FALSE if the host is not supported
364 *
365 * @throws IOException
366 * in case of I/O error
367 */
368 private boolean imprt(String url) throws IOException {
369 try {
370 reader.getLibrary().imprt(BasicReader.getUrl(url), null);
371 main.refreshStories();
372 return true;
373 } catch (UnknownHostException e) {
374 return false;
375 }
376 }
377
378 @Override
379 public void openExternal(BasicLibrary lib, String luid, boolean sync)
380 throws IOException {
381 reader.openExternal(lib, luid, sync);
382 }
383
384 /**
385 * Display an error message and log it.
386 *
387 * @param message
388 * the message
389 * @param title
390 * the title of the error message
391 */
392 private void error(String message, String title) {
393 error(message, title, null);
394 }
395
396 /**
397 * Display an error message and log it, including the linked
398 * {@link Exception}.
399 *
400 * @param message
401 * the message
402 * @param title
403 * the title of the error message
404 * @param e
405 * the exception to log if any (can be NULL)
406 */
407 private void error(String message, String title, Exception e) {
408 Instance.getTraceHandler().error(title + ": " + message);
409 if (e != null) {
410 Instance.getTraceHandler().error(e);
411 }
412
413 if (e != null) {
414 messageBox(title, message //
415 + "\n" + e.getMessage());
416 } else {
417 messageBox(title, message);
418 }
419 }
420
421 /**
422 * Ask the user and, if confirmed, close the {@link TApplication} this
423 * {@link TWidget} is running on.
424 * <p>
425 * This should result in the program terminating.
426 *
427 * @param widget
428 * the {@link TWidget}
429 */
430 static public void close(TWidget widget) {
431 close(widget.getApplication());
432 }
433
434 /**
435 * Ask the user and, if confirmed, close the {@link TApplication}.
436 * <p>
437 * This should result in the program terminating.
438 *
439 * @param app
440 * the {@link TApplication}
441 */
442 static void close(TApplication app) {
443 // TODO: i18n
444 if (app.messageBox("Confirmation", "(TODO: i18n) Exit application?",
445 TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
446 app.exit();
447 }
448 }
449 }