Ticket #3596: natural_sort.patch

src/kits/tracker/WidgetAttributeText.cpp

@@ -63 +63 @@
 
 const int32 kGenericReadBufferSize = 1024;
 
-
 template <class View>
 float
 TruncStringBase(BString *result, const char *str, int32 length,
@@ -595 +594 @@
     if (fValueDirty)
         ReadValue(&fFullValueText);
 
-    return strcasecmp(fFullValueText.String(), compareTo->ValueAsText(view));
+    return NaturalCompare(fFullValueText.String(), compareTo->ValueAsText(view));
 }
 
 
@@ -782 +781 @@
     if (NameAttributeText::sSortFolderNamesFirst)
         return fModel->CompareFolderNamesFirst(attr.TargetModel());
 
-    return strcasecmp(fFullValueText.String(), compareTo->ValueAsText(view));
+    return NaturalCompare(fFullValueText.String(), compareTo->ValueAsText(view));
 }
 
 

src/kits/tracker/Model.cpp

@@ -321 +321 @@
     } else if (resolvedCompareModel->IsDirectory())
         return 1;
 
-    return strcasecmp(Name(), compareModel->Name());
+    return NaturalCompare(Name(), compareModel->Name());
 }
 
 

src/kits/tracker/Utilities.h

@@ -176 +176 @@
 void DisallowMetaKeys(BTextView *);
 void DisallowFilenameKeys(BTextView *);
 
+struct Chunk {
+    int32 type;
+    char *ascii;
+        // Type = 0
+    int32 num;
+        // Type = 1
+};
+
+inline bool 
+IsDigit(const char c) 
+{
+    if ((c >= 48 && c <= 57) || c == 32) 
+        return true;
+    else 
+        return false;
+}
+
+// Compares two strings naturally, as opposed to lexicographically
+inline int 
+NaturalCompare(const char *s1, const char *s2) 
+{
+    Chunk a, b;
+    size_t len1 = strlen(s1), len2 = strlen(s2);
+    char bufferA[len1 + 1], bufferB[len2 + 1];
+    uint32 i = 0, j = 0;
+
+    while (true) {
+        if (i == len1) 
+            a.type = -1;
+        else if (IsDigit(s1[i])) 
+            a.type = 1;
+        else 
+            a.type = 0;
+
+        if (j == len2) 
+            b.type = -1;
+        else if (IsDigit(s2[j])) 
+            b.type = 1;
+        else 
+            b.type = 0;
+
+        if (a.type == b.type && a.type == -1) 
+            return 0;
+        else {
+            if (a.type == 0) {
+                int32 k = i;
+                while (!IsDigit(s1[k]) && s1[k] != 0) {
+                    bufferA[k - i] = s1[k];
+                    k++;
+                }
+                bufferA[k - i] = 0;
+                a.ascii = bufferA;
+                i += k - i;
+            } else if (a.type == 1) {
+                int32 k = i;
+                while (IsDigit(s1[k]) && s1[k] != 0) {
+                    bufferA[k - i] = s1[k];
+                    k++;
+                }
+                bufferA[k - i] = 0;
+                a.ascii = bufferA;
+                a.num = atoi(bufferA);
+                i += k - i;
+            }
+
+            if (b.type == 0) {
+                int32 k = j;
+                while (!IsDigit(s2[k]) && s2[k] != 0) {
+                    bufferB[k - j] = s2[k];
+                    k++;
+                }
+                bufferB[k - j] = 0;
+                b.ascii = bufferB;
+                j += k - j;
+            }
+
+            else if (b.type == 1) {
+                int32 k = j;
+                while (IsDigit(s2[k]) && s2[k] != 0) {
+                    bufferB[k - j] = s2[k];
+                    k++;
+                }
+                bufferB[k - j] = 0;
+                b.ascii = bufferB;
+                b.num = atoi(bufferB);
+                j += k - j;
+            }
+        }
+
+        if (a.type == -1) 
+            return -1;
+        if (b.type == -1) 
+            return 1;
+
+        if (a.type == b.type) {
+            if (a.type == 0) {
+                if (strcasecmp(a.ascii, b.ascii))
+                    return strcasecmp(a.ascii, b.ascii);
+            } else {
+                if (a.num != b.num) {
+                    if (a.num < b.num) 
+                        return -1;
+                    if (a.num > b.num) 
+                        return 1;
+                }
+            }
+        } else 
+            return strcasecmp(a.ascii, b.ascii);
+    }
+  return 0;
+}
+
 bool ValidateStream(BMallocIO *, uint32, int32 version);
 
 uint32 HashString(const char *string, uint32 seed);
 uint32 AttrHashString(const char *string, uint32 type);
 
-
 class OffscreenBitmap {
     // a utility class for setting up offscreen bitmaps
     public: