backend/oni/OniSplit.java

package net.oni2.aeinstaller.backend.oni;

import java.io.File;
import java.io.IOException;
import java.util.Vector;

import net.oni2.aeinstaller.backend.AppExecution;
import net.oni2.aeinstaller.backend.CaseInsensitiveFile;
import net.oni2.aeinstaller.backend.DotNet;
import net.oni2.aeinstaller.backend.Paths;
import net.oni2.aeinstaller.backend.Settings;
import net.oni2.aeinstaller.backend.Settings.Platform;

/**
 * @author Christian Illy
 */
public class OniSplit {

        /**
         * @return Is Onisplit installed?
         */
        public static boolean isOniSplitInstalled() {
                return getProgramFile().exists();
        }

        /**
         * Export given dat-file to target folder
         * 
         * @param targetFolder
         *            Target folder
         * @param input
         *            Dat file
         * @return OniSplit output
         */
        public static Vector<String> export(File targetFolder, File input) {
                return export(targetFolder, input, null);
        }

        /**
         * Export named resources from given dat-file to target folder
         * 
         * @param targetFolder
         *            Target folder
         * @param input
         *            Dat file
         * @param pattern
         *            Filename pattern for files to export
         * @return OniSplit output
         */
        public static Vector<String> export(File targetFolder, File input,
                        String pattern) {
                if (!targetFolder.exists())
                        targetFolder.mkdir();

                Vector<String> cmdLine = getProgramInvocation();
                if (pattern == null)
                        cmdLine.add("-export");
                else
                        cmdLine.add("-export:" + pattern);
                cmdLine.add(targetFolder.getPath());
                cmdLine.add(input.getPath());
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * Import given folder to a .dat-file
         * 
         * @param sourceFolders
         *            Folders containing .oni-files
         * @param targetFile
         *            Target .dat-file
         * @return OniSplit output
         */
        public static Vector<String> importLevel(Vector<File> sourceFolders,
                        File targetFile) {
                Vector<String> cmdLine = getProgramInvocation();
                cmdLine.add(getImportParam());
                for (File f : sourceFolders)
                        cmdLine.add(f.getPath());
                cmdLine.add(targetFile.getPath());
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * Pack a level to a .dat-file. More powerful variant which allows
         * specifying single .oni/.dat files
         * 
         * @param sourceFoldersFiles
         *            Folders (for recursive .oni import) or files (.dat and single
         *            .oni) to import
         * @param targetFile
         *            Target .dat-file
         * @return OniSplit output
         */
        public static Vector<String> packLevel(Vector<File> sourceFoldersFiles,
                        File targetFile) {
                Vector<String> cmdLine = getProgramInvocation();
                cmdLine.add(getPackParam());
                cmdLine.add(getPackTypeParam());
                cmdLine.add("-out");
                cmdLine.add(targetFile.getPath());
                for (File f : sourceFoldersFiles)
                        cmdLine.add(f.getPath());
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * Move files from one location to another using OniSplit so relations are
         * handled
         * 
         * @param targetFolder
         *            Target folder for files
         * @param input
         *            Files to move, can contain wildcards
         * @param moveParameter
         *            e.g. overwrite, delete
         * @return OniSplit output
         */
        public static Vector<String> move(File targetFolder, String input,
                        String moveParameter) {
                if (!targetFolder.exists())
                        targetFolder.mkdir();

                Vector<String> cmdLine = getProgramInvocation();
                cmdLine.add("-move"
                                + (moveParameter != null ? ":" + moveParameter : ""));
                cmdLine.add(targetFolder.getPath());
                cmdLine.add(input);
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * Convert given .oni-files to XML and put them in target folder
         * 
         * @param targetFolder
         *            Target folder
         * @param inputFiles
         *            .oni files
         * @return OniSplit output
         */
        public static Vector<String> convertOniToXML(File targetFolder,
                        Vector<File> inputFiles) {
                if (!targetFolder.exists())
                        targetFolder.mkdirs();

                Vector<String> cmdLine = getProgramInvocation();
                cmdLine.add("-extract:xml");
                cmdLine.add(targetFolder.getPath());
                for (File f : inputFiles) {
                        cmdLine.add(f.getPath());
                }
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * Convert given XML-files to .oni and put them in target folder
         * 
         * @param targetFolder
         *            Target folder
         * @param inputFiles
         *            XML-files
         * @return OniSplit output
         */
        public static Vector<String> convertXMLtoOni(File targetFolder,
                        Vector<File> inputFiles) {
                if (!targetFolder.exists())
                        targetFolder.mkdirs();

                Vector<String> cmdLine = getProgramInvocation();
                cmdLine.add("-create");
                cmdLine.add(targetFolder.getPath());
                for (File f : inputFiles) {
                        cmdLine.add(f.getPath());
                }
                Vector<String> res = null;
                try {
                        res = AppExecution.executeAndWait(cmdLine);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        private static String getImportParam() {
                if (Settings.getPlatform() == Platform.MACOS)
                        return "-import:sep";
                else
                        return "-import:nosep";
        }

        private static String getPackParam() {
                return "pack";
        }

        private static String getPackTypeParam() {
                if (Settings.getPlatform() == Platform.MACOS)
                        return "-type:macintel";
                else
                        return "-type:pc";
        }

        private static Vector<String> getProgramInvocation() {
                Vector<String> res = new Vector<String>();
                if (DotNet.getRuntimeExe().length() > 0)
                        res.add(DotNet.getRuntimeExe());
                res.add(getProgramFile().getPath());
                return res;
        }

        private static File getProgramFile() {
                File toolsPath = CaseInsensitiveFile.getCaseInsensitiveFile(Paths.getEditionBasePath(), "Tools");
                return CaseInsensitiveFile.getCaseInsensitiveFile(toolsPath, "Onisplit.exe");
        }
}
Revision:	699
Committed:	Sun Mar 17 17:52:08 2013 UTC (12 years, 6 months ago) by alloc
Content type:	text/x-java
File size:	6227 byte(s)
Log Message:	AEI2 0.99t: - Access to files/folders which can be different in case because of user interaction are now case insensitive - Few cleanups
#	Content
1	package net.oni2.aeinstaller.backend.oni;
2
3	import java.io.File;
4	import java.io.IOException;
5	import java.util.Vector;
6
7	import net.oni2.aeinstaller.backend.AppExecution;
8	import net.oni2.aeinstaller.backend.CaseInsensitiveFile;
9	import net.oni2.aeinstaller.backend.DotNet;
10	import net.oni2.aeinstaller.backend.Paths;
11	import net.oni2.aeinstaller.backend.Settings;
12	import net.oni2.aeinstaller.backend.Settings.Platform;
13
14	/**
15	* @author Christian Illy
16	*/
17	public class OniSplit {
18
19	/**
20	* @return Is Onisplit installed?
21	*/
22	public static boolean isOniSplitInstalled() {
23	return getProgramFile().exists();
24	}
25
26	/**
27	* Export given dat-file to target folder
28	*
29	* @param targetFolder
30	* Target folder
31	* @param input
32	* Dat file
33	* @return OniSplit output
34	*/
35	public static Vector<String> export(File targetFolder, File input) {
36	return export(targetFolder, input, null);
37	}
38
39	/**
40	* Export named resources from given dat-file to target folder
41	*
42	* @param targetFolder
43	* Target folder
44	* @param input
45	* Dat file
46	* @param pattern
47	* Filename pattern for files to export
48	* @return OniSplit output
49	*/
50	public static Vector<String> export(File targetFolder, File input,
51	String pattern) {
52	if (!targetFolder.exists())
53	targetFolder.mkdir();
54
55	Vector<String> cmdLine = getProgramInvocation();
56	if (pattern == null)
57	cmdLine.add("-export");
58	else
59	cmdLine.add("-export:" + pattern);
60	cmdLine.add(targetFolder.getPath());
61	cmdLine.add(input.getPath());
62	Vector<String> res = null;
63	try {
64	res = AppExecution.executeAndWait(cmdLine);
65	} catch (IOException e) {
66	e.printStackTrace();
67	}
68	return res;
69	}
70
71	/**
72	* Import given folder to a .dat-file
73	*
74	* @param sourceFolders
75	* Folders containing .oni-files
76	* @param targetFile
77	* Target .dat-file
78	* @return OniSplit output
79	*/
80	public static Vector<String> importLevel(Vector<File> sourceFolders,
81	File targetFile) {
82	Vector<String> cmdLine = getProgramInvocation();
83	cmdLine.add(getImportParam());
84	for (File f : sourceFolders)
85	cmdLine.add(f.getPath());
86	cmdLine.add(targetFile.getPath());
87	Vector<String> res = null;
88	try {
89	res = AppExecution.executeAndWait(cmdLine);
90	} catch (IOException e) {
91	e.printStackTrace();
92	}
93	return res;
94	}
95
96	/**
97	* Pack a level to a .dat-file. More powerful variant which allows
98	* specifying single .oni/.dat files
99	*
100	* @param sourceFoldersFiles
101	* Folders (for recursive .oni import) or files (.dat and single
102	* .oni) to import
103	* @param targetFile
104	* Target .dat-file
105	* @return OniSplit output
106	*/
107	public static Vector<String> packLevel(Vector<File> sourceFoldersFiles,
108	File targetFile) {
109	Vector<String> cmdLine = getProgramInvocation();
110	cmdLine.add(getPackParam());
111	cmdLine.add(getPackTypeParam());
112	cmdLine.add("-out");
113	cmdLine.add(targetFile.getPath());
114	for (File f : sourceFoldersFiles)
115	cmdLine.add(f.getPath());
116	Vector<String> res = null;
117	try {
118	res = AppExecution.executeAndWait(cmdLine);
119	} catch (IOException e) {
120	e.printStackTrace();
121	}
122	return res;
123	}
124
125	/**
126	* Move files from one location to another using OniSplit so relations are
127	* handled
128	*
129	* @param targetFolder
130	* Target folder for files
131	* @param input
132	* Files to move, can contain wildcards
133	* @param moveParameter
134	* e.g. overwrite, delete
135	* @return OniSplit output
136	*/
137	public static Vector<String> move(File targetFolder, String input,
138	String moveParameter) {
139	if (!targetFolder.exists())
140	targetFolder.mkdir();
141
142	Vector<String> cmdLine = getProgramInvocation();
143	cmdLine.add("-move"
144	+ (moveParameter != null ? ":" + moveParameter : ""));
145	cmdLine.add(targetFolder.getPath());
146	cmdLine.add(input);
147	Vector<String> res = null;
148	try {
149	res = AppExecution.executeAndWait(cmdLine);
150	} catch (IOException e) {
151	e.printStackTrace();
152	}
153	return res;
154	}
155
156	/**
157	* Convert given .oni-files to XML and put them in target folder
158	*
159	* @param targetFolder
160	* Target folder
161	* @param inputFiles
162	* .oni files
163	* @return OniSplit output
164	*/
165	public static Vector<String> convertOniToXML(File targetFolder,
166	Vector<File> inputFiles) {
167	if (!targetFolder.exists())
168	targetFolder.mkdirs();
169
170	Vector<String> cmdLine = getProgramInvocation();
171	cmdLine.add("-extract:xml");
172	cmdLine.add(targetFolder.getPath());
173	for (File f : inputFiles) {
174	cmdLine.add(f.getPath());
175	}
176	Vector<String> res = null;
177	try {
178	res = AppExecution.executeAndWait(cmdLine);
179	} catch (IOException e) {
180	e.printStackTrace();
181	}
182	return res;
183	}
184
185	/**
186	* Convert given XML-files to .oni and put them in target folder
187	*
188	* @param targetFolder
189	* Target folder
190	* @param inputFiles
191	* XML-files
192	* @return OniSplit output
193	*/
194	public static Vector<String> convertXMLtoOni(File targetFolder,
195	Vector<File> inputFiles) {
196	if (!targetFolder.exists())
197	targetFolder.mkdirs();
198
199	Vector<String> cmdLine = getProgramInvocation();
200	cmdLine.add("-create");
201	cmdLine.add(targetFolder.getPath());
202	for (File f : inputFiles) {
203	cmdLine.add(f.getPath());
204	}
205	Vector<String> res = null;
206	try {
207	res = AppExecution.executeAndWait(cmdLine);
208	} catch (IOException e) {
209	e.printStackTrace();
210	}
211	return res;
212	}
213
214	private static String getImportParam() {
215	if (Settings.getPlatform() == Platform.MACOS)
216	return "-import:sep";
217	else
218	return "-import:nosep";
219	}
220
221	private static String getPackParam() {
222	return "pack";
223	}
224
225	private static String getPackTypeParam() {
226	if (Settings.getPlatform() == Platform.MACOS)
227	return "-type:macintel";
228	else
229	return "-type:pc";
230	}
231
232	private static Vector<String> getProgramInvocation() {
233	Vector<String> res = new Vector<String>();
234	if (DotNet.getRuntimeExe().length() > 0)
235	res.add(DotNet.getRuntimeExe());
236	res.add(getProgramFile().getPath());
237	return res;
238	}
239
240	private static File getProgramFile() {
241	File toolsPath = CaseInsensitiveFile.getCaseInsensitiveFile(Paths.getEditionBasePath(), "Tools");
242	return CaseInsensitiveFile.getCaseInsensitiveFile(toolsPath, "Onisplit.exe");
243	}
244	}