Fix remote save, better GUI if bad import url
[fanfix.git] / src / be / nikiroo / fanfix / output / BasicOutput.java
1 package be.nikiroo.fanfix.output;
2
3 import java.io.File;
4 import java.io.IOException;
5 import java.util.ArrayList;
6 import java.util.List;
7
8 import be.nikiroo.fanfix.Instance;
9 import be.nikiroo.fanfix.bundles.StringId;
10 import be.nikiroo.fanfix.data.Chapter;
11 import be.nikiroo.fanfix.data.Paragraph;
12 import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
13 import be.nikiroo.fanfix.data.Story;
14 import be.nikiroo.utils.Progress;
15
16 /**
17 * This class is the base class used by the other output classes. It can be used
18 * outside of this package, and have static method that you can use to get
19 * access to the correct support class.
20 *
21 * @author niki
22 */
23 public abstract class BasicOutput {
24 /**
25 * The supported output types for which we can get a {@link BasicOutput}
26 * object.
27 *
28 * @author niki
29 */
30 public enum OutputType {
31 /** EPUB files created with this program */
32 EPUB,
33 /** Pure text file with some rules */
34 TEXT,
35 /** TEXT but with associated .info file */
36 INFO_TEXT,
37 /** DEBUG output to console */
38 SYSOUT,
39 /** ZIP with (PNG) images */
40 CBZ,
41 /** LaTeX file with "book" template */
42 LATEX,
43 /** HTML files in a dedicated directory */
44 HTML,
45
46 ;
47
48 @Override
49 public String toString() {
50 return super.toString().toLowerCase();
51 }
52
53 /**
54 * A description of this output type.
55 *
56 * @param longDesc
57 * TRUE for the long description, FALSE for the short one
58 *
59 * @return the description
60 */
61 public String getDesc(boolean longDesc) {
62 StringId id = longDesc ? StringId.OUTPUT_DESC
63 : StringId.OUTPUT_DESC_SHORT;
64
65 String desc = Instance.getTrans().getStringX(id, this.name());
66
67 if (desc == null) {
68 desc = Instance.getTrans().getString(id, this);
69 }
70
71 if (desc == null) {
72 desc = this.toString();
73 }
74
75 return desc;
76 }
77
78 /**
79 * The default extension to add to the output files.
80 *
81 * @param readerTarget
82 * the target to point to to read the {@link Story} (for
83 * instance, the main entry point if this {@link Story} is in
84 * a directory bundle)
85 *
86 * @return the extension
87 */
88 public String getDefaultExtension(boolean readerTarget) {
89 BasicOutput output = BasicOutput.getOutput(this, false);
90 if (output != null) {
91 return output.getDefaultExtension(readerTarget);
92 }
93
94 return null;
95 }
96
97 /**
98 * Call {@link OutputType#valueOf(String)} after conversion to upper
99 * case.
100 *
101 * @param typeName
102 * the possible type name
103 *
104 * @return NULL or the type
105 */
106 public static OutputType valueOfUC(String typeName) {
107 return OutputType.valueOf(typeName == null ? null : typeName
108 .toUpperCase());
109 }
110
111 /**
112 * Call {@link OutputType#valueOf(String)} after conversion to upper
113 * case but return def for NULL and empty instead of raising an
114 * exception.
115 *
116 * @param typeName
117 * the possible type name
118 * @param def
119 * the default value
120 *
121 * @return NULL or the type
122 */
123 public static OutputType valueOfNullOkUC(String typeName, OutputType def) {
124 if (typeName == null || typeName.isEmpty()) {
125 return def;
126 }
127
128 return OutputType.valueOfUC(typeName);
129 }
130
131 /**
132 * Call {@link OutputType#valueOf(String)} after conversion to upper
133 * case but return def in case of error instead of raising an exception.
134 *
135 * @param typeName
136 * the possible type name
137 * @param def
138 * the default value
139 *
140 * @return NULL or the type
141 */
142 public static OutputType valueOfAllOkUC(String typeName, OutputType def) {
143 try {
144 return OutputType.valueOfUC(typeName);
145 } catch (Exception e) {
146 return def;
147 }
148 }
149 }
150
151 /** The creator name (this program, by me!) */
152 static final String EPUB_CREATOR = "Fanfix (by Niki)";
153
154 /** The current best name for an image */
155 private String imageName;
156 private File targetDir;
157 private String targetName;
158 private OutputType type;
159 private boolean writeCover;
160 private boolean writeInfo;
161 private Progress storyPg;
162 private Progress chapPg;
163
164 /**
165 * Process the {@link Story} into the given target.
166 *
167 * @param story
168 * the {@link Story} to export
169 * @param target
170 * the target where to save to (will not necessary be taken as is
171 * by the processor, for instance an extension can be added)
172 * @param pg
173 * the optional progress reporter
174 *
175 * @return the actual main target saved, which can be slightly different
176 * that the input one
177 *
178 * @throws IOException
179 * in case of I/O error
180 */
181 public File process(Story story, String target, Progress pg)
182 throws IOException {
183 storyPg = pg;
184
185 File targetDir = null;
186 String targetName = null;
187 if (target != null) {
188 target = new File(target).getAbsolutePath();
189 targetDir = new File(target).getParentFile();
190 targetName = new File(target).getName();
191
192 String ext = getDefaultExtension(false);
193 if (ext != null && !ext.isEmpty()) {
194 if (targetName.toLowerCase().endsWith(ext)) {
195 targetName = targetName.substring(0, targetName.length()
196 - ext.length());
197 }
198 }
199 }
200
201 return process(story, targetDir, targetName);
202 }
203
204 /**
205 * Process the {@link Story} into the given target.
206 * <p>
207 * This method is expected to be overridden in most cases.
208 *
209 * @param story
210 * the {@link Story} to export
211 * @param targetDir
212 * the target dir where to save to
213 * @param targetName
214 * the target filename (will not necessary be taken as is by the
215 * processor, for instance an extension can be added)
216 *
217 *
218 * @return the actual main target saved, which can be slightly different
219 * that the input one
220 *
221 * @throws IOException
222 * in case of I/O error
223 */
224 protected File process(Story story, File targetDir, String targetName)
225 throws IOException {
226 this.targetDir = targetDir;
227 this.targetName = targetName;
228
229 writeStory(story);
230
231 return null;
232 }
233
234 /**
235 * The output type.
236 *
237 * @return the type
238 */
239 public OutputType getType() {
240 return type;
241 }
242
243 /**
244 * Enable the creation of a .info file next to the resulting processed file.
245 *
246 * @return TRUE to enable it
247 */
248 protected boolean isWriteInfo() {
249 return writeInfo;
250 }
251
252 /**
253 * Enable the creation of a cover file next to the resulting processed file
254 * if possible.
255 *
256 * @return TRUE to enable it
257 */
258 protected boolean isWriteCover() {
259 return writeCover;
260 }
261
262 /**
263 * The output type.
264 *
265 * @param type
266 * the new type
267 * @param writeInfo
268 * TRUE to enable the creation of a .info file
269 * @param writeCover
270 * TRUE to enable the creation of a cover if possible
271 *
272 * @return this
273 */
274 protected BasicOutput setType(OutputType type, boolean writeCover,
275 boolean writeInfo) {
276 this.type = type;
277 this.writeCover = writeCover;
278 this.writeInfo = writeInfo;
279
280 return this;
281 }
282
283 /**
284 * The default extension to add to the output files.
285 *
286 * @param readerTarget
287 * the target to point to to read the {@link Story} (for
288 * instance, the main entry point if this {@link Story} is in a
289 * directory bundle)
290 *
291 * @return the extension
292 */
293 public String getDefaultExtension(
294 @SuppressWarnings("unused") boolean readerTarget) {
295 return "";
296 }
297
298 @SuppressWarnings("unused")
299 protected void writeStoryHeader(Story story) throws IOException {
300 }
301
302 @SuppressWarnings("unused")
303 protected void writeChapterHeader(Chapter chap) throws IOException {
304 }
305
306 @SuppressWarnings("unused")
307 protected void writeParagraphHeader(Paragraph para) throws IOException {
308 }
309
310 @SuppressWarnings("unused")
311 protected void writeStoryFooter(Story story) throws IOException {
312 }
313
314 @SuppressWarnings("unused")
315 protected void writeChapterFooter(Chapter chap) throws IOException {
316 }
317
318 @SuppressWarnings("unused")
319 protected void writeParagraphFooter(Paragraph para) throws IOException {
320 }
321
322 protected void writeStory(Story story) throws IOException {
323 if (storyPg == null) {
324 storyPg = new Progress(0, story.getChapters().size() + 2);
325 } else {
326 storyPg.setMinMax(0, story.getChapters().size() + 2);
327 }
328
329 String chapterNameNum = String.format("%03d", 0);
330 String paragraphNumber = String.format("%04d", 0);
331 imageName = paragraphNumber + "_" + chapterNameNum + ".png";
332
333 if (story.getMeta() != null) {
334 story.getMeta().setType("" + getType());
335 }
336
337 if (writeCover) {
338 InfoCover.writeCover(targetDir, targetName, story.getMeta());
339 }
340 if (writeInfo) {
341 InfoCover.writeInfo(targetDir, targetName, story.getMeta());
342 }
343
344 storyPg.setProgress(1);
345
346 List<Progress> chapPgs = new ArrayList<Progress>(story.getChapters()
347 .size());
348 for (Chapter chap : story) {
349 chapPg = new Progress(0, chap.getParagraphs().size());
350 storyPg.addProgress(chapPg, 1);
351 chapPgs.add(chapPg);
352 chapPg = null;
353 }
354
355 writeStoryHeader(story);
356 for (int i = 0; i < story.getChapters().size(); i++) {
357 chapPg = chapPgs.get(i);
358 writeChapter(story.getChapters().get(i));
359 chapPg.setProgress(chapPg.getMax());
360 chapPg = null;
361 }
362 writeStoryFooter(story);
363
364 storyPg.setProgress(storyPg.getMax());
365 storyPg = null;
366 }
367
368 protected void writeChapter(Chapter chap) throws IOException {
369 String chapterNameNum;
370 if (chap.getName() == null || chap.getName().isEmpty()) {
371 chapterNameNum = String.format("%03d", chap.getNumber());
372 } else {
373 chapterNameNum = String.format("%03d", chap.getNumber()) + "_"
374 + chap.getName().replace(" ", "_");
375 }
376
377 int num = 0;
378 String paragraphNumber = String.format("%04d", num++);
379 imageName = chapterNameNum + "_" + paragraphNumber + ".png";
380
381 writeChapterHeader(chap);
382 int i = 1;
383 for (Paragraph para : chap) {
384 paragraphNumber = String.format("%04d", num++);
385 imageName = chapterNameNum + "_" + paragraphNumber + ".png";
386 writeParagraph(para);
387 if (chapPg != null) {
388 chapPg.setProgress(i++);
389 }
390 }
391 writeChapterFooter(chap);
392 }
393
394 protected void writeParagraph(Paragraph para) throws IOException {
395 writeParagraphHeader(para);
396 writeTextLine(para.getType(), para.getContent());
397 writeParagraphFooter(para);
398 }
399
400 @SuppressWarnings("unused")
401 protected void writeTextLine(ParagraphType type, String line)
402 throws IOException {
403 }
404
405 /**
406 * Return the current best guess for an image name, based upon the current
407 * {@link Chapter} and {@link Paragraph}.
408 *
409 * @param prefix
410 * add the original target name as a prefix
411 *
412 * @return the guessed name
413 */
414 protected String getCurrentImageBestName(boolean prefix) {
415 if (prefix) {
416 return targetName + "_" + imageName;
417 }
418
419 return imageName;
420 }
421
422 /**
423 * Return the given word or sentence as <b>bold</b>.
424 *
425 * @param word
426 * the input
427 *
428 * @return the bold output
429 */
430 protected String enbold(String word) {
431 return word;
432 }
433
434 /**
435 * Return the given word or sentence as <i>italic</i>.
436 *
437 * @param word
438 * the input
439 *
440 * @return the italic output
441 */
442 protected String italize(String word) {
443 return word;
444 }
445
446 /**
447 * Decorate the given text with <b>bold</b> and <i>italic</i> words,
448 * according to {@link BasicOutput#enbold(String)} and
449 * {@link BasicOutput#italize(String)}.
450 *
451 * @param text
452 * the input
453 *
454 * @return the decorated output
455 */
456 protected String decorateText(String text) {
457 StringBuilder builder = new StringBuilder();
458
459 int bold = -1;
460 int italic = -1;
461 char prev = '\0';
462 for (char car : text.toCharArray()) {
463 switch (car) {
464 case '*':
465 if (bold >= 0 && prev != ' ') {
466 String data = builder.substring(bold);
467 builder.setLength(bold);
468 builder.append(enbold(data));
469 bold = -1;
470 } else if (bold < 0
471 && (prev == ' ' || prev == '\0' || prev == '\n')) {
472 bold = builder.length();
473 } else {
474 builder.append(car);
475 }
476
477 break;
478 case '_':
479 if (italic >= 0 && prev != ' ') {
480 String data = builder.substring(italic);
481 builder.setLength(italic);
482 builder.append(enbold(data));
483 italic = -1;
484 } else if (italic < 0
485 && (prev == ' ' || prev == '\0' || prev == '\n')) {
486 italic = builder.length();
487 } else {
488 builder.append(car);
489 }
490
491 break;
492 default:
493 builder.append(car);
494 break;
495 }
496
497 prev = car;
498 }
499
500 if (bold >= 0) {
501 builder.insert(bold, '*');
502 }
503
504 if (italic >= 0) {
505 builder.insert(italic, '_');
506 }
507
508 return builder.toString();
509 }
510
511 /**
512 * Return a {@link BasicOutput} object compatible with the given
513 * {@link OutputType}.
514 *
515 * @param type
516 * the type
517 * @param infoCover
518 * force the <tt>.info</tt> file and the cover to be saved next
519 * to the main target file
520 *
521 * @return the {@link BasicOutput}
522 */
523 public static BasicOutput getOutput(OutputType type, boolean infoCover) {
524 if (type != null) {
525 switch (type) {
526 case EPUB:
527 return new Epub().setType(type, infoCover, infoCover);
528 case TEXT:
529 return new Text().setType(type, true, infoCover);
530 case INFO_TEXT:
531 return new InfoText().setType(type, true, true);
532 case SYSOUT:
533 return new Sysout().setType(type, false, false);
534 case CBZ:
535 return new Cbz().setType(type, infoCover, infoCover);
536 case LATEX:
537 return new LaTeX().setType(type, infoCover, infoCover);
538 case HTML:
539 return new Html().setType(type, infoCover, infoCover);
540 }
541 }
542
543 return null;
544 }
545 }