// -----------------------------------------------------------------------------
int get_theme_list_sort(gconstpointer themeEntry1, gconstpointer themeEntry2)
{
// TODO: make this more robust by using theme entry file & path strings as well
const GString* n1 = ((const ThemeEntry*)themeEntry1)->pName;
const GString* n2 = ((const ThemeEntry*)themeEntry2)->pName;
const GString* p1 = ((const ThemeEntry*)themeEntry1)->pPath;
const GString* p2 = ((const ThemeEntry*)themeEntry2)->pPath;
const GString* f1 = ((const ThemeEntry*)themeEntry1)->pFile;
const GString* f2 = ((const ThemeEntry*)themeEntry2)->pFile;
const bool ok1 = n1 && n2 && n1->str && n2->str;
const bool ok2 = p1 && p2 && p1->str && p2->str;
const bool ok3 = f1 && f2 && f1->str && f2->str;
int ret = 0; // default to same if
if( ok1 && (ret = strnatcasecmp(n1->str, n2->str)) == 0 )
{
if( ok2 && (ret = strnatcasecmp(p1->str, p2->str)) == 0 )
{
if( ok3 )
ret = strnatcasecmp(f1->str, f2->str);
}
}
return ret;
}
int compare_level_names(const void *a, const void *b)
{
FLevelStatistics *A = (FLevelStatistics*)a;
FLevelStatistics *B = (FLevelStatistics*)b;
return strnatcasecmp(A->name, B->name);
}
int compare_episode_names(const void *a, const void *b)
{
FStatistics *A = (FStatistics*)a;
FStatistics *B = (FStatistics*)b;
return strnatcasecmp(A->epi_header, B->epi_header);
}
bool naturalStringSort(const std::string& lhs, const std::string& rhs)
{
int val = strnatcasecmp(lhs.c_str(), rhs.c_str());
if(val == 1)
return false;
return true;
}
gint theme_name_compare(GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
gchar *path_a, *path_b;
gtk_tree_model_get(model, a, COL_THEME_FILE, &path_a, -1);
gtk_tree_model_get(model, b, COL_THEME_FILE, &path_b, -1);
gchar *name_a = path_a;
gchar *p;
for (p = name_a; *p; p++) {
if (*p == '/')
name_a = p + 1;
}
gchar *name_b = path_b;
for (p = name_b; *p; p++) {
if (*p == '/')
name_b = p + 1;
}
if (g_str_equal(name_a, name_b))
return 0;
if (g_str_equal(name_a, "tint2rc"))
return -1;
if (g_str_equal(name_b, "tint2rc"))
return 1;
gint result = strnatcasecmp(name_a, name_b);
g_free(path_a);
g_free(path_b);
return result;
}
cListItem* cListBox::BubbleSortList(cListItem *head, int count, int col_id, bool Descending)
{
int i, j;
cListItem *p0, *p1, *p2, *p3;
bool MisOrdered;
for (i = 1; i < count; i++)
{
p0 = (class cListItem*)NULL;
p1 = head;
p2 = head->m_Next;
p3 = p2->m_Next;
for (j = 1; j <= (count - i); j++)
{
// MisOrdered = Ascending sort check
MisOrdered = (strnatcasecmp(p1->m_Data[col_id].c_str(), p2->m_Data[col_id].c_str()) > 0);
//MisOrdered = StrCmpIn(p2->m_Data[col_id], p1->m_Data[col_id]);
if ((!Descending && MisOrdered) || (Descending && !MisOrdered))
{
// Adjust the pointers...
p1->m_Next = p3;
p2->m_Next = p1;
if (p0)
p0->m_Next = p2;
// Set the head pointer if it was changed...
if (head == p1)
head = p2;
// Progress the pointers
p0 = p2;
p2 = p1->m_Next;
if (j < (count - i))
p3 = (p3->m_Next != (class cListItem*)NULL) ? p3->m_Next : (class cListItem*)NULL;
}
else
{
// Nothing to swap, just progress the pointers...
p0 = p1;
p1 = p2;
p2 = p3;
if (j < (count - i))
p3 = (p3->m_Next != (class cListItem*)NULL) ? p3->m_Next : (class cListItem*)NULL;
}
}
}
return head;
}
static int compare_strings(const void *a, const void *b)
{
char const *pa = *(char const **)a, *pb = *(char const **)b;
int ret;
if (fold_case)
ret = strnatcasecmp(pa, pb);
else
ret = strnatcmp(pa, pb);
if (reverse)
ret *= -1;
if (verbose)
trace_result(pa, pb, ret);
return ret;
}
/* support function for qsort() */
static int compare(const void* p1, const void* p2)
{
struct entry* e1 = (struct entry*)p1;
struct entry* e2 = (struct entry*)p2;
int criteria;
if (e1->attr & ATTR_DIRECTORY && e2->attr & ATTR_DIRECTORY)
{ /* two directories */
criteria = compare_sort_dir;
#ifdef HAVE_MULTIVOLUME
if (e1->attr & ATTR_VOLUME || e2->attr & ATTR_VOLUME)
{ /* a volume identifier is involved */
if (e1->attr & ATTR_VOLUME && e2->attr & ATTR_VOLUME)
criteria = SORT_ALPHA; /* two volumes: sort alphabetically */
else /* only one is a volume: volume first */
return (e2->attr & ATTR_VOLUME) - (e1->attr & ATTR_VOLUME);
}
#endif
}
else if (!(e1->attr & ATTR_DIRECTORY) && !(e2->attr & ATTR_DIRECTORY))
{ /* two files */
criteria = global_settings.sort_file;
}
else /* dir and file, dir goes first */
return (e2->attr & ATTR_DIRECTORY) - (e1->attr & ATTR_DIRECTORY);
switch(criteria)
{
case SORT_TYPE:
case SORT_TYPE_REVERSED:
{
int t1 = e1->attr & FILE_ATTR_MASK;
int t2 = e2->attr & FILE_ATTR_MASK;
if (!t1) /* unknown type */
t1 = INT_MAX; /* gets a high number, to sort after known */
if (!t2) /* unknown type */
t2 = INT_MAX; /* gets a high number, to sort after known */
if (t1 != t2) /* if different */
return (t1 - t2) * (criteria == SORT_TYPE_REVERSED ? -1 : 1);
/* else fall through to alphabetical sorting */
}
case SORT_DATE:
case SORT_DATE_REVERSED:
/* Ignore SORT_TYPE */
if (criteria == SORT_DATE || criteria == SORT_DATE_REVERSED)
{
if (e1->time_write != e2->time_write)
return (e1->time_write - e2->time_write)
* (criteria == SORT_DATE_REVERSED ? -1 : 1);
/* else fall through to alphabetical sorting */
}
case SORT_ALPHA:
case SORT_ALPHA_REVERSED:
{
if (global_settings.sort_case)
{
if (global_settings.interpret_numbers == SORT_INTERPRET_AS_NUMBER)
return strnatcmp(e1->name, e2->name)
* (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
else
return strncmp(e1->name, e2->name, MAX_PATH)
* (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
}
else
{
if (global_settings.interpret_numbers == SORT_INTERPRET_AS_NUMBER)
return strnatcasecmp(e1->name, e2->name)
* (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
else
return strncasecmp(e1->name, e2->name, MAX_PATH)
* (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
}
}
}
return 0; /* never reached */
}
/*
* Natural Order String Comparison - the 'lessThan' helper function *with* case folding
*/
static bool lamexp_natural_string_sort_helper_fold_case(const QString &str1, const QString &str2)
{
return (strnatcasecmp(QWCHAR(str1), QWCHAR(str2)) < 0);
}
static inline bool compareFileNames(const char *str1, const char *str2)
{
return strnatcasecmp(str1, str2) < 0;
}
static inline bool compareFileNames(const QString &str1, const QString &str2)
{
return strnatcasecmp(str1.data(), str2.data()) < 0;
}
/* natural = 1 performs a "natural" numeric sort on strings -Hinoserm */
static int
array_tree_compare(array_iter *a, array_iter *b, int case_sens, int objname, bool natural)
{
char pad_char[] = "";
if (a->type != b->type) {
if (a->type == PROG_INTEGER && b->type == PROG_FLOAT) {
if (fabs
(((double) a->data.number -
b->data.fnumber) / (double) a->data.number) < DBL_EPSILON) {
return 0;
} else if (a->data.number > b->data.fnumber) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_FLOAT && b->type == PROG_INTEGER) {
if (a->data.fnumber == b->data.fnumber) {
return 0;
} else
if (fabs((a->data.fnumber - b->data.number) / a->data.fnumber) <
DBL_EPSILON) {
return 0;
} else if (a->data.fnumber > b->data.number) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_OBJECT && b->type == PROG_STRING
&& objname && valid_obj(a->data.objref)) {
char *astr = (char *) NAME(a->data.objref);
char *bstr = (b->data.string) ? b->data.string->data : pad_char;
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
} else if (a->type == PROG_STRING && b->type == PROG_OBJECT
&& objname && valid_obj(b->data.objref)) {
char *astr = (a->data.string) ? a->data.string->data : pad_char;
char *bstr = (char *) NAME(b->data.objref);
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
}
return (a->type - b->type);
}
/* Indexes are of same type if we reached here. */
if (a->type == PROG_OBJECT && objname && valid_obj(a->data.objref)
&& valid_obj(b->data.objref)) {
char *astr = (char *) NAME(a->data.objref);
char *bstr = (char *) NAME(b->data.objref);
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
}
if (a->type == PROG_OBJECT) {
if (a->data.objref > b->data.objref)
return 1;
else if (a->data.objref < b->data.objref)
return -1;
else
return 0;
}
if (a->type == PROG_FLOAT) {
if (a->data.fnumber == b->data.fnumber) {
return 0;
} else
if (fabs((a->data.fnumber - b->data.fnumber) / a->data.fnumber) <
DBL_EPSILON) {
return 0;
} else if (a->data.fnumber > b->data.fnumber) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_STRING) {
char pad_char[] = "";
char *astr = (a->data.string) ? a->data.string->data : pad_char;
char *bstr = (b->data.string) ? b->data.string->data : pad_char;
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
} else if (a->type == PROG_ARRAY) {
/* Sort arrays by memory address. */
/* This is a bug, really. */
/* in a perfect world, we'd compare the array elements recursively. */
return (a->data.array - b->data.array);
} else if (a->type == PROG_LOCK) {
/* Sort locks by memory address. */
/* This is a bug, really. */
/* in a perfect world, we'd compare the locks by element. */
char *la;
char *lb;
int retval = 0;
la = (char *) unparse_boolexp((dbref) 1, a->data.lock, 0);
la = string_dup(la);
lb = (char *) unparse_boolexp((dbref) 1, b->data.lock, 0);
retval = strcmp(la, lb);
free(la);
return retval;
} else if (a->type == PROG_ADD) {
int result = (a->data.addr->progref - b->data.addr->progref);
if (result) {
return result;
}
return (a->data.addr->data - b->data.addr->data);
} else {
return (a->data.number - b->data.number);
}
}
bool ProxyModel::compareFileNames(const char *str1, const char *str2)
{
return strnatcasecmp(str1, str2) < 0;
}
bool ProxyModel::compareFileNames(const QString &str1, const QString &str2)
{
return strnatcasecmp(str1.data(), str2.data()) < 0;
}
