From ead1aa222a2aa4fa443f342ad87045eca8e6c43d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jindra=20Pet=C5=99=C3=ADk?= Date: Sun, 1 Oct 2023 16:04:59 +0200 Subject: [PATCH] Added AS3 Natural sorting of packages and script --- CHANGELOG.md | 1 + .../decompiler/flash/timeline/AS3Package.java | 5 +- .../src/natorder/NaturalOrderComparator.java | 209 ++++++++++++++++++ src/com/jpexs/build/LicenseUpdater.java | 2 +- 4 files changed, 214 insertions(+), 3 deletions(-) create mode 100644 libsrc/ffdec_lib/src/natorder/NaturalOrderComparator.java diff --git a/CHANGELOG.md b/CHANGELOG.md index 0cad329a6..5960fa493 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,6 +23,7 @@ All notable changes to this project will be documented in this file. - [#2010] word wrapping in the translation tool - ABC Explorer tool - FLA export - remember last selected FLA version/compression +- AS3 Natural sorting of packages and script ### Fixed - [#2043] StartSound2 tag handling diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/timeline/AS3Package.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/timeline/AS3Package.java index 28d66b8e1..d2ef43229 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/timeline/AS3Package.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/timeline/AS3Package.java @@ -26,6 +26,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.TreeMap; +import natorder.NaturalOrderComparator; /** * @@ -37,9 +38,9 @@ public class AS3Package extends AS3ClassTreeItem { public String packageName; - private final Map subPackages = new TreeMap<>(); + private final Map subPackages = new TreeMap<>(new NaturalOrderComparator()); - private final Map scripts = new TreeMap<>(); + private final Map scripts = new TreeMap<>(new NaturalOrderComparator()); private List sortedPackages; diff --git a/libsrc/ffdec_lib/src/natorder/NaturalOrderComparator.java b/libsrc/ffdec_lib/src/natorder/NaturalOrderComparator.java new file mode 100644 index 000000000..c655e8b6d --- /dev/null +++ b/libsrc/ffdec_lib/src/natorder/NaturalOrderComparator.java @@ -0,0 +1,209 @@ +package natorder; + +/* + NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java. + Copyright (C) 2003 by Pierre-Luc Paour + + Based on the C version by Martin Pool, of which this is more or less a straight conversion. + Copyright (C) 2000 by Martin Pool + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +import java.util.*; + +public class NaturalOrderComparator implements Comparator +{ + int compareRight(String a, String b) + { + int bias = 0, ia = 0, ib = 0; + + // The longest run of digits wins. That aside, the greatest + // value wins, but we can't know that it will until we've scanned + // both numbers to know that they have the same magnitude, so we + // remember it in BIAS. + for (;; ia++, ib++) + { + char ca = charAt(a, ia); + char cb = charAt(b, ib); + + if (!isDigit(ca) && !isDigit(cb)) { + return bias; + } + if (!isDigit(ca)) { + return -1; + } + if (!isDigit(cb)) { + return +1; + } + if (ca == 0 && cb == 0) { + return bias; + } + + if (bias == 0) { + if (ca < cb) { + bias = -1; + } else if (ca > cb) { + bias = +1; + } + } + } + } + + public int compare(Object o1, Object o2) + { + String a = o1.toString(); + String b = o2.toString(); + + int ia = 0, ib = 0; + int nza = 0, nzb = 0; + char ca, cb; + + while (true) { + // Only count the number of zeroes leading the last number compared + nza = nzb = 0; + + ca = charAt(a, ia); + cb = charAt(b, ib); + + // skip over leading spaces or zeros + while (Character.isSpaceChar(ca) || ca == '0') { + if (ca == '0') { + nza++; + } else { + // Only count consecutive zeroes + nza = 0; + } + + ca = charAt(a, ++ia); + } + + while (Character.isSpaceChar(cb) || cb == '0') { + if (cb == '0') { + nzb++; + } else { + // Only count consecutive zeroes + nzb = 0; + } + + cb = charAt(b, ++ib); + } + + // Process run of digits + if (Character.isDigit(ca) && Character.isDigit(cb)) { + int bias = compareRight(a.substring(ia), b.substring(ib)); + if (bias != 0) { + return bias; + } + } + + if (ca == 0 && cb == 0) { + // The strings compare the same. Perhaps the caller + // will want to call strcmp to break the tie. + return compareEqual(a, b, nza, nzb); + } + if (ca < cb) { + return -1; + } + if (ca > cb) { + return +1; + } + + ++ia; + ++ib; + } + } + + static boolean isDigit(char c) { + return Character.isDigit(c) || c == '.' || c == ','; + } + + static char charAt(String s, int i) { + return i >= s.length() ? 0 : s.charAt(i); + } + + static int compareEqual(String a, String b, int nza, int nzb) { + if (nza - nzb != 0) + return nza - nzb; + + if (a.length() == b.length()) + return a.compareTo(b); + + return a.length() - b.length(); + } + + @SuppressWarnings("unchecked") // JPEXS + public static void main(String[] args) + { + String[] strings = new String[] { "1-2", "1-02", "1-20", "10-20", "fred", "jane", "pic01", + "pic2", "pic02", "pic02a", "pic3", "pic4", "pic 4 else", "pic 5", "pic05", "pic 5", + "pic 5 something", "pic 6", "pic 7", "pic100", "pic100a", "pic120", "pic121", + "pic02000", "tom", "x2-g8", "x2-y7", "x2-y08", "x8-y8" }; + + List orig = Arrays.asList(strings); + + System.out.println("Original: " + orig); + + List scrambled = Arrays.asList(strings); + Collections.shuffle(scrambled); + + System.out.println("Scrambled: " + scrambled); + + Collections.sort(scrambled, new NaturalOrderComparator()); + + System.out.println("Sorted: " + scrambled); + + shuffle3000(scrambled); + + compareSymmetric(); + + floatsWithCommas(); + } + + @SuppressWarnings("unchecked") // JPEXS + static void shuffle3000(List scrambled) { + Collections.shuffle(scrambled, new Random(3000)); + Collections.sort(scrambled, new NaturalOrderComparator()); + + System.out.println("Sorted: " + scrambled); + } + + static void compareSymmetric() { + NaturalOrderComparator naturalOrderComparator = new NaturalOrderComparator(); + + int compare1 = naturalOrderComparator.compare("1-2", "1-02"); + int compare2 = naturalOrderComparator.compare("1-02", "1-2"); + + System.out.println(compare1 + " == " + compare2); + + compare1 = naturalOrderComparator.compare("pic 5", "pic05"); + compare2 = naturalOrderComparator.compare("pic05", "pic 5"); + + System.out.println(compare1 + " == " + compare2); + } + + @SuppressWarnings("unchecked") // JPEXS + static void floatsWithCommas() { + List unSorted = Arrays.asList("0.9", "1.0c", "1.2", "1.3", "0.6", "1.1", "0.7", "0.3", "1.0b", "1.0", "0.8"); + + System.out.println("Unsorted: " + unSorted); + + unSorted.sort(new NaturalOrderComparator()); + + System.out.println("Sorted: " + unSorted); + } +} diff --git a/src/com/jpexs/build/LicenseUpdater.java b/src/com/jpexs/build/LicenseUpdater.java index 30b9dad6f..a5b42c328 100644 --- a/src/com/jpexs/build/LicenseUpdater.java +++ b/src/com/jpexs/build/LicenseUpdater.java @@ -44,7 +44,7 @@ public class LicenseUpdater { public static void updateLicense() { updateLicenseInDir(new File(".\\src\\"), false); updateLicenseInDir(new File(".\\test\\"), false); - updateLicenseInDir(new File(".\\libsrc\\ffdec_lib\\src\\"), true); + updateLicenseInDir(new File(".\\libsrc\\ffdec_lib\\src\\com\\"), true); //Not in src/ as we need to skip natorder package updateLicenseInDir(new File(".\\libsrc\\ffdec_lib\\test\\"), true); }