evisum/src/ui.c

#include "system.h"
#include "process.h"
#include "disks.h"
#include "ui.h"
#include <stdio.h>
#include <sys/types.h>
#include <pwd.h>

#if defined(__APPLE__) && defined(__MACH__)
# define __MacOS__
#endif

static Eina_Lock _lock;
static results_t *_results = NULL;
static long _memory_total = 0, _memory_used = 0;
static Data_Unit _data_unit_current = 0;

void
ui_shutdown(Ui *ui)
{
   evas_object_hide(ui->win);

   if (ui->thread_system)
     ecore_thread_cancel(ui->thread_system);

   if (ui->thread_process)
     ecore_thread_cancel(ui->thread_process);

   if (ui->thread_system)
     ecore_thread_wait(ui->thread_system, 1.0);

   if (ui->thread_process)
     ecore_thread_wait(ui->thread_process, 1.0);

   eina_lock_free(&_lock);

   ecore_main_loop_quit();
}

static void
_system_stats_thread(void *data, Ecore_Thread *thread)
{
   Ui *ui;
   int i;

   ui = data;

   while (1)
     {
        results_t *results = malloc(sizeof(results_t));
        system_stats_all_get(results);
        ecore_thread_feedback(thread, results);

        for (i = 0; i < ui->poll_delay * 2; i++)
          {
             if (ecore_thread_check(thread))
               return;

             if (ui->skip_wait)
               {
                  ui->skip_wait = EINA_FALSE;
                  break;
               }

             usleep(500000);
          }
     }
}

const char *
_data_unit_symbol_get(Data_Unit unit)
{
   const char *symbol;

   switch (unit)
     {
      case DATA_UNIT_KB:
        symbol = "K";
        break;

      case DATA_UNIT_MB:
        symbol = "M";
        break;

      case DATA_UNIT_GB:
        symbol = "G";
        break;
     }

   return symbol;
}

static unsigned long
_mem_adjust(Data_Unit unit, unsigned long value)
{
   if (unit == DATA_UNIT_KB)
     {
        //FIXME: KB is memory base default.
     }
   else if (unit == DATA_UNIT_MB)
     {
        value >>= 10;
     }
   else if (unit == DATA_UNIT_GB)
     {
        value >>= 20;
     }

   return value;
}

static char *
_progress_mem_format_cb(double val)
{
   char buf[1024];
   const char *symbol = _data_unit_symbol_get(_data_unit_current);

   snprintf(buf, sizeof(buf), "%ld %c out of %ld %c",
            _mem_adjust(_data_unit_current, _memory_used), *symbol,
            _mem_adjust(_data_unit_current, _memory_total), *symbol);

   return strdup(buf);
}

static void
_progress_mem_format_free_cb(char *str)
{
   if (str)
     free(str);
}

static char *
_progress_incoming_format_cb(double val)
{
   char buf[1024];
   double incoming;
   const char *unit = "B/s";

   incoming = _results->incoming;
   if (incoming > 1048576)
     {
        incoming /= 1048576;
        unit = "MB/s";
     }
   else if (incoming > 1024 && incoming < 1048576)
     {
        incoming /= 1024;
        unit = "KB/s";
     }

   snprintf(buf, sizeof(buf), "%.2f %s", incoming, unit);

   return strdup(buf);
}

static void
_progress_incoming_format_free_cb(char *str)
{
   if (str)
     free(str);
}

static char *
_progress_outgoing_format_cb(double val)
{
   char buf[1024];
   double outgoing;
   const char *unit = "B/s";

   outgoing = _results->outgoing;
   if (outgoing > 1048576)
     {
        outgoing /= 1048576;
        unit = "MB/s";
     }
   else if (outgoing > 1024 && outgoing < 1048576)
     {
        outgoing /= 1024;
        unit = "KB/s";
     }

   snprintf(buf, sizeof(buf), "%.2f %s", outgoing, unit);

   return strdup(buf);
}

static void
_progress_outgoing_format_free_cb(char *str)
{
   if (str)
     free(str);
}

static void
_extra_view_update(Ui *ui, results_t *results)
{
   Evas_Object *box, *frame, *progress;
   int i;

   if (!ui->extra_visible)
     return;

   _results = results;

   elm_box_clear(ui->extra_activity);

   box = elm_box_add(ui->content);
   evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   evas_object_show(box);

   if (results->power.battery_count)
     {
        frame = elm_frame_add(box);
        evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
        evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
        if (results->power.have_ac)
          elm_object_text_set(frame, "Battery (plugged in)");
        else
          elm_object_text_set(frame, "Battery");

        evas_object_show(frame);

        progress = elm_progressbar_add(frame);
        evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
        evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
        elm_progressbar_span_size_set(progress, 1.0);
        elm_progressbar_unit_format_set(progress, "%1.2f%%");
        elm_progressbar_value_set(progress, (double)results->power.percent / 100);
        evas_object_show(progress);
        elm_object_content_set(frame, progress);
        elm_box_pack_end(box, frame);
     }

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Network Incoming");
   evas_object_show(frame);

   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress, "");
   elm_progressbar_unit_format_function_set(progress, _progress_incoming_format_cb, _progress_incoming_format_free_cb);

   if (results->incoming == 0)
     elm_progressbar_value_set(progress, 0);
   else
     elm_progressbar_value_set(progress, 1.0);

   evas_object_show(progress);

   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Network Outgoing");
   evas_object_show(frame);

   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress, "");
   elm_progressbar_unit_format_function_set(progress, _progress_outgoing_format_cb, _progress_outgoing_format_free_cb);
   if (results->outgoing == 0)
     elm_progressbar_value_set(progress, 0);
   else
     elm_progressbar_value_set(progress, 1.0);

   evas_object_show(progress);

   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   elm_box_pack_end(ui->extra_activity, box);
}

static unsigned long
_disk_adjust(Data_Unit unit, unsigned long value)
{
   if (unit == DATA_UNIT_KB)
     {
        value >>= 10;
     }
   else if (unit == DATA_UNIT_MB)
     {
        value >>= 20;
     }
   else if (unit == DATA_UNIT_GB)
     {
        value >>= 30;
     }

   return value;
}

static void
_ui_disk_add(Ui *ui, const char *path, const char *mount, unsigned long total, unsigned long used)
{
   Evas_Object *frame, *progress;
   const char *symbol;
   double ratio, value;

   frame = elm_frame_add(ui->disk_activity);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, 0);
   elm_object_text_set(frame, eina_slstr_printf("%s on %s", path, mount));
   evas_object_show(frame);

   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);

   symbol = _data_unit_symbol_get(ui->data_unit);

   elm_progressbar_unit_format_set(progress,
                                   eina_slstr_printf(
                                   "%lu%c of %lu%c",
                                   _disk_adjust(ui->data_unit, used), *symbol,
                                   _disk_adjust(ui->data_unit, total), *symbol));

   elm_object_content_set(frame, progress);

   ratio = total / 100.0;
   value = used / ratio;

   if (used == 0 && total == 0)
     elm_progressbar_value_set(progress, 1.0);
   else
     elm_progressbar_value_set(progress, value / 100.0);

   evas_object_show(progress);

   elm_box_pack_end(ui->disk_activity, frame);
}

static void
_disk_view_update(Ui *ui)
{
   Eina_List *disks;
   char *path;
   unsigned long total, used;

   if (!ui->disk_visible)
     return;

   elm_box_clear(ui->disk_activity);

   disks = disks_get();
   EINA_LIST_FREE(disks, path)
     {
        char *mount = disk_mount_point_get(path);
        if (mount)
          {
             if (disk_usage_get(mount, &total, &used))
               {
                  _ui_disk_add(ui, path, mount, total, used);
               }
             free(mount);
          }

        free(path);
     }
   if (disks)
     free(disks);
}

static void
_memory_view_update(Ui *ui, results_t *results)
{
   Evas_Object *box, *frame, *progress;
   const char *symbol;
   double ratio, value;

   if (!ui->mem_visible)
     return;

   elm_box_clear(ui->mem_activity);

   symbol = _data_unit_symbol_get(ui->data_unit);

   box = elm_box_add(ui->content);
   evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   evas_object_show(box);

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Memory Used");
   evas_object_show(frame);
   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress,
                                   eina_slstr_printf(
                                   "%lu %c / %lu %c",
                                   _mem_adjust(ui->data_unit, results->memory.used), *symbol,
                                   _mem_adjust(ui->data_unit, results->memory.total), *symbol));

   ratio = results->memory.total / 100.0;
   value = results->memory.used / ratio;
   elm_progressbar_value_set(progress, value / 100);
   evas_object_show(progress);
   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Memory Cached");
   evas_object_show(frame);
   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress, eina_slstr_printf(
                                   "%lu %c / %lu %c",
                                   _mem_adjust(ui->data_unit, results->memory.cached), *symbol,
                                   _mem_adjust(ui->data_unit, results->memory.total), *symbol));

   ratio = results->memory.total / 100.0;
   value = results->memory.cached / ratio;
   elm_progressbar_value_set(progress, value / 100);
   evas_object_show(progress);
   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Memory Buffered");
   evas_object_show(frame);
   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress,
                                   eina_slstr_printf(
                                   "%lu %c / %lu %c",
                                   _mem_adjust(ui->data_unit, results->memory.buffered), *symbol,
                                   _mem_adjust(ui->data_unit, results->memory.total), *symbol));

   ratio = results->memory.total / 100.0;
   value = results->memory.buffered / ratio;
   elm_progressbar_value_set(progress, value / 100);
   evas_object_show(progress);
   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   frame = elm_frame_add(box);
   evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
   evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_object_text_set(frame, "Memory Shared");
   evas_object_show(frame);
   progress = elm_progressbar_add(frame);
   evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   elm_progressbar_span_size_set(progress, 1.0);
   elm_progressbar_unit_format_set(progress,
                                   eina_slstr_printf(
                                   "%lu %c / %lu %c",
                                   _mem_adjust(ui->data_unit, results->memory.shared), *symbol,
                                   _mem_adjust(ui->data_unit, results->memory.total), *symbol));

   ratio = results->memory.total / 100.0;
   value = results->memory.shared / ratio;
   elm_progressbar_value_set(progress, value / 100);
   evas_object_show(progress);
   elm_object_content_set(frame, progress);
   elm_box_pack_end(box, frame);

   elm_box_pack_end(ui->mem_activity, box);
}

static void
_cpu_view_update(Ui *ui, results_t *results)
{
   Evas_Object *box, *frame, *progress;
   int i;

   if (!ui->cpu_visible)
     return;

   elm_box_clear(ui->cpu_activity);

   box = elm_box_add(ui->content);
   evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   evas_object_show(box);

   for (i = 0; i < results->cpu_count; i++)
     {
        frame = elm_frame_add(box);
        evas_object_size_hint_align_set(frame, EVAS_HINT_FILL, 0);
        evas_object_size_hint_weight_set(frame, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
        if (i == 0 && results->temperature != INVALID_TEMP)
          elm_object_text_set(frame, eina_slstr_printf("CPU %d (%d °C)", i, results->temperature));
        else
          elm_object_text_set(frame, eina_slstr_printf("CPU %d", i));

        evas_object_show(frame);

        progress = elm_progressbar_add(frame);
        evas_object_size_hint_align_set(progress, EVAS_HINT_FILL, EVAS_HINT_FILL);
        evas_object_size_hint_weight_set(progress, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
        elm_progressbar_span_size_set(progress, 1.0);
        elm_progressbar_unit_format_set(progress, "%1.2f%%");

        elm_progressbar_value_set(progress, results->cores[i]->percent / 100);
        evas_object_show(progress);
        elm_object_content_set(frame, progress);
        elm_box_pack_end(box, frame);
     }

   elm_box_pack_end(ui->cpu_activity, box);
}

static void
_system_stats_thread_feedback_cb(void *data, Ecore_Thread *thread, void *msg)
{
   Ui *ui;
   results_t *results;
   double cpu_usage = 0.0;
   int i;

   ui = data;
   results = msg;

   if (ecore_thread_check(thread))
     goto out;

   _cpu_view_update(ui, results);
   _memory_view_update(ui, results);
   _disk_view_update(ui);
   _extra_view_update(ui, results);

   for (i = 0; i < results->cpu_count; i++)
     {
        cpu_usage += results->cores[i]->percent;

        free(results->cores[i]);
     }

   cpu_usage = cpu_usage / results->cpu_count;

   _memory_total = results->memory.total;
   _memory_used = results->memory.used;

   elm_progressbar_value_set(ui->progress_cpu, (double)cpu_usage / 100);
   elm_progressbar_value_set(ui->progress_mem, (double)((results->memory.total / 100.0) * results->memory.used) / 1000000000000);

out:
   free(results->cores);
   free(results);
}

static int
_sort_by_pid(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->pid - inf2->pid;
}

static int
_sort_by_uid(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->uid - inf2->uid;
}

static int
_sort_by_nice(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->nice - inf2->nice;
}

static int
_sort_by_pri(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->priority - inf2->priority;
}

static int
_sort_by_cpu(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->cpu_id - inf2->cpu_id;
}

static int
_sort_by_threads(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return inf1->numthreads - inf2->numthreads;
}

static int
_sort_by_size(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;
   int64_t size1, size2;

   inf1 = p1; inf2 = p2;

   size1 = inf1->mem_size;
   size2 = inf2->mem_size;

   if (size1 < size2)
     return -1;
   if (size2 > size1)
     return 1;

   return 0;
}

static int
_sort_by_rss(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;
   int64_t size1, size2;

   inf1 = p1; inf2 = p2;

   size1 = inf1->mem_rss;
   size2 = inf2->mem_rss;

   if (size1 < size2)
     return -1;
   if (size2 > size1)
     return 1;

   return 0;
}

static int
_sort_by_cpu_usage(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;
   double one, two;

   inf1 = p1; inf2 = p2;

   one = inf1->cpu_usage;
   two = inf2->cpu_usage;

   if (one < two)
     return -1;
   if (two > one)
     return 1;

   return 0;
}

static int
_sort_by_cmd(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return strcasecmp(inf1->command, inf2->command);
}

static int
_sort_by_state(const void *p1, const void *p2)
{
   const Proc_Stats *inf1, *inf2;

   inf1 = p1; inf2 = p2;

   return strcmp(inf1->state, inf2->state);
}

static void
_fields_append(Ui *ui, Proc_Stats *proc)
{
   const char *symbol;
   int64_t mem_size, mem_rss;

   if (ui->program_pid == proc->pid)
     return;

   symbol = _data_unit_symbol_get(ui->data_unit);

   mem_size = proc->mem_size;
   mem_rss = proc->mem_rss;

   if (ui->data_unit == DATA_UNIT_KB)
     {
        mem_size >>= 10;
        mem_rss >>= 10;
     }
   else if (ui->data_unit == DATA_UNIT_MB)
     {
        mem_size >>= 20;
        mem_rss >>= 20;
     }
   else
     {
        mem_size >>= 30;
        mem_rss >>= 30;
     }

   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_PID], eina_slstr_printf("<link>%d</link> <br>", proc->pid), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_UID], eina_slstr_printf("%d <br>", proc->uid), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_SIZE], eina_slstr_printf("%lld %c<br>", mem_size, *symbol), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_RSS], eina_slstr_printf("%lld %c<br>", mem_rss, *symbol), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_COMMAND], eina_slstr_printf("%s<br>", proc->command), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_STATE], eina_slstr_printf("%s <br>", proc->state), TEXT_FIELD_MAX);
   eina_strlcat(ui->fields[PROCESS_INFO_FIELD_CPU_USAGE], eina_slstr_printf("%.1f%% <br>", proc->cpu_usage), TEXT_FIELD_MAX);
}

static void
_fields_show(Ui *ui)
{
   elm_object_text_set(ui->entry_pid, ui->fields[PROCESS_INFO_FIELD_PID]);
   elm_object_text_set(ui->entry_uid, ui->fields[PROCESS_INFO_FIELD_UID]);
   elm_object_text_set(ui->entry_size, ui->fields[PROCESS_INFO_FIELD_SIZE]);
   elm_object_text_set(ui->entry_rss, ui->fields[PROCESS_INFO_FIELD_RSS]);
   elm_object_text_set(ui->entry_cmd, ui->fields[PROCESS_INFO_FIELD_COMMAND]);
   elm_object_text_set(ui->entry_state, ui->fields[PROCESS_INFO_FIELD_STATE]);
   elm_object_text_set(ui->entry_cpu_usage, ui->fields[PROCESS_INFO_FIELD_CPU_USAGE]);
}

static void
_fields_clear(Ui *ui)
{
   for (int i = 0; i < PROCESS_INFO_FIELDS; i++)
     {
        ui->fields[i][0] = '\0';
     }
}

static void
_fields_free(Ui *ui)
{
   for (int i = 0; i < PROCESS_INFO_FIELDS; i++)
     {
        free(ui->fields[i]);
     }
}

static Eina_List *
_list_sort(Ui *ui, Eina_List *list)
{
   switch (ui->sort_type)
     {
      case SORT_BY_NONE:
      case SORT_BY_PID:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_pid);
        break;

      case SORT_BY_UID:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_uid);
        break;

      case SORT_BY_NICE:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_nice);
        break;

      case SORT_BY_PRI:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_pri);
        break;

      case SORT_BY_CPU:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_cpu);
        break;

      case SORT_BY_THREADS:
        list = eina_list_sort(list, eina_list_count(list), _sort_by_threads);
        break;