[fanfix.git] / src / be / nikiroo / fanfix / output / BasicOutput.java

package be.nikiroo.fanfix.output;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.bundles.StringId;
import be.nikiroo.fanfix.data.Chapter;
import be.nikiroo.fanfix.data.Paragraph;
import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.utils.Progress;

/**
 * This class is the base class used by the other output classes. It can be used
 * outside of this package, and have static method that you can use to get
 * access to the correct support class.
 * 
 * @author niki
 */
public abstract class BasicOutput {
	/**
	 * The supported output types for which we can get a {@link BasicOutput}
	 * object.
	 * 
	 * @author niki
	 */
	public enum OutputType {
		/** EPUB files created with this program */
		EPUB,
		/** Pure text file with some rules */
		TEXT,
		/** TEXT but with associated .info file */
		INFO_TEXT,
		/** DEBUG output to console */
		SYSOUT,
		/** ZIP with (PNG) images */
		CBZ,
		/** LaTeX file with "book" template */
		LATEX,
		/** HTML files in a dedicated directory */
		HTML,

		;

		public String toString() {
			return super.toString().toLowerCase();
		}

		/**
		 * A description of this output type.
		 * 
		 * @param longDesc
		 *            TRUE for the long description, FALSE for the short one
		 * 
		 * @return the description
		 */
		public String getDesc(boolean longDesc) {
			StringId id = longDesc ? StringId.OUTPUT_DESC
					: StringId.OUTPUT_DESC_SHORT;

			String desc = Instance.getTrans().getStringX(id, this.name());

			if (desc == null) {
				desc = Instance.getTrans().getString(id, this);
			}

			return desc;
		}

		/**
		 * The default extension to add to the output files.
		 * 
		 * @param readerTarget
		 *            the target to point to to read the {@link Story} (for
		 *            instance, the main entry point if this {@link Story} is in
		 *            a directory bundle)
		 * 
		 * @return the extension
		 */
		public String getDefaultExtension(boolean readerTarget) {
			BasicOutput output = BasicOutput.getOutput(this, false);
			if (output != null) {
				return output.getDefaultExtension(readerTarget);
			}

			return null;
		}

		/**
		 * Call {@link OutputType#valueOf(String.toUpperCase())}.
		 * 
		 * @param typeName
		 *            the possible type name
		 * 
		 * @return NULL or the type
		 */
		public static OutputType valueOfUC(String typeName) {
			return OutputType.valueOf(typeName == null ? null : typeName
					.toUpperCase());
		}

		/**
		 * Call {@link OutputType#valueOf(String.toUpperCase())} but return NULL
		 * for NULL and empty instead of raising an exception.
		 * 
		 * @param typeName
		 *            the possible type name
		 * 
		 * @return NULL or the type
		 */
		public static OutputType valueOfNullOkUC(String typeName) {
			if (typeName == null || typeName.isEmpty()) {
				return null;
			}

			return OutputType.valueOfUC(typeName);
		}

		/**
		 * Call {@link OutputType#valueOf(String.toUpperCase())} but return NULL
		 * in case of error instead of raising an exception.
		 * 
		 * @param typeName
		 *            the possible type name
		 * 
		 * @return NULL or the type
		 */
		public static OutputType valueOfAllOkUC(String typeName) {
			try {
				return OutputType.valueOfUC(typeName);
			} catch (Exception e) {
				return null;
			}
		}
	}

	/** The creator name (this program, by me!) */
	static final String EPUB_CREATOR = "Fanfix (by Niki)";

	/** The current best name for an image */
	private String imageName;
	private File targetDir;
	private String targetName;
	private OutputType type;
	private boolean writeCover;
	private boolean writeInfo;
	private Progress storyPg;
	private Progress chapPg;

	/**
	 * Process the {@link Story} into the given target.
	 * 
	 * @param story
	 *            the {@link Story} to export
	 * @param target
	 *            the target where to save to (will not necessary be taken as is
	 *            by the processor, for instance an extension can be added)
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the actual main target saved, which can be slightly different
	 *         that the input one
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	public File process(Story story, String target, Progress pg)
			throws IOException {
		storyPg = pg;

		target = new File(target).getAbsolutePath();
		File targetDir = new File(target).getParentFile();
		String targetName = new File(target).getName();

		String ext = getDefaultExtension(false);
		if (ext != null && !ext.isEmpty()) {
			if (targetName.toLowerCase().endsWith(ext)) {
				targetName = targetName.substring(0,
						targetName.length() - ext.length());
			}
		}

		return process(story, targetDir, targetName);
	}

	/**
	 * Process the {@link Story} into the given target.
	 * <p>
	 * This method is expected to be overridden in most cases.
	 * 
	 * @param story
	 *            the {@link Story} to export
	 * @param targetDir
	 *            the target dir where to save to
	 * @param targetName
	 *            the target filename (will not necessary be taken as is by the
	 *            processor, for instance an extension can be added)
	 * 
	 * 
	 * @return the actual main target saved, which can be slightly different
	 *         that the input one
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected File process(Story story, File targetDir, String targetName)
			throws IOException {
		this.targetDir = targetDir;
		this.targetName = targetName;

		writeStory(story);

		return null;
	}

	/**
	 * The output type.
	 * 
	 * @return the type
	 */
	public OutputType getType() {
		return type;
	}

	/**
	 * The output type.
	 * 
	 * @param type
	 *            the new type
	 * @param infoCover
	 *            TRUE to enable the creation of a .info file and a cover if
	 *            possible
	 * 
	 * @return this
	 */
	protected BasicOutput setType(OutputType type, boolean writeCover,
			boolean writeInfo) {
		this.type = type;
		this.writeCover = writeCover;
		this.writeInfo = writeInfo;

		return this;
	}

	/**
	 * The default extension to add to the output files.
	 * 
	 * @param readerTarget
	 *            the target to point to to read the {@link Story} (for
	 *            instance, the main entry point if this {@link Story} is in a
	 *            directory bundle)
	 * 
	 * @return the extension
	 */
	public String getDefaultExtension(boolean readerTarget) {
		return "";
	}

	protected void writeStoryHeader(Story story) throws IOException {
	}

	protected void writeChapterHeader(Chapter chap) throws IOException {
	}

	protected void writeParagraphHeader(Paragraph para) throws IOException {
	}

	protected void writeStoryFooter(Story story) throws IOException {
	}

	protected void writeChapterFooter(Chapter chap) throws IOException {
	}

	protected void writeParagraphFooter(Paragraph para) throws IOException {
	}

	protected void writeStory(Story story) throws IOException {
		if (storyPg == null) {
			storyPg = new Progress(0, story.getChapters().size() + 2);
		} else {
			storyPg.setMinMax(0, story.getChapters().size() + 2);
		}

		String chapterNameNum = String.format("%03d", 0);
		String paragraphNumber = String.format("%04d", 0);
		imageName = paragraphNumber + "_" + chapterNameNum + ".png";

		if (story.getMeta() != null) {
			story.getMeta().setType("" + getType());
		}

		if (writeCover) {
			InfoCover.writeCover(targetDir, targetName, story.getMeta());
		}
		if (writeInfo) {
			InfoCover.writeInfo(targetDir, targetName, story.getMeta());
		}

		storyPg.setProgress(1);

		List<Progress> chapPgs = new ArrayList<Progress>(story.getChapters()
				.size());
		for (Chapter chap : story) {
			chapPg = new Progress(0, chap.getParagraphs().size());
			storyPg.addProgress(chapPg, 1);
			chapPgs.add(chapPg);
			chapPg = null;
		}

		writeStoryHeader(story);
		for (int i = 0; i < story.getChapters().size(); i++) {
			chapPg = chapPgs.get(i);
			writeChapter(story.getChapters().get(i));
			chapPg.setProgress(chapPg.getMax());
			chapPg = null;
		}
		writeStoryFooter(story);

		storyPg.setProgress(storyPg.getMax());
		storyPg = null;
	}

	protected void writeChapter(Chapter chap) throws IOException {
		String chapterNameNum;
		if (chap.getName() == null || chap.getName().isEmpty()) {
			chapterNameNum = String.format("%03d", chap.getNumber());
		} else {
			chapterNameNum = String.format("%03d", chap.getNumber()) + "_"
					+ chap.getName().replace(" ", "_");
		}

		int num = 0;
		String paragraphNumber = String.format("%04d", num++);
		imageName = chapterNameNum + "_" + paragraphNumber + ".png";

		writeChapterHeader(chap);
		int i = 1;
		for (Paragraph para : chap) {
			paragraphNumber = String.format("%04d", num++);
			imageName = chapterNameNum + "_" + paragraphNumber + ".png";
			writeParagraph(para);
			if (chapPg != null) {
				chapPg.setProgress(i++);
			}
		}
		writeChapterFooter(chap);
	}

	protected void writeParagraph(Paragraph para) throws IOException {
		writeParagraphHeader(para);
		writeTextLine(para.getType(), para.getContent());
		writeParagraphFooter(para);
	}

	protected void writeTextLine(ParagraphType type, String line)
			throws IOException {
	}

	/**
	 * Return the current best guess for an image name, based upon the current
	 * {@link Chapter} and {@link Paragraph}.
	 * 
	 * @param prefix
	 *            add the original target name as a prefix
	 * 
	 * @return the guessed name
	 */
	protected String getCurrentImageBestName(boolean prefix) {
		if (prefix) {
			return targetName + "_" + imageName;
		}

		return imageName;
	}

	/**
	 * Return the given word or sentence as <b>bold</b>.
	 * 
	 * @param word
	 *            the input
	 * 
	 * @return the bold output
	 */
	protected String enbold(String word) {
		return word;
	}

	/**
	 * Return the given word or sentence as <i>italic</i>.
	 * 
	 * @param word
	 *            the input
	 * 
	 * @return the italic output
	 */
	protected String italize(String word) {
		return word;
	}

	/**
	 * Decorate the given text with <b>bold</b> and <i>italic</i> words,
	 * according to {@link BasicOutput#enbold(String)} and
	 * {@link BasicOutput#italize(String)}.
	 * 
	 * @param text
	 *            the input
	 * 
	 * @return the decorated output
	 */
	protected String decorateText(String text) {
		StringBuilder builder = new StringBuilder();

		int bold = -1;
		int italic = -1;
		char prev = '\0';
		for (char car : text.toCharArray()) {
			switch (car) {
			case '*':
				if (bold >= 0 && prev != ' ') {
					String data = builder.substring(bold);
					builder.setLength(bold);
					builder.append(enbold(data));
					bold = -1;
				} else if (bold < 0
						&& (prev == ' ' || prev == '\0' || prev == '\n')) {
					bold = builder.length();
				} else {
					builder.append(car);
				}

				break;
			case '_':
				if (italic >= 0 && prev != ' ') {
					String data = builder.substring(italic);
					builder.setLength(italic);
					builder.append(enbold(data));
					italic = -1;
				} else if (italic < 0
						&& (prev == ' ' || prev == '\0' || prev == '\n')) {
					italic = builder.length();
				} else {
					builder.append(car);
				}

				break;
			default:
				builder.append(car);
				break;
			}

			prev = car;
		}

		if (bold >= 0) {
			builder.insert(bold, '*');
		}

		if (italic >= 0) {
			builder.insert(italic, '_');
		}

		return builder.toString();
	}

	/**
	 * Return a {@link BasicOutput} object compatible with the given
	 * {@link OutputType}.
	 * 
	 * @param type
	 *            the type
	 * @param infoCover
	 *            force the <tt>.info</tt> file and the cover to be saved next
	 *            to the main target file
	 * 
	 * @return the {@link BasicOutput}
	 */
	public static BasicOutput getOutput(OutputType type, boolean infoCover) {
		if (type != null) {
			switch (type) {
			case EPUB:
				return new Epub().setType(type, infoCover, infoCover);
			case TEXT:
				return new Text().setType(type, true, infoCover);
			case INFO_TEXT:
				return new InfoText().setType(type, true, true);
			case SYSOUT:
				return new Sysout().setType(type, false, false);
			case CBZ:
				return new Cbz().setType(type, infoCover, infoCover);
			case LATEX:
				return new LaTeX().setType(type, infoCover, infoCover);
			case HTML:
				return new Html().setType(type, infoCover, infoCover);
			}
		}

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