├── .classpath
├── .gitignore
├── .project
├── .settings
    └── org.eclipse.jdt.core.prefs
├── README.md
├── lib
    ├── CodecJOrbis.jar
    ├── JOrbisStandalone.jar
    └── gson-2.8.2.jar
├── release
    ├── CellPacker.jar
    ├── CellPacker_Modloader.jar
    └── CellPacker_old_2.0.jar
├── scripts
    ├── dark.patch
    └── time.patch
└── src
    ├── dev
        └── lb
        │   └── cellpacker
        │       ├── CellPackerMain.java
        │       ├── Logger.java
        │       ├── NamedRange.java
        │       ├── TextAreaPrintStream.java
        │       ├── Utils.java
        │       ├── annotation
        │           ├── Async.java
        │           ├── Calculated.java
        │           ├── Shortcut.java
        │           └── Unmodifiable.java
        │       ├── controls
        │           ├── CheckBoxList.java
        │           ├── JAudioPlayer.java
        │           ├── JDraggableScrollPane.java
        │           ├── JHistoryTextField.java
        │           ├── JImageViewer.java
        │           ├── JSpriteViewer.java
        │           ├── LaunchWindow.java
        │           ├── MainWindow.java
        │           ├── SpriteSavingList.java
        │           └── TutorialWindow.java
        │       └── structure
        │           ├── ByteData.java
        │           ├── NamedObject.java
        │           ├── ResourceCategory.java
        │           ├── ResourceContainer.java
        │           ├── ResourceFile.java
        │           ├── ResourceViewManager.java
        │           ├── Script.java
        │           ├── SearchableResourceViewManager.java
        │           ├── ViewCategory.java
        │           ├── cdb
        │               ├── CDBFile.java
        │               ├── Column.java
        │               ├── Line.java
        │               ├── ScriptReader.java
        │               ├── Sheet.java
        │               └── SheetProps.java
        │           ├── resource
        │               ├── AtlasResource.java
        │               ├── CompoundAtlasResource.java
        │               ├── FontResource.java
        │               ├── ImageResource.java
        │               ├── JsonResource.java
        │               ├── Resource.java
        │               └── SoundResource.java
        │           └── view
        │               ├── AtlasImageResourceView.java
        │               ├── CastleDBResourceView.java
        │               ├── FontResourceView.java
        │               ├── JsonResourceView.java
        │               ├── ResourceView.java
        │               ├── SingleResourceView.java
        │               └── StaticResourceView.java
    └── resources
        └── ico.png


/.classpath:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <classpath>
 3 | 	<classpathentry kind="src" path="src"/>
 4 | 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 5 | 	<classpathentry kind="lib" path="lib/CodecJOrbis.jar"/>
 6 | 	<classpathentry kind="lib" path="lib/JOrbisStandalone.jar"/>
 7 | 	<classpathentry kind="lib" path="lib/gson-2.8.2.jar">
 8 | 		<attributes>
 9 | 			<attribute name="javadoc_location" value="jar:file:/D:/Lars/Prgm/WorkspaceEclipse/APIS/gson-2.8.4-javadoc.jar!/"/>
10 | 		</attributes>
11 | 	</classpathentry>
12 | 	<classpathentry kind="output" path="bin"/>
13 | </classpath>
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /bin/
2 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>CellPacker</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.jdt.core.javabuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 	</buildSpec>
14 | 	<natures>
15 | 		<nature>org.eclipse.jdt.core.javanature</nature>
16 | 	</natures>
17 | </projectDescription>
18 | 


--------------------------------------------------------------------------------
/.settings/org.eclipse.jdt.core.prefs:
--------------------------------------------------------------------------------
 1 | eclipse.preferences.version=1
 2 | org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 3 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 4 | org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
 5 | org.eclipse.jdt.core.compiler.compliance=1.8
 6 | org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 7 | org.eclipse.jdt.core.compiler.debug.localVariable=generate
 8 | org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 9 | org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
10 | org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
11 | org.eclipse.jdt.core.compiler.source=1.8
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # CellPacker [Outdated]
 2 | 
 3 | **Dead Cells now has its own 
 4 | (basic) modding tools.** This project is no longer required and might not support newer versions of the game.
 5 | 
 6 | CellPacker can still be used as a resource viewer and editor (unless the res.pak format changes in the future), but can **not** be
 7 | used to create mods compatible with the Steam workshop
 8 | 
 9 | ## [Old description below]
10 | 
11 | A modding utility for Dead Cells  
12 | 
13 | Version 2.1 of CellPacker: Information and Help
14 | Please read this file before using the program.
15 | The compiled file can be found [here](https://github.com/ReBuilders101/CellPacker/raw/master/release/CellPacker.jar).
16 |   
17 | --------------------------------------------------------------------------------------------------------
18 | CellPacker is an application to view and modify the resources used by the game Dead Cells.  
19 | **NOTE:** The format of the Dead Cells resource file can change at any time and there is no official
20 | 	documentation. This program was designed to be used with the Baguette Update, but will most
21 | 	likely also work on newer and older versions.  
22 |   
23 | --------------------------------------------------------------------------------------------------------
24 | ### Features:  
25 | 
26 | 1. View all images/textures of the game that are stored in the resource file
27 | 2. Play all sounds stored in the resource files
28 | 3. Group connected resources into views, so they are easier to find
29 | 4. Export all resources as files (PNG for images, OGG for sounds)
30 | 5. Search for resources
31 | 6. Replace reources with custom ones. This way you can create your own textures or sounds for the game
32 | 7. Re-pack the modified file so it can be used by Dead Cells 
33 | 8. ~~A launcher that lets you run scripts to modify the resources, so you can choose if you want to play with modifications without opening the editor~~
34 | 9. Editing of the game data, either with a text editor or with the external program [CastleDB](http://castledb.org/) (recommended)
35 | 
36 |   
37 | --------------------------------------------------------------------------------------------------------
38 | ### How to use:  
39 | #### Download
40 | [CellPacker Download](https://github.com/ReBuilders101/CellPacker/raw/master/release/CellPacker.jar)
41 | ##### Editor
42 | 1. CellPacker.jar can be run from any folder. Double-click to execute (Java 8 or newer must be installed)
43 | 2. Use File>Open to open the res.pak file in your Dead Cells folder (usually found at <Steam folder>/steamapps/common/Dead Cells/)
44 | 3. On the right, a tree with all found resources will appear. Click on an item to see the resource.
45 | 4. To replace a resource or to export it to a file, select Edit>Resource Options and choose your option.
46 | **IMPORTANT:** When replacing images, make sure the replacement has the same size (pixles, not bytes) as the original.
47 | 5. You can always restore a modified resource to its original state with the Resource Options menu.
48 | 6. To create a version containing your changes that is useable by Dead Cells, simply use File>Save and overwrite the
49 | existing res.pak file. Mare sure to back up the original file before.
50 |   
51 | ##### ~~Scripting~~
52 | The scripting feature was never fully implemented and was made obsolete when modding through the Steam Workshop was introduced
53 | 
54 | ##### Uninstall
55 | CellPacker does not create any permanent files. Simply delete the CellPacker.jar file to delete the program from your computer.
56 | 
57 | --------------------------------------------------------------------------------------------------------  
58 | ### Compiled files and code:
59 | ##### Compiled files
60 | Use the CellPacker.jar in the release folder.
61 | ##### If you want to compile the code:
62 | This repository contains a full eclipse project, you can just clone and import it. It will probably also work with any other IDE.
63 | All jar files in the `lib` folder are dependencies.
64 |   
65 | --------------------------------------------------------------------------------------------------------
66 | ### License:  
67 | Basic:
68 | * Do whatever you want.
69 |   
70 | But: 
71 | * Please don't claim that you made this. It's not nice.
72 | * Feel free to take any code from this project and use it for your own project.
73 | 
74 | Also: 
75 | * If Dead Cells breaks, it is not my fault.
76 | 
77 | ##### Third Party Licenses and Credits:
78 | This program uses the following third party librarys:
79 | - CodecJOrbis by Paul Lamb (http://paulscode.com), because Java does not support the OGG sound format.
80 | - Gson (under the Apache License 2.0, can be found at http://www.apache.org/licenses/LICENSE-2.0) to parse JSON.
81 | 


--------------------------------------------------------------------------------
/lib/CodecJOrbis.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/lib/CodecJOrbis.jar


--------------------------------------------------------------------------------
/lib/JOrbisStandalone.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/lib/JOrbisStandalone.jar


--------------------------------------------------------------------------------
/lib/gson-2.8.2.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/lib/gson-2.8.2.jar


--------------------------------------------------------------------------------
/release/CellPacker.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/release/CellPacker.jar


--------------------------------------------------------------------------------
/release/CellPacker_Modloader.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/release/CellPacker_Modloader.jar


--------------------------------------------------------------------------------
/release/CellPacker_old_2.0.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/release/CellPacker_old_2.0.jar


--------------------------------------------------------------------------------
/scripts/dark.patch:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"add": {
  3 | 		"sheets":[
  4 | 			{
  5 | 				"CPWHERE": {
  6 | 					"id": "name",
  7 | 					"value": "level"
  8 | 				},
  9 | 				"lines": [
 10 | 					{
 11 | 						"CPWHERE": {
 12 | 							"id": "id",
 13 | 							"value": "PrisonStart"
 14 | 						},
 15 | 						"flags": 64
 16 | 					},
 17 | 					{
 18 | 						"CPWHERE": {
 19 | 							"id": "id",
 20 | 							"value": "PrisonCourtyard"
 21 | 						},
 22 | 						"flags": 65
 23 | 					},
 24 | 					{
 25 | 						"CPWHERE": {
 26 | 							"id": "id",
 27 | 							"value": "PrisonDepths"
 28 | 						},
 29 | 						"flags": 64
 30 | 					},
 31 | 					{
 32 | 						"CPWHERE": {
 33 | 							"id": "id",
 34 | 							"value": "SewerShort"
 35 | 						},
 36 | 						"flags": 72
 37 | 					},
 38 | 					{
 39 | 						"CPWHERE": {
 40 | 							"id": "id",
 41 | 							"value": "PrisonStart"
 42 | 						},
 43 | 						"flags": 64
 44 | 					},
 45 | 					{
 46 | 						"CPWHERE": {
 47 | 							"id": "id",
 48 | 							"value": "PrisonRoof"
 49 | 						},
 50 | 						"flags": 65
 51 | 					},
 52 | 					{
 53 | 						"CPWHERE": {
 54 | 							"id": "id",
 55 | 							"value": "SewerDepths"
 56 | 						},
 57 | 						"flags": 72
 58 | 					},
 59 | 					{
 60 | 						"CPWHERE": {
 61 | 							"id": "id",
 62 | 							"value": "Ossuary"
 63 | 						},
 64 | 						"flags": 64
 65 | 					},
 66 | 					{
 67 | 						"CPWHERE": {
 68 | 							"id": "id",
 69 | 							"value": "StiltVillage"
 70 | 						},
 71 | 						"flags": 325
 72 | 					},
 73 | 					{
 74 | 						"CPWHERE": {
 75 | 							"id": "id",
 76 | 							"value": "AncientTemple"
 77 | 						},
 78 | 						"flags": 64
 79 | 					},
 80 | 					{
 81 | 						"CPWHERE": {
 82 | 							"id": "id",
 83 | 							"value": "Cemetery"
 84 | 						},
 85 | 						"flags": 65
 86 | 					},
 87 | 					{
 88 | 						"CPWHERE": {
 89 | 							"id": "id",
 90 | 							"value": "ClockTower"
 91 | 						},
 92 | 						"flags": 192
 93 | 					}
 94 | 				]
 95 | 			}
 96 | 			,
 97 | 			{
 98 | 				"CPWHERE": {
 99 | 					"id": "name",
100 | 					"value": "room"
101 | 				},
102 | 				"lines": [
103 | 					{
104 | 						"CPWHERE": {
105 | 							"id": "id",
106 | 							"value": "PrisonFlaskRoom"
107 | 						},
108 | 						"markers": [
109 | 							{
110 | 								"x": 28,
111 | 								"y": 30,
112 | 								"marker": "DarknessRemover",
113 | 								"width": 1,
114 | 								"height": 1,
115 | 								"customId": "-7"
116 | 							},
117 | 							{
118 | 								"x": 93,
119 | 								"y": 28,
120 | 								"marker": "DarknessRemover",
121 | 								"width": 1,
122 | 								"height": 1,
123 | 								"customId": "-7"
124 | 							},
125 | 							{
126 | 								"x": 83,
127 | 								"y": 26,
128 | 								"marker": "DarknessRemover",
129 | 								"width": 1,
130 | 								"height": 1,
131 | 								"customId": "-7"
132 | 							},
133 | 							{
134 | 								"x": 51,
135 | 								"y": 26,
136 | 								"marker": "DarknessRemover",
137 | 								"width": 1,
138 | 								"height": 1,
139 | 								"customId": "-7"
140 | 							}
141 | 						]
142 | 					},
143 | 					{
144 | 						"CPWHERE": {
145 | 							"id": "id",
146 | 							"value": "Exit_LR"
147 | 						},
148 | 						"markers": [
149 | 							{
150 | 								"x": 3,
151 | 								"y": 7,
152 | 								"marker": "DarknessRemover",
153 | 								"width": 1,
154 | 								"height": 1,
155 | 								"customId": "-7"
156 | 							},
157 | 							{
158 | 								"x": 11,
159 | 								"y": 7,
160 | 								"marker": "DarknessRemover",
161 | 								"width": 1,
162 | 								"height": 1,
163 | 								"customId": "-7"
164 | 							}
165 | 						]
166 | 					},
167 | 					{
168 | 						"CPWHERE": {
169 | 							"id": "id",
170 | 							"value": "Exit_LDR"
171 | 						},
172 | 						"markers": [
173 | 							{
174 | 								"x": 6,
175 | 								"y": 6,
176 | 								"marker": "DarknessRemover",
177 | 								"width": 1,
178 | 								"height": 1,
179 | 								"customId": "-7"
180 | 							},
181 | 							{
182 | 								"x": 16,
183 | 								"y": 6,
184 | 								"marker": "DarknessRemover",
185 | 								"width": 1,
186 | 								"height": 1,
187 | 								"customId": "-7"
188 | 							}
189 | 						]
190 | 					},
191 | 					{
192 | 						"CPWHERE": {
193 | 							"id": "id",
194 | 							"value": "Exit_UL"
195 | 						},
196 | 						"markers": [
197 | 							{
198 | 								"x": 7,
199 | 								"y": 5,
200 | 								"marker": "DarknessRemover",
201 | 								"width": 1,
202 | 								"height": 1,
203 | 								"customId": "-7"
204 | 							}
205 | 						]
206 | 					},
207 | 					{
208 | 						"CPWHERE": {
209 | 							"id": "id",
210 | 							"value": "Exit_DL"
211 | 						},
212 | 						"markers": [
213 | 							{
214 | 								"x": 9,
215 | 								"y": 11,
216 | 								"marker": "DarknessRemover",
217 | 								"width": 1,
218 | 								"height": 1,
219 | 								"customId": "-7"
220 | 							}
221 | 						]
222 | 					},
223 | 					{
224 | 						"CPWHERE": {
225 | 							"id": "id",
226 | 							"value": "BasicEntrance_R"
227 | 						},
228 | 						"markers": [
229 | 							{
230 | 								"x": 22,
231 | 								"y": 8,
232 | 								"marker": "DarknessRemover",
233 | 								"width": 1,
234 | 								"height": 1,
235 | 								"customId": "-7"
236 | 							}
237 | 						]
238 | 					},
239 | 					{
240 | 						"CPWHERE": {
241 | 							"id": "id",
242 | 							"value": "BasicEntrance_D"
243 | 						},
244 | 						"markers": [
245 | 							{
246 | 								"x": 14,
247 | 								"y": 12,
248 | 								"marker": "DarknessRemover",
249 | 								"width": 1,
250 | 								"height": 1,
251 | 								"customId": "-7"
252 | 							}
253 | 						]
254 | 					},
255 | 					{
256 | 						"CPWHERE": {
257 | 							"id": "id",
258 | 							"value": "BasicEntrance_U"
259 | 						},
260 | 						"markers": [
261 | 							{
262 | 								"x": 17,
263 | 								"y": 7,
264 | 								"marker": "DarknessRemover",
265 | 								"width": 1,
266 | 								"height": 1,
267 | 								"customId": "-7"
268 | 							}
269 | 						]
270 | 					},
271 | 					{
272 | 						"CPWHERE": {
273 | 							"id": "id",
274 | 							"value": "OutsideEntrance"
275 | 						},
276 | 						"markers": [
277 | 							{
278 | 								"x": 22,
279 | 								"y": 14,
280 | 								"marker": "DarknessRemover",
281 | 								"width": 1,
282 | 								"height": 1,
283 | 								"customId": "-7"
284 | 							}
285 | 						]
286 | 					},
287 | 					{
288 | 						"CPWHERE": {
289 | 							"id": "id",
290 | 							"value": "PrisonStartExit"
291 | 						},
292 | 						"markers": [
293 | 							{
294 | 								"x": 26,
295 | 								"y": 5,
296 | 								"marker": "DarknessRemover",
297 | 								"width": 1,
298 | 								"height": 1,
299 | 								"customId": "-7"
300 | 							}
301 | 						]
302 | 					},
303 | 					{
304 | 						"CPWHERE": {
305 | 							"id": "id",
306 | 							"value": "PrisonMonsterDoor"
307 | 						},
308 | 						"markers": [
309 | 							{
310 | 								"x": 2,
311 | 								"y": 10,
312 | 								"marker": "DarknessRemover",
313 | 								"width": 1,
314 | 								"height": 1,
315 | 								"customId": "5"
316 | 							},
317 | 							{
318 | 								"x": 10,
319 | 								"y": 10,
320 | 								"marker": "DarknessRemover",
321 | 								"width": 1,
322 | 								"height": 1,
323 | 								"customId": "5"
324 | 							}
325 | 						]
326 | 					},
327 | 					{
328 | 						"CPWHERE": {
329 | 							"id": "id",
330 | 							"value": "PrisonDepthsEntrance"
331 | 						},
332 | 						"markers": [
333 | 							{
334 | 								"x": 22,
335 | 								"y": 16,
336 | 								"marker": "DarknessRemover",
337 | 								"width": 1,
338 | 								"height": 1,
339 | 								"customId": "-7"
340 | 							}
341 | 						]
342 | 					},
343 | 					{
344 | 						"CPWHERE": {
345 | 							"id": "id",
346 | 							"value": "PrisonHubEntrance"
347 | 						},
348 | 						"markers": [
349 | 							{
350 | 								"x": 19,
351 | 								"y": 17,
352 | 								"marker": "DarknessRemover",
353 | 								"width": 1,
354 | 								"height": 1,
355 | 								"customId": "-7"
356 | 							}
357 | 						]
358 | 					},
359 | 					{
360 | 						"CPWHERE": {
361 | 							"id": "id",
362 | 							"value": "RoofEntrance"
363 | 						},
364 | 						"markers": [
365 | 							{
366 | 								"x": 23,
367 | 								"y": 8,
368 | 								"marker": "DarknessRemover",
369 | 								"width": 1,
370 | 								"height": 1,
371 | 								"customId": "5"
372 | 							},
373 | 							{
374 | 								"x": 18,
375 | 								"y": 28,
376 | 								"marker": "DarknessRemover",
377 | 								"width": 1,
378 | 								"height": 1,
379 | 								"customId": "-7"
380 | 							}
381 | 						]
382 | 					},
383 | 					{
384 | 						"CPWHERE": {
385 | 							"id": "id",
386 | 							"value": "RoofEndSubRoom"
387 | 						},
388 | 						"markers": [
389 | 							{
390 | 								"x": 9,
391 | 								"y": 18,
392 | 								"marker": "DarknessRemover",
393 | 								"width": 1,
394 | 								"height": 1,
395 | 								"customId": "-7"
396 | 							}
397 | 						]
398 | 					},
399 | 					{
400 | 						"CPWHERE": {
401 | 							"id": "id",
402 | 							"value": "RoofEndNothing"
403 | 						},
404 | 						"markers": [
405 | 							{
406 | 								"x": 9,
407 | 								"y": 18,
408 | 								"marker": "DarknessRemover",
409 | 								"width": 1,
410 | 								"height": 1,
411 | 								"customId": "-7"
412 | 							}
413 | 						]
414 | 					},
415 | 					{
416 | 						"CPWHERE": {
417 | 							"id": "id",
418 | 							"value": "RoofEndBridge"
419 | 						},
420 | 						"markers": [
421 | 							{
422 | 								"x": 9,
423 | 								"y": 15,
424 | 								"marker": "DarknessRemover",
425 | 								"width": 1,
426 | 								"height": 1,
427 | 								"customId": "5"
428 | 							},
429 | 							{
430 | 								"x": 39,
431 | 								"y": 16,
432 | 								"marker": "DarknessRemover",
433 | 								"width": 1,
434 | 								"height": 1,
435 | 								"customId": "-7"
436 | 							}
437 | 						]
438 | 					},
439 | 					{
440 | 						"CPWHERE": {
441 | 							"id": "id",
442 | 							"value": "RoofEndExit"
443 | 						},
444 | 						"markers": [
445 | 							{
446 | 								"x": 13,
447 | 								"y": 26,
448 | 								"marker": "DarknessRemover",
449 | 								"width": 1,
450 | 								"height": 1,
451 | 								"customId": "5"
452 | 							},
453 | 							{
454 | 								"x": 23,
455 | 								"y": 108,
456 | 								"marker": "DarknessRemover",
457 | 								"width": 1,
458 | 								"height": 1,
459 | 								"customId": "-7"
460 | 							}
461 | 						]
462 | 					},
463 | 					{
464 | 						"CPWHERE": {
465 | 							"id": "id",
466 | 							"value": "RoofInnerExit"
467 | 						},
468 | 						"markers": [
469 | 							{
470 | 								"x": 14,
471 | 								"y": 5,
472 | 								"marker": "DarknessRemover",
473 | 								"width": 1,
474 | 								"height": 1,
475 | 								"customId": "-7"
476 | 							}
477 | 						]
478 | 					},
479 | 					{
480 | 						"CPWHERE": {
481 | 							"id": "id",
482 | 							"value": "SewerShortEntrance"
483 | 						},
484 | 						"markers": [
485 | 							{
486 | 								"x": 13,
487 | 								"y": 5,
488 | 								"marker": "DarknessRemover",
489 | 								"width": 1,
490 | 								"height": 1,
491 | 								"customId": "5"
492 | 							},
493 | 							{
494 | 								"x": 25,
495 | 								"y": 12,
496 | 								"marker": "DarknessRemover",
497 | 								"width": 1,
498 | 								"height": 1,
499 | 								"customId": "-7"
500 | 							}
501 | 						]
502 | 					},
503 | 					{
504 | 						"CPWHERE": {
505 | 							"id": "id",
506 | 							"value": "SewerDepthsEntrance"
507 | 						},
508 | 						"markers": [
509 | 							{
510 | 								"x": 24,
511 | 								"y": 9,
512 | 								"marker": "DarknessRemover",
513 | 								"width": 1,
514 | 								"height": 1,
515 | 								"customId": "5"
516 | 							},
517 | 							{
518 | 								"x": 32,
519 | 								"y": 23,
520 | 								"marker": "DarknessRemover",
521 | 								"width": 1,
522 | 								"height": 1,
523 | 								"customId": "-7"
524 | 							}
525 | 						]
526 | 					},
527 | 					{
528 | 						"CPWHERE": {
529 | 							"id": "id",
530 | 							"value": "SewerCreature"
531 | 						},
532 | 						"markers": [
533 | 							{
534 | 								"x": 12,
535 | 								"y": 6,
536 | 								"marker": "DarknessRemover",
537 | 								"width": 1,
538 | 								"height": 1,
539 | 								"customId": "5"
540 | 							},
541 | 							{
542 | 								"x": 31,
543 | 								"y": 6,
544 | 								"marker": "DarknessRemover",
545 | 								"width": 1,
546 | 								"height": 1,
547 | 								"customId": "-7"
548 | 							}
549 | 						]
550 | 					},
551 | 					{
552 | 						"CPWHERE": {
553 | 							"id": "id",
554 | 							"value": "OssEntrance"
555 | 						},
556 | 						"markers": [
557 | 							{
558 | 								"x": 18,
559 | 								"y": 24,
560 | 								"marker": "DarknessRemover",
561 | 								"width": 1,
562 | 								"height": 1,
563 | 								"customId": "5"
564 | 							},
565 | 							{
566 | 								"x": 45,
567 | 								"y": 28,
568 | 								"marker": "DarknessRemover",
569 | 								"width": 1,
570 | 								"height": 1,
571 | 								"customId": "-7"
572 | 							}
573 | 						]
574 | 					},
575 | 					{
576 | 						"CPWHERE": {
577 | 							"id": "id",
578 | 							"value": "SVEntrance"
579 | 						},
580 | 						"markers": [
581 | 							{
582 | 								"x": 8,
583 | 								"y": 20,
584 | 								"marker": "DarknessRemover",
585 | 								"width": 1,
586 | 								"height": 1,
587 | 								"customId": "-7"
588 | 							}
589 | 						]
590 | 					},
591 | 					{
592 | 						"CPWHERE": {
593 | 							"id": "id",
594 | 							"value": "SVEnd"
595 | 						},
596 | 						"markers": [
597 | 							{
598 | 								"x": 28,
599 | 								"y": 26,
600 | 								"marker": "DarknessRemover",
601 | 								"width": 1,
602 | 								"height": 1,
603 | 								"customId": "-7"
604 | 							},
605 | 							{
606 | 								"x": 12,
607 | 								"y": 80,
608 | 								"marker": "DarknessRemover",
609 | 								"width": 1,
610 | 								"height": 1,
611 | 								"customId": "-7"
612 | 							},
613 | 							{
614 | 								"x": 10,
615 | 								"y": 90,
616 | 								"marker": "DarknessRemover",
617 | 								"width": 1,
618 | 								"height": 1,
619 | 								"customId": "-7"
620 | 							},
621 | 							{
622 | 								"x": 31,
623 | 								"y": 90,
624 | 								"marker": "DarknessRemover",
625 | 								"width": 1,
626 | 								"height": 1,
627 | 								"customId": "-7"
628 | 							},
629 | 							{
630 | 								"x": 59,
631 | 								"y": 90,
632 | 								"marker": "DarknessRemover",
633 | 								"width": 1,
634 | 								"height": 1,
635 | 								"customId": "-7"
636 | 							}
637 | 						]
638 | 					},
639 | 					{
640 | 						"CPWHERE": {
641 | 							"id": "id",
642 | 							"value": "SVInteriorExit"
643 | 						},
644 | 						"markers": [
645 | 							{
646 | 								"x": 22,
647 | 								"y": 40,
648 | 								"marker": "DarknessRemover",
649 | 								"width": 1,
650 | 								"height": 1,
651 | 								"customId": "-7"
652 | 							}
653 | 						]
654 | 					},
655 | 					{
656 | 						"CPWHERE": {
657 | 							"id": "id",
658 | 							"value": "SVMidGate"
659 | 						},
660 | 						"markers": [
661 | 							{
662 | 								"x": 11,
663 | 								"y": 52,
664 | 								"marker": "DarknessRemover",
665 | 								"width": 1,
666 | 								"height": 1,
667 | 								"customId": "5"
668 | 							},
669 | 							{
670 | 								"x": 8,
671 | 								"y": 87,
672 | 								"marker": "DarknessRemover",
673 | 								"width": 1,
674 | 								"height": 1,
675 | 								"customId": "-7"
676 | 							},
677 | 							{
678 | 								"x": 14,
679 | 								"y": 87,
680 | 								"marker": "DarknessRemover",
681 | 								"width": 1,
682 | 								"height": 1,
683 | 								"customId": "-7"
684 | 							}
685 | 						]
686 | 					},
687 | 					{
688 | 						"CPWHERE": {
689 | 							"id": "id",
690 | 							"value": "CEntrance"
691 | 						},
692 | 						"markers": [
693 | 							{
694 | 								"x": 7,
695 | 								"y": 27,
696 | 								"marker": "DarknessRemover",
697 | 								"width": 1,
698 | 								"height": 1,
699 | 								"customId": "5"
700 | 							},
701 | 							{
702 | 								"x": 14,
703 | 								"y": 96,
704 | 								"marker": "DarknessRemover",
705 | 								"width": 1,
706 | 								"height": 1,
707 | 								"customId": "-7"
708 | 							},
709 | 							{
710 | 								"x": 30,
711 | 								"y": 96,
712 | 								"marker": "DarknessRemover",
713 | 								"width": 1,
714 | 								"height": 1,
715 | 								"customId": "-7"
716 | 							}
717 | 						]
718 | 					},
719 | 					{
720 | 						"CPWHERE": {
721 | 							"id": "id",
722 | 							"value": "CEndExit"
723 | 						},
724 | 						"markers": [
725 | 							{
726 | 								"x": 22,
727 | 								"y": 27,
728 | 								"marker": "DarknessRemover",
729 | 								"width": 1,
730 | 								"height": 1,
731 | 								"customId": "5"
732 | 							},
733 | 							{
734 | 								"x": 8,
735 | 								"y": 83,
736 | 								"marker": "DarknessRemover",
737 | 								"width": 1,
738 | 								"height": 1,
739 | 								"customId": "-7"
740 | 							},
741 | 							{
742 | 								"x": 33,
743 | 								"y": 83,
744 | 								"marker": "DarknessRemover",
745 | 								"width": 1,
746 | 								"height": 1,
747 | 								"customId": "-7"
748 | 							}
749 | 						]
750 | 					},
751 | 					{
752 | 						"CPWHERE": {
753 | 							"id": "id",
754 | 							"value": "CLadderGateDone"
755 | 						},
756 | 						"markers": [
757 | 							{
758 | 								"x": 15,
759 | 								"y": 15,
760 | 								"marker": "DarknessRemover",
761 | 								"width": 1,
762 | 								"height": 1,
763 | 								"customId": "-7"
764 | 							}
765 | 						]
766 | 					},
767 | 					{
768 | 						"CPWHERE": {
769 | 							"id": "id",
770 | 							"value": "CemEntrance"
771 | 						},
772 | 						"markers": [
773 | 							{
774 | 								"x": 26,
775 | 								"y": 48,
776 | 								"marker": "DarknessRemover",
777 | 								"width": 1,
778 | 								"height": 1,
779 | 								"customId": "-7"
780 | 							}
781 | 						]
782 | 					},
783 | 					{
784 | 						"CPWHERE": {
785 | 							"id": "id",
786 | 							"value": "CemEnd"
787 | 						},
788 | 						"markers": [
789 | 							{
790 | 								"x": 13,
791 | 								"y": 71,
792 | 								"marker": "DarknessRemover",
793 | 								"width": 1,
794 | 								"height": 1,
795 | 								"customId": "-7"
796 | 							}
797 | 						]
798 | 					},
799 | 					{
800 | 						"CPWHERE": {
801 | 							"id": "id",
802 | 							"value": "CemBigCrypt"
803 | 						},
804 | 						"markers": [
805 | 							{
806 | 								"x": 7,
807 | 								"y": 22,
808 | 								"marker": "DarknessRemover",
809 | 								"width": 1,
810 | 								"height": 1,
811 | 								"customId": "5"
812 | 							},
813 | 							{
814 | 								"x": 48,
815 | 								"y": 22,
816 | 								"marker": "DarknessRemover",
817 | 								"width": 1,
818 | 								"height": 1,
819 | 								"customId": "-7"
820 | 							},
821 | 							{
822 | 								"x": 18,
823 | 								"y": 38,
824 | 								"marker": "DarknessRemover",
825 | 								"width": 1,
826 | 								"height": 1,
827 | 								"customId": "-7"
828 | 							}
829 | 						]
830 | 					},
831 | 					{
832 | 						"CPWHERE": {
833 | 							"id": "id",
834 | 							"value": "ClockTowerEntrance"
835 | 						},
836 | 						"markers": [
837 | 							{
838 | 								"x": 49,
839 | 								"y": 13,
840 | 								"marker": "DarknessRemover",
841 | 								"width": 1,
842 | 								"height": 1,
843 | 								"customId": "5"
844 | 							},
845 | 							{
846 | 								"x": 33,
847 | 								"y": 31,
848 | 								"marker": "DarknessRemover",
849 | 								"width": 1,
850 | 								"height": 1,
851 | 								"customId": "-7"
852 | 							},
853 | 							{
854 | 								"x": 53,
855 | 								"y": 31,
856 | 								"marker": "DarknessRemover",
857 | 								"width": 1,
858 | 								"height": 1,
859 | 								"customId": "-7"
860 | 							}
861 | 						]
862 | 					},
863 | 					{
864 | 						"CPWHERE": {
865 | 							"id": "id",
866 | 							"value": "ClockTowerExit"
867 | 						},
868 | 						"markers": [
869 | 							{
870 | 								"x": 4,
871 | 								"y": 8,
872 | 								"marker": "DarknessRemover",
873 | 								"width": 1,
874 | 								"height": 1,
875 | 								"customId": "-7"
876 | 							}
877 | 						]
878 | 					},
879 | 					{
880 | 						"CPWHERE": {
881 | 							"id": "id",
882 | 							"value": "AncientEntrance"
883 | 						},
884 | 						"markers": [
885 | 							{
886 | 								"x": 20,
887 | 								"y": 14,
888 | 								"marker": "DarknessRemover",
889 | 								"width": 1,
890 | 								"height": 1,
891 | 								"customId": "-7"
892 | 							}
893 | 						]
894 | 					}
895 | 				]
896 | 			}
897 | 		]
898 | 	}
899 | }


--------------------------------------------------------------------------------
/scripts/time.patch:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"add": {
 3 | 		"sheets":[
 4 | 			{
 5 | 				"CPWHERE": {
 6 | 					"id": "name", "value": "room"
 7 | 				}
 8 | 				,
 9 | 				"lines": [ 
10 | 					{
11 | 						"CPWHERE": {
12 | 							"id": "id",
13 | 							"value": "PrisonFlaskRoom"
14 | 						}
15 | 						,
16 | 						"markers": [
17 | 							{
18 | 								"x": 85,
19 | 								"y": 26,
20 | 								"marker": "FixedLoot",
21 | 								"width": 1,
22 | 								"height": 1,
23 | 								"item": "TimeDistorsion"
24 | 							},
25 | 							{
26 | 								"x": 83,
27 | 								"y": 26,
28 | 								"marker": "FixedBlueprint",
29 | 								"width": 1,
30 | 								"height": 1,
31 | 								"item": "TimeDistorsion"
32 | 							}
33 | 						]
34 | 					}
35 | 				]
36 | 			},
37 | 			{
38 | 				"CPWHERE": {
39 | 					"id": "name", "value": "item"
40 | 				}
41 | 				,
42 | 				"lines": [
43 | 					{
44 | 						"CPWHERE": {
45 | 							"id": "id", "value": "TimeDistorsion"
46 | 						}
47 | 						,
48 | 						"droppable": true,
49 | 						"hasLevels": true,
50 | 						"cellCost": 1
51 | 					}
52 | 				]
53 | 			}
54 | 		]
55 | 	}
56 | }


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/CellPackerMain.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker;
 2 | 
 3 | import java.io.File;
 4 | 
 5 | import javax.swing.ImageIcon;
 6 | import javax.swing.UIManager;
 7 | import javax.swing.UnsupportedLookAndFeelException;
 8 | 
 9 | import dev.lb.cellpacker.controls.LaunchWindow;
10 | import dev.lb.cellpacker.controls.MainWindow;
11 | 
12 | public class CellPackerMain {
13 | 
14 | 	public static final boolean MODLOADER = false;
15 | 	
16 | 	public static boolean ASK_RESOURCE_RESTORE = true;
17 | 	public static File CHOOSE_ROOT_FILE = new File(".");
18 | 	
19 | 	public static MainWindow mainFrame;
20 | 	
21 | 	public static void main(String[] args) {
22 | 		try {
23 | 			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
24 | 		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
25 | 				| UnsupportedLookAndFeelException e1) {
26 | 			Logger.printWarning("CellPackerMain.main()", "Could not set L&F for this platform");
27 | 		}
28 | 		
29 | 		if(MODLOADER){
30 | 			LaunchWindow lw = new LaunchWindow(false);
31 | 			lw.setVisible(true);
32 | 			lw.setIconImage(new ImageIcon(CellPackerMain.class.getResource("/resources/ico.png")).getImage());
33 | 		}else{
34 | 			mainFrame = new MainWindow();
35 | 			mainFrame.setVisible(true);
36 | 		}
37 | 	}
38 | 
39 | 	
40 | 	@SuppressWarnings("unused")
41 | 	private static String concat(String[] array){
42 | 		if(array == null) return null;
43 | 		if(array.length == 0) return null;
44 | 		String concat = "";
45 | 		for(String s : array){
46 | 			concat = concat + s + " ";
47 | 		}
48 | 		return concat;
49 | 	}
50 | 	
51 | 	public static MainWindow getMainFrame(){
52 | 		return mainFrame;
53 | 	}
54 | 	
55 | }
56 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/Logger.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker;
 2 | 
 3 | public final class Logger {
 4 | 	private Logger(){}
 5 | 	
 6 | 	public static void throwFatal(Throwable ex, int exitCode){
 7 | 		System.err.println("[ErrorHandler]: A fatal error has occurred:");
 8 | 		ex.printStackTrace();
 9 | 		System.exit(exitCode);
10 | 	}
11 | 	
12 | 	public static void throwFatal(Throwable ex){
13 | 		throwFatal(ex, 1);
14 | 	}
15 | 	
16 | 	public static void printWarning(String trace, String warning){
17 | 		System.out.println("[WARNING|" + trace + "]: " + warning);
18 | 	}
19 | 	
20 | }
21 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/NamedRange.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker;
 2 | 
 3 | public class NamedRange{
 4 | 
 5 | 	private String key;
 6 | 	private int start;
 7 | 	private int end;
 8 | 	
 9 | 	public NamedRange(String name, int start) {
10 | 		this.key = name;
11 | 		this.start = start;
12 | 	}
13 | 	
14 | 	public String getName() {
15 | 		return key;
16 | 	}
17 | 
18 | 	public int getStart() {
19 | 		return start;
20 | 	}
21 | 	
22 | 	public int getEnd(){
23 | 		return end;
24 | 	}
25 | 	
26 | 	public int getSize(){
27 | 		return end - start;
28 | 	}
29 | 	
30 | 	public void setEnd(int value) {
31 | 		end = value;
32 | 	}
33 | 
34 | 	@Override
35 | 	public String toString() {
36 | 		return "NamedRange [name=" + key + ", start=" + start + ", end=" + end + "]";
37 | 	}
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/TextAreaPrintStream.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker;
 2 | 
 3 | import java.io.ByteArrayOutputStream;
 4 | import java.io.PrintStream;
 5 | 
 6 | import javax.swing.JTextArea;
 7 | 
 8 | public class TextAreaPrintStream extends PrintStream{
 9 | 	
10 | 	private JTextArea textArea;
11 | 	
12 | 	public TextAreaPrintStream(JTextArea area){
13 | 		super(new ByteArrayOutputStream(), true);
14 | 		textArea = area;
15 | 		
16 | 	}
17 | 
18 | 	@Override
19 | 	public void flush() {
20 | 		super.flush();
21 | 		textArea.setText(new String(((ByteArrayOutputStream) out).toByteArray()));
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/Utils.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker;
  2 | 
  3 | import java.awt.BorderLayout;
  4 | import java.awt.Component;
  5 | import java.awt.Container;
  6 | import java.awt.Desktop;
  7 | import java.awt.Dimension;
  8 | import java.awt.FlowLayout;
  9 | import java.awt.LayoutManager;
 10 | import java.io.ByteArrayOutputStream;
 11 | import java.io.IOException;
 12 | import java.io.Reader;
 13 | import java.io.StringReader;
 14 | import java.net.URI;
 15 | import java.net.URISyntaxException;
 16 | import java.util.function.Consumer;
 17 | import java.util.function.Predicate;
 18 | import java.util.function.Supplier;
 19 | 
 20 | import javax.swing.BorderFactory;
 21 | import javax.swing.JComponent;
 22 | import javax.swing.JOptionPane;
 23 | import javax.swing.JPanel;
 24 | import javax.swing.JProgressBar;
 25 | import javax.swing.JTextArea;
 26 | 
 27 | import com.google.gson.JsonArray;
 28 | import com.google.gson.JsonElement;
 29 | import com.google.gson.JsonObject;
 30 | import com.google.gson.stream.JsonReader;
 31 | import com.google.gson.stream.JsonToken;
 32 | import com.google.gson.stream.MalformedJsonException;
 33 | 
 34 | 
 35 | public final class Utils {
 36 | 	private Utils(){}
 37 | 	
 38 | 	public static <T extends JComponent> T setWidth(T control, int width){
 39 | 		control.setPreferredSize(new Dimension(width, control.getPreferredSize().height));
 40 | 		return control;
 41 | 	}
 42 | 	
 43 | 	public static <T extends JComponent> T setMaxWidth(T control){
 44 | 		control.setMaximumSize(new Dimension(Integer.MAX_VALUE, control.getMaximumSize().height));
 45 | 		return control;
 46 | 	}
 47 | 	
 48 | 	public static <T> T call(T object, Consumer<T> action){
 49 | 		action.accept(object);
 50 | 		return object;
 51 | 	}
 52 | 	
 53 | 	public static <T extends JComponent> T setHeight(T control, int height){
 54 | 		control.setPreferredSize(new Dimension(control.getPreferredSize().width, height));
 55 | 		return control;
 56 | 	}
 57 | 	
 58 | 	public static <T extends JComponent> T setPrefSize(T control, int width, int height){
 59 | 		control.setPreferredSize(new Dimension(width, height));
 60 | 		return control;
 61 | 	}
 62 | 	
 63 | 	public static JPanel createGroupBox(String title){
 64 | 		JPanel pan = new JPanel();
 65 | 		pan.setBorder(BorderFactory.createTitledBorder(title));
 66 | 		return pan;
 67 | 	}
 68 | 	
 69 | 	public static JPanel createGroupBox(String title, LayoutManager layout){
 70 | 		JPanel pan = new JPanel(layout);
 71 | 		pan.setBorder(BorderFactory.createTitledBorder(title));
 72 | 		return pan;
 73 | 	}
 74 | 	
 75 | 	public static <T extends Container> T addAll(T container, Component...components){
 76 | 		for(Component c : components){
 77 | 			container.add(c);
 78 | 		}
 79 | 		return container;
 80 | 	}
 81 | 	
 82 | 	public static JTextArea getTextDisplay(String text){
 83 | 		JTextArea txt = new JTextArea(text);
 84 | 		txt.setEditable(false);
 85 | 		return txt;
 86 | 	}
 87 | 	
 88 | 	public static JProgressBar getWaitingBar(int width){
 89 | 		JProgressBar pro = new JProgressBar();
 90 | 		pro.setIndeterminate(true);
 91 | 		return setWidth(pro, width);
 92 | 	}
 93 | 	
 94 | 	public static Container asyncFill(Supplier<Component> content, int waitBarWidth){
 95 | 		JPanel con = new JPanel();
 96 | 		JProgressBar wait = getWaitingBar(waitBarWidth);
 97 | 		con.add(wait);
 98 | 		new Thread(() -> {
 99 | 			Component com = content.get();
100 | 			con.remove(wait);
101 | 			con.setLayout(new BorderLayout());
102 | 			con.add(com);
103 | 			con.revalidate();
104 | 		}).start();
105 | 		return con;
106 | 	}
107 | 	
108 | 	public static Container asyncFill(Supplier<Component> content, int waitBarWidth, Object constraints){
109 | 		JPanel con = new JPanel();
110 | 		JProgressBar wait = getWaitingBar(waitBarWidth);
111 | 		con.add(wait, constraints);
112 | 		new Thread(() -> {
113 | 			Component com = content.get();
114 | 			con.remove(wait);
115 | 			con.setLayout(new BorderLayout());
116 | 			con.add(com, constraints);
117 | 			con.revalidate();
118 | 		}).start();
119 | 		return con;
120 | 	}
121 | 	
122 | 	public static JPanel pack(Component...components){
123 | 		JPanel container = new JPanel(new FlowLayout());
124 | 		for(Component c : components){
125 | 			container.add(c);
126 | 		}
127 | 		return container;
128 | 	}
129 | 	
130 | 	
131 | 	//Validation methods from SO
132 | 	public static boolean isJsonValid(final String json) {
133 | 	    return isJsonValid(new StringReader(json));
134 | 	}
135 | 
136 | 	private static boolean isJsonValid(final Reader reader) {
137 | 	    return isJsonValid(new JsonReader(reader));
138 | 	}
139 | 
140 | 	private static boolean isJsonValid(final JsonReader jsonReader) {
141 | 	    try {
142 | 	        JsonToken token;
143 | 	        loop:
144 | 	        while ( (token = jsonReader.peek()) != JsonToken.END_DOCUMENT && token != null ) {
145 | 	            switch ( token ) {
146 | 	            case BEGIN_ARRAY:
147 | 	                jsonReader.beginArray();
148 | 	                break;
149 | 	            case END_ARRAY:
150 | 	                jsonReader.endArray();
151 | 	                break;
152 | 	            case BEGIN_OBJECT:
153 | 	                jsonReader.beginObject();
154 | 	                break;
155 | 	            case END_OBJECT:
156 | 	                jsonReader.endObject();
157 | 	                break;
158 | 	            case NAME:
159 | 	                jsonReader.nextName();
160 | 	                break;
161 | 	            case STRING:
162 | 	            case NUMBER:
163 | 	            case BOOLEAN:
164 | 	            case NULL:
165 | 	                jsonReader.skipValue();
166 | 	                break;
167 | 	            case END_DOCUMENT:
168 | 	                break loop;
169 | 	            default:
170 | 	                throw new AssertionError(token);
171 | 	            }
172 | 	        }
173 | 	        return true;
174 | 	    } catch ( final MalformedJsonException ignored ) {
175 | 	        return false;
176 | 	    } catch (IOException | AssertionError e) {
177 | 			e.printStackTrace();
178 | 			return false;
179 | 		}
180 | 	}
181 | 	
182 | 	public static void showAboutDialog(String text, String title, String url){
183 | 		int result = JOptionPane.showOptionDialog(CellPackerMain.getMainFrame(), text, title, JOptionPane.DEFAULT_OPTION,
184 | 				JOptionPane.INFORMATION_MESSAGE, null, new String[]{"Go to website", "Close"}, 0);
185 | 		if(result == 1) return;
186 | 		try {
187 | 			Desktop.getDesktop().browse(new URI(url));
188 | 		} catch (IOException | URISyntaxException e) {
189 | 			e.printStackTrace();
190 | 		}
191 | 	}
192 | 	
193 | 	public static void addJSON(JsonObject base, JsonObject add){
194 | 		//Iterate over all entries in add
195 | 		for(String addKey : add.keySet()){
196 | 			//get the current entry as an object
197 | 			JsonElement addElement = add.get(addKey); 
198 | 			//If the base tag does not have this tag yet, add this tag to base
199 | 			if(!base.has(addKey)){
200 | 				base.add(addKey, addElement);
201 | 			}else{ //If it does exist, try to merge depending on the type
202 | 				addJsonByType(base.get(addKey), addElement, (e) -> base.add(addKey, e));
203 | 			}
204 | 		}
205 | 	}
206 | 	
207 | 	private static void addJsonByType(JsonElement baseElement, JsonElement addElement, Consumer<JsonElement> overwriteAction){
208 | 		//The simplest is a primitive, it is just replaced:
209 | 		if(baseElement.isJsonPrimitive() && addElement.isJsonPrimitive()){
210 | 			overwriteAction.accept(addElement);
211 | 		//If they are both objects, recursively call this merge method
212 | 		}else if(baseElement.isJsonObject() && addElement.isJsonObject()){
213 | 			addJSON(baseElement.getAsJsonObject(), addElement.getAsJsonObject());
214 | 		//If they are arrays, find markers or append
215 | 		}else if(baseElement.isJsonArray() && addElement.isJsonArray()){
216 | 			//save the elements in new variables
217 | 			JsonArray addArray = addElement.getAsJsonArray();
218 | 			JsonArray baseArray = baseElement.getAsJsonArray();
219 | 			//Then iterate over the added array
220 | 			for(JsonElement addArrayElement : addArray){
221 | 				//Handle depending on type
222 | 				//If it is an object, look for markers
223 | 				if(addArrayElement.isJsonObject()){
224 | 					//Check for CPWHERE (overrides CPINDEX) and if it is an object
225 | 					if(addArrayElement.getAsJsonObject().has("CPWHERE") &&
226 | 							addArrayElement.getAsJsonObject().get("CPWHERE").isJsonObject()){
227 | 						JsonObject whereObject = addArrayElement.getAsJsonObject().get("CPWHERE").getAsJsonObject();
228 | 						//Test if where has the Strings 'id' and 'value'
229 | 						if(whereObject.has("id") && whereObject.get("id").isJsonPrimitive() &&
230 | 								whereObject.has("value") && whereObject.get("value").isJsonPrimitive()){
231 | 							String id = whereObject.get("id").getAsString();
232 | 							String value = whereObject.get("value").getAsString();
233 | 							//Now find an entry in the base array that has id==value
234 | 							for(int i = 0; i < baseArray.size(); i++){
235 | 								JsonElement baseArrayElement = baseArray.get(i);
236 | 								//The element has to be an object and has to have a tag called id that is a primitive
237 | 								if(baseArrayElement.isJsonObject() && baseArrayElement.getAsJsonObject().has(id) &&
238 | 										baseArrayElement.getAsJsonObject().get(id).isJsonPrimitive()){
239 | 									//Value has to be equal
240 | 									if(baseArrayElement.getAsJsonObject().get(id).getAsString().equals(value)){
241 | 										//We found a tag
242 | 										//Now remove the CPWHERE part
243 | 										addArrayElement.getAsJsonObject().remove("CPWHERE");
244 | 										final int index = i; //This is necessary, lambda doesn't like non-finals 
245 | 										addJsonByType(baseArrayElement, addArrayElement, (e) -> baseArray.set(index, e));
246 | 										//Then break out of the for loop, only the first item should be modified
247 | 										break;
248 | 									}
249 | 								}
250 | 							}
251 | 						}else{
252 | 							System.err.println("Json Parser - Add: Found CPWHERE tag, but 'id' or 'value' tags were missing");
253 | 						}
254 | 						//if the reqired fields do not exist, do nothing
255 | 						
256 | 					//Check for CPINDEX next and if it is a primitive
257 | 					}else if(addArrayElement.getAsJsonObject().has("CPINDEX") &&
258 | 							addArrayElement.getAsJsonObject().get("CPINDEX").isJsonPrimitive()){
259 | 						//Check if the index is within range
260 | 						int index = addArrayElement.getAsJsonObject().get("CPINDEX").getAsInt();
261 | 						if(index >= 0 && index < baseArray.size()){
262 | 							//Get the element from the base array
263 | 							JsonElement baseArrayElement = baseArray.get(index);
264 | 							//Also remove the CPINDEX tag before merging
265 | 							addArrayElement.getAsJsonObject().remove("CPINDEX");
266 | 							addJsonByType(baseArrayElement, addArrayElement, (e) -> baseArray.set(index, e));
267 | 						}else{
268 | 							System.err.println("Json Parser - Add: Found CPINDEX tag, but index was out of bounds");
269 | 						}
270 | 						//If the index is out of bounds, do nothing
271 | 					//If no marker is found, simply append
272 | 					}else{
273 | 						baseArray.add(addArrayElement);
274 | 					}
275 | 				//Primitives and arrays (can you even put arrays in arrays in json?) cannot have a marker and are appended
276 | 				}else{
277 | 					baseArray.add(addArrayElement);
278 | 				}
279 | 			}
280 | 		//If they are different types, they are also replaced
281 | 		}else{
282 | 			overwriteAction.accept(addElement);
283 | 		}
284 | 	}
285 | 
286 | 	
287 | 	private static void removeJsonByType(JsonElement baseElement, JsonElement removeElement, Runnable deleteAction){
288 | 		//Basic behavior: if any is primitive, delete
289 | 		//If both are objects, recursive call removeJson
290 | 		//If both are arrays, go through entries and apply this
291 | 		//If they are different types, delete
292 | 		if(baseElement.isJsonPrimitive() && removeElement.isJsonPrimitive()){
293 | 			deleteAction.run();
294 | 		}else if(baseElement.isJsonObject() && removeElement.isJsonObject()){
295 | 			removeJSON(baseElement.getAsJsonObject(), removeElement.getAsJsonObject());
296 | 		}else if(baseElement.isJsonArray() && removeElement.isJsonArray()){
297 | 			//Iterate over the remove array entries
298 | 			JsonArray removeArray = removeElement.getAsJsonArray();
299 | 			JsonArray baseArray = baseElement.getAsJsonArray();
300 | 			for(JsonElement removeArrayElement : removeArray){
301 | 				if(removeArrayElement.isJsonObject()){
302 | 					if(removeArrayElement.getAsJsonObject().has("CPINDEX") &&
303 | 							removeArrayElement.getAsJsonObject().get("CPINDEX").isJsonPrimitive()){
304 | 						final int index = removeArrayElement.getAsJsonObject().get("CPINDEX").getAsInt();
305 | 						if(index >= 0 && index < baseArray.size()){
306 | 							removeJsonByType(baseArray.get(index), removeArrayElement, () -> baseArray.remove(index));
307 | 						}else{
308 | 							System.err.println("Json Parser - Remove: Found CPINDEX tag, but index was out of bounds");
309 | 						}
310 | 					}else if(removeArrayElement.getAsJsonObject().has("CPWHERE") &&
311 | 							removeArrayElement.getAsJsonObject().get("CPWHERE").isJsonObject()){
312 | 						JsonObject whereObject = removeArrayElement.getAsJsonObject().get("CPWHERE").getAsJsonObject();
313 | 						if(whereObject.has("id") && whereObject.get("id").isJsonPrimitive() &&
314 | 								whereObject.has("value") && whereObject.get("value").isJsonPrimitive()){
315 | 							String id = whereObject.get("id").getAsString();
316 | 							String value = whereObject.get("value").getAsString();
317 | 							//Now iterate over basearray and find tag to remove
318 | 							for(int i = 0; i < baseArray.size(); i++){
319 | 								JsonElement baseArrayElement = baseArray.get(i);
320 | 								//can only delete objects bc only objects can have id==value
321 | 								if(baseArrayElement.isJsonObject() && baseArrayElement.getAsJsonObject().has(id) &&
322 | 										baseArrayElement.getAsJsonObject().get(id).isJsonPrimitive() &&
323 | 										baseArrayElement.getAsJsonObject().get(id).getAsString().equals(value)){
324 | 									//We have a match, now delete it
325 | 									final int index = i;
326 | 									removeJsonByType(baseArrayElement, removeArrayElement, () -> baseArray.remove(index));
327 | 									break;
328 | 								}
329 | 							}
330 | 						}else{
331 | 							System.err.println("Json Parser - Remove: Found CPWHERE tag, but 'id' or 'value' tags were missing");
332 | 						}
333 | 					}
334 | 				}
335 | 				//If you don't give me a hint on what entry you mean, I'm afraid I can't do anything for you. 
336 | 			}
337 | 		}else{
338 | 			deleteAction.run();
339 | 		}
340 | 	}
341 | 	
342 | 	public static void removeJSON(JsonObject base, JsonObject remove){
343 | 		//iterate over all entries in remove
344 | 		for(String removeKey : remove.keySet()){
345 | 			//If base does not have this tag, just ignore, else handle depending on type
346 | 			if(base.has(removeKey)){
347 | 				JsonElement removeElement = remove.get(removeKey);
348 | 				JsonElement baseElement = base.get(removeKey);
349 | 				removeJsonByType(baseElement, removeElement, () -> base.remove(removeKey));
350 | 			}
351 | 		}
352 | 	}
353 | 	
354 | 	public static <T> boolean contains(Iterable<T> l, Predicate<T> test){
355 | 		for(T t : l){
356 | 			if(test.test(t))
357 | 				return true;
358 | 		}
359 | 		return false;
360 | 	}
361 | 	
362 | 	public static <T> T getFirst(Iterable<T> l, Predicate<T> test){
363 | 		for(T t : l){
364 | 			if(test.test(t))
365 | 				return t;
366 | 		}
367 | 		return null;
368 | 	}
369 | 	
370 | 	public static byte[] concat(byte[] a, byte[] b){
371 | 		byte[] c = new byte[a.length + b.length];
372 | 		System.arraycopy(a, 0, c, 0, a.length);
373 | 	    System.arraycopy(b, 0, c, a.length, b.length);
374 | 	    return c;
375 | 	}
376 | 	
377 | 	public static byte[] encodeInt(int num){
378 | 		return new byte[] {
379 | 	            (byte)(num),
380 | 	            (byte)(num >>> 8),
381 | 	            (byte)(num >>> 16),
382 | 	            (byte)(num >>> 24)};
383 | 	}
384 | 	
385 | 	public static int decodeInt(byte[] num){
386 | 		if(num.length != 4)
387 | 			throw new NumberFormatException("Array size must be 4");
388 | 		return ((num[0]) & 0xFF) + ((num[1] & 0xFF) << 8) +
389 | 				((num[2] & 0xFF) << 16) + ((num[3] & 0xFF) << 24);
390 | 	}
391 | 	
392 | 	public static void writeInt(ByteArrayOutputStream out, int i) throws IOException{
393 | 		out.write(encodeInt(i));
394 | 	}
395 | 	
396 | 	public static void writeString(ByteArrayOutputStream out, String s, byte terminator) throws IOException{
397 | 		out.write((byte) s.length());
398 | 		out.write(s.getBytes());
399 | 		out.write(terminator);
400 | 	}
401 | 	
402 | }
403 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/annotation/Async.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.annotation;
 2 | 
 3 | import static java.lang.annotation.RetentionPolicy.CLASS;
 4 | import static java.lang.annotation.ElementType.METHOD;
 5 | 
 6 | import java.lang.annotation.Retention;
 7 | import java.lang.annotation.Target;
 8 | 
 9 | /**
10 |  * Annotated methods should be called asynchonously, because they may be blocking the thread for some time.
11 |  * @author Lars
12 |  *
13 |  */
14 | @Retention(CLASS)
15 | @Target(METHOD)
16 | public @interface Async {
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/annotation/Calculated.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.annotation;
 2 | 
 3 | import static java.lang.annotation.ElementType.METHOD;
 4 | import static java.lang.annotation.RetentionPolicy.CLASS;
 5 | 
 6 | import java.lang.annotation.Retention;
 7 | import java.lang.annotation.Target;
 8 | 
 9 | /**
10 |  * The object returned by the annotated method is newly cfeated eery time the method is called
11 |  * This method should only be used in cases where it isn't obvoius that the returned object is not
12 |  * a field or stored in a variable.
13 |  * @author Lars b.
14 |  * @version 1.0
15 |  */
16 | @Retention(CLASS)
17 | @Target(METHOD)
18 | public @interface Calculated {
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/annotation/Shortcut.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.annotation;
 2 | 
 3 | import static java.lang.annotation.ElementType.METHOD;
 4 | import static java.lang.annotation.RetentionPolicy.CLASS;
 5 | 
 6 | import java.lang.annotation.Retention;
 7 | import java.lang.annotation.Target;
 8 | 
 9 | /**
10 |  * Annotated methods are shortcuts for other methods. The name of a method call
11 |  * with the same result is stored in the value parameter of this annotation.
12 |  * @author Lars b.
13 |  * @version 1.0
14 |  */
15 | @Retention(CLASS)
16 | @Target(METHOD)
17 | public @interface Shortcut {
18 | 	String value();
19 | }
20 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/annotation/Unmodifiable.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.annotation;
 2 | 
 3 | import static java.lang.annotation.ElementType.METHOD;
 4 | import static java.lang.annotation.RetentionPolicy.CLASS;
 5 | 
 6 | import java.lang.annotation.Retention;
 7 | import java.lang.annotation.Target;
 8 | 
 9 | /**
10 |  * Annotated methods return unmodifiable/immutable objects.
11 |  * @author Lars B.
12 |  * @version 1.0
13 |  */
14 | @Retention(CLASS)
15 | @Target(METHOD)
16 | public @interface Unmodifiable {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/CheckBoxList.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.Component;
 4 | import java.awt.event.MouseAdapter;
 5 | import java.awt.event.MouseEvent;
 6 | 
 7 | import javax.swing.DefaultListModel;
 8 | import javax.swing.JCheckBox;
 9 | import javax.swing.JList;
10 | import javax.swing.ListCellRenderer;
11 | import javax.swing.ListModel;
12 | import javax.swing.ListSelectionModel;
13 | import javax.swing.UIManager;
14 | import javax.swing.border.Border;
15 | import javax.swing.border.EmptyBorder;
16 | 
17 | public class CheckBoxList extends JList<JCheckBox>{
18 | 	private static final long serialVersionUID = 2796368191296898045L;
19 | 
20 | 	protected static Border noFocusBorder =
21 | 			new EmptyBorder(1, 1, 1, 1);
22 | 
23 | 	public CheckBoxList()
24 | 	{
25 | 		super(new DefaultListModel<>());
26 | 		
27 | 		setCellRenderer(new CellRenderer());
28 | 
29 | 		addMouseListener(new MouseAdapter()
30 | 		{
31 | 			public void mousePressed(MouseEvent e)
32 | 			{
33 | 				int index = locationToIndex(e.getPoint());
34 | 
35 | 				if (index != -1) {
36 | 					JCheckBox checkbox = (JCheckBox)
37 | 							getModel().getElementAt(index);
38 | 					checkbox.setSelected(
39 | 							!checkbox.isSelected());
40 | 					repaint();
41 | 				}
42 | 			}
43 | 		}
44 | 				);
45 | 
46 | 		setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
47 | 	}
48 | 
49 | 	public void addCheckbox(JCheckBox checkBox) {
50 | 	    ListModel<JCheckBox> currentList = this.getModel();
51 | 	    JCheckBox[] newList = new JCheckBox[currentList.getSize() + 1];
52 | 	    for (int i = 0; i < currentList.getSize(); i++) {
53 | 	        newList[i] = (JCheckBox) currentList.getElementAt(i);
54 | 	    }
55 | 	    newList[newList.length - 1] = checkBox;
56 | 	    setListData(newList);
57 | 	}
58 | 	
59 | 	protected class CellRenderer implements ListCellRenderer<JCheckBox>
60 | 	{
61 | 		public Component getListCellRendererComponent(
62 | 				JList<? extends JCheckBox> list, JCheckBox value, int index,
63 | 				boolean isSelected, boolean cellHasFocus)
64 | 		{
65 | 			JCheckBox checkbox = (JCheckBox) value;
66 | 			checkbox.setBackground(isSelected ?
67 | 					getSelectionBackground() : getBackground());
68 | 			checkbox.setForeground(isSelected ?
69 | 					getSelectionForeground() : getForeground());
70 | 			checkbox.setEnabled(isEnabled());
71 | 			checkbox.setFont(getFont());
72 | 			checkbox.setFocusPainted(false);
73 | 			checkbox.setBorderPainted(true);
74 | 			checkbox.setBorder(isSelected ?
75 | 					UIManager.getBorder(
76 | 							"List.focusCellHighlightBorder") : noFocusBorder);
77 | 			return checkbox;
78 | 		}
79 | 	}
80 | }
81 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/JAudioPlayer.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.controls;
  2 | 
  3 | import java.awt.Dimension;
  4 | import java.awt.FlowLayout;
  5 | import java.awt.event.MouseEvent;
  6 | import java.awt.event.MouseListener;
  7 | import java.util.concurrent.TimeUnit;
  8 | 
  9 | import javax.sound.sampled.Clip;
 10 | import javax.sound.sampled.LineEvent;
 11 | import javax.sound.sampled.LineListener;
 12 | import javax.swing.JButton;
 13 | import javax.swing.JLabel;
 14 | import javax.swing.JPanel;
 15 | import javax.swing.JSlider;
 16 | import javax.swing.Timer;
 17 | 
 18 | import dev.lb.sound.ogg.JOrbisDecoder;
 19 | 
 20 | public class JAudioPlayer extends JPanel implements MouseListener{
 21 | 	private static final long serialVersionUID = -7802517197319750907L;
 22 | 
 23 | 	private Clip sound;
 24 | 	
 25 | 	private JButton playpause;
 26 | 	private JButton stop;
 27 | 	private JSlider progress;
 28 | 	
 29 | 	private JPanel contentHolder;
 30 | 	private JLabel done;
 31 | 	private JLabel total;
 32 | 	private Timer barUpdater;
 33 | 	
 34 | 	private boolean playing;
 35 | 	private boolean pressing;
 36 | 	
 37 | 	public JAudioPlayer(){
 38 | 		super();
 39 | 		contentHolder = new JPanel();
 40 | 		contentHolder.setLayout(new FlowLayout());
 41 | 		
 42 | 		playpause = new JButton("Play");
 43 | 		playpause.addActionListener((e) -> {
 44 | 			if(playing){
 45 | 				pause();
 46 | 			}else{
 47 | 				play();
 48 | 			}
 49 | 		});
 50 | 		playpause.setPreferredSize(new Dimension(100, playpause.getPreferredSize().height));
 51 | 		stop = new JButton("Stop");
 52 | 		stop.addActionListener((e) -> {
 53 | 			stop(true);
 54 | 		});
 55 | 		stop.setPreferredSize(new Dimension(100, stop.getPreferredSize().height));
 56 | 		
 57 | 		progress = new JSlider();
 58 | 		progress.setPreferredSize(new Dimension(200,progress.getPreferredSize().height));
 59 | 		progress.addMouseListener(this);
 60 | 		progress.setSnapToTicks(false);
 61 | 		
 62 | 		barUpdater = new Timer(50, (e) -> updateSlider());
 63 | 		
 64 | 		done = new JLabel("00:00");
 65 | 		total = new JLabel("00:00");
 66 | 		
 67 | 		pressing = false;
 68 | 		
 69 | 		
 70 | 		contentHolder.add(playpause);
 71 | 		contentHolder.add(done);
 72 | 		contentHolder.add(progress);
 73 | 		contentHolder.add(total);
 74 | 		contentHolder.add(stop);
 75 | 		this.add(contentHolder);
 76 | 	}
 77 | 	
 78 | 	public JAudioPlayer(Clip clip){
 79 | 		this();
 80 | 		this.setClip(clip);
 81 | 	}
 82 | 	
 83 | 	public void play(){
 84 | 		playpause.setText("Pause");
 85 | 		if(sound == null || playing)
 86 | 			return;
 87 | 		playing = true;
 88 | 		barUpdater.start();
 89 | 		new Thread(sound::start).start();
 90 | 		updateSlider();
 91 | 	}
 92 | 	
 93 | 	public void pause(){
 94 | 		if(sound == null || !playing)
 95 | 			return;
 96 | 		barUpdater.stop();
 97 | 		playpause.setText("Play");
 98 | 		playing = false;
 99 | 		sound.stop();
100 | 		updateSlider();
101 | 	}
102 | 	
103 | 	public void stop(boolean force){
104 | 		playpause.setText("Play");
105 | 		if(sound == null || (!playing && !force))
106 | 			return;
107 | 		barUpdater.stop();
108 | 		sound.stop();
109 | 		sound.flush();
110 | 		sound.setFramePosition(0);
111 | 		playing = false;
112 | 		updateSlider();
113 | 	}
114 | 	
115 | 	
116 | 	public void setClip(Clip c){
117 | 		reset();
118 | 		sound = c;
119 | 		sound.addLineListener(new LineListener(){
120 | 		    public void update(LineEvent e){
121 | 		        if(e.getType() == LineEvent.Type.STOP){
122 | 		            stop(false);
123 | 		        }
124 | 		    }
125 | 		});
126 | 		progress.setMinimum(0);
127 | 		progress.setMaximum(sound.getFrameLength());
128 | 		int sec = JOrbisDecoder.getLengthInSeconds(sound);
129 | 		total.setText(String.format("%02d:%02d", 
130 | 			    TimeUnit.SECONDS.toMinutes(sec),
131 | 			    TimeUnit.SECONDS.toSeconds(sec) - 
132 | 			    TimeUnit.MINUTES.toSeconds(TimeUnit.SECONDS.toMinutes(sec))));
133 | 	}
134 | 	
135 | 	public void updateSlider(){
136 | 		if(sound == null)
137 | 			return;
138 | 		if(!pressing)
139 | 			progress.setValue(sound.getFramePosition());
140 | 		int sec = JOrbisDecoder.getPlayTimeInSeconds(sound);
141 | 		done.setText(String.format("%02d:%02d", 
142 | 			    TimeUnit.SECONDS.toMinutes(sec),
143 | 			    TimeUnit.SECONDS.toSeconds(sec) - 
144 | 			    TimeUnit.MINUTES.toSeconds(TimeUnit.SECONDS.toMinutes(sec))));
145 | 		done.repaint();
146 | 	}
147 | 	
148 | 	public void reset(){
149 | 		if(sound == null)
150 | 			return;
151 | 		barUpdater.stop();
152 | 		sound.stop();
153 | 		sound.flush();
154 | 		sound = null;
155 | 		playing = false;
156 | 		progress.setValue(0);
157 | 		done.setText("00:00");
158 | 		total.setText("00:00");
159 | 	}
160 | 
161 | 	@Override
162 | 	public void mouseClicked(MouseEvent e) {}
163 | 	@Override
164 | 	public void mouseEntered(MouseEvent e) {}
165 | 	@Override
166 | 	public void mouseExited(MouseEvent e) {}
167 | 	@Override
168 | 	public void mousePressed(MouseEvent e) {
169 | 		pressing = true;
170 | 	}
171 | 
172 | 	
173 | 	@Override
174 | 	public void mouseReleased(MouseEvent e) {
175 | 		if(sound != null && progress.getValue() != sound.getFramePosition())
176 | 			sound.setFramePosition(progress.getValue());
177 | 		pressing = false;
178 | 	}
179 | 
180 | 	@Override
181 | 	public void setPreferredSize(Dimension preferredSize) {}
182 | 	
183 | }
184 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/JDraggableScrollPane.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.Component;
 4 | import java.awt.Point;
 5 | import java.awt.Rectangle;
 6 | import java.awt.event.MouseEvent;
 7 | import java.awt.event.MouseListener;
 8 | import java.awt.event.MouseMotionListener;
 9 | 
10 | import javax.swing.JComponent;
11 | import javax.swing.JScrollPane;
12 | import javax.swing.JViewport;
13 | 
14 | public class JDraggableScrollPane extends JScrollPane implements MouseMotionListener, MouseListener{
15 | 	private static final long serialVersionUID = -3429376543623295066L;
16 | 
17 | 	private Point currentDrag;
18 | 
19 | 	public JDraggableScrollPane(Component view, int vsbPolicy, int hsbPolicy) {
20 | 		super(view, vsbPolicy, hsbPolicy);
21 | 		this.getViewport().getView().addMouseMotionListener(this);
22 | 		this.getViewport().getView().addMouseListener(this);
23 | 	}
24 | 
25 | 	public JDraggableScrollPane(Component view) {
26 | 		super(view);
27 | 		if(this.getViewport().getView() != null){
28 | 			this.getViewport().getView().addMouseMotionListener(this);
29 | 			this.getViewport().getView().addMouseListener(this);
30 | 		}
31 | 	}
32 | 
33 | 	@Override
34 | 	public void mouseDragged(MouseEvent e) {
35 | 		if (currentDrag != null) {
36 |             JViewport viewPort = getViewport();
37 |             if (viewPort != null) {
38 |                 int deltaX = currentDrag.x - e.getX();
39 |                 int deltaY = currentDrag.y - e.getY();
40 | 
41 |                 Rectangle view = viewPort.getViewRect();
42 |                 view.x += deltaX;
43 |                 view.y += deltaY;
44 | 
45 |                 ((JComponent) getViewport().getView()).scrollRectToVisible(view);
46 |             }
47 |         }
48 | 	}
49 | 
50 | 	@Override
51 | 	public void mousePressed(MouseEvent e) {
52 | 		currentDrag = new Point(e.getPoint());
53 | 	}
54 | 	
55 | 	@Override
56 | 	public void mouseMoved(MouseEvent e) {}
57 | 	@Override
58 | 	public void mouseEntered(MouseEvent e) {}
59 | 	@Override
60 | 	public void mouseExited(MouseEvent e) {}
61 | 	@Override
62 | 	public void mouseClicked(MouseEvent e) {}
63 | 	@Override
64 | 	public void mouseReleased(MouseEvent e) {}
65 | }
66 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/JHistoryTextField.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.event.KeyEvent;
 4 | import java.awt.event.KeyListener;
 5 | import java.util.ArrayList;
 6 | import java.util.List;
 7 | 
 8 | import javax.swing.JTextField;
 9 | 
10 | public class JHistoryTextField extends JTextField implements KeyListener{
11 | 	private static final long serialVersionUID = 4185648576613819237L;
12 | 	
13 | 	private List<String> history;
14 | 	private int historyIndex;
15 | 	private String temp;
16 | 	
17 | 	public JHistoryTextField(){
18 | 		super();
19 | 		history = new ArrayList<>();
20 | 		historyIndex = 0;
21 | 		addKeyListener(this);
22 | 	}
23 | 	
24 | 	public void clearHistory(){
25 | 		history.clear();
26 | 	}
27 | 	
28 | 	public void addHistory(){
29 | 		history.add(getText());
30 | 		temp = "";
31 | 		historyIndex = history.size();
32 | 		setText("");
33 | 	}
34 | 
35 | 	public void updateText(){
36 | 		setText(history.get(historyIndex));
37 | 	}
38 | 	
39 | 	@Override
40 | 	public void keyPressed(KeyEvent e) {
41 | 		if(e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_KP_UP){
42 | 			historyIndex--;
43 | 			if(history.isEmpty()) return;
44 | 			if(historyIndex == history.size() - 1){
45 | 				temp = getText();
46 | 			}
47 | 			if(historyIndex < 0){
48 | 				historyIndex = 0;
49 | 			}
50 | 			updateText();
51 | 		}else if(e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_KP_DOWN){
52 | 			historyIndex++;
53 | 			if(historyIndex == history.size()){
54 | 				setText(temp);
55 | 			}else if(historyIndex > history.size()){
56 | 				historyIndex = history.size();
57 | 			}else{
58 | 				updateText();
59 | 			}
60 | 		}
61 | 	}
62 | 
63 | 	@Override
64 | 	public void keyReleased(KeyEvent e) {}
65 | 
66 | 	@Override
67 | 	public void keyTyped(KeyEvent e) {}
68 | 		
69 | }
70 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/JImageViewer.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.Dimension;
 4 | import java.awt.Graphics;
 5 | import java.awt.Image;
 6 | import java.awt.event.MouseWheelEvent;
 7 | import java.awt.event.MouseWheelListener;
 8 | import java.awt.image.BufferedImage;
 9 | 
10 | import javax.swing.JPanel;
11 | 
12 | public class JImageViewer extends JPanel implements MouseWheelListener{
13 | 	private static final long serialVersionUID = -4208234595443517732L;
14 | 
15 | 	private Image image;
16 | 	private Image overlay;
17 | 	
18 | 	private double scrollFactor = 1.0D;
19 | 	
20 | 	public JImageViewer(Image mainImage) {
21 | 		image = mainImage;
22 | 		this.addMouseWheelListener(this);
23 | 	}
24 | 	
25 | 	@Override
26 | 	protected void paintComponent(Graphics g) {
27 | 		super.paintComponent(g);
28 | 		g.drawImage(image, 0, 0, (int) (getPreferredSize().width * scrollFactor), (int) (getPreferredSize().height * scrollFactor), getBackground(), this);
29 | 		if(overlay != null){
30 | 			g.drawImage(overlay, 0, 0, (int) (getPreferredSize().width * scrollFactor), (int) (getPreferredSize().height * scrollFactor), getBackground(), this);
31 | 		}
32 | 	}
33 | 	
34 | 	protected Image getMainImage(){
35 | 		return image;
36 | 	}
37 | 	
38 | 	public Image getOverlay() {
39 | 		return overlay;
40 | 	}
41 | 
42 | 	public void setOverlay(Image overlay) {
43 | 		this.overlay = overlay;
44 | 	}
45 | 
46 | 	
47 | 	@Override
48 | 	public Dimension getPreferredSize(){
49 | 		return new Dimension((int) (image.getWidth(this) * scrollFactor), (int) (image.getHeight(this) * scrollFactor));
50 | 	}
51 | 
52 | 	@Override
53 | 	public Dimension getMinimumSize(){
54 | 		return getPreferredSize();
55 | 	}
56 | 	
57 | 	@Override
58 | 	public Dimension getMaximumSize(){
59 | 		return getPreferredSize();
60 | 	}
61 | 	
62 | 	public void setOverlay(BufferedImage overlay2) {
63 | 		overlay = overlay2;
64 | 	}
65 | 
66 | 	@Override
67 | 	public void mouseWheelMoved(MouseWheelEvent e) {
68 | 		int clicks = e.getWheelRotation();
69 | 		if(clicks < 0 && scrollFactor < 5){ //ZOOM IN
70 | 			scrollFactor *= 1.25D;
71 | 		}else if(clicks > 0 && scrollFactor > 0.2){ //ZOOM OUT
72 | 			scrollFactor /= 1.25D;
73 | 		}
74 | 		this.revalidate();
75 | 	}
76 | 
77 | }
78 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/JSpriteViewer.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.Dimension;
 4 | import java.awt.Graphics;
 5 | import java.awt.event.MouseWheelEvent;
 6 | import java.awt.image.BufferedImage;
 7 | 
 8 | public class JSpriteViewer extends JImageViewer{
 9 | 	private static final long serialVersionUID = -5063070371711033414L;
10 | 	public static final BufferedImage EMPTY_SPRITE;
11 | 	static{
12 | 		EMPTY_SPRITE = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB);
13 | 		EMPTY_SPRITE.createGraphics().drawString("No sprite", 20, 50);
14 | 	}
15 | 	
16 | 	private BufferedImage currentSprite = EMPTY_SPRITE;
17 | 	private BufferedImage currentSpriteF = EMPTY_SPRITE;
18 | 	private boolean filter;
19 | 	private int cx, cy, cw, ch;
20 | 	
21 | 	public JSpriteViewer(BufferedImage mainImage, BufferedImage filterImage) {
22 | 		super(mainImage);
23 | 		this.setOverlay(filterImage);
24 | 	}
25 | 
26 | 	@Override
27 | 	public Dimension getPreferredSize() {
28 | 		return new Dimension(0, 0);
29 | 	}
30 | 	
31 | 	public void setSprite(int x, int y, int width, int height){
32 | 		currentSprite = ((BufferedImage) getMainImage()).getSubimage(x, y, width, height);
33 | 		currentSpriteF = getOverlay() == null ? null : ((BufferedImage) getOverlay()).getSubimage(x, y, width, height);
34 | 		cx = x;
35 | 		cy = y;
36 | 		cw = width;
37 | 		ch = height;
38 | 		this.repaint();
39 | 	}
40 | 	
41 | 	public void setNoSprite(){
42 | 		currentSprite = EMPTY_SPRITE;
43 | 		cx = 0;
44 | 		cy = 0;
45 | 		cw = 0;
46 | 		ch = 0;
47 | 		this.repaint();
48 | 	}
49 | 
50 | 	public void setUseFilter(boolean useFilter){
51 | 		filter = useFilter;
52 | 		repaint();
53 | 	}
54 | 	
55 | 	@Override
56 | 	public void mouseWheelMoved(MouseWheelEvent e) {
57 | 		//No scrolling allowed
58 | 	}
59 | 
60 | 	@Override
61 | 	protected void paintComponent(Graphics g) {
62 | 		double ratio = ((double) currentSprite.getHeight(this) / (double) currentSprite.getWidth(this));
63 | 		double thisRatio = ((double) getHeight() / (double) getWidth());
64 | 		int scaleWidth, scaleHeight, startX, startY;
65 | 		if(ratio < thisRatio){//Wide
66 | 			scaleWidth = getWidth();
67 | 			scaleHeight = (int) (getWidth() *  ratio);
68 | 			startX = 0;
69 | 			startY = (getHeight() - scaleHeight) / 2;
70 | 		}else{//Tall
71 | 			scaleWidth = (int) (getHeight() * (1D / ratio));
72 | 			scaleHeight = getHeight();
73 | 			startX = (getWidth() - scaleWidth) / 2;
74 | 			startY = 0;
75 | 		}
76 | 		g.clearRect(0, 0, getWidth(), getHeight());
77 | 		g.drawImage(filter ? currentSpriteF : currentSprite, startX, startY, scaleWidth, scaleHeight, this);
78 | 	}
79 | 
80 | 	public int getCx() {
81 | 		return cx;
82 | 	}
83 | 
84 | 	public int getCy() {
85 | 		return cy;
86 | 	}
87 | 
88 | 	public int getCw() {
89 | 		return cw;
90 | 	}
91 | 
92 | 	public int getCh() {
93 | 		return ch;
94 | 	}
95 | }
96 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/LaunchWindow.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.controls;
  2 | 
  3 | import java.awt.BorderLayout;
  4 | import java.awt.Dimension;
  5 | import java.io.File;
  6 | import java.io.FileInputStream;
  7 | import java.io.IOException;
  8 | import java.nio.file.Files;
  9 | import java.util.ArrayList;
 10 | import java.util.HashMap;
 11 | import java.util.List;
 12 | import java.util.Map;
 13 | 
 14 | import javax.swing.DefaultListModel;
 15 | import javax.swing.ImageIcon;
 16 | import javax.swing.JButton;
 17 | import javax.swing.JCheckBox;
 18 | import javax.swing.JFrame;
 19 | import javax.swing.JOptionPane;
 20 | import javax.swing.JPanel;
 21 | import javax.swing.JScrollPane;
 22 | import javax.swing.ListModel;
 23 | import javax.swing.border.EmptyBorder;
 24 | 
 25 | import com.google.gson.Gson;
 26 | import com.google.gson.JsonElement;
 27 | import com.google.gson.JsonObject;
 28 | import com.google.gson.JsonParser;
 29 | 
 30 | import dev.lb.cellpacker.CellPackerMain;
 31 | import dev.lb.cellpacker.Utils;
 32 | import dev.lb.cellpacker.structure.ResourceCategory;
 33 | import dev.lb.cellpacker.structure.ResourceFile;
 34 | import dev.lb.cellpacker.structure.Script;
 35 | import dev.lb.cellpacker.structure.resource.JsonResource;
 36 | 
 37 | public class LaunchWindow extends JFrame{
 38 | 	private static final long serialVersionUID = 2286569184156822247L;
 39 | 	
 40 | 	public static final int NO_PROBLEM = 0;
 41 | 	public static final int NEED_SETUP = 1;
 42 | 	public static final int NOT_DEADCELLS = 2; 
 43 | 	
 44 | 	private Map<JCheckBox,Script> chk2script = new HashMap<>();
 45 | 	@SuppressWarnings("unused")
 46 | 	private boolean update;
 47 | 	private JButton launch;
 48 | 	private JButton launchgl;
 49 | 	private JButton reload;
 50 | 	private JButton pack;
 51 | 	private JButton help;
 52 | 	private CheckBoxList chl;
 53 | 	
 54 | 	public LaunchWindow(boolean update){
 55 | 		super("CellPacker Launcher 2.1");
 56 | 		this.update = update;
 57 | 		
 58 | 		JPanel content = new JPanel(new BorderLayout());
 59 | 		JPanel buttons = new JPanel();
 60 | 		//buttons.setLayout(new BoxLayout(buttons, BoxLayout.X_AXIS));
 61 | 		chl = new CheckBoxList();
 62 | 		content.add(new JScrollPane(chl), BorderLayout.CENTER);
 63 | 		launch = new JButton("Start Dead Cells");
 64 | 		launchgl = new JButton("Start Dead Cells (OpenGL - Legacy)");
 65 | 		pack = new JButton("Start CellPacker");
 66 | 		help = new JButton("Help / About");
 67 | 		launch.setBorder(new EmptyBorder(5, 10, 5, 10));
 68 | 		launchgl.setBorder(new EmptyBorder(5, 10, 5, 10));
 69 | 		pack.setBorder(new EmptyBorder(5, 10, 5, 10));
 70 | 		help.setBorder(new EmptyBorder(5, 10, 5, 10));
 71 | 		launch.setPreferredSize(new Dimension(150, 50));
 72 | 		launchgl.setPreferredSize(new Dimension(150, 50));
 73 | 		reload = new JButton("Reload scripts");
 74 | 		reload.addActionListener((e) -> {
 75 | 			chl.setModel(new DefaultListModel<>());
 76 | 			if(setupCorrect()){
 77 | 				reloadScripts();
 78 | 			}else{
 79 | 				chl.addCheckbox(new JCheckBox("<Error>"));
 80 | 			}
 81 | 		});
 82 | 		reload.setPreferredSize(new Dimension(150, 50));
 83 | 		pack.setPreferredSize(new Dimension(150, 50));
 84 | 		help.setPreferredSize(new Dimension(150, 50));
 85 | 		help.addActionListener((e) -> {
 86 | 			Utils.showAboutDialog("<html>For more information read the Readme on the github page:<br>https://github.com/ReBuilders101/CellPacker/blob/master/README.md", "About / Help", "https://github.com/ReBuilders101/CellPacker/blob/master/README.md");
 87 | 		});
 88 | 		pack.addActionListener((e) -> {
 89 | 			CellPackerMain.mainFrame = new MainWindow();
 90 | 			CellPackerMain.mainFrame.setVisible(true);
 91 | 			CellPackerMain.mainFrame.setIconImage(new ImageIcon(CellPackerMain.class.getResource("/resources/ico.png")).getImage());
 92 | 			this.dispose();
 93 | 		});
 94 | 		launch.addActionListener((e) -> {
 95 | 			launch(false);
 96 | 		});
 97 | 		launchgl.addActionListener((e) -> {
 98 | 			launch(true);
 99 | 		});
100 | 		buttons.add(launch);
101 | 		buttons.add(launchgl);
102 | 		buttons.add(pack);
103 | 		buttons.add(reload);
104 | 		buttons.add(help);
105 | 		content.add(buttons, BorderLayout.SOUTH);
106 | 		
107 | 		if(setupCorrect()){
108 | 			reloadScripts();
109 | 		}else{
110 | 			chl.addCheckbox(new JCheckBox("<Error>"));
111 | 		}
112 | 		
113 | 		
114 | 		this.add(content);
115 | 		this.setPreferredSize(new Dimension(800, 300));
116 | 		this.setMinimumSize(new Dimension(400, 200));
117 | 		this.pack();
118 | 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
119 | 	}
120 | 	
121 | 	private void reloadScripts(){
122 | 		//Get all available patches
123 | 		File patchDir = new File("./cpscripts");
124 | 		for(File script : patchDir.listFiles((e) -> e.getPath().endsWith(".patch") && e.isFile())){
125 | 			//read file to json
126 | 			byte[] data = new byte[(int) script.length()];
127 | 			try(FileInputStream fis = new FileInputStream(script)){
128 | 				fis.read(data);
129 | 			} catch (IOException e1) {
130 | 				e1.printStackTrace();
131 | 			}
132 | 			String json = new String(data);
133 | 			if(Utils.isJsonValid(json)){ //Can be parsed
134 | 				JsonElement jsonElement = new JsonParser().parse(json);
135 | 				if(jsonElement.isJsonObject()){
136 | 					String name = "";
137 | 					String desc = "";
138 | 					if(jsonElement.getAsJsonObject().has("info") && jsonElement.getAsJsonObject().get("info").isJsonObject()){
139 | 						System.out.println("Found info section");
140 | 						JsonObject info = jsonElement.getAsJsonObject().get("info").getAsJsonObject();
141 | 						name = info.has("name") ? info.get("name").getAsString() : script.getName();
142 | 						desc = info.has("desc") ? info.get("desc").getAsString() : "No description";
143 | 					}else{
144 | 						System.out.println("Found no info section");
145 | 						//Add box by file name
146 | 						name = script.getName();
147 | 						desc = "No description";
148 | 					}
149 | 					JsonObject add = new JsonObject();
150 | 					if(jsonElement.getAsJsonObject().has("add") && jsonElement.getAsJsonObject().get("add").isJsonObject()){
151 | 						add = jsonElement.getAsJsonObject().get("add").getAsJsonObject();
152 | 					}
153 | 					JsonObject remove = new JsonObject();
154 | 					if(jsonElement.getAsJsonObject().has("remove") && jsonElement.getAsJsonObject().get("remove").isJsonObject()){
155 | 						add = jsonElement.getAsJsonObject().get("remove").getAsJsonObject();
156 | 					}
157 | 					Script sc = new Script(name, desc, add, remove);
158 | 					JCheckBox box = new JCheckBox(name);
159 | 					box.setToolTipText(desc);
160 | 					chk2script.put(box, sc);
161 | 					chl.addCheckbox(box);
162 | 				}else{
163 | 					JOptionPane.showMessageDialog(this, "The file " + script.getName() + " is not a valid JSON Script and cannot be used as a script", "Error", JOptionPane.ERROR_MESSAGE);
164 | 				}
165 | 			}else{
166 | 				JOptionPane.showMessageDialog(this, "The file " + script.getName() + " is not valid JSON and cannot be used as a script", "Error", JOptionPane.ERROR_MESSAGE);
167 | 			}
168 | 			
169 | 			//chl.addCheckbox(new JCheckBox(script.getName().substring(0, script.getName().lastIndexOf('.'))));
170 | 		}
171 | 	}
172 | 	
173 | 	private void launch(boolean gl){
174 | 		//Patch resource
175 | 		ResourceFile rf = ResourceFile.fromFile(new File("./res.pak.cpbackup"));
176 | 		JsonResource datacdb = (JsonResource) rf.getRootContainer().getResource("data.cdb");
177 | 		JsonObject cdbJson = new JsonParser().parse((String) datacdb.getContent()).getAsJsonObject();
178 | 		ListModel<JCheckBox> model = chl.getModel();
179 | 		List<Script> toApply = new ArrayList<>();
180 | 		for(int i = 0; i < model.getSize(); i++){
181 | 			if(model.getElementAt(i).isSelected()) toApply.add(chk2script.get(model.getElementAt(i))); //If the checkbox is selected, put this script on the list
182 | 		}
183 | 		//Apply every script
184 | 		for(Script script : toApply){
185 | 			if(script.getRemoveSection() != null)
186 | 				Utils.removeJSON(cdbJson, script.getRemoveSection());
187 | 			if(script.getAddSection() != null){
188 | 				Utils.addJSON(cdbJson, script.getAddSection());
189 | 			}
190 | 		}
191 | 		String newdata = new Gson().toJson(cdbJson);
192 | 		JsonResource cdbNew = new JsonResource(datacdb.getName(), datacdb.getPath(), datacdb.getMagicNumber(), newdata.getBytes());
193 | 		ResourceCategory cat = rf.getRootContainer();
194 | 		cat.replaceResource("data.cdb", cdbNew);
195 | 		ResourceFile newRf = ResourceFile.fromTree(cat);
196 | 		newRf.writeToFile(new File("./res.pak"));
197 | 		
198 | 		//Replacement is done, now launch
199 | 		File deadCellsExe = gl ? new File("./deadcells_gl.exe") : new File("./deadcells.exe");
200 | 		try {
201 | 			new ProcessBuilder(deadCellsExe.getAbsolutePath()).start();
202 | 		} catch (IOException e1) {
203 | 			e1.printStackTrace();
204 | 			JOptionPane.showMessageDialog(this, "Error while launching: " + e1.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
205 | 		}
206 | 	}
207 | 	
208 | 	private boolean setupCorrect(){
209 | 		boolean isdc = true;
210 | 		if(!new File("./deadcells.exe").exists()){
211 | 			launch.setEnabled(false);
212 | 			isdc = false;
213 | 		}
214 | 		if(!new File("./deadcells_gl.exe").exists()){
215 | 			launchgl.setEnabled(false);
216 | 			isdc = false;
217 | 		}
218 | 		if(!new File("./res.pak").exists()){
219 | 			launch.setEnabled(false);
220 | 			launchgl.setEnabled(false);
221 | 			isdc = false;
222 | 		}
223 | 		if(isdc){ //Only continue initialization if inside dead cells folder
224 | 			if(!new File("./cpscripts/").exists()){
225 | 				new File("./cpscripts/").mkdir();
226 | 			}
227 | 			if(!new File("./res.pak.cpbackup").exists()){//No backup, so res.pak is the original
228 | 				try {
229 | 					Files.copy(new File("./res.pak").toPath(), new File("./res.pak.cpbackup").toPath());
230 | 				} catch (IOException e) {
231 | 					e.printStackTrace();
232 | 					JOptionPane.showMessageDialog(this, "An error occurred while copying res.pak to res.pak.cpbackup: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
233 | 					return false;
234 | 				}
235 | 			}
236 | 			return true;
237 | 		}else{
238 | 			JOptionPane.showMessageDialog(this, "<html>One of the files 'res.pak', 'deadcells.exe' and 'deadcells_gl.exe' could not be found.<br>This may be because CellPacker.jar is not placed in the Dead Cells folder", "Error", JOptionPane.ERROR_MESSAGE);
239 | 			return false;
240 | 		}
241 | 	}
242 | }
243 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/MainWindow.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.controls;
  2 | 
  3 | import java.awt.BorderLayout;
  4 | import java.awt.Dimension;
  5 | import java.awt.event.ComponentEvent;
  6 | import java.awt.event.ComponentListener;
  7 | import java.awt.event.WindowEvent;
  8 | import java.awt.event.WindowListener;
  9 | 
 10 | import javax.swing.BoxLayout;
 11 | import javax.swing.JCheckBoxMenuItem;
 12 | import javax.swing.JFileChooser;
 13 | import javax.swing.JFrame;
 14 | import javax.swing.JLabel;
 15 | import javax.swing.JMenu;
 16 | import javax.swing.JMenuBar;
 17 | import javax.swing.JMenuItem;
 18 | import javax.swing.JOptionPane;
 19 | import javax.swing.JPanel;
 20 | import javax.swing.JScrollPane;
 21 | import javax.swing.JSplitPane;
 22 | import javax.swing.JTextField;
 23 | import javax.swing.JTree;
 24 | import javax.swing.border.EmptyBorder;
 25 | import javax.swing.event.DocumentEvent;
 26 | import javax.swing.event.DocumentListener;
 27 | import javax.swing.event.TreeSelectionEvent;
 28 | import javax.swing.event.TreeSelectionListener;
 29 | import javax.swing.filechooser.FileNameExtensionFilter;
 30 | import javax.swing.tree.DefaultMutableTreeNode;
 31 | import javax.swing.tree.DefaultTreeModel;
 32 | import javax.swing.tree.TreePath;
 33 | 
 34 | import dev.lb.cellpacker.Utils;
 35 | import dev.lb.cellpacker.structure.ResourceFile;
 36 | import dev.lb.cellpacker.structure.SearchableResourceViewManager;
 37 | import dev.lb.cellpacker.structure.view.ResourceView;
 38 | import dev.lb.cellpacker.structure.view.StaticResourceView;
 39 | 
 40 | public class MainWindow extends JFrame implements TreeSelectionListener, WindowListener, ComponentListener, DocumentListener{
 41 | 	private static final long serialVersionUID = 3681709759315746587L;
 42 | 	
 43 | 	private JSplitPane split;
 44 | 	
 45 | 	private JTree tree;
 46 | 	private SearchableResourceViewManager view;
 47 | 	private JMenu resourceMenu;
 48 | 	private JTextField searchField;
 49 | 	private boolean fixCDB;
 50 | 	
 51 | 	public MainWindow(){
 52 | 		super("Cellpacker Editor 2.1");
 53 | 		split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
 54 | 		fixCDB = true;
 55 | 		
 56 | 		DefaultMutableTreeNode root = new DefaultMutableTreeNode(new StaticResourceView("No Files", "No files loaded", new byte[0]));
 57 | 		tree =  new JTree(root);
 58 | 		tree.setSelectionPath(new TreePath(root));
 59 | 		tree.addTreeSelectionListener(this);
 60 | 		this.setPreferredSize(new Dimension(800, 600));
 61 | 
 62 | 		JPanel searchCon = new JPanel();
 63 | 		searchCon.setLayout(new BoxLayout(searchCon, BoxLayout.X_AXIS));
 64 | 		searchCon.setBorder(new EmptyBorder(3, 5, 5, 2));
 65 | 		JLabel fixedDesc = new JLabel("Search: ");
 66 | 		searchField = new JTextField();
 67 | 		searchField.getDocument().addDocumentListener(this);
 68 | 		fixedDesc.setMaximumSize(fixedDesc.getPreferredSize());
 69 | 		searchCon.add(fixedDesc);
 70 | 		searchCon.add(searchField);
 71 | 		
 72 | 		JPanel rightCon = new JPanel(new BorderLayout());
 73 | 		rightCon.add(new JScrollPane(tree), BorderLayout.CENTER);
 74 | 		rightCon.add(searchCon, BorderLayout.SOUTH);
 75 | 		split.setRightComponent(rightCon);
 76 | 		
 77 | 		
 78 | 		JMenuItem reuseable;
 79 | 		JMenuBar menu = new JMenuBar();
 80 | 		JMenu file = new JMenu("File");
 81 | 		//OPEN
 82 | 		reuseable = new JMenuItem("Open");
 83 | 		reuseable.addActionListener((e) -> {
 84 | 			if(view != null){
 85 | 				if(JOptionPane.showConfirmDialog(this, "A resource file is already opened. Unsaved changes will be lost. Do you want to continue?", "Open Resource",
 86 | 						JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) != JOptionPane.YES_OPTION){
 87 | 					return;
 88 | 				}
 89 | 			}
 90 | 			JFileChooser jfc =  new JFileChooser(".");
 91 | 			jfc.setFileFilter(new FileNameExtensionFilter("Dead Cells Resource File", "*.pak", "pak", ".pak"));
 92 | 			int result = jfc.showOpenDialog(this);
 93 | 			if(result == JFileChooser.APPROVE_OPTION && jfc.getSelectedFile() != null){
 94 | 				setResourceFileOnStart(ResourceFile.fromFile(jfc.getSelectedFile()));
 95 | 			}
 96 | 		});
 97 | 		reuseable.setToolTipText("Open a Dead Cells resource file to view its contents (usually called res.pak)");
 98 | 		file.add(reuseable);
 99 | 		//SAVE
100 | 		reuseable = new JMenuItem("Save");
101 | 		reuseable.setToolTipText("Save the currently opened resource file with all modifications. (To use in-game, simply replace the original res.pak with this one)");
102 | 		reuseable.addActionListener((e) -> {
103 | 			if(view == null){
104 | 				JOptionPane.showMessageDialog(this, "No resource is opened", "Error", JOptionPane.ERROR_MESSAGE);
105 | 				return;
106 | 			}
107 | 			JFileChooser jfc = new JFileChooser();
108 | 			jfc.setFileFilter(new FileNameExtensionFilter("Dead Cells Resource File", "*.pak", "pak", ".pak"));
109 | 			if(jfc.showSaveDialog(this) == JFileChooser.APPROVE_OPTION && jfc.getSelectedFile() != null){
110 | 				view.buildFileWithChanges().writeToFile(jfc.getSelectedFile());
111 | 			}
112 | 		});
113 | 		file.add(reuseable);
114 | 		file.addSeparator();
115 | 		//EXPORTALL
116 | 		reuseable = new JMenuItem("Export all");
117 | 		reuseable.setToolTipText("Export all resources to a folder. (and create a header template file for future imports)");
118 | 		reuseable.addActionListener((e) -> {
119 | 			if(view == null){
120 | 				JOptionPane.showMessageDialog(this, "No resource is opened", "Error", JOptionPane.ERROR_MESSAGE);
121 | 				return;
122 | 			}
123 | 			JFileChooser jfc = new JFileChooser();
124 | 			jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
125 | 			if(jfc.showSaveDialog(this) == JFileChooser.APPROVE_OPTION && jfc.getSelectedFile() != null){
126 | 				view.buildFileWithChanges().writeAllResources(jfc.getSelectedFile());
127 | 			}
128 | 		});
129 | 		file.add(reuseable);
130 | 		file.addSeparator();
131 | 		JCheckBoxMenuItem reuseable2 = new JCheckBoxMenuItem("Create fixed data.cdb", true);
132 | 		reuseable2.setToolTipText("The version of data.cdb included in res.pak can not be directly read by CastleDB. This will create a fixed version called data.exported.cdb");
133 | 		reuseable2.addChangeListener((e) ->{
134 | 			fixCDB = reuseable2.isSelected();
135 | 		});
136 | 		file.add(reuseable2);
137 | 		file.addSeparator();
138 | 		//CLOSE
139 | 		reuseable = new JMenuItem("Close");
140 | 		reuseable.setToolTipText("Closes the currently opened resource file");
141 | 		reuseable.addActionListener((e) -> {
142 | 			if(view == null){
143 | 				JOptionPane.showMessageDialog(this, "No resource is opened", "Error", JOptionPane.ERROR_MESSAGE);
144 | 				return;
145 | 			}
146 | 			if(JOptionPane.showConfirmDialog(this, "<html>Unsaved changes will be lost.<br>Are you sure you want to close the file?", "Close file", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
147 | 				view = null;
148 | 				DefaultMutableTreeNode root2 = new DefaultMutableTreeNode(new StaticResourceView("No Files", "No files loaded", new byte[0]));
149 | 				((DefaultTreeModel) tree.getModel()).setRoot(root2);
150 | 				tree.setSelectionPath(new TreePath(root));
151 | 			}
152 | 		});
153 | 		file.add(reuseable);
154 | 		//QUIT
155 | 		reuseable = new JMenuItem("Quit");
156 | 		reuseable.setToolTipText("Quit the program. Unsaved changes will be lost.");
157 | 		reuseable.addActionListener((e) -> {
158 | 			if(JOptionPane.showConfirmDialog(this, "<html>Unsaved changes will be lost.<br>Are you sure you want to quit?", "Quit program", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
159 | 				this.dispose();
160 | 			}
161 | 		});
162 | 		file.add(reuseable);
163 | 		file.setBorder(new EmptyBorder(0, 5, 0, 5));
164 | 		menu.add(file);
165 | 		
166 | 		JMenu edit = new JMenu("Edit");
167 | 		resourceMenu = new JMenu("Resource Options");
168 | 		resourceMenu.add("<No options available>");
169 | 		edit.add(resourceMenu);
170 | 		edit.addSeparator();
171 | 		//RESTORE
172 | 		reuseable = new JMenuItem("Restore all resources");
173 | 		reuseable.setToolTipText("Restore all resources to their original state");
174 | 		reuseable.addActionListener((e) -> {
175 | 			if(view == null){
176 | 				JOptionPane.showMessageDialog(this, "No resource is opened", "Error", JOptionPane.ERROR_MESSAGE);
177 | 				return;
178 | 			}
179 | 			if(JOptionPane.showConfirmDialog(this, "<html>Unsaved changes will be lost.<br>Are you sure you want to restore all resources?", "Restore resources", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
180 | 				//view.getViewsUnsorted().forEach((v) -> v.restoreAllResources(this));
181 | 			}
182 | 		});
183 | 		edit.add(reuseable);
184 | 		//RELOAD
185 | 		reuseable = new JMenuItem("Reload current resource");
186 | 		reuseable.setToolTipText("Reloads this component and the display elements.");
187 | 		reuseable.addActionListener((e) -> {
188 | 			if(view == null){
189 | 				JOptionPane.showMessageDialog(this, "No resource is opened", "Error", JOptionPane.ERROR_MESSAGE);
190 | 				return;
191 | 			}
192 | 			ResourceView rv = view.getResourceView(tree.getSelectionPath());
193 | 			if(rv == null){
194 | 				JOptionPane.showMessageDialog(this, "No resource is selected", "Error", JOptionPane.ERROR_MESSAGE);
195 | 				return;
196 | 			}
197 | 			rv.focusLost();
198 | 			rv.forceInit();
199 | 		});
200 | 		edit.add(reuseable);
201 | 		//SEARCH
202 | 		reuseable = new JMenuItem("Seach for resource");
203 | 		reuseable.setToolTipText("Search for a resource view");
204 | 		reuseable.addActionListener((e) -> {
205 | 			String term = JOptionPane.showInputDialog(this, "Search:", "Search for resource view", JOptionPane.QUESTION_MESSAGE);
206 | 			searchField.setText(term);
207 | 		});
208 | 		edit.add(reuseable);
209 | 		edit.setBorder(new EmptyBorder(0, 5, 0, 5));
210 | 		menu.add(edit);
211 | 		JMenu help = new JMenu("Help");
212 | 		reuseable = new JMenuItem("Show tutorial");
213 | 		reuseable.addActionListener((e) -> {
214 | 			Utils.showAboutDialog("<html>For more information read the Readme on the github page:<br>https://github.com/ReBuilders101/CellPacker/blob/master/README.md", "About / Help", "https://github.com/ReBuilders101/CellPacker/blob/master/README.md");
215 | 		});
216 | 		help.add(reuseable);
217 | 		help.addSeparator();
218 | 		reuseable = new JMenuItem("Show source code");
219 | 		reuseable.setToolTipText("The source code of this project is available on GitHub");
220 | 		reuseable.addActionListener((e) -> {
221 | 			Utils.showAboutDialog("<html>The source code of this project is available on GitHub:<br>https://github.com/ReBuilders101/CellPacker", "Source code", "https://github.com/ReBuilders101/CellPacker");
222 | 		});
223 | 		help.add(reuseable);
224 | 		help.addSeparator();
225 | 		reuseable = new JMenuItem("About");
226 | 		reuseable.setToolTipText("Show the projects readme-file");
227 | 		reuseable.addActionListener((e) -> {
228 | 			Utils.showAboutDialog("<html>Open the projects readme-file:<br>https://github.com/ReBuilders101/CellPacker/blob/master/README.md", "Source code", "https://github.com/ReBuilders101/CellPacker/blob/master/README.md");
229 | 		});
230 | 		help.add(reuseable);
231 | 		reuseable = new JMenuItem("About CastleDB");
232 | 		reuseable.setToolTipText("Information about CastleDB, the database used by Dead Cells");
233 | 		reuseable.addActionListener((e) -> {
234 | 			Utils.showAboutDialog("<html>CastleDB is used by Dead Cells to store information about levels, monsters, items and more.<br>CastleDB can be used to open and edit the file data.exported.cdb more easily:<br>http://castledb.org/", "Source code", "http://castledb.org/");
235 | 		});
236 | 		help.add(reuseable);
237 | 		help.setBorder(new EmptyBorder(0, 5, 0, 5));
238 | 		menu.add(help);
239 | 		
240 | 		split.setLeftComponent(((ResourceView) root.getUserObject()).getDisplay());
241 | 		
242 | 		split.setDividerLocation(0.8);
243 | 		
244 | 		this.setJMenuBar(menu);
245 | 		this.add(split);
246 | 		this.addWindowListener(this);
247 | 		this.addComponentListener(this);
248 | 		this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
249 | 		
250 | 		this.pack();
251 | 	}
252 | 
253 | 	public void setResourceFileOnStart(ResourceFile file){
254 | 		view = null;
255 | 		view = new SearchableResourceViewManager(file);
256 | 		view.setTree(tree);
257 | 		view.setSearchString("", tree);
258 | 		tree.setSelectionPath(new TreePath(tree.getModel().getRoot()));
259 | 	}
260 | 	
261 | 	public boolean fixCDB(){
262 | 		return fixCDB;
263 | 	}
264 | 	
265 | 	@Override
266 | 	public void valueChanged(TreeSelectionEvent e) {
267 | 		if(e.getOldLeadSelectionPath() != null){
268 | 			ResourceView ro = (ResourceView) ((DefaultMutableTreeNode) e.getOldLeadSelectionPath().getLastPathComponent()).getUserObject();
269 | 			ro.focusLost();
270 | 		}
271 | 		
272 | 		ResourceView rv = (ResourceView) (
273 | 				((DefaultMutableTreeNode) e.getPath().getLastPathComponent()).getUserObject());
274 | 		split.setLeftComponent(rv.getDisplay());
275 | 		split.setDividerLocation(0.8);
276 | 
277 | 		resourceMenu.removeAll();
278 | 		for(JMenuItem menu : rv.getContextMenu()){
279 | 			if(menu.getText().equals("$Sep$")){
280 | 				resourceMenu.addSeparator();
281 | 			}else{
282 | 				resourceMenu.add(menu);
283 | 			}
284 | 		}
285 | 	}
286 | 
287 | 	@Override
288 | 	public void windowClosing(WindowEvent e) {
289 | 		if(JOptionPane.showConfirmDialog(this, "<html>Unsaved changes will be lost.<br>Are you sure you want to quit?", "Quit program", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
290 | 			if(tree.getSelectionPath() != null)
291 | 				((ResourceView )((DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent()).getUserObject()).focusLost();
292 | 			this.dispose();
293 | 		}
294 | 	}
295 | 
296 | 	@Override
297 | 	public void componentResized(ComponentEvent e) {
298 | 		split.setDividerLocation(0.8);
299 | 	}
300 | 	
301 | 	@Override
302 | 	public void changedUpdate(DocumentEvent e) {
303 | 		if(tree.getSelectionPath() != null){
304 | 			ResourceView ro = (ResourceView) ((DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent()).getUserObject();
305 | 			ro.focusLost();
306 | 		}
307 | 
308 | 		tree.setSelectionPath(new TreePath(tree.getModel().getRoot()));
309 | 		if(view != null) view.setSearchString(searchField.getText(), tree);
310 | 	}
311 | 	
312 | 	@Override 
313 | 	public void insertUpdate(DocumentEvent e) {
314 | 		changedUpdate(e);
315 | 	}
316 | 	
317 | 	@Override
318 | 	public void removeUpdate(DocumentEvent e) {
319 | 		changedUpdate(e);
320 | 	}
321 | 	
322 | 	@Override public void windowActivated(WindowEvent e) {}
323 | 	@Override public void windowDeactivated(WindowEvent e) {}
324 | 	@Override public void windowDeiconified(WindowEvent e) {}
325 | 	@Override public void windowIconified(WindowEvent e) {}
326 | 	@Override public void windowOpened(WindowEvent e) {}
327 | 	@Override public void windowClosed(WindowEvent e) {}
328 | 	@Override public void componentHidden(ComponentEvent e) {}
329 | 	@Override public void componentMoved(ComponentEvent e) {}
330 | 	@Override public void componentShown(ComponentEvent e) {}
331 | }
332 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/SpriteSavingList.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.controls;
  2 | 
  3 | import java.util.Vector;
  4 | 
  5 | import javax.swing.JButton;
  6 | import javax.swing.JCheckBox;
  7 | import javax.swing.JList;
  8 | import javax.swing.JRadioButton;
  9 | import javax.swing.JTextArea;
 10 | import javax.swing.ListModel;
 11 | import javax.swing.event.ChangeEvent;
 12 | import javax.swing.event.ChangeListener;
 13 | import javax.swing.event.ListSelectionEvent;
 14 | import javax.swing.event.ListSelectionListener;
 15 | 
 16 | import dev.lb.cellpacker.structure.resource.AtlasResource.Sprite;
 17 | 
 18 | public class SpriteSavingList extends JList<Sprite> implements ListSelectionListener, ChangeListener{
 19 | 	private static final long serialVersionUID = 4434097800055693891L;
 20 | 
 21 | 	private JSpriteViewer connectedJSP;
 22 | 	private JTextArea connectedDetails;
 23 | 	private JRadioButton filter;
 24 | 	private JRadioButton normal;
 25 | 	private JCheckBox highlight;
 26 | 	private JButton anim;
 27 | 	
 28 | 	public SpriteSavingList() {
 29 | 		super();
 30 | 		this.addListSelectionListener(this);
 31 | 	}
 32 | 	public SpriteSavingList(Sprite[] listData) {
 33 | 		super(listData);
 34 | 		this.addListSelectionListener(this);
 35 | 	}
 36 | 	public SpriteSavingList(ListModel<Sprite> dataModel) {
 37 | 		super(dataModel);
 38 | 		this.addListSelectionListener(this);
 39 | 	}
 40 | 	public SpriteSavingList(Vector<? extends Sprite> listData) {
 41 | 		super(listData);
 42 | 		this.addListSelectionListener(this);
 43 | 	}
 44 | 
 45 | 	public void setJSP(JSpriteViewer jsp){
 46 | 		connectedJSP = jsp;
 47 | 	}
 48 | 	
 49 | 	public void setDetailsArea(JTextArea area){
 50 | 		connectedDetails = area;
 51 | 	}
 52 | 	
 53 | 	public boolean hasDetailsArea(){
 54 | 		return connectedDetails != null;
 55 | 	}
 56 | 	
 57 | 	public JSpriteViewer getJSP(){
 58 | 		return connectedJSP;
 59 | 	}
 60 | 	
 61 | 	public boolean hasJSP(){
 62 | 		return connectedJSP != null;
 63 | 	}
 64 | 	
 65 | 	public void setHighlightButton(JCheckBox h, JButton nh){
 66 | 		highlight = h;
 67 | 		anim = nh;
 68 | 		highlight.setEnabled(false);
 69 | 		anim.setEnabled(false);
 70 | 		//NO
 71 | 	}
 72 | 	
 73 | 	public void setRadioButtons(JRadioButton rbmain, JRadioButton rbfilt){
 74 | 		filter = rbfilt;
 75 | 		normal = rbmain;
 76 | 		filter.addChangeListener(this);
 77 | 		normal.addChangeListener(this);
 78 | 	}
 79 | 	
 80 | 	@Override
 81 | 	public void valueChanged(ListSelectionEvent e) {
 82 | 		Sprite sp = getSelectedValue();
 83 | 		if(connectedJSP != null){
 84 | 			connectedJSP.setSprite(sp.getX(), sp.getY(), sp.getWidth(), sp.getHeight());
 85 | 		}
 86 | 		if(connectedDetails != null){
 87 | 			connectedDetails.setText("");
 88 | 			connectedDetails.append("Sprite name: " + sp.getName() + "\n");
 89 | 			connectedDetails.append("Sprite size: " + sp.getWidth() + "x" + sp.getHeight() + "\n");
 90 | 			connectedDetails.append("Sprite position: " + sp.getX() + "|" + sp.getY() + "\n");
 91 | 			connectedDetails.append("Sprite offset: " + sp.getOffsetX() + "|" + sp.getOffsetY() + "\n");
 92 | 			connectedDetails.append("Sprite origin: " + sp.getOrigX() + "|" + sp.getOrigY());
 93 | 		}
 94 | 	}
 95 | 	@Override
 96 | 	public void stateChanged(ChangeEvent e) {
 97 | 		connectedJSP.setUseFilter(filter.isSelected());
 98 | 	}
 99 | 	
100 | 
101 | }
102 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/controls/TutorialWindow.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.controls;
 2 | 
 3 | import java.awt.BorderLayout;
 4 | import java.awt.CardLayout;
 5 | import java.awt.Dimension;
 6 | 
 7 | import javax.swing.Box;
 8 | import javax.swing.BoxLayout;
 9 | import javax.swing.JButton;
10 | import javax.swing.JFrame;
11 | import javax.swing.JLabel;
12 | import javax.swing.JPanel;
13 | 
14 | public class TutorialWindow extends JFrame{
15 | 	private static final long serialVersionUID = -2088638449931971957L;
16 | 
17 | 	public TutorialWindow(boolean mode){
18 | 		JPanel root = new JPanel(new BorderLayout());
19 | 		JPanel textCon = new JPanel();
20 | 		CardLayout card = new CardLayout();
21 | 		textCon.setLayout(card);
22 | 		root.add(textCon, BorderLayout.CENTER);
23 | 		
24 | 		JButton previous = new JButton("Previous");
25 | 		JButton next = new JButton("Next");
26 | 		previous.addActionListener((e) -> card.previous(textCon));
27 | 		next.addActionListener((e) -> card.next(textCon));
28 | 		
29 | 		JPanel southCon = new JPanel();
30 | 		southCon.setLayout(new BoxLayout(southCon, BoxLayout.X_AXIS));
31 | 		southCon.add(previous);
32 | 		southCon.add(Box.createGlue());
33 | 		southCon.add(next);
34 | 		root.add(southCon, BorderLayout.SOUTH);
35 | 		add(root);
36 | 		
37 | 		//Panels
38 | 		
39 | 		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
40 | 		setPreferredSize(new Dimension(600, 400));
41 | 		pack();
42 | 		setVisible(true);
43 | 	}
44 | 	
45 | 	@SuppressWarnings("unused")
46 | 	private static void createPanel(JPanel con, String text){
47 | 		JLabel textField = new JLabel("<html> <p style=\"width:100%\">" + text + "</p></html>");
48 | 		con.add(textField);
49 | 	}
50 | 	
51 | }
52 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ByteData.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import java.io.ByteArrayInputStream;
 4 | import java.io.InputStream;
 5 | 
 6 | public interface ByteData {
 7 | 	public byte[] getData();
 8 | 	public default InputStream getDataAsStream(){
 9 | 		return new ByteArrayInputStream(getData());
10 | 	}
11 | 	public default int getLength(){
12 | 		return getData().length;
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/NamedObject.java:
--------------------------------------------------------------------------------
1 | package dev.lb.cellpacker.structure;
2 | 
3 | public interface NamedObject {
4 | 	public String getName();
5 | }
6 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ResourceCategory.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | import dev.lb.cellpacker.structure.resource.Resource;
 7 | 
 8 | public class ResourceCategory implements ResourceContainer<Resource>{
 9 | 
10 | 	private List<Resource> res;
11 | 	private List<ResourceContainer<Resource>> con;
12 | 	private String name;
13 | 	private ResourceContainer<Resource> parent;
14 | 	
15 | 	public ResourceCategory(String name, ResourceContainer<Resource> parent){
16 | 		this.name = name;
17 | 		res = new ArrayList<>();
18 | 		con = new ArrayList<>();
19 | 	}
20 | 	
21 | 	@Override
22 | 	public List<Resource> getResources() {
23 | 		return res;
24 | 	}
25 | 
26 | 	@Override
27 | 	public List<ResourceContainer<Resource>> getSubCategories() {
28 | 		return con;
29 | 	}
30 | 
31 | 	@Override
32 | 	public String getName() {
33 | 		return name;
34 | 	}
35 | 
36 | 	@Override
37 | 	public ResourceContainer<Resource> getParent() {
38 | 		return parent;
39 | 	}
40 | 
41 | 	@Override
42 | 	public void setName(String name) {
43 | 		this.name = name;
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ResourceContainer.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import java.util.List;
 4 | 
 5 | import dev.lb.cellpacker.Utils;
 6 | 
 7 | public interface ResourceContainer<T extends NamedObject> {
 8 | 	
 9 | 	public ResourceContainer<T> getParent();
10 | 	public List<T> getResources();
11 | 	public List<ResourceContainer<T>> getSubCategories();
12 | 	public String getName();
13 | 	public void setName(String name);
14 | 	
15 | 	public default T getResource(int index){
16 | 		return getResources().get(index);
17 | 	}
18 | 
19 | 	public default T getResource(String name){
20 | 		return Utils.getFirst(getResources(), (r) -> r.getName().equals(name));
21 | 	}
22 | 
23 | 	public default ResourceContainer<T> getSubCategory(int index){
24 | 		return getSubCategories().get(index);
25 | 	}
26 | 
27 | 	public default ResourceContainer<T> getSubCategory(String name){
28 | 		return Utils.getFirst(getSubCategories(), (c) -> c.getName().equals(name));
29 | 	}
30 | 	
31 | 	public default void addResource(T r){
32 | 		getResources().add(r);
33 | 	}
34 | 	
35 | 	public default void addSubCategory(ResourceContainer<T> c){
36 | 		getSubCategories().add(c);
37 | 	}
38 | 	
39 | 	public default boolean hasResources(){
40 | 		if(getResources() == null){
41 | 			return false;
42 | 		}else{
43 | 			return !getResources().isEmpty();
44 | 		}
45 | 	}
46 | 	
47 | 	public default boolean hasSubCategories(){
48 | 		if(getSubCategories() == null){
49 | 			return false;
50 | 		}else{
51 | 			return !getSubCategories().isEmpty();
52 | 		}
53 | 	}
54 | 	
55 | 	public default boolean isRoot(){
56 | 		return getParent() == null;
57 | 	}
58 | 	
59 | 	public default String getFullPath(){
60 | 		if(isRoot()){
61 | 			return getName();
62 | 		}else{
63 | 			return getParent().getFullPath() + "/" + getName();
64 | 		}
65 | 	}
66 | 	
67 | 	public default T getResouceByPath(String pathFromHere){
68 | 		if(pathFromHere.startsWith("/")) pathFromHere = pathFromHere.substring(1);
69 | 		if(!pathFromHere.contains("/")){//only one left, so it's the name
70 | 			return getResource(pathFromHere);
71 | 		}else{//The first path element is the next category
72 | 			ResourceContainer<T> cat = getSubCategory(pathFromHere.substring(0, pathFromHere.indexOf("/")));
73 | 			String newPath = pathFromHere.substring(pathFromHere.indexOf("/"));
74 | 			return cat.getResouceByPath(newPath);
75 | 		}
76 | 	}
77 | 	
78 | 	public default int getTotalSize(){
79 | 		return getResources().size() + getSubCategories().size();
80 | 	}
81 | 	
82 | 	public default void replaceResource(String oldName, T newRes){
83 | 		T res = getResource(oldName);
84 | 		getResources().remove(res);
85 | 		getResources().add(newRes);
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ResourceFile.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure;
  2 | 
  3 | import java.io.ByteArrayOutputStream;
  4 | import java.io.File;
  5 | import java.io.FileInputStream;
  6 | import java.io.FileNotFoundException;
  7 | import java.io.FileOutputStream;
  8 | import java.io.IOException;
  9 | import java.io.InputStream;
 10 | import java.util.Arrays;
 11 | import java.util.Collections;
 12 | import java.util.Map;
 13 | 
 14 | import dev.lb.cellpacker.Logger;
 15 | import dev.lb.cellpacker.Utils;
 16 | import dev.lb.cellpacker.annotation.Unmodifiable;
 17 | import dev.lb.cellpacker.structure.resource.Resource;
 18 | 
 19 | public class ResourceFile implements ByteData{
 20 | 	private Map<String, Integer> header;
 21 | 	private ResourceCategory root;
 22 | 	private byte[] data;
 23 | 	private int dataStartPointer;
 24 | 	
 25 | 	private ResourceFile(ResourceCategory root, byte[] data, int ptr) {
 26 | 		this.data = data;
 27 | 		this.dataStartPointer = ptr;
 28 | 		this.root = root;
 29 | 	}
 30 | 
 31 | 	public ResourceCategory getRootContainer(){
 32 | 		return root;
 33 | 	}
 34 | 	
 35 | 	@Override
 36 | 	public byte[] getData() {
 37 | 		return data;
 38 | 	}
 39 | 	
 40 | 	public byte[] getHeader(){
 41 | 		return Arrays.copyOf(getData(), dataStartPointer);
 42 | 	}
 43 | 	
 44 | 	@Unmodifiable
 45 | 	public Map<String, Integer> getHeaderMap(){
 46 | 		return Collections.unmodifiableMap(header);
 47 | 	}
 48 | 	
 49 | 	public byte[] getBody(){
 50 | 		return Arrays.copyOfRange(getData(), dataStartPointer, getLength());
 51 | 	}
 52 | 	
 53 | 	public void writeAllResources(File targetFolder){
 54 | 		writeCategoryToFolder(root, targetFolder);
 55 | 	}
 56 | 	
 57 | 	private static void writeCategoryToFolder(ResourceContainer<Resource> category, File targetFolder){
 58 | 		//Write subcategories recursively
 59 | 		targetFolder.mkdirs();
 60 | 		for(ResourceContainer<Resource> cat : category.getSubCategories()){
 61 | 			writeCategoryToFolder(cat, new File(targetFolder.getAbsolutePath() + File.separator + cat.getName()));
 62 | 		}
 63 | 		//Then write all resources
 64 | 		for(Resource res : category.getResources()){
 65 | 			File resFile = new File(targetFolder.getAbsolutePath() + File.separator + res.getName());
 66 | 			try(FileOutputStream fos = new FileOutputStream(resFile)){
 67 | 				fos.write(res.getData());
 68 | 			} catch (IOException e) {
 69 | 				e.printStackTrace();
 70 | 			}
 71 | 		}
 72 | 	}
 73 | 	
 74 | 	public void writeToFile(File file){
 75 | 		try(FileOutputStream fos = new FileOutputStream(file)){
 76 | 			fos.write(getData());
 77 | 		} catch (IOException e) {
 78 | 			e.printStackTrace();
 79 | 		}
 80 | 	}
 81 | 	
 82 | 	public static ResourceFile fromFile(File file){
 83 | 		if(file == null){
 84 | 			Logger.throwFatal(new NullPointerException("Argument 'file' must not be null"));
 85 | 		}
 86 | 		if(!file.exists()){
 87 | 			Logger.throwFatal(new FileNotFoundException("The file in Argument 'file' does not exist"));
 88 | 		}
 89 | 		InputStream in = null;
 90 | 		try{
 91 | 			in = new FileInputStream(file);
 92 | 			byte[] data = new byte[(int) file.length()];
 93 | 			in.read(data);
 94 | 			return ResourceFile.fromBytes(data);
 95 | 		} catch (IOException e) {
 96 | 			Logger.throwFatal(e);
 97 | 		}finally{
 98 | 			try {
 99 | 				if(in != null) in.close();
100 | 			} catch (IOException e) {
101 | 				Logger.throwFatal(new IOException("An exception occurred while closing a file stream: "
102 | 						+ e.getMessage(), e));
103 | 			}
104 | 		}
105 | 		return null;
106 | 	}
107 | 	
108 | 	/**
109 | 	 * Reads a category from bytes
110 | 	 * @param pointer The current pointer position. It should be on the Name String terminator byte (0x01) 
111 | 	 * @param name The name of the new Category
112 | 	 * @param data The byte data to parse
113 | 	 * @param parent The parent container, can be a category or resource file
114 | 	 * @return The new pointer position. It should be the next item's name string length byte
115 | 	 */
116 | 	private static int readCategory(int pointer, int datatag, String name, byte[] data, ResourceCategory parent){
117 | 		//0. create category object
118 | 		ResourceCategory current = new ResourceCategory(name, parent);
119 | 		parent.addSubCategory(current);
120 | 		//1. Read category length
121 | 		int length = Utils.decodeInt(Arrays.copyOfRange(data, pointer + 1, pointer + 5));
122 | 		pointer += 5; //pointer is now on first item name length byte
123 | 		
124 | 		for(int i = 0; i < length; i++){
125 | 			int stringlength = data[pointer] & 0xFF;
126 | 			String string = new String(Arrays.copyOfRange(data, pointer + 1, pointer + stringlength + 1));
127 | 			pointer += stringlength + 1; //pointer is now on string terminator
128 | 			if(data[pointer] == (byte) 0x00){ //it's a resource
129 | 				pointer = readResource(pointer, datatag, string, data, current);
130 | 			}else if(data[pointer] == (byte) 0x01){ //it's a category
131 | 				pointer = readCategory(pointer, datatag, string, data, current);
132 | 			}else{
133 | 				Logger.throwFatal(new Exception("String terminator is neither 0 nor 1 (pointer: " +
134 | 						Integer.toHexString(pointer) + ", value: " + Integer.toHexString(data[pointer]) + ")"));
135 | 			}
136 | 		}
137 | 		
138 | 		return pointer;
139 | 	}
140 | 	
141 | 	/**
142 | 	 * Reads a resource from bytes
143 | 	 * @param pointer The current pointer position. It should be on the Name String terminator byte (0x00) 
144 | 	 * @param name The name of the new Resource
145 | 	 * @param data The byte data to parse
146 | 	 * @param parent The parent container, can be a category or resource file
147 | 	 * @return The new pointer position. It should be the next item's name string length byte
148 | 	 */
149 | 	private static int readResource(int pointer, int datatag, String name, byte[] data, ResourceCategory parent){
150 | 		//0.Read all 3 ints
151 | 		int offset = Utils.decodeInt(Arrays.copyOfRange(data, pointer + 1, pointer + 5));
152 | 		int length = Utils.decodeInt(Arrays.copyOfRange(data, pointer + 5, pointer + 9));
153 | 		int magicn = Utils.decodeInt(Arrays.copyOfRange(data, pointer + 9, pointer + 13));
154 | 		pointer += 13;
155 | 		String path = parent.getFullPath() + "/" + name;
156 | 		byte[] resData = Arrays.copyOfRange(data, datatag + offset, datatag + offset + length);
157 | 		Resource res = Resource.createFromExtension(name, path, magicn, resData);
158 | 		
159 | 		parent.addResource(res);
160 | 		return pointer;
161 | 	}
162 | 	
163 | 	public static ResourceFile fromBytes(byte[] bytes){
164 | 		//0. validate
165 | 		if(bytes == null){
166 | 			Logger.throwFatal(new NullPointerException("Argument 'bytes' must not be null"));
167 | 		}
168 | 		if(!(bytes[0] == (byte) 0x50 && bytes[1] == (byte) 0x41 && bytes[2] == (byte) 0x4B))
169 | 			Logger.printWarning("ResourceFile.fromBytes()", "Could not find identifier string 'PAK'!");
170 | 		//1. Find data tag
171 | 		int datatag = Utils.decodeInt(Arrays.copyOfRange(bytes, 4, 8));
172 | 		//2. Read header
173 | 		ResourceCategory root0 = new ResourceCategory("$ROOT", null); //Root, so parent is null
174 | 		readCategory(0x0D, datatag, "res.pak", bytes, root0); //0x0D might not work if atlas is the root category
175 | 		
176 | 		ResourceCategory root = (ResourceCategory) root0.getSubCategory("res.pak"); //extract the root again
177 | 		return new ResourceFile(root, bytes, datatag);
178 | 	}
179 | 	
180 | 	public static ResourceFile fromTree(ResourceContainer<Resource> resources){
181 | 		ByteArrayOutputStream header = new ByteArrayOutputStream();
182 | 		ByteArrayOutputStream data = new ByteArrayOutputStream();
183 | 		try {
184 | 			//The PAK. Identifier
185 | 			header.write(new byte[]{(byte) 0x50, (byte) 0x41, (byte) 0x4B, (byte) 0x00}); //=PAK.
186 | 			//8 bytes for data offset and length, leave them at 09 for now since these values are not yet known
187 | 			header.write(new byte[8]); //=........
188 | 			//The actual header content
189 | 			resources.setName(""); //Set an empty name for the root category
190 | 			treeToBytes(resources, header, data);
191 | 			//Then write the DATA Identifier
192 | 			header.write(new byte[]{(byte) 0x44, (byte) 0x41, (byte) 0x54, (byte) 0x41}); //=DATA
193 | 			
194 | 		} catch (IOException e) {
195 | 			e.printStackTrace();
196 | 		}
197 | 		
198 | 		byte[] allData = Utils.concat(header.toByteArray(), data.toByteArray());
199 | 		//TODO data length and offset
200 | 		byte[] dataoff = Utils.encodeInt(header.size());
201 | 		byte[] datalen = Utils.encodeInt(data.size());
202 | 		System.arraycopy(dataoff, 0, allData, 4, 4);
203 | 		System.arraycopy(datalen, 0, allData, 8, 4);
204 | 		return new ResourceFile((ResourceCategory) resources, allData, header.size());
205 | 	}
206 | 	
207 | 	private static void treeToBytes(ResourceContainer<Resource> resources, ByteArrayOutputStream header, ByteArrayOutputStream data) throws IOException{
208 | 		//First write the name
209 | 		Utils.writeString(header, resources.getName(), (byte) 0x01);
210 | 		//Then the length
211 | 		Utils.writeInt(header, resources.getTotalSize());
212 | 		//And then the resources/categories
213 | 		//Categories first
214 | 		for(ResourceContainer<Resource> categories : resources.getSubCategories()){
215 | 			treeToBytes(categories, header, data);
216 | 		}
217 | 		//Resources second
218 | 		for(Resource res : resources.getResources()){
219 | 			//Write the resource:
220 | 			//Name first
221 | 			Utils.writeString(header, res.getOriginalName(), (byte) 0x00);
222 | 			//Then the three integers
223 | 			Utils.writeInt(header, data.size()); //The data offset
224 | 			Utils.writeInt(header, res.getData().length); //The data length
225 | 			Utils.writeInt(header, res.getMagicNumber()); //The magic number
226 | 			//Also write bytes to the data section
227 | 			data.write(res.getData());
228 | 		}
229 | 	}
230 | }
231 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ResourceViewManager.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure;
  2 | 
  3 | import java.util.ArrayList;
  4 | 
  5 | import java.util.Arrays;
  6 | import java.util.HashMap;
  7 | import java.util.List;
  8 | import java.util.Map;
  9 | import javax.swing.JTree;
 10 | import javax.swing.tree.DefaultMutableTreeNode;
 11 | import javax.swing.tree.DefaultTreeModel;
 12 | import javax.swing.tree.TreeNode;
 13 | import javax.swing.tree.TreePath;
 14 | 
 15 | import dev.lb.cellpacker.NamedRange;
 16 | import dev.lb.cellpacker.Utils;
 17 | import dev.lb.cellpacker.structure.resource.AtlasResource;
 18 | import dev.lb.cellpacker.structure.resource.CompoundAtlasResource;
 19 | import dev.lb.cellpacker.structure.resource.FontResource;
 20 | import dev.lb.cellpacker.structure.resource.ImageResource;
 21 | import dev.lb.cellpacker.structure.resource.JsonResource;
 22 | import dev.lb.cellpacker.structure.resource.Resource;
 23 | import dev.lb.cellpacker.structure.view.AtlasImageResourceView;
 24 | import dev.lb.cellpacker.structure.view.CastleDBResourceView;
 25 | import dev.lb.cellpacker.structure.view.FontResourceView;
 26 | import dev.lb.cellpacker.structure.view.JsonResourceView;
 27 | import dev.lb.cellpacker.structure.view.ResourceView;
 28 | import dev.lb.cellpacker.structure.view.SingleResourceView;
 29 | import dev.lb.cellpacker.structure.view.StaticResourceView;
 30 | 
 31 | public class ResourceViewManager {
 32 | 
 33 | 	protected ViewCategory root;
 34 | 	protected ResourceFile file;
 35 | 	
 36 | 	public ResourceViewManager(ResourceFile res){
 37 | 		root = new ViewCategory("res.pak", null);
 38 | 		file = res;
 39 | 		//now buld the views;
 40 | 		readCategory(file.getRootContainer(), root);
 41 | 	}
 42 | 	
 43 | 	
 44 | 	private void readCategory(ResourceContainer<Resource> cat, ViewCategory viewCat){
 45 | 		//First do all the subcategories
 46 | 		for(ResourceContainer<Resource> subCat : cat.getSubCategories()){
 47 | 			//Create the subcategory
 48 | 			ViewCategory sub = new ViewCategory(subCat.getName(), viewCat);
 49 | 			readCategory(subCat, sub);
 50 | 			viewCat.addSubCategory(sub);
 51 | 		}
 52 | 		//Then do all the resources
 53 | 		for(ResourceView newView : createViews(cat.getResources())){
 54 | 			viewCat.addResource(newView);
 55 | 		}
 56 | 	}
 57 | 	
 58 | 	private List<ResourceView> createViews(List<Resource> source){
 59 | 		List<Resource> resources = new ArrayList<>(source); //The array to detect any leftovers (can't use source because of concurrent modification)
 60 | 		List<ResourceView> views = new ArrayList<>();
 61 | 		
 62 | 		for(Resource r : source){
 63 | 			//Find the type of the resource
 64 | 			if(r instanceof JsonResource){
 65 | 				if(r.getName().equals("data.cdb")){
 66 | 					views.add(new CastleDBResourceView(r.getName(),(JsonResource) r));
 67 | 				}else{
 68 | 					views.add(new JsonResourceView(r.getName(),(JsonResource) r));
 69 | 				}
 70 | 				resources.remove(r);
 71 | 			}else if(r.getName().endsWith(".ogg") ||
 72 | 			   r.getName().endsWith(".json") ||
 73 | 			   r.getName().endsWith(".cdb")){
 74 | 			   //Always single
 75 | 				views.add(new SingleResourceView(r.getName(),r));
 76 | 				resources.remove(r);
 77 | 			}else if(r.getName().endsWith(".fnt") ||
 78 | 					 r.getName().endsWith(".atlas") ||
 79 | 					 r.getName().endsWith("_n.png")){
 80 | 				continue; //handled via the .png resource
 81 | 			}else if(r.getName().endsWith(".png")){ // All normal images (no filter)
 82 | 				boolean n = Utils.contains(resources, (s) -> s.getName().equals(r.getMainName() + "_n.png"));
 83 | 				boolean a = Utils.contains(resources, (s) -> s.getName().equals(r.getMainName() + ".atlas"));
 84 | 				boolean f = Utils.contains(resources, (s) -> s.getName().equals(r.getMainName() + ".fnt"));
 85 | 				if(f){
 86 | 					Resource fnt = Utils.getFirst(resources, (s) -> s.getName().equals(r.getMainName() + ".fnt"));
 87 | 					views.add(new FontResourceView(fnt.getName(), (ImageResource) r, (FontResource) fnt));
 88 | 					resources.remove(r);
 89 | 					resources.remove(fnt);
 90 | 				}else{
 91 | 					if(n && a){
 92 | 						ImageResource nr = (ImageResource) Utils.getFirst(resources, (s) -> s.getName().equals(r.getMainName() + "_n.png"));
 93 | 						AtlasResource  ar = (AtlasResource)  Utils.getFirst(resources, (s) -> s.getName().equals(r.getMainName() + ".atlas"));
 94 | 						views.add(new AtlasImageResourceView(r.getName(), (ImageResource) r, ar, nr));
 95 | 						resources.remove(r);
 96 | 						resources.remove(ar);
 97 | 						resources.remove(nr);
 98 | 					}else if(n){
 99 | 						ImageResource nr = (ImageResource) Utils.getFirst(resources, (s) -> s.getName().equals(r.getMainName() + "_n.png"));
100 | 						views.add(new AtlasImageResourceView(r.getName(), (ImageResource) r, null , nr));
101 | 						resources.remove(r);
102 | 						resources.remove(nr);
103 | 					}else if(a){
104 | 						AtlasResource  ar = (AtlasResource)  Utils.getFirst(resources, (s) -> s.getName().equals(r.getMainName() + ".atlas"));
105 | 						views.add(new AtlasImageResourceView(r.getName(), (ImageResource) r, ar, null));
106 | 						resources.remove(r);
107 | 						resources.remove(ar);
108 | 					}else{ //It's a single image
109 | 						views.add(new SingleResourceView(r.getName(), (ImageResource) r));
110 | 						resources.remove(r);
111 | 					}
112 | 				}
113 | 			}else{
114 | 				views.add(new SingleResourceView(r.getName(), r)); //Unknown type
115 | 				resources.remove(r);
116 | 			}
117 | 		}
118 | 		//Process leftovers + special cases
119 | 		if(!resources.isEmpty()){
120 | 			for(Resource r : resources){
121 | 				//Allocate atlas by it's internally saved image name, others: SingleResourceView
122 | 				if(r instanceof AtlasResource){
123 | 					//If the file name does not match, this might be a compound atlas (why does this exist??)
124 | 					for(Map.Entry<String, AtlasResource> e : parseCompoundAtlas((AtlasResource) r).entrySet()){
125 | 						ResourceView rv = Utils.getFirst(views, (v) -> v.getName().equals(e.getKey()));
126 | 						if(rv instanceof AtlasImageResourceView){ //Add to view
127 | 							if(!((AtlasImageResourceView) rv).setAtlasPostInit(e.getValue())){ //If setting atlas failed
128 | 								views.add(new SingleResourceView(r.getName(), r));
129 | 							}
130 | 						}else{
131 | 							views.add(new SingleResourceView(r.getName(), r));
132 | 						}
133 | 					}
134 | 				}else{
135 | 					views.add(new SingleResourceView(r.getName(), r));
136 | 					//Don't remove from resources because concurrent modification = bad in for loops
137 | 				}
138 | 			}
139 | 		}
140 | 		return views;
141 | 	}
142 | 	
143 | 	public ViewCategory getRootCategory(){
144 | 		return root;
145 | 	}
146 | 	
147 | 	private static Map<String, AtlasResource> parseCompoundAtlas(AtlasResource ar){
148 | 		byte[] data = ar.getData();
149 | 		int pointer = 4;
150 | 		Map<String, AtlasResource> ret = new HashMap<>();
151 | 		List<NamedRange> name2start = new ArrayList<>();
152 | 		int filenamelen = data[4] & 0xFF;
153 | 		String filename = new String(Arrays.copyOfRange(data, pointer + 1, pointer + filenamelen + 1));
154 | 		pointer = pointer + filenamelen + 1;
155 | 		name2start.add(new NamedRange(filename, pointer - filenamelen - 1));
156 | 		
157 | 		do{
158 | 			//Beginning sprite
159 | 			int strlen = data[pointer] & 0xFF;
160 | 			//New compound part?
161 | 			if(strlen == 0){
162 | 				//Finish last range
163 | 				name2start.get(name2start.size() - 1).setEnd(pointer);
164 | 				pointer++; //Move to string length byte
165 | 				int fnamelen = data[pointer] & 0xFF;
166 | 				String fname = new String(Arrays.copyOfRange(data, pointer + 1, pointer + filenamelen + 1));
167 | 				pointer = pointer + fnamelen + 1;
168 | 				name2start.add(new NamedRange(fname, pointer - fnamelen - 1));
169 | 			}else{
170 | 				//The data does not have to be read, just pass over
171 | 				pointer = pointer + 19 + strlen;
172 | 			}
173 | 		}while(pointer < data.length - 2); //The -2 is important
174 | 		//Finish last:
175 | 		name2start.get(name2start.size() - 1).setEnd(data.length);
176 | 		
177 | 		System.out.println("Read compound atlas: " + ar.getName() + ", found resources: " + name2start);
178 | 		//Now create separate resources
179 | 		for(int i = 0; i < name2start.size(); i++){
180 | 			NamedRange nr = name2start.get(i);
181 | 			byte[] newData = new byte[nr.getSize() + 4]; //4 bytes for BATL
182 | 			//Also put BATL
183 | 			newData[0] = 0x42;
184 | 			newData[1] = 0x41;
185 | 			newData[2] = 0x54;
186 | 			newData[3] = 0x4C;
187 | 			System.arraycopy(data, nr.getStart(), newData, 4, nr.getSize());
188 | 			ret.put(nr.getName(), new CompoundAtlasResource(nr.getName(), ar.getPath(), ar.getMagicNumber(), newData, ar.getName(), i));
189 | 		}
190 | 		return ret;
191 | 	}
192 | 	
193 | 	public ResourceView getResourceView(String categoryPath, String name){
194 | 		return root.getResouceByPath(categoryPath + "/" + name);
195 | 	}
196 | 	
197 | 	public ResourceView getResourceView(String fullPath){
198 | 		return root.getResouceByPath(fullPath);
199 | 	}
200 | 	
201 | 	public ResourceFile getResourceFile(){
202 | 		return file;
203 | 	}
204 | 	
205 | 	public ResourceView getResourceView(TreePath path){
206 | 		return getResourceView(getCategoryName(path), getViewName(path));
207 | 	}
208 | 	
209 | 	public TreeNode createTree(){
210 | 		return createTreeFor(root);
211 | 	}
212 | 	
213 | 	private DefaultMutableTreeNode createTreeFor(ViewCategory vc){
214 | 		DefaultMutableTreeNode thisNode = new DefaultMutableTreeNode(new StaticResourceView(vc.getName(), "Category root node", new byte[0]));
215 | 		//first loop subcategories
216 | 		for(ResourceContainer<ResourceView> subcvs : vc.getSubCategories()){
217 | 			thisNode.add(createTreeFor((ViewCategory) subcvs));
218 | 		}
219 | 		//then the resourceviews
220 | 		for(ResourceView subrv : vc.getResources()){
221 | 			thisNode.add(new DefaultMutableTreeNode(subrv));
222 | 		}
223 | 		return thisNode;
224 | 	}
225 | 	
226 | 	private ResourceCategory createResourceTree(ResourceContainer<ResourceView> treeRoot, ResourceContainer<Resource> parent){
227 | 		//Do the subcategories first
228 | 		ResourceCategory returnRoot = new ResourceCategory(treeRoot.getName(), parent);
229 | 		for(ResourceContainer<ResourceView> subViewCat : treeRoot.getSubCategories()){
230 | 			returnRoot.addSubCategory(createResourceTree(subViewCat, returnRoot));
231 | 		}
232 | 		//Then the resourceviews
233 | 		for(ResourceView rvs : treeRoot.getResources()){
234 | 			//Add all resources to root
235 | 			for(Resource res : rvs.getAllResources()){
236 | 					returnRoot.addResource(res);
237 | 			}
238 | 		}
239 | 		return returnRoot;
240 | 	}
241 | 	
242 | 	public ResourceFile buildFileWithChanges(){
243 | 		//So basically just convert the view tree back into a resource tree
244 | 		ResourceCategory resources = createResourceTree(root, null);
245 | 		//And then make a new resource file
246 | 		return ResourceFile.fromTree(resources);
247 | 	}
248 | 	
249 | 	public void setTree(JTree tree){
250 | 		((DefaultTreeModel) tree.getModel()).setRoot(createTree());
251 | 	}
252 | 	
253 | 	public static String getCategoryName(TreePath selection){
254 | 		return ((ResourceView) ((DefaultMutableTreeNode) selection.getPathComponent(selection.getPathCount() - 2)).getUserObject()).getName();
255 | 	}
256 | 	public static String getViewName(TreePath selection){
257 | 		return ((ResourceView) ((DefaultMutableTreeNode) selection.getLastPathComponent()).getUserObject()).getName();
258 | 	}
259 | 	
260 | }
261 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/Script.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import com.google.gson.JsonObject;
 4 | 
 5 | @Deprecated
 6 | public class Script {
 7 | 	private String name;
 8 | 	private String desc;
 9 | 	private JsonObject add;
10 | 	private JsonObject remove;
11 | 	
12 | 	public Script(String name, String desc, JsonObject add, JsonObject remove) {
13 | 		super();
14 | 		this.name = name;
15 | 		this.desc = desc;
16 | 		this.add = add;
17 | 		this.remove = remove;
18 | 	}
19 | 	public String getName() {
20 | 		return name;
21 | 	}
22 | 	public String getDesc() {
23 | 		return desc;
24 | 	}
25 | 	public JsonObject getAddSection() {
26 | 		return add;
27 | 	}
28 | 	public JsonObject getRemoveSection() {
29 | 		return remove;
30 | 	}
31 | }
32 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/SearchableResourceViewManager.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import javax.swing.JTree;
 4 | import javax.swing.tree.DefaultMutableTreeNode;
 5 | import javax.swing.tree.TreeNode;
 6 | 
 7 | import dev.lb.cellpacker.structure.view.ResourceView;
 8 | import dev.lb.cellpacker.structure.view.StaticResourceView;
 9 | 
10 | public class SearchableResourceViewManager extends ResourceViewManager{
11 | 
12 | 	private String searchString;
13 | 	
14 | 	public SearchableResourceViewManager(ResourceFile res) {
15 | 		super(res);
16 | 		setSearchString("");
17 | 	}
18 | 
19 | 	public String getSearchString() {
20 | 		return searchString;
21 | 	}
22 | 
23 | 	public boolean setSearchString(String searchString) {
24 | 		String old = this.searchString;
25 | 		this.searchString = searchString;
26 | 		return old == null ? true : !old.equals(searchString);
27 | 	}
28 | 	
29 | 	public void setSearchString(String searchString, JTree toUpdate){
30 | 		if(setSearchString(searchString)){
31 | 			setTree(toUpdate);
32 | 		}
33 | 	}
34 | 
35 | 	@Override
36 | 	public TreeNode createTree() {
37 | 		return createTreeForSearch(root);
38 | 	}
39 | 	
40 | 	private DefaultMutableTreeNode createTreeForSearch(ViewCategory vc){
41 | 		DefaultMutableTreeNode thisNode = new DefaultMutableTreeNode(new StaticResourceView(vc.getName(), "Category root node", new byte[0]));
42 | 		//first loop subcategories, add them if they are not empty
43 | 		for(ResourceContainer<ResourceView> subcvs : vc.getSubCategories()){
44 | 			DefaultMutableTreeNode subNode = createTreeForSearch((ViewCategory) subcvs);
45 | 			if(!subNode.isLeaf()){
46 | 				thisNode.add(createTreeForSearch((ViewCategory) subcvs));
47 | 			}
48 | 		}
49 | 		//then the resourceviews if name matches
50 | 		for(ResourceView subrv : vc.getResources()){
51 | 			if(subrv.getName().contains(searchString)){
52 | 				thisNode.add(new DefaultMutableTreeNode(subrv));
53 | 			}
54 | 		}
55 | 		return thisNode;
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/ViewCategory.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | import dev.lb.cellpacker.structure.view.ResourceView;
 7 | 
 8 | public class ViewCategory implements ResourceContainer<ResourceView>{
 9 | 
10 | 	private List<ResourceView> res;
11 | 	private List<ResourceContainer<ResourceView>> con;
12 | 	private String name;
13 | 	private ResourceContainer<ResourceView> parent;
14 | 	
15 | 	public ViewCategory(String name, ResourceContainer<ResourceView> parent){
16 | 		this.name = name;
17 | 		res = new ArrayList<>();
18 | 		con = new ArrayList<>();
19 | 	}
20 | 	
21 | 	@Override
22 | 	public List<ResourceView> getResources() {
23 | 		return res;
24 | 	}
25 | 
26 | 	@Override
27 | 	public List<ResourceContainer<ResourceView>> getSubCategories() {
28 | 		return con;
29 | 	}
30 | 
31 | 	@Override
32 | 	public String getName() {
33 | 		return name;
34 | 	}
35 | 
36 | 	@Override
37 | 	public ResourceContainer<ResourceView> getParent() {
38 | 		return parent;
39 | 	}
40 | 
41 | 	@Override
42 | 	public void setName(String name) {
43 | 		this.name = name;
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/CDBFile.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.cdb;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Arrays;
 5 | import java.util.List;
 6 | 
 7 | public class CDBFile {
 8 | 	
 9 | 	private boolean compress;
10 | 	private Sheet[] sheets;
11 | 	
12 | 	private CDBFile(){
13 | 		//init by Gson
14 | 	}
15 | 	
16 | 	public Sheet[] getSheets(){
17 | 		return sheets;
18 | 	}
19 | 	
20 | 	public boolean getCompress(){
21 | 		return compress;
22 | 	}
23 | 
24 | 	@Override
25 | 	public String toString() {
26 | 		return "CDBFile [compress=" + compress + ", sheets=" + Arrays.toString(sheets) + "]";
27 | 	}
28 | 	
29 | 	public static CDBFile parse(String json){
30 | 		return null;
31 | 	}
32 | 	
33 | 	public static String write(CDBFile cdb){
34 | 		return null;
35 | 	}
36 | 	
37 | 	public Sheet[] getMainSheets(){
38 | 		List<Sheet> mains = new ArrayList<>();
39 | 		for(Sheet s : sheets){
40 | 			if(!s.getName().contains("@")) mains.add(s);
41 | 		}
42 | 		return mains.toArray(new Sheet[0]);
43 | 	}
44 | 	
45 | 	public Sheet getSheet(String name){
46 | 		for(Sheet s : sheets){
47 | 			if(s.getName().equals(name)){
48 | 				return s;
49 | 			}
50 | 		}
51 | 		return null;
52 | 	}
53 | 	
54 | 	public Sheet getSheet(String name, boolean allowSubSheeets){
55 | 		for(Sheet s : sheets){
56 | 			if(s.getName().equals(name) && (allowSubSheeets || !s.getName().contains("@"))){
57 | 				return s;
58 | 			}
59 | 		}
60 | 		return null;
61 | 	}
62 | 	
63 | 	public Sheet getSheet(int index){
64 | 		if(index >= 0 && index < sheets.length){
65 | 			return sheets[index];
66 | 		}else{
67 | 			return null;
68 | 		}
69 | 	}
70 | 	
71 | }
72 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/Column.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.cdb;
 2 | 
 3 | public class Column {
 4 | 	private String name;
 5 | 	private String typeStr;
 6 | 	private boolean opt;
 7 | 	private String kind;
 8 | 	
 9 | 	private Column(){
10 | 	}
11 | 	
12 | 	public ColumnType getType(){
13 | 		return ColumnType.getType(typeStr);
14 | 	}
15 | 	
16 | 	public String getName() {
17 | 		return name;
18 | 	}
19 | 
20 | 	public String getTypeStr() {
21 | 		return typeStr;
22 | 	}
23 | 
24 | 	public boolean isOpt() {
25 | 		return opt;
26 | 	}
27 | 
28 | 	public String getKind() {
29 | 		return kind;
30 | 	}
31 | 	
32 | 	public static enum ColumnType{
33 | 		UUID(0,"Unique ID"),STRING(1, "String/Text"),BOOLEAN(2, "Boolean"),INTEGER(3, "Integer"),FLOAT(4, "Float/Decimal Number"),
34 | 		ENUM(5, "Custom Enumeration"),REFERENCE(6, "Reference"),IMAGE(7, "Image"),SUBSHEET(8, "Subsheet/List"),CUSTOM(9, "Custom Type"),
35 | 		FLAGS(10, "Flags"),COLOR(11, "Color"),DATALAYER(12, "Data layer"),FILE(13, "File"),ICON(14, "Icon"),
36 | 		TILELAYER(15, "Tile Layer"),DYNAMIC(16, "Dynamic/Array"),INVALID(-1,"Invalid Type");
37 | 		private int id;
38 | 		private String name;
39 | 		private ColumnType(int id, String name){
40 | 			this.id = id;
41 | 			this.name = name;
42 | 		}
43 | 		public int getId(){
44 | 			return id;
45 | 		}
46 | 		@Override
47 | 		public String toString(){
48 | 			return name;
49 | 		}
50 | 		
51 | 		public static boolean isNumeric(ColumnType c){
52 | 			return c == FLOAT || c == ColumnType.INTEGER;
53 | 		}
54 | 		
55 | 		public static ColumnType getType(String typeStr){
56 | 			if(typeStr.contains(":")) typeStr = typeStr.substring(0, typeStr.indexOf(':'));
57 | 			switch(typeStr){
58 | 			case "0" : return UUID;
59 | 			case "1" : return STRING;
60 | 			case "2" : return BOOLEAN;
61 | 			case "3" : return INTEGER;
62 | 			case "4" : return FLOAT;
63 | 			case "5" : return ENUM;
64 | 			case "6" : return REFERENCE;
65 | 			case "7" : return IMAGE;
66 | 			case "17" : //Act like 8
67 | 			case "8" : return SUBSHEET;
68 | 			case "9" : return CUSTOM;
69 | 			case "10" : return FLAGS;
70 | 			case "11" : return COLOR;
71 | 			case "12" : return DATALAYER;
72 | 			case "13" : return FILE;
73 | 			case "14" : return ICON;
74 | 			case "15" : return TILELAYER;
75 | 			case "16" : return DYNAMIC;
76 | 			default : return INVALID;
77 | 			}
78 | 		}
79 | 	}
80 | }
81 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/Line.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.cdb;
 2 | 
 3 | import java.lang.reflect.Type;
 4 | 
 5 | import com.google.gson.JsonArray;
 6 | import com.google.gson.JsonDeserializationContext;
 7 | import com.google.gson.JsonDeserializer;
 8 | import com.google.gson.JsonElement;
 9 | import com.google.gson.JsonObject;
10 | import com.google.gson.JsonParseException;
11 | import com.google.gson.JsonSerializationContext;
12 | import com.google.gson.JsonSerializer;
13 | 
14 | import dev.lb.cellpacker.structure.cdb.Column.ColumnType;
15 | 
16 | public class Line {
17 | 	
18 | 	JsonElement data;
19 | 	
20 | 	private Line(){
21 | 	}
22 | 	
23 | 	public JsonObject getData(){
24 | 		return data.getAsJsonObject();
25 | 	}
26 | 	
27 | 	public String getValue(String colName, Sheet sheet){
28 | 		JsonElement value = data.getAsJsonObject().get(colName);
29 | 		ColumnType ct = sheet.getColumn(colName).getType();
30 | 		if(value == null){
31 | 			return null;
32 | 		}else if(value.isJsonPrimitive()){
33 | 			return value.getAsString();
34 | 		}else if(value instanceof JsonObject){
35 | 			if(ct == ColumnType.ICON){
36 | 				return "<Icon>";
37 | 			}else if(ct == ColumnType.SUBSHEET){
38 | 				return "<SubSheet: " + sheet.getName() + "@" + colName + ">";
39 | 			}else{
40 | 				return "<JsonObject/Data>";
41 | 			}
42 | 		}else if(value instanceof JsonArray){
43 | 			boolean all = true; //Are all values primitives?
44 | 			for(JsonElement e : value.getAsJsonArray()){
45 | 				if(!e.isJsonPrimitive()){
46 | 					all = false;
47 | 					break;
48 | 				}
49 | 			}
50 | 			if(all){
51 | 				String out = "[";
52 | 				JsonArray arr = value.getAsJsonArray();
53 | 				if(arr.size() == 0){
54 | 					out += "]";
55 | 				}else{
56 | 					for(int i = 0; i < arr.size() - 1; i++){
57 | 						out += arr.get(i).getAsString() + ", ";
58 | 					}
59 | 					out += arr.get(arr.size() - 1).getAsString() + "]";
60 | 				}
61 | 				return out;
62 | 			}else{
63 | 				return "<JsonArray/List or Array>";
64 | 			}
65 | 		}else{
66 | 			return "<Unknown Type/Value>";
67 | 		}
68 | 	}
69 | 	
70 | 	public static class LineSerial implements JsonDeserializer<Line>, JsonSerializer<Line>{
71 | 
72 | 		public static LineSerial instance = new LineSerial();
73 | 		private LineSerial() {}
74 | 		
75 | 		@Override
76 | 		public JsonElement serialize(Line src, Type typeOfSrc, JsonSerializationContext context) {
77 | 			return src.getData();
78 | 		}
79 | 
80 | 		@Override
81 | 		public Line deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
82 | 				throws JsonParseException {
83 | 			Line l = new Line();
84 | 			l.data = json;
85 | 			return l;
86 | 		}
87 | 		
88 | 	}
89 | }
90 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/ScriptReader.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.cdb;
  2 | 
  3 | import java.io.PrintStream;
  4 | import java.util.ArrayList;
  5 | import java.util.Arrays;
  6 | import java.util.List;
  7 | import java.util.function.Predicate;
  8 | 
  9 | import com.google.gson.Gson;
 10 | import com.google.gson.JsonElement;
 11 | import com.google.gson.JsonObject;
 12 | import com.google.gson.JsonParser;
 13 | 
 14 | import dev.lb.cellpacker.Utils;
 15 | import dev.lb.cellpacker.structure.ResourceFile;
 16 | import dev.lb.cellpacker.structure.cdb.Column.ColumnType;
 17 | import dev.lb.cellpacker.structure.resource.JsonResource;
 18 | 
 19 | public class ScriptReader {
 20 | 	
 21 | 	public static JsonResource patchJsonResource(JsonResource json, JsonObject scriptAdd, JsonObject scriptRemove){
 22 | 		JsonElement resource = new JsonParser().parse((String) json.getContent());
 23 | 		if(!(resource instanceof JsonObject)){
 24 | 			System.out.println("Error: not an object");
 25 | 			return json;
 26 | 		}else{
 27 | 			JsonObject res2 = (JsonObject) resource;
 28 | 			Utils.removeJSON(res2, scriptRemove);
 29 | 			Utils.addJSON(res2, scriptAdd);
 30 | 			String newJson = new Gson().toJson(res2);
 31 | 			return new JsonResource(json.getName(), json.getPath(), json.getMagicNumber(), newJson.getBytes());
 32 | 		}
 33 | 	}
 34 | 	
 35 | 	//This part of the file is the discontiniued script parser
 36 | 	
 37 | 	private CDBFile file;
 38 | 	private PrintStream out;
 39 | 	private ResourceFile rfile;
 40 | 	
 41 | 	public ScriptReader(CDBFile file, PrintStream out){
 42 | 		this.file = file;
 43 | 		this.out = out;
 44 | 		rfile = null;
 45 | 		out.println("WARNING: ScriptReader is not fully implemented.");
 46 | 		out.flush();
 47 | 	}
 48 | 	
 49 | 	public ScriptReader(CDBFile file, PrintStream out, ResourceFile rfile){
 50 | 		this.file = file;
 51 | 		this.out = out;
 52 | 		this.rfile = rfile;
 53 | 		out.println("Output:\n");
 54 | 		out.flush();
 55 | 	}
 56 | 	
 57 | 	public void execute(String command){
 58 | 		out.println("\n > Command: " + command);
 59 | 		parseCommand(command);
 60 | 		out.flush();
 61 | 	}
 62 | 	
 63 | 	private void parseCommand(String command){
 64 | 		String[] commands = command.split(":");
 65 | 		for(int i = 0; i < commands.length; i++){
 66 | 			commands[i] = commands[i].trim();
 67 | 		}
 68 | 		parseCommand(commands);
 69 | 	}
 70 | 	
 71 | 	private void parseCommand(String[] commandParts){
 72 | 		CommandSelection cs = new CommandSelection(file, out);
 73 | 		for(String command : commandParts){
 74 | 			if(CommandType.getType(command) == CommandType.REPLACE && rfile == null){
 75 | 				out.println("This Script Reader does not support replacement of file resources.");
 76 | 				out.println("Resource file replacement is not possible in data.cdb console view.");
 77 | 				return;
 78 | 			}else{
 79 | 				if(!cs.apply(command)){ //If the command is invalid
 80 | 					break;
 81 | 				}
 82 | 			}
 83 | 		}
 84 | 	}
 85 | 	
 86 | 	public static class CommandSelection{
 87 | 		
 88 | 		private CDBFile file;
 89 | 		private PrintStream out;
 90 | 		
 91 | 		private Sheet sheetName;
 92 | 		private Column colName;
 93 | 		private List<Line> lineNames;
 94 | 		
 95 | 		OperatorType operator;
 96 | 		
 97 | 		public CommandSelection(CDBFile file, PrintStream out){
 98 | 			this.file = file;
 99 | 			this.out = out;
100 | 		}
101 | 		
102 | 		public CommandSelection(CommandSelection old){
103 | 			this.file = old.file;
104 | 			this.out = old.out;
105 | 			this.sheetName = old.sheetName;
106 | 			this.colName = old.colName;
107 | 			this.lineNames = old.lineNames;
108 | 		}
109 | 		
110 | 		public boolean apply(String command){
111 | 			switch (CommandType.getType(command)) {
112 | 			case COLUMN:
113 | 				return applySelectColumn(command);
114 | 			case LINE:
115 | 				return applySelectLine(command);
116 | 			case TABLE:
117 | 				return applySelectSheet(command);
118 | 			case OPERATION:
119 | 				return applyOperation(command);
120 | 			case PRINT:
121 | 				return applyInfo(command);
122 | 			default:
123 | 				out.println("ParseError: Command unknown or not supported");
124 | 				return false;
125 | 			}
126 | 		}
127 | 		
128 | 		private boolean applyOperation(String command){
129 | 			if(!command.contains(" ")){
130 | 				out.println("ParseError: missing value argument for operator.");
131 | 			}else if(colName == null){
132 | 				out.println("ParseError: You have to select a column before using an operator");
133 | 			}else if(sheetName == null){
134 | 				out.println("ParseError: you have to select a table/sheet before selecting a line/entry");
135 | 			}else{
136 | 				String operator = command.substring(0, command.indexOf(' '));
137 | 				@SuppressWarnings("unused")
138 | 				String value = command.substring(0, command.indexOf(' '));
139 | 				switch (operator) {
140 | 				case "add":
141 | 					if(ColumnType.isNumeric(colName.getType())){
142 | 						lineNames.forEach((l) -> {
143 | 							
144 | 						});
145 | 					}
146 | 					break;
147 | 				default:
148 | 					out.println("Unknown operator " + operator);
149 | 				}
150 | 			}
151 | 			return false;
152 | 		}
153 | 		
154 | 		private boolean applySelectLine(String command){
155 | 			if(!command.contains(" ")){
156 | 				out.println("ParseError: missing argument for getLine/getEntry command.");
157 | 				return false;
158 | 			}else if(lineNames != null){
159 | 				out.println("ParseError: cannot select line/entry twice. Use getLine <condition1>,<condition2> to select with more than one condition");
160 | 				return false;
161 | 			}else if(sheetName == null){
162 | 				out.println("ParseError: you have to select a table/sheet before selecting a line/entry");
163 | 				return false;
164 | 			}else{
165 | 				lineNames = new ArrayList<>();
166 | 				String temp = command.substring(command.indexOf(' '));
167 | 				String[] conditions = temp.split(",");
168 | 				for(int i = 0; i < conditions.length; i++){
169 | 					conditions[i] = conditions[i].trim();
170 | 				}
171 | 				List<Line> available = new ArrayList<>(Arrays.asList(sheetName.getLines()));
172 | 				for(String condition : conditions){ //Apply all conditions to the available lines
173 | 					String[] sp = condition.split("=");
174 | 					if(sp.length != 2){
175 | 						out.println("ParseError: Invalid condition (missing or too many '='): " + condition);
176 | 						return false;
177 | 					}else{
178 | 						String col = sp[0];
179 | 						String value = sp[1];
180 | 						Predicate<Line> p = (l) -> !(l.getValue(col, sheetName).equals(value));
181 | 						available.removeIf(p);
182 | 					}
183 | 				}
184 | 				lineNames.addAll(available);
185 | 				return true; //After successful for loop
186 | 			}
187 | 		}
188 | 		
189 | 		private boolean applySelectColumn(String command){
190 | 			if(!command.contains(" ")){
191 | 				out.println("ParseError: missing argument for getColumn/getField command.");
192 | 				return false;
193 | 			}else if(colName != null){
194 | 				out.println("ParseError: cannot select column/field twice. Already selected: " + colName.getName());
195 | 				return false;
196 | 			}else if(sheetName == null){
197 | 				out.println("ParseError: you have to select a table/sheet before selecting a column/field");
198 | 				return false;
199 | 			}else{
200 | 				int index = command.indexOf(' ');
201 | 				String colId = command.substring(index + 1);
202 | 				Column c = sheetName.getColumn(colId);
203 | 				if(c == null){ //check for id
204 | 					if(colId.matches("\\d+")){ //Is number
205 | 						c = sheetName.getColumn(Integer.parseInt(colId));
206 | 						if(c == null){
207 | 							out.println("ParseError: column/field with name or id '" + colId + "' not found.");
208 | 							return false;
209 | 						}else{
210 | 							colName = c;
211 | 							return true;
212 | 						}
213 | 					}else{
214 | 						out.println("ParseError: column/field with name '" + colId + "' not found.");
215 | 						return false;
216 | 					}
217 | 				}else{
218 | 					colName = c;
219 | 					return true;
220 | 				}
221 | 			}
222 | 		}
223 | 		
224 | 		private boolean applySelectSheet(String command){
225 | 			if(!command.contains(" ")){
226 | 				out.println("ParseError: missing argument for getSheet/getTable command.");
227 | 				return false;
228 | 			}else if(sheetName != null){
229 | 				out.println("ParseError: cannot select table/sheet twice. Already selected: " + sheetName.getName());
230 | 				return false;
231 | 			}else{
232 | 				int index = command.indexOf(' ');
233 | 				String sheetId = command.substring(index + 1);
234 | 				Sheet s = file.getSheet(sheetId, false);
235 | 				if(s == null){ //check for id
236 | 					if(sheetId.matches("\\d+")){ //Is number
237 | 						s = file.getSheet(Integer.parseInt(sheetId));
238 | 						if(s == null){
239 | 							out.println("ParseError: sheet/table with name or id '" + sheetId + "' not found.");
240 | 							return false;
241 | 						}else{
242 | 							sheetName = s;
243 | 							return true;
244 | 						}
245 | 					}else{
246 | 						out.println("ParseError: sheet/table with name '" + sheetId + "' not found.");
247 | 						return false;
248 | 					}
249 | 				}else{
250 | 					sheetName = s;
251 | 					return true;
252 | 				}
253 | 			}
254 | 		}
255 | 		
256 | 		private boolean applyInfo(String command){
257 | 			if(command.equals("help")){
258 | 				out.println("TODO: HELP");
259 | 				return true;
260 | 			}else if(command.equals("info") || command.equals("print")){
261 | 				if(sheetName == null){
262 | 					out.println("Information: No table/sheet selected, tables/sheets available (no subsheets): ");
263 | 					for(Sheet s : file.getMainSheets()){
264 | 						out.println(s.getName());
265 | 					}
266 | 				}else{
267 | 					out.println("Information: Sheet selected: " + sheetName.getName());
268 | 					//Both
269 | 					if(colName == null){
270 | 						out.println("No column/field selected, columns/fields available: ");
271 | 						for(Column c : sheetName.getColumns()){
272 | 							out.println(c.getName() + " | " + c.getType().toString());
273 | 						}
274 | 					}else{
275 | 						out.println("Selected column: " + colName.getName() + " | " + colName.getType().toString());
276 | 					}
277 | 					if(lineNames == null){
278 | 						out.println("No line(s) selected (" + sheetName.getLines().length + " lines available)");
279 | 						maybePrintLines(Arrays.asList(sheetName.getLines()), 1000);
280 | 					}else{
281 | 						maybePrintLines(lineNames, 1000);
282 | 					}
283 | 				}
284 | 				return true;
285 | 			}else{
286 | 				out.println("ParseError: help/info/print command does not take arguments.");
287 | 				return false;
288 | 			}
289 | 		}
290 | 		
291 | 		private void maybePrintLines(List<Line> lines, int limit){
292 | 			out.println("Selected lines: " + lines.size());
293 | 			if(lines.size() < limit){
294 | 				out.println("Details:");
295 | 				for(Line l : lines){
296 | 					if(colName == null){
297 | 						for(Column c : sheetName.getColumns()){
298 | 							out.print(c.getName() + "=" + l.getValue(c.getName(), sheetName) + " ");
299 | 						}
300 | 						out.println();
301 | 					}else{
302 | 						out.println(colName.getName() + "=" + l.getValue(colName.getName(), sheetName));
303 | 					}
304 | 				}
305 | 			}
306 | 		}
307 | 		
308 | 	}//END COMMAND SELECTION INNER CLASS
309 | 	
310 | 	public static enum OperatorType{
311 | 		ADD,SET,APPEND,REMOVE;
312 | 	}
313 | 	
314 | 	public static enum CommandType{
315 | 		TABLE,COLUMN,LINE,OPERATION,PRINT,REPLACE,INVALID;
316 | 		
317 | 		public static CommandType getType(String command){
318 | 			command = command.trim();
319 | 			if(command.contains(" ")) command = command.substring(0, command.indexOf(' '));
320 | 			switch (command) {
321 | 			case "getTable":
322 | 			case "getSheet":
323 | 				return TABLE;
324 | 			case "getField":
325 | 			case "getColumn":
326 | 				return COLUMN;
327 | 			case "getLine":
328 | 			case "getEntry":
329 | 				return LINE;
330 | 			case "add":
331 | 			case "set":
332 | 			case "append":
333 | 			case "remove":
334 | 				return OPERATION;
335 | 			case "print":
336 | 			case "info":
337 | 			case "help":
338 | 				return PRINT;
339 | 			case "replace": //Only for not-cdb in scripts
340 | 				return REPLACE;
341 | 			default:
342 | 				return INVALID;
343 | 			}
344 | 		}
345 | 	}
346 | 	
347 | }
348 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/Sheet.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.cdb;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class Sheet {
 6 | 	private String name;
 7 | 	private int[] separators;
 8 | 	private SheetProps props;
 9 | 	private Column[] columns;
10 | 	private Line[] lines;
11 | 	
12 | 	private Sheet(){
13 | 		
14 | 	}
15 | 	
16 | 	public String getName() {
17 | 		return name;
18 | 	}
19 | 	public int[] getSeparators() {
20 | 		return separators;
21 | 	}
22 | 	public SheetProps getProps() {
23 | 		return props;
24 | 	}
25 | 	public Column[] getColumns() {
26 | 		return columns;
27 | 	}
28 | 	public Line[] getLines() {
29 | 		return lines;
30 | 	}
31 | 
32 | 	public Column getColumn(String name){
33 | 		for(Column c : columns){
34 | 			if(c.getName().equals(name))
35 | 				return c;
36 | 		}
37 | 		return null;
38 | 	}
39 | 	
40 | 	public Column getColumn(int index){
41 | 		if(index >= 0 && index < columns.length){
42 | 			return columns[index];
43 | 		}else{
44 | 			return null;
45 | 		}
46 | 	}
47 | 	
48 | 	@Override
49 | 	public String toString() {
50 | 		return "Sheet [name=" + name + ", separators=" + Arrays.toString(separators) + ", props=" + props + ", columns="
51 | 				+ Arrays.toString(columns) + ", lines=" + Arrays.toString(lines) + "]";
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/cdb/SheetProps.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.cdb;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class SheetProps {
 6 | 	private String[] separatorTitles;
 7 | 	private boolean hide;
 8 | 	private boolean isProps;
 9 | 	
10 | 	private SheetProps(){
11 | 		
12 | 	}
13 | 
14 | 	public String[] getSeparatorTitles() {
15 | 		return separatorTitles;
16 | 	}
17 | 
18 | 	public boolean isHide() {
19 | 		return hide;
20 | 	}
21 | 
22 | 	public boolean isProps() {
23 | 		return isProps;
24 | 	}
25 | 
26 | 	@Override
27 | 	public String toString() {
28 | 		return "SheetProps [separatorTitles=" + Arrays.toString(separatorTitles) + ", hide=" + hide + ", isProps="
29 | 				+ isProps + "]";
30 | 	}
31 | 	
32 | }
33 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/AtlasResource.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.resource;
  2 | 
  3 | import java.awt.BorderLayout;
  4 | import java.awt.Component;
  5 | import java.awt.Dimension;
  6 | import java.awt.GridLayout;
  7 | import java.awt.Point;
  8 | import java.awt.Rectangle;
  9 | import java.awt.image.BufferedImage;
 10 | import java.util.ArrayList;
 11 | import java.util.Arrays;
 12 | import java.util.Collections;
 13 | import java.util.List;
 14 | 
 15 | import javax.swing.ButtonGroup;
 16 | import javax.swing.DefaultListModel;
 17 | import javax.swing.JButton;
 18 | import javax.swing.JCheckBox;
 19 | import javax.swing.JLabel;
 20 | import javax.swing.JPanel;
 21 | import javax.swing.JRadioButton;
 22 | import javax.swing.JScrollPane;
 23 | import javax.swing.JTabbedPane;
 24 | import javax.swing.JTextArea;
 25 | import javax.swing.ListSelectionModel;
 26 | import javax.swing.border.CompoundBorder;
 27 | import javax.swing.border.EmptyBorder;
 28 | import javax.swing.filechooser.FileFilter;
 29 | import javax.swing.filechooser.FileNameExtensionFilter;
 30 | 
 31 | import dev.lb.cellpacker.Utils;
 32 | import dev.lb.cellpacker.annotation.Async;
 33 | import dev.lb.cellpacker.annotation.Unmodifiable;
 34 | import dev.lb.cellpacker.controls.JSpriteViewer;
 35 | import dev.lb.cellpacker.controls.SpriteSavingList;
 36 | 
 37 | public class AtlasResource extends Resource{
 38 | 
 39 | 	private String hexString;
 40 | 	private JTextArea textDisplay;
 41 | 	private AtlasData atlasData;
 42 | 	
 43 | 	public AtlasResource(String name, String path, int magic, byte[] data) {
 44 | 		super(name, path, magic, data);
 45 | 	}
 46 | 	
 47 | 	private final static char[] hexArray = "0123456789ABCDEF".toCharArray();
 48 | 	public static String bytesToString(byte[] bytes){
 49 | 		char[] chars = new char[3*bytes.length];
 50 | 		for(int i = 0; i < bytes.length; i++){
 51 | 			int data = bytes[i] & 0xFF;
 52 | 			chars[i * 3] = hexArray[data >>> 4];
 53 | 			chars[i * 3 + 1] = hexArray[data & 0x0F];
 54 | 			chars[i * 3 + 2] = 0x20;
 55 | 		}
 56 | 		return new String(chars);
 57 | 	}
 58 | 	
 59 | 	@Async
 60 | 	private void init(){
 61 | 		if(isInitialized)
 62 | 			return;
 63 | 		hexString = bytesToString(data);
 64 | 		atlasData = new AtlasData(data);
 65 | 		isInitialized = true;
 66 | 	}
 67 | 	
 68 | 	@Override
 69 | 	public Component getComponent() {
 70 | 		if(!isInitialized){
 71 | 			return Utils.asyncFill(() -> {
 72 | 				init();
 73 | 				textDisplay = new JTextArea(hexString);
 74 | 				textDisplay.setLineWrap(true);
 75 | 				textDisplay.setWrapStyleWord(true);
 76 | 				textDisplay.setEditable(false);
 77 | 				return new JScrollPane(textDisplay);
 78 | 			}, 300);
 79 | 		}else{
 80 | 			textDisplay = new JTextArea(hexString);
 81 | 			textDisplay.setLineWrap(true);
 82 | 			textDisplay.setWrapStyleWord(true);
 83 | 			textDisplay.setEditable(false);
 84 | 			return new JScrollPane(textDisplay);
 85 | 		}
 86 | 	}
 87 | 
 88 | 	@Async
 89 | 	@Override
 90 | 	public Object getContent() {
 91 | 		if(!isInitialized)
 92 | 			init();
 93 | 		return hexString;
 94 | 	}
 95 | 
 96 | 	@Override
 97 | 	public Resource clone() {
 98 | 		return new AtlasResource(getName(), getPath(), getMagicNumber(), getData());
 99 | 	}
100 | 
101 | 	@Override
102 | 	public FileFilter getFileFilter() {
103 | 		return new FileNameExtensionFilter("Atlas File", "*.atlas", ".atlas", "atlas");
104 | 	}
105 | 
106 | 	public Component createSpriteView(ImageResource main, ImageResource filter, JTabbedPane tabs) {
107 | 		if(!isInitialized){
108 | 			return Utils.asyncFill(() -> {
109 | 				init();
110 | 				return atlasData.createView(main.getImage(), filter == null ? null : filter.getImage(), tabs);
111 | 			}, 300);
112 | 		}else{
113 | 			return atlasData.createView(main.getImage(), filter == null ? null : filter.getImage(), tabs);
114 | 		}
115 | 	}
116 | 	
117 | 	@Async
118 | 	public AtlasData getAtlasData(){
119 | 		if(!isInitialized)
120 | 			init();
121 | 		return atlasData;
122 | 	}
123 | 	
124 | 	public static class AtlasData{
125 | 		private List<Sprite> sprites;
126 | 		//private JSpriteViewer currentSprite;
127 | 		//private SpriteSavingList currentList;
128 | 		
129 | 		public Component createView(BufferedImage main, BufferedImage filter, JTabbedPane tabs){
130 | 			JPanel con = new JPanel(new BorderLayout());
131 | 			SpriteSavingList currentList = new SpriteSavingList(new DefaultListModel<>());
132 | 			sprites.forEach((s) -> ((DefaultListModel<Sprite>) currentList.getModel()).addElement(s));
133 | 			currentList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
134 | 			JScrollPane listScroll = new JScrollPane(currentList);
135 | 			listScroll.setBorder(new CompoundBorder(new EmptyBorder(10, 10, 10, 10), listScroll.getBorder()));
136 | 			JPanel westCon = new JPanel(new BorderLayout());
137 | 			westCon.add(Utils.call(new JLabel("Select sprite:"), (c) -> c.setBorder(new EmptyBorder(10, 10, 0, 10))), BorderLayout.NORTH); //Overly complicated, but fun
138 | 			westCon.add(listScroll, BorderLayout.CENTER);
139 | 			con.add(westCon, BorderLayout.WEST);
140 | 			JPanel centerCon = new JPanel(new BorderLayout());
141 | 			JSpriteViewer currentSprite = new JSpriteViewer(main, filter);
142 | 			JTextArea details = new JTextArea();
143 | 			details.setBorder(new EmptyBorder(10, 20, 10, 20));
144 | 			currentList.setDetailsArea(details);
145 | 			JPanel southCon = new JPanel(new BorderLayout());
146 | 			southCon.add(details, BorderLayout.CENTER);
147 | 			JPanel options = new JPanel(new GridLayout(2, 2));
148 | 			// OPTIONS
149 | 			JRadioButton jrbMain = new JRadioButton("Show main image", true);
150 | 			JRadioButton jrbFilt = new JRadioButton("Show Filter image", false);
151 | 			if(filter == null) jrbFilt.setEnabled(false);
152 | 			ButtonGroup group = new ButtonGroup();
153 | 			group.add(jrbMain);
154 | 			group.add(jrbFilt);
155 | 			currentList.setRadioButtons(jrbMain, jrbFilt);
156 | 			
157 | 			JCheckBox highlight = new JCheckBox("Highlight in image", false);
158 | 			JButton animation = new JButton("Animations");
159 | 			currentList.setHighlightButton(highlight, animation);
160 | 			options.add(jrbMain);
161 | 			options.add(jrbFilt);
162 | 			options.add(highlight);
163 | 			options.add(animation);
164 | 			options.setBorder(new EmptyBorder(10, 10, 10, 10));
165 | 			// /OPTIONS
166 | 			southCon.add(options, BorderLayout.EAST);
167 | 			centerCon.add(southCon, BorderLayout.SOUTH);
168 | 			JPanel jspBorder = new JPanel(new BorderLayout());
169 | 			jspBorder.setBorder(new EmptyBorder(20, 20, 20, 20));
170 | 			jspBorder.add(currentSprite, BorderLayout.CENTER);
171 | 			centerCon.add(jspBorder, BorderLayout.CENTER);
172 | 			con.add(centerCon, BorderLayout.CENTER);
173 | 			
174 | 			currentList.setJSP(currentSprite);
175 | 			if(currentList.getModel().getSize() > 0) currentList.setSelectedIndex(0);
176 | 			
177 | 			return con;
178 | 		}
179 | 		
180 | 		public AtlasData(byte[] data){
181 | 			sprites = new ArrayList<>();
182 | 			int pointer = 4;
183 | 			int filenamelen = data[4] & 0xFF;
184 | 			String filename = new String(Arrays.copyOfRange(data, pointer + 1, pointer + filenamelen + 1));
185 | 			pointer = pointer + filenamelen + 1;
186 | 			
187 | 			do{
188 | 				//Beginning sprite
189 | 				int strlen = data[pointer] & 0xFF;
190 | 				String name = new String(Arrays.copyOfRange(data, pointer + 1, pointer + strlen + 1));
191 | 				pointer = pointer + strlen + 3; //First data byte
192 | 				byte[] spriteData = Arrays.copyOfRange(data, pointer, pointer + 16);
193 | 				Sprite current = new Sprite(name, decodeByte2(spriteData, 0), decodeByte2(spriteData, 2), decodeByte2(spriteData, 4),
194 | 						decodeByte2(spriteData, 6), decodeByte2(spriteData, 8), decodeByte2(spriteData, 10),
195 | 						decodeByte2(spriteData, 12), decodeByte2(spriteData, 14));
196 | 				sprites.add(current);
197 | 				pointer += 16;
198 | 			}while(pointer < data.length - 2); //The -2 is important
199 | 			System.out.println("Read " + sprites.size() + " Sprites for file " + filename);
200 | 		}
201 | 		
202 | 		public static int decodeByte2(byte[] data, int off1){
203 | 			return (data[off1] & 0xFF) + ((data[off1 + 1] & 0xFF) << 8); 
204 | 		}
205 | 		
206 | 		@Unmodifiable
207 | 		public List<Sprite> getSprites(){
208 | 			return Collections.unmodifiableList(sprites);
209 | 		}
210 | 	}
211 | 	
212 | 	
213 | 	public static class Sprite{
214 | 		private String name;
215 | 		private int x;
216 | 		private int y;
217 | 		private int width;
218 | 		private int height;
219 | 		private int offsetX;
220 | 		private int offsetY;
221 | 		private int origX;
222 | 		private int origY;
223 | 		
224 | 		private Sprite(String name, int x, int y, int width, int height, int offsetX, int offsetY, int origX, int origY) {
225 | 			this.name = name;
226 | 			this.x = x;
227 | 			this.y = y;
228 | 			this.width = width;
229 | 			this.height = height;
230 | 			this.offsetX = offsetX;
231 | 			this.offsetY = offsetY;
232 | 			this.origX = origX;
233 | 			this.origY = origY;
234 | 		}
235 | 		
236 | 		public Point getPosition(){
237 | 			return new Point(x, y);
238 | 		}
239 | 		
240 | 		public Dimension getSize(){
241 | 			return new Dimension(width, height);
242 | 		}
243 | 		
244 | 		public Rectangle getArea(){
245 | 			return new Rectangle(x, y, width, height);
246 | 		}
247 | 		
248 | 		public BufferedImage getImageSection(BufferedImage main){
249 | 			return main.getSubimage(x, y, width, height);
250 | 		}
251 | 
252 | 		public String getName(){
253 | 			return name;
254 | 		}
255 | 		
256 | 		public int getX() {
257 | 			return x;
258 | 		}
259 | 
260 | 		public int getY() {
261 | 			return y;
262 | 		}
263 | 
264 | 		public int getWidth() {
265 | 			return width;
266 | 		}
267 | 
268 | 		public int getHeight() {
269 | 			return height;
270 | 		}
271 | 
272 | 		public int getOffsetX() {
273 | 			return offsetX;
274 | 		}
275 | 
276 | 		public int getOffsetY() {
277 | 			return offsetY;
278 | 		}
279 | 
280 | 		public int getOrigX() {
281 | 			return origX;
282 | 		}
283 | 
284 | 		public int getOrigY() {
285 | 			return origY;
286 | 		}
287 | 
288 | 		@Override
289 | 		public String toString() {
290 | 			return name;
291 | 		}
292 | 		
293 | 	}
294 | 
295 | }
296 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/CompoundAtlasResource.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.resource;
 2 | 
 3 | import java.util.Comparator;
 4 | 
 5 | public class CompoundAtlasResource extends AtlasResource{
 6 | 
 7 | 	private String compoundFileName;
 8 | 	private int index;
 9 | 	
10 | 	public CompoundAtlasResource(String name, String path, int magic, byte[] data, String compoundFileName, int index) {
11 | 		super(name, path, magic, data);
12 | 		this.compoundFileName = compoundFileName;
13 | 		this.index = index;
14 | 	}
15 | 
16 | 	public String getCompoundFileName() {
17 | 		return compoundFileName;
18 | 	}
19 | 
20 | 	public int getIndex() {
21 | 		return index;
22 | 	}
23 | 	
24 | 	public static int compare(CompoundAtlasResource o1, CompoundAtlasResource o2) {
25 | 		if(o1.index < o2.index){
26 | 			return -1;
27 | 		}else if(o1.index > o2.index){
28 | 			return 1;
29 | 		}else{ //Equal
30 | 			return 0;
31 | 		}
32 | 	}
33 | 
34 | 	@Override
35 | 	public Resource clone() {
36 | 		return new CompoundAtlasResource(getName(), getPath(), getMagicNumber(), getData(), getCompoundFileName(), getIndex());
37 | 	}
38 | 	
39 | 	public static Comparator<CompoundAtlasResource> getIndexComparator(){
40 | 		return new Comparator<CompoundAtlasResource>() {
41 | 			@Override
42 | 			public int compare(CompoundAtlasResource o1, CompoundAtlasResource o2) {
43 | 				if(o1.getIndex() < o2.getIndex()) return -1;
44 | 				if(o1.getIndex() == o2.getIndex()) return 0;
45 | 				if(o1.getIndex() > o2.getIndex()) return 1;
46 | 				return 0; //This is actually impossible to reach, but the compiler needs it to be happy.
47 | 			}
48 | 		};
49 | 	}
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/FontResource.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.resource;
 2 | 
 3 | import java.awt.Component;
 4 | 
 5 | import javax.swing.JLabel;
 6 | import javax.swing.JPanel;
 7 | import javax.swing.JScrollPane;
 8 | import javax.swing.JTextArea;
 9 | import javax.swing.filechooser.FileFilter;
10 | import javax.swing.filechooser.FileNameExtensionFilter;
11 | 
12 | import dev.lb.cellpacker.Utils;
13 | 
14 | public class FontResource extends Resource{
15 | 	
16 | 	private String hexString;
17 | 	private JTextArea textDisplay;
18 | 	
19 | 	public FontResource(String name, String path, int magic, byte[] data) {
20 | 		super(name, path, magic, data);
21 | 	}
22 | 
23 | 	public void init() {
24 | 		if(isInitialized)
25 | 			return;
26 | 		hexString = AtlasResource.bytesToString(data);
27 | 		isInitialized = true;
28 | 	}
29 | 
30 | 	@Override
31 | 	public Component getComponent() {
32 | 		if(!isInitialized){
33 | 			return Utils.asyncFill(() -> {
34 | 				init();
35 | 				textDisplay = new JTextArea(hexString);
36 | 				textDisplay.setLineWrap(true);
37 | 				textDisplay.setWrapStyleWord(true);
38 | 				textDisplay.setEditable(false);
39 | 				return new JScrollPane(textDisplay);
40 | 			}, 300);
41 | 		}else{
42 | 			textDisplay = new JTextArea(hexString);
43 | 			textDisplay.setLineWrap(true);
44 | 			textDisplay.setWrapStyleWord(true);
45 | 			textDisplay.setEditable(false);
46 | 			return new JScrollPane(textDisplay);
47 | 		}
48 | 	}
49 | 
50 | 	@Override
51 | 	public Object getContent() {
52 | 		return textDisplay;
53 | 	}
54 | 
55 | 	@Override
56 | 	public Resource clone() {
57 | 		return new FontResource(getName(), getPath(), getMagicNumber(), getData());
58 | 	}
59 | 
60 | 	@Override
61 | 	public FileFilter getFileFilter() {
62 | 		return new FileNameExtensionFilter("XML Font", "*.fnt", ".fnt", "fnt");
63 | 	}
64 | 
65 | 	public Component getCharView(ImageResource image) {
66 | 		JPanel center = new JPanel();
67 | 		center.add(new JLabel("Still WIP, Sorry."));
68 | 		return center;
69 | 	}
70 | 
71 | }
72 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/ImageResource.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.resource;
 2 | 
 3 | import java.awt.Component;
 4 | import java.awt.image.BufferedImage;
 5 | import java.io.IOException;
 6 | 
 7 | import javax.imageio.ImageIO;
 8 | import javax.swing.Icon;
 9 | import javax.swing.ImageIcon;
10 | import javax.swing.filechooser.FileFilter;
11 | import javax.swing.filechooser.FileNameExtensionFilter;
12 | 
13 | import dev.lb.cellpacker.Logger;
14 | import dev.lb.cellpacker.Utils;
15 | import dev.lb.cellpacker.annotation.Async;
16 | import dev.lb.cellpacker.annotation.Calculated;
17 | import dev.lb.cellpacker.controls.JDraggableScrollPane;
18 | import dev.lb.cellpacker.controls.JImageViewer;
19 | 
20 | public class ImageResource extends Resource{
21 | 
22 | 	private BufferedImage content;
23 | 	private BufferedImage overlay;
24 | 	
25 | 	private JImageViewer jim;
26 | 	
27 | 	public ImageResource(String name, String path, int magic, byte[] data){
28 | 		super(name, path, magic, data);
29 | 	}
30 | 
31 | 	@Async
32 | 	public void init() {
33 | 		if(isInitialized)
34 | 			return;
35 | 		try {
36 | 			content = ImageIO.read(getDataAsStream());
37 | 		} catch (IOException e) {
38 | 			Logger.throwFatal(new IOException("Could not read image from byte stream: " + e.getMessage(), e));
39 | 		}
40 | 		isInitialized = true;
41 | 	}
42 | 	
43 | 	@Async
44 | 	public BufferedImage getImage(){
45 | 		if(!isInitialized)
46 | 			init();
47 | 		return content;
48 | 	}
49 | 	
50 | 	@Async
51 | 	public Object getContent(){
52 | 		return getImage();
53 | 	}
54 | 	
55 | 	@Calculated
56 | 	@Async
57 | 	public Icon getIcon(){
58 | 		return new ImageIcon(getImage());
59 | 	}
60 | 
61 | 	public void setOverlay(BufferedImage img){
62 | 		overlay = img;
63 | 		if(jim != null)	jim.setOverlay(overlay);
64 | 	}
65 | 	
66 | 	@Override
67 | 	public Component getComponent() {
68 | 		if(!isInitialized){
69 | 			return Utils.asyncFill(() -> {
70 | 				init();
71 | 				jim = new JImageViewer(content);
72 | 				jim.setOverlay(overlay);
73 | 				return new JDraggableScrollPane(jim);//new JScrollPane(new JLabel(getIcon()));
74 | 			}, 300);
75 | 		}else{
76 | 			jim = new JImageViewer(content);
77 | 			jim.setOverlay(overlay);
78 | 			return new JDraggableScrollPane(jim);//new JScrollPane(new JLabel(getIcon()));
79 | 		}
80 | 	}
81 | 
82 | 	@Override
83 | 	public Resource clone() {
84 | 		return new ImageResource(getName(), getPath(), getMagicNumber(), getData());
85 | 	}
86 | 
87 | 	@Override
88 | 	public FileFilter getFileFilter() {
89 | 		return new FileNameExtensionFilter("PNG Images", "*.png", ".png", "png");
90 | 	}
91 | 	
92 | }
93 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/JsonResource.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.resource;
 2 | 
 3 | import java.awt.Component;
 4 | 
 5 | import javax.swing.JScrollPane;
 6 | import javax.swing.JTextArea;
 7 | import javax.swing.filechooser.FileFilter;
 8 | import javax.swing.filechooser.FileNameExtensionFilter;
 9 | 
10 | import com.google.gson.JsonElement;
11 | import com.google.gson.JsonParser;
12 | 
13 | public class JsonResource extends Resource{
14 | 
15 | 	private String content;
16 | 	
17 | 	public JsonResource(String name, String path, int magic, byte[] data) {
18 | 		super(name, path, magic, data);
19 | 	}
20 | 
21 | 	public void init() {
22 | 		if(isInitialized)
23 | 			return;
24 | 		content = new String(data);
25 | 	}
26 | 	
27 | 	public JsonElement getJsonElement(){
28 | 		if(!isInitialized)
29 | 			init();
30 | 		return new JsonParser().parse(content);
31 | 	}
32 | 	
33 | 	@Override
34 | 	public Object getContent() {
35 | 		if(!isInitialized)
36 | 			init();
37 | 		return content;
38 | 	}
39 | 
40 | 	@Override
41 | 	public Component getComponent() {
42 | 		if(!isInitialized)
43 | 			init();
44 | 		JTextArea display = new JTextArea();
45 | 		display.setText(content);
46 | 		display.setEditable(false);
47 | 		return new JScrollPane(display);
48 | 	}
49 | 
50 | 	@Override
51 | 	public Resource clone() {
52 | 		return new JsonResource(getName(), getPath(), getMagicNumber(), getData());
53 | 	}
54 | 
55 | 	@Override
56 | 	public FileFilter getFileFilter() {
57 | 		return new FileNameExtensionFilter("JSON File", "*.json", ".json", "json", "*.cdb", ".cdb", "cdb");
58 | 	}
59 | 	
60 | }
61 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/Resource.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.resource;
  2 | 
  3 | import java.awt.Component;
  4 | 
  5 | import javax.swing.filechooser.FileFilter;
  6 | 
  7 | import dev.lb.cellpacker.structure.ByteData;
  8 | import dev.lb.cellpacker.structure.NamedObject;
  9 | import dev.lb.cellpacker.structure.view.StaticResourceView;
 10 | 
 11 | public abstract class Resource implements ByteData, Comparable<Resource>, NamedObject{
 12 | 	
 13 | 	protected byte[] data;
 14 | 	protected String name;
 15 | 	protected String path;
 16 | 	protected boolean isInitialized;
 17 | 	protected int magic;
 18 | 	
 19 | 	public Resource(String name, String path, int magic, byte[] data){
 20 | 		this.name = name;
 21 | 		this.path = path;
 22 | 		this.data = data;
 23 | 		this.magic = magic;
 24 | 		this.isInitialized = false;
 25 | 	}
 26 | 	
 27 | 	@Override
 28 | 	public byte[] getData(){
 29 | 		return data;
 30 | 	}
 31 | 	
 32 | 	public String getName(){
 33 | 		return name;
 34 | 	}
 35 | 	
 36 | 	public int getMagicNumber(){
 37 | 		return magic;
 38 | 	}
 39 | 	
 40 | 	public String getOriginalName(){
 41 | 		return getName();
 42 | 	}
 43 | 	
 44 | 	public static Resource createFromExtension(String name, String path, int magic, byte[] data){
 45 | //		System.out.println("Extension for:" + name + ": " + getExtension(name));
 46 | //		System.err.println(data.length);
 47 | 		switch(getExtension(name)){
 48 | 			case ".png": return new ImageResource(name, path, magic, data);
 49 | 			case ".ogg": return new SoundResource(name, path, magic, data);
 50 | 			case ".wav": return new SoundResource(name, path, magic, data);
 51 | 			case ".atlas": return new AtlasResource(name, path, magic, data);
 52 | 			case ".json": return new JsonResource(name, path, magic, data);
 53 | 			case ".cdb" : return new JsonResource(name, path, magic, data);
 54 | 			case ".fnt": return new FontResource(name, path, magic, data);
 55 | 			default: return StaticResourceView.staticTextResource(name, "Unknown resource format: " + getExtension(name), data);
 56 | 		}
 57 | 	}
 58 | 	
 59 | 	public static Resource createFromType(String name, String path, int magic, byte[] data, Class<? extends Resource> type){
 60 | 		if(type == ImageResource.class){
 61 | 			return new ImageResource(name, path, magic, data);
 62 | 		}else if(type == SoundResource.class){
 63 | 			return new SoundResource(name, path, magic, data);
 64 | 		}else if(type == AtlasResource.class){
 65 | 			return new AtlasResource(name, path, magic, data);
 66 | 		}else if(type == FontResource.class){
 67 | 			return new FontResource(name, path, magic, data);
 68 | 		}else if(type == JsonResource.class){
 69 | 			return new JsonResource(name, path, magic, data);
 70 | 		}else{
 71 | 			return StaticResourceView.staticTextResource(name, "Ooops. Something went wrong while creating a resource: Resource:createFromType()", data);
 72 | 		}
 73 | 	}
 74 | 	
 75 | 	protected void setName(String newName){
 76 | 		this.name = newName;
 77 | 	}
 78 | 	
 79 | 	public String getPath(){
 80 | 		return path;
 81 | 	}
 82 | 	
 83 | 	public String getPathAndName(){
 84 | 		return path + "/" + name;
 85 | 	}
 86 | 	
 87 | 	public String getMainName(){
 88 | 		String mname = name.substring(0, name.lastIndexOf('.'));
 89 | 		if(mname.endsWith("_n"))
 90 | 			mname = name.substring(0, mname.length() - 2);
 91 | 		return mname;
 92 | 	}
 93 | 	
 94 | 	public int compareTo(Resource r){
 95 | 		return getMainName().compareTo(r.getMainName());
 96 | 	}
 97 | 	
 98 | 	public abstract Component getComponent();
 99 | 	public abstract Object getContent();
100 | 	public abstract Resource clone();
101 | 	public abstract FileFilter getFileFilter();
102 | 	
103 | 	public static String getExtension(String name){
104 | 		return name.substring(name.lastIndexOf('.'));
105 | 	}
106 | }
107 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/resource/SoundResource.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.resource;
 2 | 
 3 | import java.awt.Component;
 4 | import java.io.IOException;
 5 | import javax.sound.sampled.Clip;
 6 | import javax.sound.sampled.LineUnavailableException;
 7 | import javax.swing.filechooser.FileFilter;
 8 | import javax.swing.filechooser.FileNameExtensionFilter;
 9 | 
10 | import dev.lb.cellpacker.Utils;
11 | import dev.lb.cellpacker.annotation.Async;
12 | import dev.lb.cellpacker.controls.JAudioPlayer;
13 | import dev.lb.sound.ogg.JOrbisDecoder;
14 | 
15 | 
16 | public class SoundResource extends Resource{
17 | 
18 | 	private Clip content;
19 | 	private JAudioPlayer current;
20 | 	private String origName;
21 | 	
22 | 	public SoundResource(String name, String path, int magic, byte[] data) {
23 | 		super(name, path, magic, data);
24 | 		origName = name;
25 | 		if(name.endsWith(".wav"));
26 | 			name = name.substring(0, name.length() - 4) + ".ogg";
27 | 		setName(name);
28 | 	}
29 | 
30 | 	
31 | 	@Async
32 | 	private void init() {
33 | 		if(isInitialized) return;
34 | 		try {
35 | 			content = JOrbisDecoder.decodeOggSteramToClip(getDataAsStream());
36 | 		} catch (LineUnavailableException | IOException e) {
37 | 			e.printStackTrace();
38 | 		}
39 | 		isInitialized = true;
40 | 	}
41 | 
42 | 	@Async
43 | 	public Clip getSoundClip(){
44 | 		if(!isInitialized)
45 | 			init();
46 | 		return content;
47 | 	}
48 | 	
49 | 	@Async
50 | 	@Override
51 | 	public Object getContent() {
52 | 		return getSoundClip();
53 | 	}
54 | 
55 | 	public void stopPlaying(){
56 | 		if(current != null)
57 | 			current.stop(true);
58 | 	}
59 | 	
60 | 	@Override
61 | 	public Component getComponent() {
62 | 		if(!isInitialized){
63 | 			return Utils.asyncFill(() -> {
64 | 				init();
65 | 				current = new JAudioPlayer(content);
66 | 				return current;
67 | 			}, 300);
68 | 		}else{
69 | 			if(current != null) current.stop(true);
70 | 			current = new JAudioPlayer(content);
71 | 			return current;
72 | 		}
73 | 	}
74 | 
75 | 	@Override
76 | 	public Resource clone() {
77 | 		return new SoundResource(getName(), getPath(), getMagicNumber(), getData());
78 | 	}
79 | 
80 | 	@Override
81 | 	public FileFilter getFileFilter() {
82 | 		return new FileNameExtensionFilter("OGG Sound", "*.ogg", ".ogg", "ogg");
83 | 	}
84 | 
85 | 
86 | 	@Override
87 | 	public String getOriginalName() {
88 | 		return origName;
89 | 	}
90 | 
91 | }
92 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/AtlasImageResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.Component;
  4 | import java.io.File;
  5 | import java.util.ArrayList;
  6 | import java.util.List;
  7 | 
  8 | import javax.swing.JFileChooser;
  9 | import javax.swing.JMenu;
 10 | import javax.swing.JMenuItem;
 11 | import javax.swing.JOptionPane;
 12 | import javax.swing.JTabbedPane;
 13 | 
 14 | import dev.lb.cellpacker.Utils;
 15 | import dev.lb.cellpacker.structure.resource.AtlasResource;
 16 | import dev.lb.cellpacker.structure.resource.ImageResource;
 17 | import dev.lb.cellpacker.structure.resource.Resource;
 18 | 
 19 | public class AtlasImageResourceView extends ResourceView{
 20 | 
 21 | 	public static final int MAIN_IMAGE_TAB_INDEX = 0;
 22 | 	public static final int FILTER_IMAGE_TAB_INDEX = 3;
 23 | 	
 24 | 	private String name;
 25 | 	
 26 | 	private ImageResource main;
 27 | 	private ImageResource mainOriginal;
 28 | 	private AtlasResource atlas;
 29 | 	private AtlasResource atlasOriginal;
 30 | 	private ImageResource filter;
 31 | 	private ImageResource filterOriginal;
 32 | 	
 33 | 	private boolean mainModified;
 34 | 	private boolean atlasModified;
 35 | 	private boolean filterModified;
 36 | 	
 37 | 	private boolean isInitialized;
 38 | 	
 39 | 	private JTabbedPane display;
 40 | 	private JMenuItem[] menu;
 41 | 	
 42 | 	public AtlasImageResourceView(String resourceName, ImageResource mainImage, AtlasResource atlasRes, ImageResource filterImage) {
 43 | 		name = resourceName;
 44 | 		main = mainImage;
 45 | 		atlas = atlasRes;
 46 | 		filter = filterImage;
 47 | 		
 48 | 		mainModified = false;
 49 | 		atlasModified = false;
 50 | 		filterModified = false;
 51 | 		isInitialized = false;
 52 | 	}
 53 | 
 54 | 	public void forceInit(){
 55 | 		isInitialized = false;
 56 | 		init();
 57 | 	}
 58 | 	
 59 | 	@Override
 60 | 	public String getName() {
 61 | 		return name;
 62 | 	}
 63 | 
 64 | 	@Override
 65 | 	public Component getDisplay() {
 66 | 		init();
 67 | 		return display;
 68 | 	}
 69 | 	
 70 | 	/**
 71 | 	 * Allows you to set a new atlas resource for this view directly after calling the constructor,
 72 | 	 * that is before the first tree is built with this view and the init() method is called. 
 73 | 	 * Use with caution.
 74 | 	 * @return if the replacement was successful
 75 | 	 */
 76 | 	public boolean setAtlasPostInit(AtlasResource r){
 77 | 		if(atlas == null){
 78 | 			atlas = r;
 79 | 			return true;
 80 | 		}else{
 81 | 			return false;
 82 | 		}
 83 | 	}
 84 | 
 85 | 	@Override
 86 | 	public void replaceCurrentResource(Component dialogParent) {
 87 | 		//Prompt for resource to replace
 88 | 		int response = 0;
 89 | 		if(atlas == null){
 90 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to replace?", "Select resource",
 91 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Filter Image"}, 0);
 92 | 			if(response == 1) response = 2;
 93 | 		}else if(filter == null){
 94 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to replace?", "Select resource",
 95 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file"}, 0);
 96 | 		}else{	
 97 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to replace?", "Select resource",
 98 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file", "Filter Image"}, 0);
 99 | 		}
100 | 		switch(response){
101 | 		case 0:
102 | 			Resource newRes0 = ResourceView.selectReplaceResource(dialogParent, main);
103 | 			if(newRes0 != null && newRes0 instanceof ImageResource){
104 | 				if(mainModified){
105 | 					main = (ImageResource) newRes0;
106 | 				}else{
107 | 					mainOriginal = main;
108 | 					main = (ImageResource) newRes0;
109 | 					mainModified = true;
110 | 				}
111 | 				forceInit();
112 | 			}
113 | 			break;
114 | 		case 1:
115 | 			Resource newRes1 = ResourceView.selectReplaceResource(dialogParent, atlas);
116 | 			if(newRes1 != null){
117 | 				if(atlasModified){
118 | 					atlas = (AtlasResource) newRes1;
119 | 				}else{
120 | 					atlasOriginal = atlas;
121 | 					atlas = (AtlasResource) newRes1;
122 | 					atlasModified = true;
123 | 				}
124 | 				forceInit();
125 | 			}
126 | 			break;
127 | 		case 2:
128 | 			Resource newRes2 = ResourceView.selectReplaceResource(dialogParent, filter);
129 | 			if(newRes2 != null){
130 | 				if(filterModified){
131 | 					filter = (ImageResource) newRes2;
132 | 				}else{
133 | 					filterOriginal = filter;
134 | 					filter = (ImageResource) newRes2;
135 | 					filterModified = true;
136 | 				}
137 | 				forceInit();
138 | 			}
139 | 			break;
140 | 		}
141 | 	}
142 | 
143 | 	@Override
144 | 	public void restoreCurrentResource(Component dialogParent) {
145 | 		int opNum = (mainModified ? 1 : 0) + (atlasModified ? 1 : 0) + (filterModified ? 1 : 0);
146 | 		int response = 0;
147 | 		if(opNum == 0){
148 | 			JOptionPane.showMessageDialog(dialogParent, "This resource is still unmodified and can not be restored.", "Info", JOptionPane.INFORMATION_MESSAGE);
149 | 			return;
150 | 		}else if(opNum == 1){
151 | 			response = (atlasModified ? 1 : 0) + (filterModified ? 2 : 0);
152 | 		}else{
153 | 			if(mainModified && atlasModified){
154 | 				response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to restore?", "Select resource",
155 | 						JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file"}, 0);
156 | 				if(response == JOptionPane.CLOSED_OPTION) return;
157 | 			}else if(mainModified && filterModified){
158 | 				response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to restore?", "Select resource",
159 | 						JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Filter Image"}, 0);
160 | 				if(response == JOptionPane.CLOSED_OPTION) return;
161 | 				if(response == 1) response = 2;
162 | 			}else if(atlasModified && filterModified){
163 | 				response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to restore?", "Select resource",
164 | 						JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Atlas file", "Filter Image"}, 0);
165 | 				if(response == JOptionPane.CLOSED_OPTION) return;
166 | 				response++;
167 | 			}else if(mainModified && atlasModified && filterModified){
168 | 				response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to restore?", "Select resource",
169 | 						JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file", "Filter Image"}, 0);
170 | 				if(response == JOptionPane.CLOSED_OPTION) return;
171 | 			}
172 | 		}
173 | 		//Now ask again
174 | 		if(JOptionPane.showConfirmDialog(dialogParent, "<html>Changes made to this resource will be lost.<br>Are you sure you want to restore " + 
175 | 				(response == 0 ? "the main image" : (response == 1 ? "the atlas file" : "the filter image")) + "?",
176 | 				"Confirm restoring", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
177 | 			switch (response) {
178 | 			case 0:
179 | 				main = mainOriginal;
180 | 				mainOriginal = null;
181 | 				mainModified = false;
182 | 				break;
183 | 			case 1:
184 | 				atlas = atlasOriginal;
185 | 				atlasOriginal = null;
186 | 				atlasModified = false;
187 | 				break;
188 | 			case 2:
189 | 				filter = filterOriginal;
190 | 				filterOriginal = null;
191 | 				filterModified = false;
192 | 				break;
193 | 			}
194 | 			forceInit();
195 | 		}
196 | 	}
197 | 
198 | 	@Override
199 | 	public void restoreAllResources(Component dialogParent) {
200 | 		if(mainModified){
201 | 			main = mainOriginal;
202 | 			mainOriginal = null;
203 | 			mainModified = false;
204 | 		}
205 | 		if(atlasModified){
206 | 			atlas = atlasOriginal;
207 | 			atlasOriginal = null;
208 | 			atlasModified = false;
209 | 		}
210 | 		if(filterModified){
211 | 			filter = filterOriginal;
212 | 			filterOriginal = null;
213 | 			filterModified = false;
214 | 		}
215 | 		if(mainModified || atlasModified || filterModified) forceInit();
216 | 	}
217 | 
218 | 	@Override
219 | 	public JMenuItem[] getContextMenu() {
220 | 		init();
221 | 		return menu;
222 | 	}
223 | 
224 | 	@Override
225 | 	public void exportResource(Component dialogParent) {
226 | 		int response = 0;
227 | 		if(atlas == null && filter == null){ //Actually this shouldn't happen
228 | 			JOptionPane.showMessageDialog(dialogParent, "<html>Warning: Assigned wrong view type (AtlasImageResourceView:exportResource())<br>This error is not critical and the program can continue.", "Warning", JOptionPane.WARNING_MESSAGE);
229 | 		}else if(atlas == null){
230 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to export?", "Select resource",
231 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Filter Image"}, 0);
232 | 			if(response == JOptionPane.CLOSED_OPTION) return;
233 | 			if(response == 1) response = 2;
234 | 		}else if(filter == null){
235 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to export?", "Select resource",
236 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file"}, 0);
237 | 			if(response == JOptionPane.CLOSED_OPTION) return;
238 | 		}else{
239 | 			response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to export?", "Select resource",
240 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Main Image", "Atlas file", "Filter Image"}, 0);
241 | 			if(response == JOptionPane.CLOSED_OPTION) return;
242 | 		}
243 | 		ResourceView.exportResourceToFile(dialogParent, response == 0 ? main : (response == 1 ? atlas : filter));
244 | 	}
245 | 
246 | 	@Override
247 | 	public void exportResourceView(Component dialogParent) {
248 | 		JFileChooser jfc = new JFileChooser();
249 | 		jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
250 | 		if(jfc.showSaveDialog(dialogParent) == JFileChooser.APPROVE_OPTION){
251 | 			File file = jfc.getSelectedFile();
252 | 			ResourceView.exportResourceToFile(dialogParent, main, new File(file, main.getName()));
253 | 			if(atlas != null) ResourceView.exportResourceToFile(dialogParent, atlas, new File(file, atlas.getName()));
254 | 			if(filter != null) ResourceView.exportResourceToFile(dialogParent, filter, new File(file, filter.getName()));
255 | 		}
256 | 	}
257 | 	
258 | 	@Override
259 | 	public void init() {
260 | 		if(isInitialized) return;
261 | 		if(menu == null){
262 | 			menu = new JMenuItem[6];
263 | 			JMenu views = new JMenu("Show view");
264 | 			JMenuItem reuseable = new JMenuItem("Main Image");
265 | 			reuseable.addActionListener((e) -> {
266 | 				display.setSelectedIndex(0);
267 | 			});
268 | 			views.add(reuseable);
269 | 			if(atlas != null){
270 | 				reuseable = new JMenuItem("Atlas file");
271 | 				reuseable.addActionListener((e) -> {
272 | 					display.setSelectedIndex(1);
273 | 				});
274 | 				views.add(reuseable);
275 | 				reuseable = new JMenuItem("Sprite/Animation view");
276 | 				reuseable.addActionListener((e) -> {
277 | 					display.setSelectedIndex(2);
278 | 				});
279 | 				views.add(reuseable);
280 | 			}
281 | 			if(filter != null){
282 | 				reuseable = new JMenuItem("Filter Image");
283 | 				reuseable.addActionListener((e) -> {
284 | 					display.setSelectedIndex(atlas == null ? 1 : 3);
285 | 				});
286 | 				views.add(reuseable);
287 | 			}
288 | 			
289 | 			menu[0] = views;
290 | 			menu[1] = new JMenuItem("$Sep$");
291 | 			
292 | 			menu[2] = new JMenuItem("Export this resource");
293 | 			menu[2].setToolTipText("Export the currently visible resource to a file");
294 | 			menu[2].addActionListener((e) -> {
295 | 				exportResource(menu[0]);
296 | 			});
297 | 			menu[3] = new JMenuItem("Export this view");
298 | 			menu[3].setToolTipText("Export the currently visible view to a file");
299 | 			menu[3].addActionListener((e) -> {
300 | 				exportResourceView(menu[3]);
301 | 			});
302 | 			menu[4] = new JMenuItem("Replace this resource");
303 | 			menu[4].setToolTipText("Replace the currently visible resource with a file");
304 | 			menu[4].addActionListener((e) -> {
305 | 				replaceCurrentResource(menu[4]);
306 | 			});
307 | 			menu[5] = new JMenuItem("Restore this resource");
308 | 			menu[5].setToolTipText("Restore the currently visible resource to its original state");
309 | 			menu[5].addActionListener((e) -> {
310 | 				restoreCurrentResource(menu[5]);
311 | 			});
312 | 		}
313 | 		//First the currents
314 | 		if(display == null){
315 | 			display = new JTabbedPane();
316 | 		}
317 | 		display.removeAll();
318 | 		display.add("Main Image", main.getComponent());
319 | 		if(atlas != null){
320 | 			display.add("Atlas file", atlas.getComponent());
321 | 			display.add("Sprite/Animation view", atlas.createSpriteView(main, filter, display));
322 | 			//Sprite view
323 | 		}
324 | 		if(filter != null){
325 | 			display.add("Filter Image", filter.getComponent());
326 | 		}
327 | 		//display.setComponentPopupMenu(ResourceView.createPopup(menu));
328 | 		isInitialized = true;
329 | 	}
330 | 
331 | 	@Override
332 | 	public String getMainName() {
333 | 		return main.getMainName();
334 | 	}
335 | 
336 | 	@Override
337 | 	public List<Resource> getAllResources() {
338 | 		return Utils.call(new ArrayList<>(), (l) -> {
339 | 			if(main != null) l.add(main);
340 | 			if(atlas != null) l.add(atlas);
341 | 			if(filter != null) l.add(filter);
342 | 		});
343 | 	}
344 | 	
345 | }
346 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/CastleDBResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.BorderLayout;
  4 | import java.util.ArrayList;
  5 | import java.util.HashMap;
  6 | import java.util.HashSet;
  7 | import java.util.List;
  8 | import java.util.Map;
  9 | import java.util.Set;
 10 | 
 11 | import javax.swing.JMenuItem;
 12 | import javax.swing.JPanel;
 13 | import javax.swing.JScrollPane;
 14 | import javax.swing.JTextArea;
 15 | import com.google.gson.GsonBuilder;
 16 | import com.google.gson.JsonArray;
 17 | import com.google.gson.JsonElement;
 18 | import com.google.gson.JsonObject;
 19 | import com.google.gson.JsonParser;
 20 | 
 21 | import dev.lb.cellpacker.CellPackerMain;
 22 | import dev.lb.cellpacker.controls.JHistoryTextField;
 23 | import dev.lb.cellpacker.structure.resource.JsonResource;
 24 | import dev.lb.cellpacker.structure.resource.Resource;
 25 | 
 26 | public class CastleDBResourceView extends JsonResourceView{
 27 | 
 28 | 	public CastleDBResourceView(String name, JsonResource resource) {
 29 | 		super(name, resource);
 30 | 	}
 31 | 	
 32 | 	public static JsonResource fixResource(Resource unfixed){
 33 | 		StringBuilder cdb = fixCDBType(fixCDBTables((String) unfixed.getContent()));
 34 | 		return new JsonResource(unfixed.getName(), unfixed.getPath(), unfixed.getMagicNumber(), cdb.toString().getBytes());
 35 | 	}
 36 | 	
 37 | 	public static StringBuilder fixCDBType(String unfixed){
 38 | 		return fixCDBType(new StringBuilder(unfixed));
 39 | 	}
 40 | 	
 41 | 	public static StringBuilder fixCDBType(StringBuilder unfixed){
 42 | 		StringBuilder datacdb = new StringBuilder(unfixed);
 43 | 		int start = datacdb.indexOf("\"17\"", 0);
 44 | 		while(start > -1){
 45 | 			datacdb.replace(start, start + 4, "\"8\"");
 46 | 			start = datacdb.indexOf("\"17\"", start + 3);
 47 | 		}
 48 | 		return datacdb;
 49 | 	}
 50 | 	
 51 | 	public static StringBuilder fixCDBTables(String unfixed){
 52 | 		//Parse to element structure
 53 | 		Set<String> baseSheets = new HashSet<>();
 54 | 		Set<String> subSheets = new HashSet<>();
 55 | 		JsonElement root = new JsonParser().parse(unfixed);
 56 | 		JsonArray sheets = root.getAsJsonObject().get("sheets").getAsJsonArray();
 57 | 		for(JsonElement sheet : sheets){
 58 | 			String name = sheet.getAsJsonObject().get("name").getAsString();
 59 | 			if(name.contains("@")){ //Subsheet
 60 | 				subSheets.add(name);
 61 | 			}else{ //main sheet
 62 | 				baseSheets.add(name);
 63 | 			}
 64 | 		}
 65 | 		
 66 | //		 boolean createnew = JOptionPane.showOptionDialog(CellPackerMain.getMainFrame(), "How would you like to export incomplete tables (Default: remove)",
 67 | //				"Incomplete tables", JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null,
 68 | //				new String[]{"Remove", "Complete"}, 0) == 1;
 69 | 		boolean createnew = false;
 70 | 		
 71 | 		//Now find missing main sheets
 72 | 		if(createnew){
 73 | 			//new sheet name -> field name list
 74 | 			Map<String, List<String>> colNames = new HashMap<>();
 75 | 			for(String ss : subSheets){
 76 | 				//If main sheet is not found, mark it as new column
 77 | 				if(!baseSheets.contains(ss.substring(0, ss.indexOf('@')))){
 78 | 					String baseName = ss.substring(0, ss.indexOf('@'));
 79 | 					List<String> cols = colNames.get(baseName);
 80 | 					if(cols == null){
 81 | 						cols = new ArrayList<>();
 82 | 						colNames.put(baseName, cols);
 83 | 					}
 84 | 					if(ss.indexOf('@') == ss.lastIndexOf('@')){ //Only one
 85 | 						cols.add(ss.substring(ss.indexOf('@') + 1)); //Add col name
 86 | 					}
 87 | 				}
 88 | 			}
 89 | 			//Now create a new Sheet
 90 | 			for(String sheetName : colNames.keySet()){
 91 | 				JsonObject newSheet = new JsonObject();
 92 | 				newSheet.addProperty("name", sheetName);
 93 | 				newSheet.add("props", new JsonObject());
 94 | 				newSheet.add("lines", new JsonArray());
 95 | 				newSheet.add("separators", new JsonArray());
 96 | 				JsonArray cols = new JsonArray();
 97 | 				newSheet.add("columns", cols);
 98 | 				for(String propName : colNames.get(sheetName)){
 99 | 					JsonObject newCol = new JsonObject();
100 | 					newCol.addProperty("typestr", "8");
101 | 					newCol.addProperty("name", propName);
102 | 					newCol.add("display", null);
103 | 					cols.add(newCol);
104 | 				}
105 | 				sheets.add(newSheet);
106 | 			}
107 | 		}else{
108 | 			Set<JsonElement> toDelete = new HashSet<>();
109 | 			for(String ss : subSheets){
110 | 				//If main sheet is not found, mark it for deletion
111 | 				if(!baseSheets.contains(ss.substring(0, ss.indexOf('@')))){
112 | 					//Find it in sheets by it's name
113 | 					for(JsonElement sheet : sheets){
114 | 						if(sheet.getAsJsonObject().get("name").getAsString().equals(ss)){
115 | 							toDelete.add(sheet);
116 | 						}
117 | 					}
118 | 				}
119 | 			}
120 | 			//Now delete them
121 | 			for(JsonElement del : toDelete){
122 | 				sheets.remove(del);
123 | 			}
124 | 		}
125 | 		//Now turn JSON back into string
126 | 		return new StringBuilder(new GsonBuilder().serializeNulls().create().toJson(root));
127 | 	}
128 | 	
129 | 	@Override
130 | 	public void init() {
131 | 		if(isInitialized) return;
132 | 		initMenu(4);
133 | 		menu[3] = new JMenuItem("Export fixed CastleDB version");
134 | 		menu[3].setToolTipText("The version of data.cdb included in res.pak can not be directly read by CastleDB. This will create a fixed version called data.exported.cdb");
135 | 		menu[3].addActionListener((e) -> {
136 | 			JsonResource newRes = fixResource(currentResource);
137 | 			ResourceView.exportResourceToFile(CellPackerMain.getMainFrame(), newRes);
138 | 		});
139 | 		initTab0("JSON");
140 | 		JPanel console = new JPanel(new BorderLayout());
141 | 		JTextArea out = new JTextArea();
142 | 		out.setEditable(false);
143 | 		JHistoryTextField in = new JHistoryTextField();
144 | 		console.add(new JScrollPane(out), BorderLayout.CENTER);
145 | 		console.add(in, BorderLayout.SOUTH);
146 | 		/* Console currently discontiniued, use JSON merge instead
147 | 		CDBFile file = new GsonBuilder().registerTypeAdapter(Line.class, Line.LineSerial.instance).create()
148 | 				.fromJson((String) currentResource.getContent(), CDBFile.class);
149 | 		ScriptReader sr = new ScriptReader(file, new TextAreaPrintStream(out));
150 | 		in.addActionListener((e) -> {
151 | 			sr.execute(in.getText());
152 | 			in.addHistory();
153 | 		});
154 | 		//System.out.println(file);
155 | 		display.add("Console", console);
156 | 		*/
157 | 		isInitialized = true;
158 | 	}
159 | 
160 | }
161 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/FontResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.Component;
  4 | import java.io.File;
  5 | import java.util.ArrayList;
  6 | import java.util.List;
  7 | 
  8 | import javax.swing.JFileChooser;
  9 | import javax.swing.JMenu;
 10 | import javax.swing.JMenuItem;
 11 | import javax.swing.JOptionPane;
 12 | import javax.swing.JTabbedPane;
 13 | 
 14 | import dev.lb.cellpacker.Utils;
 15 | import dev.lb.cellpacker.structure.resource.FontResource;
 16 | import dev.lb.cellpacker.structure.resource.ImageResource;
 17 | import dev.lb.cellpacker.structure.resource.Resource;
 18 | 
 19 | public class FontResourceView extends ResourceView {
 20 | 
 21 | 	private FontResource font;
 22 | 	private FontResource fontOriginal;
 23 | 	private ImageResource image;
 24 | 	private ImageResource imageOriginal;
 25 | 	private String name;
 26 | 	
 27 | 	private JTabbedPane display;
 28 | 	private boolean fontModified;
 29 | 	private boolean imageModified;
 30 | 	
 31 | 	private boolean isInitialized;
 32 | 	
 33 | 	private JMenuItem[] menu;
 34 | 	
 35 | 	public FontResourceView(String resName, ImageResource png, FontResource fnt) {
 36 | 		name = resName;
 37 | 		font = fnt;
 38 | 		image = png;
 39 | 		isInitialized = false;
 40 | 	}
 41 | 
 42 | 	@Override
 43 | 	public String getName() {
 44 | 		return name;
 45 | 	}
 46 | 
 47 | 	@Override
 48 | 	public Component getDisplay() {
 49 | 		init();
 50 | 		return display;
 51 | 	}
 52 | 	
 53 | 	@Override
 54 | 	public void replaceCurrentResource(Component dialogParent) {
 55 | 		int response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to replace?", "Select resource",
 56 | 				JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Font file", "Image file"}, 0);
 57 | 		if(response == JOptionPane.CLOSED_OPTION) return;
 58 | 		if(response == 0){
 59 | 			Resource res = ResourceView.selectReplaceResource(dialogParent, font);
 60 | 			if(res != null && res instanceof FontResource){
 61 | 				if(fontModified){
 62 | 					font = (FontResource) res;
 63 | 				}else{
 64 | 					fontOriginal = font;
 65 | 					font = (FontResource) res;
 66 | 					fontModified = true;
 67 | 				}
 68 | 				forceInit();
 69 | 			}
 70 | 		}else if(response == 1){
 71 | 			Resource res = ResourceView.selectReplaceResource(dialogParent, image);
 72 | 			if(res != null && res instanceof FontResource){
 73 | 				if(imageModified){
 74 | 					image = (ImageResource) res;
 75 | 				}else{
 76 | 					imageOriginal = image;
 77 | 					image = (ImageResource) res;
 78 | 					imageModified = true;
 79 | 				}
 80 | 				forceInit();
 81 | 			}
 82 | 		}
 83 | 	}
 84 | 
 85 | 	@Override
 86 | 	public void restoreCurrentResource(Component dialogParent) {
 87 | 		if(fontModified && imageModified){
 88 | 			int response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to restore?", "Select resource",
 89 | 					JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Font file", "Image file"}, 0);
 90 | 			if(response == 0){
 91 | 				font = fontOriginal;
 92 | 				fontOriginal = null;
 93 | 				fontModified = false;
 94 | 				forceInit();
 95 | 			}else if(response == 1){
 96 | 				image = imageOriginal;
 97 | 				imageOriginal = null;
 98 | 				imageModified = false;
 99 | 				forceInit();
100 | 			}
101 | 		}else if(imageModified){
102 | 			if(JOptionPane.showConfirmDialog(dialogParent, "<html>Changes made to this resource will be lost.<br>Are you sure you want to restore this resource?",
103 | 					"Confirm restoring", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
104 | 				image = imageOriginal;
105 | 				imageOriginal = null;
106 | 				imageModified = false;
107 | 				forceInit();
108 | 			}
109 | 		}else if(fontModified){
110 | 			if(JOptionPane.showConfirmDialog(dialogParent, "<html>Changes made to this resource will be lost.<br>Are you sure you want to restore this resource?",
111 | 					"Confirm restoring", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
112 | 				font = fontOriginal;
113 | 				fontOriginal = null;
114 | 				fontModified = false;
115 | 				forceInit();
116 | 			}
117 | 		}else{
118 | 			JOptionPane.showMessageDialog(dialogParent, "This resource is still unmodified and can not be restored.", "Info", JOptionPane.INFORMATION_MESSAGE);
119 | 		}
120 | 	}
121 | 
122 | 	@Override
123 | 	public void restoreAllResources(Component dialogParent) {
124 | 		if(fontModified){
125 | 			font = fontOriginal;
126 | 			fontOriginal = null;
127 | 			fontModified = false;
128 | 		}
129 | 		if(imageModified){
130 | 			image = imageOriginal;
131 | 			imageOriginal = null;
132 | 			imageModified = false;
133 | 		}
134 | 		if(fontModified || imageModified) forceInit();
135 | 	}
136 | 
137 | 	@Override
138 | 	public JMenuItem[] getContextMenu() {
139 | 		init();
140 | 		return menu;
141 | 	}
142 | 
143 | 	@Override
144 | 	public void exportResource(Component dialogParent) {
145 | 		int response = JOptionPane.showOptionDialog(dialogParent, "Which resource do you want to export?", "Select resource",
146 | 				JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Font file", "Image file"}, 0);
147 | 		if(response == 0){
148 | 			ResourceView.exportResourceToFile(dialogParent, font);
149 | 		}else if(response == 1){
150 | 			ResourceView.exportResourceToFile(dialogParent, image);
151 | 		}
152 | 	}
153 | 
154 | 	@Override
155 | 	public void exportResourceView(Component dialogParent) {
156 | 		JFileChooser jfc = new JFileChooser();
157 | 		jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
158 | 		if(jfc.showSaveDialog(dialogParent) == JFileChooser.APPROVE_OPTION){
159 | 			File file = jfc.getSelectedFile();
160 | 			ResourceView.exportResourceToFile(dialogParent, font, new File(file, font.getName()));
161 | 			ResourceView.exportResourceToFile(dialogParent, image, new File(file, image.getName()));
162 | 		}
163 | 	}
164 | 
165 | 	public void forceInit(){
166 | 		isInitialized = true;
167 | 		init();
168 | 	}
169 | 	
170 | 	@Override
171 | 	public void init() {
172 | 		if(isInitialized) return;
173 | 		if(menu == null){
174 | 			menu = new JMenuItem[6];
175 | 			JMenu views = new JMenu("Show view");
176 | 			JMenuItem reuseable = new JMenuItem("Character Image");
177 | 			reuseable.addActionListener((e) -> {
178 | 				display.setSelectedIndex(0);
179 | 			});
180 | 			views.add(reuseable);
181 | 			reuseable = new JMenuItem("Font file");
182 | 			reuseable.addActionListener((e) -> {
183 | 				display.setSelectedIndex(1);
184 | 			});
185 | 			views.add(reuseable);
186 | 			reuseable = new JMenuItem("Character view");
187 | 			reuseable.addActionListener((e) -> {
188 | 				display.setSelectedIndex(2);
189 | 			});
190 | 			views.add(reuseable);
191 | 			
192 | 			menu[0] = views;
193 | 			menu[1] = new JMenuItem("$Sep$");
194 | 			
195 | 			menu[2] = new JMenuItem("Export this resource");
196 | 			menu[2].setToolTipText("Export the currently visible resource to a file");
197 | 			menu[2].addActionListener((e) -> {
198 | 				exportResource(menu[0]);
199 | 			});
200 | 			menu[3] = new JMenuItem("Export this view");
201 | 			menu[3].setToolTipText("Export the currently visible view to a file");
202 | 			menu[3].addActionListener((e) -> {
203 | 				exportResourceView(menu[3]);
204 | 			});
205 | 			menu[4] = new JMenuItem("Replace this resource");
206 | 			menu[4].setToolTipText("Replace the currently visible resource with a file");
207 | 			menu[4].addActionListener((e) -> {
208 | 				replaceCurrentResource(menu[4]);
209 | 			});
210 | 			menu[5] = new JMenuItem("Restore this resource");
211 | 			menu[5].setToolTipText("Restore the currently visible resource to its original state");
212 | 			menu[5].addActionListener((e) -> {
213 | 				restoreCurrentResource(menu[5]);
214 | 			});
215 | 		}
216 | 		//END MENU
217 | 		
218 | 		if(display == null) display = new JTabbedPane();
219 | 		display.removeAll();
220 | 		display.add("Character Image", image.getComponent());
221 | 		display.add("Font file", font.getComponent());
222 | 		display.addTab("Character View", font.getCharView(image));
223 | 		display.setComponentPopupMenu(ResourceView.createPopup(menu));
224 | 		
225 | 		isInitialized = true;
226 | 	}
227 | 
228 | 	@Override
229 | 	public String getMainName() {
230 | 		return font.getMainName();
231 | 	}
232 | 
233 | 	@Override
234 | 	public List<Resource> getAllResources() {
235 | 		return Utils.call(new ArrayList<>(), (l) -> {
236 | 			if(image != null) l.add(image);
237 | 			if(font != null) l.add(font);
238 | 		});
239 | 	}
240 | 
241 | }
242 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/JsonResourceView.java:
--------------------------------------------------------------------------------
 1 | package dev.lb.cellpacker.structure.view;
 2 | 
 3 | import java.awt.BorderLayout;
 4 | import java.awt.FlowLayout;
 5 | 
 6 | import javax.swing.JButton;
 7 | import javax.swing.JOptionPane;
 8 | import javax.swing.JPanel;
 9 | import javax.swing.JScrollPane;
10 | import javax.swing.JTabbedPane;
11 | import javax.swing.JTextArea;
12 | 
13 | import dev.lb.cellpacker.CellPackerMain;
14 | import dev.lb.cellpacker.Utils;
15 | import dev.lb.cellpacker.structure.resource.JsonResource;
16 | 
17 | public class JsonResourceView extends SingleResourceView{
18 | 
19 | 	public JsonResourceView(String name, JsonResource resource) {
20 | 		super(name, resource);
21 | 		
22 | 	}
23 | 
24 | 	protected void initTab0(String title){
25 | 		if(currentResource != null){
26 | 			if(display == null) display = new JTabbedPane();
27 | 			display.removeAll();
28 | 			JPanel con = new JPanel(new BorderLayout());
29 | 			JScrollPane cr = (JScrollPane) currentResource.getComponent();
30 | 			JTextArea text = (JTextArea) cr.getViewport().getView();
31 | 			con.add(cr, BorderLayout.CENTER);
32 | 			JPanel southCon = new JPanel(new FlowLayout());
33 | 			JButton edit = new JButton("Enable editing");
34 | 			JButton save = new JButton("Save changes");
35 | 			JButton disc = new JButton("Discard changes");
36 | 			save.setEnabled(false);
37 | 			disc.setEnabled(false);
38 | 			edit.addActionListener((e) -> {
39 | 				edit.setEnabled(false);
40 | 				save.setEnabled(true);
41 | 				disc.setEnabled(true);
42 | 				text.setEditable(true);
43 | 			});
44 | 			save.addActionListener((e) -> {
45 | 				int result = 0;
46 | 				if(!Utils.isJsonValid(text.getText())){
47 | 					result = JOptionPane.showOptionDialog(CellPackerMain.getMainFrame(), "The text is NOT valid JSON. This will most likely result in parsing errors.", "Invalid JSON", JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, new String[]{"Save anyways", "Discard changes", "Cancel"}, 0);
48 | 				}
49 | 				if(result == 2) return; //cancel
50 | 				edit.setEnabled(true);
51 | 				save.setEnabled(false);
52 | 				disc.setEnabled(false);
53 | 				text.setEditable(false);
54 | 				if(result == 0){ //Anyways
55 | 					JsonResource newRes = new JsonResource(currentResource.getName(), currentResource.getPath(), currentResource.getMagicNumber(), text.getText().getBytes());
56 | 					if(newRes != null){
57 | 						if(changesMade){
58 | 							currentResource = newRes;
59 | 						}else{
60 | 							originalResource = currentResource;
61 | 							currentResource = newRes;
62 | 							changesMade = true;
63 | 						}
64 | 						forceInit();
65 | 					}
66 | 				}else{ //Discard
67 | 					forceInit();
68 | 				}
69 | 			});
70 | 			disc.addActionListener((e) -> {
71 | 				if(JOptionPane.showConfirmDialog(CellPackerMain.getMainFrame(), "Are you sure that you want to discard your changes to this file?", "Discard changes",JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
72 | 					edit.setEnabled(true);
73 | 					save.setEnabled(false);
74 | 					disc.setEnabled(false);
75 | 					text.setEditable(false);
76 | 					forceInit();
77 | 				}
78 | 			});
79 | 			southCon.add(edit);
80 | 			southCon.add(save);
81 | 			southCon.add(disc);
82 | 			con.add(southCon, BorderLayout.SOUTH);
83 | 			display.add(title, con);
84 | 			//display.setComponentPopupMenu(ResourceView.createPopup(menu));
85 | 		}
86 | 	}
87 | 	
88 | 	@Override
89 | 	public void init() {
90 | 		if(isInitialized) return;
91 | 		initMenu(3);
92 | 		initTab0("Resource");
93 | 		isInitialized = true;
94 | 	}
95 | 
96 | 	
97 | }
98 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/ResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.Component;
  4 | import java.awt.Container;
  5 | import java.io.File;
  6 | import java.io.FileInputStream;
  7 | import java.io.FileOutputStream;
  8 | import java.io.IOException;
  9 | import java.util.List;
 10 | 
 11 | import javax.swing.JComponent;
 12 | import javax.swing.JFileChooser;
 13 | import javax.swing.JMenuItem;
 14 | import javax.swing.JOptionPane;
 15 | import javax.swing.JPopupMenu;
 16 | 
 17 | import dev.lb.cellpacker.structure.NamedObject;
 18 | import dev.lb.cellpacker.structure.resource.Resource;
 19 | 
 20 | public abstract class ResourceView implements NamedObject{
 21 | 	
 22 | 	/**
 23 | 	 * Returns a name for this resource view. This name will be displayed in the tree view
 24 | 	 */
 25 | 	public abstract String getName();
 26 | 	/**
 27 | 	 * Returns a component that should be displayed in the main area when this view is selected
 28 | 	 */
 29 | 	public abstract Component getDisplay();
 30 | 
 31 | 	/**
 32 | 	 * Should show a dialog where the user can select a resource to replace this one with. 
 33 | 	 */
 34 | 	public abstract void replaceCurrentResource(Component dialogParent);
 35 | 	/**
 36 | 	 * Restore the selected resource to the original version.
 37 | 	 */
 38 | 	public abstract void restoreCurrentResource(Component dialogParent);
 39 | 	/**
 40 | 	 * Restore all contained resources to the original version.
 41 | 	 */
 42 | 	public abstract void restoreAllResources(Component dialogParent);
 43 | 	/**
 44 | 	 * Returns the context menu for this resource.
 45 | 	 */
 46 | 	public abstract JMenuItem[] getContextMenu();
 47 | 	
 48 | 	/**
 49 | 	 * Exports the resource to a file, with jfc etc 
 50 | 	 */
 51 | 	public abstract void exportResource(Component dialogParent);
 52 | 	
 53 | 	/**
 54 | 	 * Exports the view to a file, with jfc etc 
 55 | 	 */
 56 | 	public abstract void exportResourceView(Component dialogParent);
 57 | 	
 58 | 	/**
 59 | 	 * Does all lazy-load initialization
 60 | 	 */
 61 | 	public abstract void init();
 62 | 	
 63 | 	public abstract List<Resource> getAllResources();
 64 | 	
 65 | 	/**
 66 | 	 * returns the name without file extension
 67 | 	 */
 68 | 	public abstract String getMainName();
 69 | 	
 70 | 	/**
 71 | 	 * Can be overridden to stop sounds or animations.
 72 | 	 */
 73 | 	public void focusLost(){}
 74 | 	
 75 | 	public abstract void forceInit();
 76 | 	
 77 | 	@Override
 78 | 	public String toString() {
 79 | 		return getName();
 80 | 	}
 81 | 	
 82 | 	public static JPopupMenu createPopup(JMenuItem[] items){
 83 | 		JPopupMenu pop = new JPopupMenu();
 84 | 		for(JMenuItem i : items){
 85 | 			if(i.getText().equals("$Sep$")){
 86 | 				pop.addSeparator();
 87 | 			}else{
 88 | 				pop.add(i);
 89 | 			}
 90 | 		}
 91 | 		return pop;
 92 | 	}
 93 | 	
 94 | 	public static void attachPopup(JPopupMenu menu, Container comp){
 95 | 		for (final Component c : comp.getComponents()) {
 96 | 	        if (c instanceof JComponent) {
 97 | 	            ((JComponent) c).setComponentPopupMenu(menu);
 98 | 	        }
 99 | 	        if (c instanceof Container) {
100 | 	            attachPopup(menu, (Container) c);
101 | 	        }
102 | 	    }
103 | 	}
104 | 	
105 | 	public static void exportResourceToFile(Component dialogParent, Resource resource){
106 | 		JFileChooser jfc = new JFileChooser();
107 | 		jfc.setFileFilter(resource.getFileFilter());
108 | 		if(jfc.showSaveDialog(dialogParent) == JFileChooser.APPROVE_OPTION && jfc.getSelectedFile() != null){
109 | 			exportResourceToFile(dialogParent, resource, jfc.getSelectedFile());
110 | 		}
111 | 	}
112 | 	
113 | 	public static void exportResourceToFile(Component dialogParent, Resource resource, File file){
114 | 		if(!file.exists() || JOptionPane.showConfirmDialog(dialogParent, "The file already exists. Are you sure you want to overwrite it?", "Overwrite file", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
115 | 			try {
116 | 				if(!file.exists())
117 | 					file.createNewFile();
118 | 				try(FileOutputStream fos = new FileOutputStream(file)){
119 | 					fos.write(resource.getData());
120 | 				}
121 | 			} catch (IOException e) {
122 | 				e.printStackTrace();
123 | 				JOptionPane.showMessageDialog(dialogParent, "An error occurred while writing: ", "Error", JOptionPane.ERROR_MESSAGE);
124 | 				return;
125 | 			}
126 | 		}
127 | 	}
128 | 	
129 | 	public static Resource selectReplaceResource(Component dialogParent, Resource oldResource){
130 | 		JFileChooser jfc = new JFileChooser();
131 | 		jfc.setFileFilter(oldResource.getFileFilter());
132 | 		if(jfc.showOpenDialog(dialogParent) == JFileChooser.APPROVE_OPTION && jfc.getSelectedFile() != null){
133 | 			byte[] data = new byte[(int) jfc.getSelectedFile().length()];
134 | 			try(FileInputStream fis = new FileInputStream(jfc.getSelectedFile());){
135 | 				fis.read(data);
136 | 			} catch (IOException e) {
137 | 				e.printStackTrace();
138 | 				JOptionPane.showMessageDialog(dialogParent, "An error occurred while reading file: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
139 | 				return null;
140 | 			}
141 | 			return Resource.createFromType(oldResource.getName(), oldResource.getPath(), oldResource.getMagicNumber(), data, oldResource.getClass());
142 | 		}
143 | 		return null;
144 | 	}
145 | }
146 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/SingleResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.Component;
  4 | import java.util.ArrayList;
  5 | import java.util.List;
  6 | 
  7 | import javax.swing.JMenuItem;
  8 | import javax.swing.JOptionPane;
  9 | import javax.swing.JTabbedPane;
 10 | 
 11 | import dev.lb.cellpacker.Utils;
 12 | import dev.lb.cellpacker.structure.resource.Resource;
 13 | import dev.lb.cellpacker.structure.resource.SoundResource;
 14 | 
 15 | public class SingleResourceView extends ResourceView{
 16 | 
 17 | 	protected Resource currentResource;
 18 | 	protected Resource originalResource;
 19 | 	protected boolean changesMade;
 20 | 	private String viewName;
 21 | 	protected boolean isInitialized;
 22 | 	protected JTabbedPane display;
 23 | 	protected JMenuItem[] menu;
 24 | 	
 25 | 	public SingleResourceView(String name, Resource resource) {
 26 | 		currentResource = resource;
 27 | 		originalResource = null;
 28 | 		changesMade = false;
 29 | 		viewName = name;
 30 | 		isInitialized = false;
 31 | 	}
 32 | 	
 33 | 	@Override
 34 | 	public String getName() {
 35 | 		return viewName;
 36 | 	}
 37 | 
 38 | 	@Override
 39 | 	public Component getDisplay() {
 40 | 		init();
 41 | 		return display;
 42 | 	}
 43 | 
 44 | 	@Override
 45 | 	public void replaceCurrentResource(Component dialogParent) {
 46 | 		Resource newRes = ResourceView.selectReplaceResource(dialogParent, currentResource); 
 47 | 		if(newRes != null){
 48 | 			if(changesMade){
 49 | 				currentResource = newRes;
 50 | 			}else{
 51 | 				originalResource = currentResource;
 52 | 				currentResource = newRes;
 53 | 				changesMade = true;
 54 | 			}
 55 | 			forceInit();
 56 | 		}
 57 | 	}
 58 | 
 59 | 	@Override
 60 | 	public void restoreCurrentResource(Component dialogParent) {
 61 | 		if(changesMade && JOptionPane.showConfirmDialog(dialogParent, "<html>Changes made to this resource will be lost.<br>Are you sure you want to restore this resource?", "Confirm restoring", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION){
 62 | 			currentResource = originalResource;
 63 | 			originalResource = null;
 64 | 			changesMade = false;
 65 | 			forceInit();
 66 | 		}else if(!changesMade){
 67 | 			JOptionPane.showMessageDialog(dialogParent, "This resource is still unmodified and can not be restored.", "Info", JOptionPane.INFORMATION_MESSAGE);
 68 | 		}
 69 | 	}
 70 | 
 71 | 	@Override
 72 | 	public void restoreAllResources(Component dialogParent) {
 73 | 		if(changesMade){
 74 | 			currentResource = originalResource;
 75 | 			originalResource = null;
 76 | 			changesMade = false;
 77 | 			forceInit();
 78 | 		}
 79 | 	}
 80 | 
 81 | 	@Override
 82 | 	public JMenuItem[] getContextMenu() {
 83 | 		init();
 84 | 		return menu;
 85 | 	}
 86 | 	
 87 | 	protected void initMenu(int size){
 88 | 		if(menu == null){
 89 | 			menu = new JMenuItem[size];
 90 | 			menu[0] = new JMenuItem("Export this resource");
 91 | 			menu[0].setToolTipText("Export the currently visible resource to a file");
 92 | 			menu[0].addActionListener((e) -> {
 93 | 				exportResource(menu[0]);
 94 | 			});
 95 | 			menu[1] = new JMenuItem("Replace this resource");
 96 | 			menu[1].setToolTipText("Replace the currently visible resource with a file");
 97 | 			menu[1].addActionListener((e) -> {
 98 | 				replaceCurrentResource(menu[1]);
 99 | 			});
100 | 			menu[2] = new JMenuItem("Restore this resource");
101 | 			menu[2].setToolTipText("Restore the currently visible resource to its original state");
102 | 			menu[2].addActionListener((e) -> {
103 | 				restoreCurrentResource(menu[2]);
104 | 			});
105 | 		}
106 | 	}
107 | 
108 | 	@Override
109 | 	public void init() {
110 | 		if(isInitialized) return;
111 | 		initMenu(3);
112 | 		if(currentResource != null){
113 | 			if(display == null) display = new JTabbedPane();
114 | 			display.removeAll();
115 | 			display.add("Resource", currentResource.getComponent());
116 | 			//display.setComponentPopupMenu(ResourceView.createPopup(menu));
117 | 		}
118 | 		isInitialized = true;
119 | 	}
120 | 	
121 | 	public void forceInit(){
122 | 		isInitialized = false;
123 | 		init();
124 | 	}
125 | 
126 | 	@Override
127 | 	public void exportResource(Component dialogParent) {
128 | 		ResourceView.exportResourceToFile(dialogParent, currentResource);
129 | 	}
130 | 
131 | 	@Override
132 | 	public void exportResourceView(Component dialogParent) {
133 | 		exportResource(dialogParent);
134 | 	}
135 | 
136 | 	@Override
137 | 	public void focusLost() {
138 | 		if(currentResource instanceof SoundResource){
139 | 			((SoundResource) currentResource).stopPlaying();
140 | 		}
141 | 		if(originalResource instanceof SoundResource){
142 | 			((SoundResource) originalResource).stopPlaying();
143 | 		}
144 | 	}
145 | 
146 | 	@Override
147 | 	public String getMainName() {
148 | 		return currentResource.getMainName();
149 | 	}
150 | 
151 | 	@Override
152 | 	public List<Resource> getAllResources() {
153 | 		return Utils.call(new ArrayList<>(), (l) -> { if(currentResource != null) l.add(currentResource); });
154 | 	}
155 | 	
156 | 	
157 | }
158 | 


--------------------------------------------------------------------------------
/src/dev/lb/cellpacker/structure/view/StaticResourceView.java:
--------------------------------------------------------------------------------
  1 | package dev.lb.cellpacker.structure.view;
  2 | 
  3 | import java.awt.Component;
  4 | import java.awt.FlowLayout;
  5 | import java.awt.image.BufferedImage;
  6 | import java.io.ByteArrayOutputStream;
  7 | import java.io.IOException;
  8 | import java.util.ArrayList;
  9 | import java.util.List;
 10 | 
 11 | import javax.imageio.ImageIO;
 12 | import javax.swing.JLabel;
 13 | import javax.swing.JMenuItem;
 14 | import javax.swing.JOptionPane;
 15 | import javax.swing.JPanel;
 16 | import javax.swing.JTabbedPane;
 17 | import javax.swing.filechooser.FileFilter;
 18 | import javax.swing.filechooser.FileNameExtensionFilter;
 19 | 
 20 | import dev.lb.cellpacker.Logger;
 21 | import dev.lb.cellpacker.Utils;
 22 | import dev.lb.cellpacker.structure.resource.ImageResource;
 23 | import dev.lb.cellpacker.structure.resource.Resource;
 24 | 
 25 | public class StaticResourceView extends ResourceView{
 26 | 
 27 | 	private String name;
 28 | 	private Resource resource;
 29 | 	
 30 | 	private Component display;
 31 | 	private JMenuItem[] menu;
 32 | 	
 33 | 	public StaticResourceView(String name, Resource resource){
 34 | 		this.name = name;
 35 | 		this.resource = resource;
 36 | 	}
 37 | 	
 38 | 	public StaticResourceView(String name, String text, byte[] data){
 39 | 		this.name = name;
 40 | 		this.resource = staticTextResource(name, text, data);
 41 | 	}
 42 | 	
 43 | 	public static Resource staticTextResource(String name2, String text, byte[] data2){
 44 | 		return new Resource(name2, "", 0, data2) {
 45 | 			
 46 | 			JPanel textA;
 47 | 			
 48 | 			{
 49 | 				textA = new JPanel(new FlowLayout());
 50 | 				textA.add(new JLabel(text));
 51 | 				this.isInitialized = true;
 52 | 			}
 53 | 			
 54 | 			@Override
 55 | 			public FileFilter getFileFilter() {
 56 | 				return new FileNameExtensionFilter("<No Files>", "");
 57 | 			}
 58 | 			
 59 | 			@Override
 60 | 			public Object getContent() {
 61 | 				return text;
 62 | 			}
 63 | 			
 64 | 			@Override
 65 | 			public Component getComponent() {
 66 | 				return textA;
 67 | 			}
 68 | 			
 69 | 			//I know this is bad
 70 | 			@Override
 71 | 			public Resource clone() {
 72 | 				return null;
 73 | 			}
 74 | 		};
 75 | 	}
 76 | 	
 77 | 	public static ImageResource defaultImage(String name, String path, String text){
 78 | 		BufferedImage img =  new BufferedImage(300, 100, BufferedImage.TYPE_INT_ARGB);
 79 | 		img.getGraphics().drawString(text, 50, 50);
 80 | 		try(ByteArrayOutputStream baos = new ByteArrayOutputStream()){
 81 | 			ImageIO.write(img, "png", baos);
 82 | 			baos.flush();
 83 | 			return new ImageResource(name, path, 0, baos.toByteArray());
 84 | 		}catch (IOException e) {
 85 | 			Logger.throwFatal(e);
 86 | 		}
 87 | 		return null;
 88 | 	}
 89 | 
 90 | 	@Override
 91 | 	public String getName() {
 92 | 		return name;
 93 | 	}
 94 | 
 95 | 	@Override
 96 | 	public Component getDisplay() {
 97 | 		init();
 98 | 		return display;
 99 | 	}
100 | 
101 | 	@Override
102 | 	public void replaceCurrentResource(Component dialogParent) {
103 | 		JOptionPane.showMessageDialog(dialogParent, "This resource can not be modified.", "Error", JOptionPane.ERROR_MESSAGE);
104 | 	}
105 | 
106 | 	@Override
107 | 	public void restoreCurrentResource(Component dialogParent) {
108 | 		JOptionPane.showMessageDialog(dialogParent, "This resource can not be modified and can not be restored", "Error", JOptionPane.ERROR_MESSAGE);
109 | 	}
110 | 
111 | 	@Override
112 | 	public void restoreAllResources(Component dialogParent) {
113 | 		//No message 
114 | 	}
115 | 
116 | 	@Override
117 | 	public JMenuItem[] getContextMenu() {
118 | 		init();
119 | 		return menu;
120 | 	}
121 | 
122 | 	@Override
123 | 	public void init() {
124 | 		if(menu == null){
125 | 			menu = new JMenuItem[1];
126 | 			menu[0] = new JMenuItem("<No options available>");
127 | 			menu[0].setToolTipText("This resource can not be modified and has no options");
128 | 		}
129 | 		if(display == null){
130 | 			JTabbedPane tabs = new JTabbedPane();
131 | 			tabs.add("Static", resource.getComponent());
132 | 			display = tabs;
133 | 			//tabs.setComponentPopupMenu(ResourceView.createPopup(menu));
134 | 		}
135 | 	}
136 | 
137 | 	@Override
138 | 	public void exportResource(Component dialogParent) {
139 | 		JOptionPane.showMessageDialog(dialogParent, "This resource can not be modified and can not be written to a file", "Error", JOptionPane.ERROR_MESSAGE);
140 | 	}
141 | 
142 | 	@Override
143 | 	public void exportResourceView(Component dialogParent) {
144 | 		JOptionPane.showMessageDialog(dialogParent, "This resource can not be modified and can not be written to a file", "Error", JOptionPane.ERROR_MESSAGE);
145 | 	}
146 | 	
147 | 	@Override
148 | 	public String getMainName() {
149 | 		return "$STATIC$";
150 | 	}
151 | 
152 | 	@Override
153 | 	public List<Resource> getAllResources() {
154 | 		return Utils.call(new ArrayList<>(), (l) -> l.add(resource));
155 | 	}
156 | 
157 | 	@Override
158 | 	public void forceInit() {}
159 | }
160 | 


--------------------------------------------------------------------------------
/src/resources/ico.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ReBuilders101/CellPacker/27babca69bdae7b8d9ad7ccc2c1b864853b30632/src/resources/ico.png


--------------------------------------------------------------------------------