2016-02-26 05:22:29 -08:00
|
|
|
#include "common.h"
|
|
|
|
|
2016-03-04 18:49:12 -08:00
|
|
|
#define EDJE_EDIT_IS_UNSTABLE_AND_I_KNOW_ABOUT_IT
|
|
|
|
#include <Edje_Edit.h>
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
#define IDX_MAX 999999
|
|
|
|
#define PROGRAM_IDX (IDX_MAX - 1)
|
|
|
|
|
|
|
|
typedef struct group_it_s group_it;
|
|
|
|
typedef struct part_it_s part_it;
|
|
|
|
typedef struct state_it_s state_it;
|
|
|
|
typedef struct programs_it_s programs_it;
|
|
|
|
typedef struct program_it_s program_it;
|
|
|
|
typedef struct list_it_s list_it;
|
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
typedef struct edc_navigator_s
|
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
Evas_Object *box;
|
2016-02-26 05:22:29 -08:00
|
|
|
Evas_Object *genlist;
|
2016-04-21 23:39:24 -07:00
|
|
|
Evas_Object *check;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_List *groups;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
Elm_Genlist_Item_Class *group_itc;
|
|
|
|
Elm_Genlist_Item_Class *part_itc;
|
|
|
|
Elm_Genlist_Item_Class *state_itc;
|
2016-02-29 00:24:49 -08:00
|
|
|
Elm_Genlist_Item_Class *programs_itc;
|
2016-02-28 07:05:44 -08:00
|
|
|
Elm_Genlist_Item_Class *program_itc;
|
|
|
|
|
2016-04-22 01:38:23 -07:00
|
|
|
Eina_Bool selected : 1;
|
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
} navi_data;
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
Item_Type_Group = 0,
|
|
|
|
Item_Type_Part = 1,
|
|
|
|
Item_Type_State = 2,
|
|
|
|
Item_Type_Programs = 3,
|
|
|
|
Item_Type_Program = 4
|
|
|
|
} Item_Type;
|
|
|
|
|
|
|
|
struct list_it_s
|
|
|
|
{
|
|
|
|
Item_Type type;
|
|
|
|
int idx;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct programs_it_s
|
2016-02-27 00:31:12 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
list_it tag;
|
|
|
|
Elm_Object_Item *it;
|
|
|
|
Eina_List *programs;
|
|
|
|
group_it *git;
|
2016-04-22 21:53:37 -07:00
|
|
|
|
|
|
|
Evas_Object *content; //Stop all programs
|
2016-04-21 23:39:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct group_it_s
|
|
|
|
{
|
|
|
|
list_it tag;
|
|
|
|
char *name;
|
|
|
|
Elm_Object_Item *it;
|
|
|
|
Eina_List *parts;
|
|
|
|
navi_data *nd;
|
|
|
|
|
|
|
|
programs_it programs;
|
|
|
|
|
|
|
|
Eina_Bool discarded: 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct part_it_s
|
|
|
|
{
|
|
|
|
list_it tag;
|
|
|
|
char *name;
|
|
|
|
Elm_Object_Item *it;
|
2016-02-27 00:31:12 -08:00
|
|
|
Edje_Part_Type type;
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_List *states;
|
|
|
|
group_it *git;
|
|
|
|
|
|
|
|
Eina_Bool discarded : 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct state_it_s
|
|
|
|
{
|
|
|
|
list_it tag;
|
|
|
|
char *name;
|
|
|
|
Elm_Object_Item *it;
|
|
|
|
part_it *pit;
|
2016-04-22 21:27:58 -07:00
|
|
|
|
|
|
|
Eina_Bool discarded : 1;
|
2016-04-21 23:39:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct program_it_s
|
|
|
|
{
|
|
|
|
list_it tag;
|
|
|
|
char *name;
|
|
|
|
Elm_Object_Item *it;
|
|
|
|
programs_it *pit;
|
|
|
|
|
2016-04-22 21:53:37 -07:00
|
|
|
Evas_Object *content; //Play button
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_Bool discarded : 1;
|
|
|
|
};
|
2016-02-27 00:31:12 -08:00
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
static navi_data *g_nd = NULL;
|
|
|
|
|
2016-02-29 04:32:30 -08:00
|
|
|
static const char *RECT_TYPE_STR = "rect";
|
|
|
|
static const char *TEXT_TYPE_STR = "text";
|
|
|
|
static const char *IMAGE_TYPE_STR = "image";
|
|
|
|
static const char *SWALLOW_TYPE_STR = "swallow";
|
|
|
|
static const char *TEXTBLOCK_TYPE_STR = "textblock";
|
|
|
|
static const char *SPACER_TYPE_STR = "spacer";
|
|
|
|
static const char *PART_TYPE_STR = "part";
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static void group_contract(group_it *git);
|
|
|
|
static void part_contract(part_it *pit);
|
|
|
|
static void programs_contract(programs_it *pit);
|
2016-02-29 00:36:45 -08:00
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
/*****************************************************************************/
|
|
|
|
/* Internal method implementation */
|
|
|
|
/*****************************************************************************/
|
2016-04-22 01:38:23 -07:00
|
|
|
static void
|
|
|
|
gl_selected_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
navi_data *nd = data;
|
|
|
|
nd->selected = EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gl_unselected_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
navi_data *nd = data;
|
|
|
|
nd->selected = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_item_deselect(navi_data *nd)
|
|
|
|
{
|
|
|
|
Elm_Object_Item *it = elm_genlist_selected_item_get(nd->genlist);
|
|
|
|
if (it) elm_genlist_item_selected_set(it, EINA_FALSE);
|
|
|
|
}
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static int
|
|
|
|
gl_comp_func(const void *pa, const void *pb)
|
|
|
|
{
|
|
|
|
const Elm_Object_Item *a = pa;
|
|
|
|
const Elm_Object_Item *b = pb;
|
|
|
|
|
|
|
|
list_it *it_a = (list_it *) elm_object_item_data_get(a);
|
|
|
|
list_it *it_b = (list_it *) elm_object_item_data_get(b);
|
|
|
|
|
|
|
|
return (it_a->idx - it_b->idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_changed_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
navi_data *nd = data;
|
2016-04-22 00:22:53 -07:00
|
|
|
Eina_Bool auto_contract = elm_check_state_get(obj);
|
|
|
|
config_auto_contract_set(auto_contract);
|
2016-04-21 23:39:24 -07:00
|
|
|
|
2016-04-22 00:22:53 -07:00
|
|
|
if (!auto_contract) return;
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
// Contract all groups instantly.
|
|
|
|
Eina_List *l;
|
|
|
|
group_it *git;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(nd->groups, l, git)
|
|
|
|
group_contract(git);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_state_free(state_it *sit)
|
|
|
|
{
|
|
|
|
elm_object_item_del(sit->it);
|
|
|
|
free(sit->name);
|
|
|
|
free(sit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_states_clear(part_it *pit)
|
|
|
|
{
|
|
|
|
state_it *sit;
|
|
|
|
EINA_LIST_FREE(pit->states, sit)
|
|
|
|
navigator_state_free(sit);
|
|
|
|
|
|
|
|
pit->states = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_program_free(program_it *pit)
|
|
|
|
{
|
|
|
|
elm_object_item_del(pit->it);
|
|
|
|
free(pit->name);
|
|
|
|
free(pit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_sub_programs_clear(programs_it *pit)
|
|
|
|
{
|
|
|
|
program_it *spit;
|
|
|
|
EINA_LIST_FREE(pit->programs, spit)
|
|
|
|
navigator_program_free(spit);
|
|
|
|
|
|
|
|
pit->programs = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_part_free(part_it *pit)
|
|
|
|
{
|
|
|
|
state_it *sit;
|
|
|
|
EINA_LIST_FREE(pit->states, sit)
|
|
|
|
navigator_state_free(sit);
|
|
|
|
|
|
|
|
elm_object_item_del(pit->it);
|
|
|
|
free(pit->name);
|
|
|
|
free(pit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_parts_clear(group_it *git)
|
|
|
|
{
|
|
|
|
part_it *pit;
|
|
|
|
EINA_LIST_FREE(git->parts, pit)
|
|
|
|
navigator_part_free(pit);
|
|
|
|
|
|
|
|
git->parts = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_programs_clear(group_it *git)
|
|
|
|
{
|
|
|
|
programs_it *pit = &git->programs;
|
|
|
|
|
|
|
|
if (!pit->it) return;
|
|
|
|
|
|
|
|
program_it *spit;
|
|
|
|
EINA_LIST_FREE(pit->programs, spit)
|
|
|
|
navigator_program_free(spit);
|
|
|
|
|
|
|
|
pit->programs = NULL;
|
|
|
|
elm_object_item_del(pit->it);
|
|
|
|
pit->it = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_group_free(group_it *git)
|
|
|
|
{
|
|
|
|
navigator_parts_clear(git);
|
|
|
|
navigator_programs_clear(git);
|
|
|
|
elm_object_item_del(git->it);
|
|
|
|
free(git->name);
|
|
|
|
free(git);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
navigator_groups_clear(navi_data *nd)
|
2016-02-29 04:32:30 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
group_it *git;
|
|
|
|
EINA_LIST_FREE(nd->groups, git)
|
|
|
|
navigator_group_free(git);
|
|
|
|
|
|
|
|
nd->groups = NULL;
|
|
|
|
}
|
2016-02-29 04:32:30 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static const char *
|
|
|
|
part_type_get(part_it *pit)
|
|
|
|
{
|
|
|
|
switch (pit->type)
|
2016-02-29 04:32:30 -08:00
|
|
|
{
|
|
|
|
case EDJE_PART_TYPE_RECTANGLE:
|
|
|
|
return RECT_TYPE_STR;
|
|
|
|
case EDJE_PART_TYPE_TEXT:
|
|
|
|
return TEXT_TYPE_STR;
|
|
|
|
case EDJE_PART_TYPE_IMAGE:
|
|
|
|
return IMAGE_TYPE_STR;
|
|
|
|
case EDJE_PART_TYPE_SWALLOW:
|
|
|
|
return SWALLOW_TYPE_STR;
|
|
|
|
case EDJE_PART_TYPE_TEXTBLOCK:
|
|
|
|
return TEXTBLOCK_TYPE_STR;
|
|
|
|
case EDJE_PART_TYPE_SPACER:
|
|
|
|
return SPACER_TYPE_STR;
|
|
|
|
default:
|
|
|
|
return PART_TYPE_STR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
find_group_proc_internal(char *utf8, char *utf8_end, const char *group_name)
|
|
|
|
{
|
|
|
|
char *p = utf8;
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
//Find group
|
|
|
|
while (utf8_end > p)
|
|
|
|
{
|
|
|
|
//Skip " ~ " Section
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
p = strstr(++p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp("group", p, strlen("group")))
|
|
|
|
{
|
|
|
|
p = strstr((p + 5), "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
if (!strncmp(group_name, p, strlen(group_name)))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-03-04 18:31:37 -08:00
|
|
|
find_group_proc(const char *group_name)
|
2016-02-29 04:32:30 -08:00
|
|
|
{
|
|
|
|
if (!group_name) return;
|
|
|
|
|
|
|
|
const char *text =
|
|
|
|
(const char *) enventor_object_text_get(base_enventor_get());
|
|
|
|
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
|
|
char *utf8_end = utf8 + strlen(utf8);
|
|
|
|
char *result = find_group_proc_internal(utf8, utf8_end, group_name);
|
|
|
|
|
|
|
|
//No found
|
|
|
|
if (!result) goto end;
|
|
|
|
|
|
|
|
//Got you!
|
|
|
|
enventor_object_select_region_set(base_enventor_get(), (result - utf8),
|
|
|
|
(result - utf8) + strlen(group_name));
|
|
|
|
end:
|
|
|
|
free(utf8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
find_part_proc_internal(char *utf8, char *utf8_end, const char* group_name,
|
|
|
|
const char *part_name, const char *part_type)
|
|
|
|
{
|
|
|
|
char *p = find_group_proc_internal(utf8, utf8_end, group_name);
|
|
|
|
|
|
|
|
//No found
|
|
|
|
if (!p) return NULL;
|
|
|
|
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
//Find part
|
|
|
|
while (utf8_end > p)
|
|
|
|
{
|
|
|
|
//Skip " ~ " Section
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
p = strstr(++p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(part_type, p, strlen(part_type)))
|
|
|
|
{
|
|
|
|
p = strstr((p + strlen(part_type)), "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
if (!strncmp(part_name, p, strlen(part_name)))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//compatibility: "part"
|
|
|
|
if (!strncmp("part", p, strlen("part")))
|
|
|
|
{
|
|
|
|
p = strstr((p + 4), "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
if (!strncmp(part_name, p, strlen(part_name)))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-03-04 18:31:37 -08:00
|
|
|
find_part_proc(const char *group_name, const char *part_name,
|
2016-02-29 04:32:30 -08:00
|
|
|
const char *part_type)
|
|
|
|
{
|
|
|
|
if (!group_name || !part_name) return;
|
|
|
|
|
|
|
|
const char *text =
|
|
|
|
(const char *) enventor_object_text_get(base_enventor_get());
|
|
|
|
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
|
|
char *utf8_end = utf8 + strlen(utf8);
|
|
|
|
|
|
|
|
const char *result = find_part_proc_internal(utf8, utf8_end, group_name,
|
|
|
|
part_name, part_type);
|
|
|
|
if (!result) goto end;
|
|
|
|
|
|
|
|
//Got you!
|
|
|
|
enventor_object_select_region_set(base_enventor_get(), (result - utf8),
|
|
|
|
(result - utf8) + strlen(part_name));
|
|
|
|
end:
|
|
|
|
free(utf8);
|
|
|
|
}
|
|
|
|
|
2016-02-29 03:19:10 -08:00
|
|
|
static void
|
2016-03-04 18:31:37 -08:00
|
|
|
find_state_proc(const char *group_name, const char *part_name,
|
2016-02-29 04:32:30 -08:00
|
|
|
const char *part_type, const char *state_name)
|
2016-02-29 03:19:10 -08:00
|
|
|
{
|
2016-02-29 04:32:30 -08:00
|
|
|
if (!group_name || !part_name) return;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
|
|
|
const char *text =
|
|
|
|
(const char *) enventor_object_text_get(base_enventor_get());
|
|
|
|
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
2016-02-29 04:32:30 -08:00
|
|
|
char *utf8_end = utf8 + strlen(utf8);
|
|
|
|
|
|
|
|
char *p = find_part_proc_internal(utf8, utf8_end, group_name,
|
|
|
|
part_name, part_type);
|
|
|
|
if (!p) goto end;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
2016-02-29 04:32:30 -08:00
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
|
|
|
char *result = NULL;
|
|
|
|
|
2016-02-29 04:32:30 -08:00
|
|
|
//Find programs
|
|
|
|
while (utf8_end > p)
|
|
|
|
{
|
|
|
|
//Skip " ~ " Section
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
p = strstr(++p, "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp("desc", p, strlen("desc")))
|
|
|
|
{
|
|
|
|
p = strstr((p + 4), "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
if (!strncmp(state_name, p, strlen(state_name)))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!result) goto end;
|
|
|
|
|
|
|
|
//Got you!
|
|
|
|
enventor_object_select_region_set(base_enventor_get(), (result - utf8),
|
|
|
|
(result - utf8) + strlen(state_name));
|
|
|
|
end:
|
|
|
|
free(utf8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char*
|
|
|
|
find_programs_proc_internal(char *utf8, char *utf8_end, const char *group_name)
|
|
|
|
{
|
|
|
|
char *p = find_group_proc_internal(utf8, utf8_end, group_name);
|
2016-03-04 06:36:27 -08:00
|
|
|
if (!p) return NULL;
|
2016-02-29 04:32:30 -08:00
|
|
|
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
//Find programs
|
|
|
|
while (utf8_end > p)
|
|
|
|
{
|
|
|
|
//Skip " ~ " Section
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
p = strstr(++p, "\"");
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp("programs", p, strlen("programs")))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-03-04 18:31:37 -08:00
|
|
|
find_programs_proc(const char *group_name)
|
2016-02-29 04:32:30 -08:00
|
|
|
{
|
|
|
|
if (!group_name) return;
|
|
|
|
|
|
|
|
const char *text =
|
|
|
|
(const char *) enventor_object_text_get(base_enventor_get());
|
|
|
|
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
|
|
char *utf8_end = utf8 + strlen(utf8);
|
|
|
|
|
|
|
|
char *result = find_programs_proc_internal(utf8, utf8_end, group_name);
|
|
|
|
|
2016-02-29 03:19:10 -08:00
|
|
|
//No found
|
2016-02-29 04:32:30 -08:00
|
|
|
if (!result) goto end;
|
|
|
|
|
|
|
|
//Got you!
|
|
|
|
enventor_object_select_region_set(base_enventor_get(), (result - utf8),
|
|
|
|
(result - utf8) + strlen("programs"));
|
|
|
|
end:
|
|
|
|
free(utf8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-03-04 18:31:37 -08:00
|
|
|
find_program_proc(const char *group_name, const char *program_name)
|
2016-02-29 04:32:30 -08:00
|
|
|
{
|
|
|
|
if (!group_name || !program_name) return;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
2016-02-29 04:32:30 -08:00
|
|
|
const char *text =
|
|
|
|
(const char *) enventor_object_text_get(base_enventor_get());
|
|
|
|
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
|
|
char *utf8_end = utf8 + strlen(utf8);
|
|
|
|
char *p = find_programs_proc_internal(utf8, utf8_end, group_name);
|
|
|
|
if (!p) goto end;
|
|
|
|
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
p += strlen("programs");
|
|
|
|
|
|
|
|
//Find program
|
|
|
|
while (utf8_end > p)
|
2016-02-29 03:19:10 -08:00
|
|
|
{
|
2016-02-29 04:32:30 -08:00
|
|
|
//Skip " ~ " Section
|
|
|
|
if (*p == '\"')
|
|
|
|
{
|
|
|
|
p = strstr(++p, "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp("program", p, strlen("program")))
|
|
|
|
{
|
|
|
|
p = strstr((p + 6), "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
if (!strncmp(program_name, p, strlen(program_name)))
|
|
|
|
{
|
|
|
|
result = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = strstr(p, "\"");
|
|
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p++;
|
2016-02-29 03:19:10 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 04:32:30 -08:00
|
|
|
//No found
|
2016-02-29 03:19:10 -08:00
|
|
|
if (!result) goto end;
|
|
|
|
|
|
|
|
//Got you!
|
|
|
|
enventor_object_select_region_set(base_enventor_get(), (result - utf8),
|
2016-02-29 04:32:30 -08:00
|
|
|
(result - utf8) + strlen(program_name));
|
2016-02-29 03:19:10 -08:00
|
|
|
end:
|
|
|
|
free(utf8);
|
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
/* State Related */
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static char *
|
|
|
|
gl_state_text_get_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *part EINA_UNUSED)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
state_it *sit = data;
|
|
|
|
return strdup(sit->name);
|
2016-02-29 03:19:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
gl_state_selected_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2016-02-29 03:19:10 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
state_it *sit = data;
|
|
|
|
find_state_proc(sit->pit->git->name, sit->pit->name, part_type_get(sit->pit),
|
|
|
|
sit->name);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
states_update(navi_data *nd, part_it *pit)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
|
|
|
Evas_Object *enventor = base_enventor_get();
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_List *state_list = enventor_object_part_states_list_get(enventor,
|
|
|
|
pit->name);
|
2016-02-26 05:22:29 -08:00
|
|
|
char *name;
|
2016-04-22 21:27:58 -07:00
|
|
|
Eina_List *l, *ll;
|
2016-04-21 23:39:24 -07:00
|
|
|
state_it *sit;
|
|
|
|
int idx = 0;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-04-22 21:27:58 -07:00
|
|
|
if (!state_list)
|
|
|
|
{
|
|
|
|
navigator_states_clear(pit);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//1. Prepare for validation.
|
|
|
|
EINA_LIST_FOREACH(pit->states, l, sit)
|
|
|
|
{
|
|
|
|
sit->discarded = EINA_TRUE;
|
|
|
|
sit->tag.idx = IDX_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
//2. New States
|
2016-04-21 23:39:24 -07:00
|
|
|
EINA_LIST_FOREACH(state_list, l, name)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-22 21:27:58 -07:00
|
|
|
Eina_Bool new_state = EINA_TRUE;
|
2016-04-21 23:39:24 -07:00
|
|
|
idx++;
|
|
|
|
|
2016-04-22 21:27:58 -07:00
|
|
|
//Check if it is existed?
|
|
|
|
EINA_LIST_FOREACH(pit->states, ll, sit)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, sit->name) &&
|
|
|
|
(strlen(name) == strlen(sit->name)))
|
|
|
|
{
|
|
|
|
sit->discarded = EINA_FALSE;
|
|
|
|
new_state = EINA_FALSE;
|
|
|
|
//update index of the item
|
|
|
|
sit->tag.idx = idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
if (!new_state) continue;
|
|
|
|
|
|
|
|
//Ok, this state is newly added
|
2016-04-21 23:39:24 -07:00
|
|
|
sit = calloc(1, sizeof(state_it));
|
|
|
|
if (!sit)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR(_("Failed to allocate Memory!"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
sit->tag.type = Item_Type_State;
|
|
|
|
sit->tag.idx = idx;
|
|
|
|
//Parsing "default" "0.00". We don't take care 0.00 in the state name.
|
|
|
|
const char *brk = strpbrk(name, " ");
|
|
|
|
if (brk) sit->name = strndup(name, brk - name);
|
|
|
|
else sit->name = strdup(name);
|
|
|
|
|
|
|
|
sit->pit = pit;
|
|
|
|
sit->it = elm_genlist_item_sorted_insert(nd->genlist,
|
|
|
|
nd->state_itc,
|
|
|
|
sit,
|
|
|
|
pit->it,
|
|
|
|
ELM_GENLIST_ITEM_NONE,
|
|
|
|
gl_comp_func,
|
|
|
|
gl_state_selected_cb,
|
|
|
|
sit);
|
|
|
|
pit->states = eina_list_append(pit->states, sit);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
2016-04-22 21:27:58 -07:00
|
|
|
//3. Update states
|
|
|
|
EINA_LIST_FOREACH_SAFE(pit->states, l, ll, sit)
|
|
|
|
{
|
|
|
|
//Remove them from the previous list.
|
|
|
|
if (sit->discarded)
|
|
|
|
{
|
|
|
|
pit->states = eina_list_remove_list(pit->states, l);
|
|
|
|
navigator_state_free(sit);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
edje_edit_string_list_free(state_list);
|
2016-02-29 03:19:10 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static Evas_Object *
|
2016-03-04 18:31:37 -08:00
|
|
|
gl_state_content_get_cb(void *data EINA_UNUSED, Evas_Object *obj,
|
|
|
|
const char *part)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
|
|
|
if (strcmp("elm.swallow.icon", part)) return NULL;
|
|
|
|
|
|
|
|
Evas_Object *image = elm_image_add(obj);
|
|
|
|
elm_image_file_set(image, EDJE_PATH, "navi_state");
|
|
|
|
|
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Program Related */
|
|
|
|
|
2016-04-22 03:31:07 -07:00
|
|
|
static void
|
|
|
|
program_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
program_it *pit = data;
|
|
|
|
Evas_Object *enventor = base_enventor_get();
|
|
|
|
enventor_object_program_run(enventor, pit->name);
|
|
|
|
|
|
|
|
if (!config_stats_bar_get()) return;
|
|
|
|
|
|
|
|
char buf[256];
|
|
|
|
snprintf(buf, sizeof(buf),_("Program Run: \"%s\""), pit->name);
|
|
|
|
stats_info_msg_update(buf);
|
|
|
|
}
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static char *
|
|
|
|
gl_program_text_get_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
program_it *spit = data;
|
|
|
|
return strdup(spit->name);
|
|
|
|
}
|
|
|
|
|
2016-04-22 21:53:37 -07:00
|
|
|
static void
|
|
|
|
gl_program_del_cb(void *data, Evas_Object *obj EINA_UNUSED)
|
|
|
|
{
|
|
|
|
//FIXME: Genlist reuses this content and it breaks edc navigator.
|
|
|
|
//This is an absolutely bug. This del_cb() is a workaround for this.
|
|
|
|
program_it *pit = data;
|
|
|
|
evas_object_del(pit->content);
|
|
|
|
}
|
|
|
|
|
2016-04-22 22:06:28 -07:00
|
|
|
static void
|
|
|
|
program_content_del_cb(void *data, Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
programs_it *pit = data;
|
|
|
|
pit->content = NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static Evas_Object *
|
2016-03-04 18:31:37 -08:00
|
|
|
gl_program_content_get_cb(void *data EINA_UNUSED, Evas_Object *obj,
|
|
|
|
const char *part)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
2016-04-22 21:14:49 -07:00
|
|
|
//1. Icon
|
2016-04-22 03:31:07 -07:00
|
|
|
if (!strcmp("elm.swallow.icon", part))
|
|
|
|
{
|
|
|
|
Evas_Object *image = elm_image_add(obj);
|
|
|
|
elm_image_file_set(image, EDJE_PATH, "navi_state");
|
|
|
|
return image;
|
|
|
|
}
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
//2. Play Button
|
2016-04-22 03:31:07 -07:00
|
|
|
program_it *pit = data;
|
2016-04-22 21:14:49 -07:00
|
|
|
|
2016-04-22 22:06:28 -07:00
|
|
|
evas_object_del(pit->content);
|
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
//Box
|
|
|
|
Evas_Object *box = elm_box_add(obj);
|
|
|
|
elm_object_tooltip_text_set(box, "Play Program");
|
2016-04-22 22:06:28 -07:00
|
|
|
evas_object_event_callback_add(box, EVAS_CALLBACK_DEL,
|
|
|
|
program_content_del_cb, pit);
|
2016-04-22 21:14:49 -07:00
|
|
|
|
|
|
|
//Button
|
|
|
|
Evas_Object *btn = elm_button_add(box);
|
|
|
|
evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
2016-04-22 19:43:47 -07:00
|
|
|
elm_object_scale_set(btn, 0.5);
|
2016-04-22 03:31:07 -07:00
|
|
|
evas_object_smart_callback_add(btn, "clicked", program_btn_clicked_cb,
|
|
|
|
pit);
|
2016-04-22 21:14:49 -07:00
|
|
|
evas_object_show(btn);
|
|
|
|
|
|
|
|
//Image
|
2016-04-22 03:31:07 -07:00
|
|
|
Evas_Object *img = elm_image_add(btn);
|
|
|
|
elm_image_file_set(img, EDJE_PATH, "navi_play");
|
|
|
|
elm_object_content_set(btn, img);
|
2016-04-22 19:43:47 -07:00
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
elm_box_pack_end(box, btn);
|
|
|
|
|
2016-04-22 21:53:37 -07:00
|
|
|
pit->content = box;
|
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
return box;
|
2016-02-29 00:24:49 -08:00
|
|
|
}
|
|
|
|
|
2016-02-28 07:05:44 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
gl_program_selected_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2016-02-28 07:05:44 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
program_it *spit = data;
|
|
|
|
find_program_proc(spit->pit->git->name, spit->name);
|
2016-02-29 00:24:49 -08:00
|
|
|
}
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
sub_programs_update(navi_data *nd, programs_it *pit)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
navigator_sub_programs_clear(pit);
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
Evas_Object *enventor = base_enventor_get();
|
|
|
|
Eina_List *program_list = enventor_object_programs_list_get(enventor);
|
|
|
|
if (!program_list) return;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Append program list
|
2016-02-28 07:05:44 -08:00
|
|
|
char *name;
|
2016-02-29 00:24:49 -08:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Object_Item *it;
|
2016-04-21 23:39:24 -07:00
|
|
|
program_it *spit;
|
|
|
|
int idx = 0;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
EINA_LIST_FOREACH(program_list, l, name)
|
2016-02-28 07:05:44 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
idx++;
|
|
|
|
|
|
|
|
spit = calloc(1, sizeof(program_it));
|
|
|
|
if (!spit)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR(_("Failed to allocate Memory!"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
spit->tag.type = Item_Type_Program;
|
|
|
|
spit->tag.idx = idx;
|
|
|
|
spit->name = strdup(name);
|
|
|
|
spit->pit = pit;
|
|
|
|
spit->it = elm_genlist_item_sorted_insert(nd->genlist,
|
|
|
|
nd->program_itc,
|
|
|
|
spit,
|
|
|
|
pit->it,
|
|
|
|
ELM_GENLIST_ITEM_NONE,
|
|
|
|
gl_comp_func,
|
|
|
|
gl_program_selected_cb,
|
|
|
|
spit);
|
|
|
|
pit->programs = eina_list_append(pit->programs, spit);
|
2016-02-28 07:05:44 -08:00
|
|
|
}
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
edje_edit_string_list_free(program_list);
|
2016-02-28 07:05:44 -08:00
|
|
|
}
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
/* Programs Related */
|
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
static void
|
|
|
|
programs_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
programs_it *pit = data;
|
|
|
|
Evas_Object *enventor = base_enventor_get();
|
|
|
|
enventor_object_programs_stop(enventor);
|
|
|
|
|
|
|
|
if (!config_stats_bar_get()) return;
|
|
|
|
|
|
|
|
stats_info_msg_update(_("Stop all running programs."));
|
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
programs_expand(programs_it *pit)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
if (elm_genlist_item_expanded_get(pit->it)) return;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
elm_genlist_item_expanded_set(pit->it, EINA_TRUE);
|
|
|
|
|
|
|
|
sub_programs_update(pit->git->nd, pit);
|
|
|
|
|
|
|
|
//If auto contraction is enabled, then close other parts
|
2016-04-22 00:22:53 -07:00
|
|
|
if (!config_auto_contract_get()) return;
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
//Contract part states
|
|
|
|
part_it *pit2;
|
|
|
|
Eina_List *l;
|
|
|
|
EINA_LIST_FOREACH(pit->git->parts, l, pit2)
|
|
|
|
part_contract(pit2);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
programs_contract(programs_it *pit)
|
2016-02-28 07:05:44 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
if (!elm_genlist_item_expanded_get(pit->it)) return;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
elm_genlist_item_expanded_set(pit->it, EINA_FALSE);
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
navigator_sub_programs_clear(pit);
|
|
|
|
}
|
2016-02-29 00:24:49 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
gl_programs_selected_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info)
|
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
programs_it *pit = data;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
find_programs_proc(pit->git->name);
|
2016-02-28 07:05:44 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
programs_update(navi_data *nd, group_it *git)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
Evas_Object *enventor = base_enventor_get();
|
|
|
|
Eina_List *program_list = enventor_object_programs_list_get(enventor);
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//oh, no programs..
|
|
|
|
if (!program_list)
|
|
|
|
{
|
|
|
|
navigator_programs_clear(git);
|
|
|
|
return;
|
|
|
|
}
|
2016-02-29 02:02:17 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
programs_it *pit = &git->programs;
|
|
|
|
|
|
|
|
//Create a programs item first time.
|
|
|
|
if (!pit->it)
|
|
|
|
{
|
|
|
|
pit->tag.type = Item_Type_Programs;
|
|
|
|
pit->tag.idx = PROGRAM_IDX;
|
|
|
|
pit->git = git;
|
2016-04-22 02:32:10 -07:00
|
|
|
pit->it = elm_genlist_item_append(nd->genlist,
|
|
|
|
nd->programs_itc,
|
|
|
|
pit,
|
|
|
|
git->it,
|
|
|
|
ELM_GENLIST_ITEM_TREE,
|
|
|
|
gl_programs_selected_cb,
|
|
|
|
pit);
|
2016-04-21 23:39:24 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!elm_genlist_item_expanded_get(pit->it)) return;
|
|
|
|
|
|
|
|
//programs item is already created, it may need to update progam lists.
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//1. Prepare for validation.
|
|
|
|
Eina_List *l, *ll;
|
|
|
|
program_it *spit;
|
|
|
|
char *name;
|
|
|
|
int idx = 0;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
EINA_LIST_FOREACH(pit->programs, l, spit)
|
|
|
|
{
|
|
|
|
spit->discarded = EINA_TRUE;
|
|
|
|
spit->tag.idx = IDX_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
//2. New programs
|
|
|
|
EINA_LIST_FOREACH(program_list, l, name)
|
|
|
|
{
|
|
|
|
Eina_Bool new_program = EINA_TRUE;
|
|
|
|
idx++;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Check if it is existed?
|
|
|
|
EINA_LIST_FOREACH(pit->programs, ll, spit)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, spit->name) &&
|
|
|
|
(strlen(name) == strlen(spit->name)))
|
|
|
|
{
|
|
|
|
spit->discarded = EINA_FALSE;
|
|
|
|
new_program = EINA_FALSE;
|
|
|
|
//update index of the item
|
|
|
|
spit->tag.idx = idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!new_program) continue;
|
|
|
|
|
|
|
|
//Ok, this program is newly added.
|
|
|
|
spit = calloc(1, sizeof(program_it));
|
|
|
|
if (!spit)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR(_("Failed to allocate Memory!"));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
spit->tag.type = Item_Type_Program;
|
|
|
|
spit->tag.idx = idx;
|
|
|
|
spit->name = strdup(name);
|
|
|
|
spit->pit = pit;
|
|
|
|
spit->it = elm_genlist_item_sorted_insert(nd->genlist,
|
|
|
|
nd->program_itc,
|
|
|
|
spit,
|
|
|
|
pit->it,
|
|
|
|
ELM_GENLIST_ITEM_NONE,
|
|
|
|
gl_comp_func,
|
|
|
|
gl_program_selected_cb,
|
|
|
|
spit);
|
|
|
|
pit->programs = eina_list_append(pit->programs, spit);
|
|
|
|
}
|
|
|
|
|
|
|
|
//3. Discarded programs
|
|
|
|
EINA_LIST_FOREACH_SAFE(pit->programs, l, ll, spit)
|
|
|
|
{
|
|
|
|
if (!spit->discarded) continue;
|
|
|
|
|
|
|
|
//Remove them from the previous list.
|
|
|
|
pit->programs = eina_list_remove_list(pit->programs, l);
|
|
|
|
navigator_program_free(spit);
|
|
|
|
}
|
|
|
|
|
|
|
|
edje_edit_string_list_free(program_list);
|
2016-02-29 00:24:49 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
gl_programs_text_get_cb(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
return strdup("PROGRAMS");
|
|
|
|
}
|
|
|
|
|
2016-04-22 21:53:37 -07:00
|
|
|
static void
|
|
|
|
gl_programs_del_cb(void *data, Evas_Object *obj EINA_UNUSED)
|
|
|
|
{
|
|
|
|
//FIXME: Genlist reuses this content and it breaks edc navigator.
|
|
|
|
//This is an absolutely bug. This del_cb() is a workaround for this.
|
|
|
|
programs_it *pit = data;
|
|
|
|
evas_object_del(pit->content);
|
|
|
|
}
|
|
|
|
|
2016-04-22 22:06:28 -07:00
|
|
|
static void
|
|
|
|
programs_content_del_cb(void *data, Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
|
|
|
{
|
|
|
|
programs_it *pit = data;
|
|
|
|
pit->content = NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
static Evas_Object *
|
2016-04-22 21:53:37 -07:00
|
|
|
gl_programs_content_get_cb(void *data, Evas_Object *obj, const char *part)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-22 21:14:49 -07:00
|
|
|
//1. Icon
|
|
|
|
if (!strcmp("elm.swallow.icon", part))
|
|
|
|
{
|
|
|
|
Evas_Object *image = elm_image_add(obj);
|
|
|
|
elm_image_file_set(image, EDJE_PATH, "navi_program");
|
2016-02-27 00:31:12 -08:00
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
return image;
|
|
|
|
}
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
//2. Stop All Button
|
|
|
|
programs_it *pit = data;
|
|
|
|
|
2016-04-22 22:06:28 -07:00
|
|
|
evas_object_del(pit->content);
|
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
//Box
|
|
|
|
Evas_Object *box = elm_box_add(obj);
|
2016-04-22 22:06:28 -07:00
|
|
|
evas_object_event_callback_add(box, EVAS_CALLBACK_DEL,
|
|
|
|
programs_content_del_cb, pit);
|
2016-04-22 21:14:49 -07:00
|
|
|
elm_object_tooltip_text_set(box, "Stop All Programs");
|
|
|
|
|
|
|
|
//Button
|
|
|
|
Evas_Object *btn = elm_button_add(box);
|
|
|
|
evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
|
|
|
elm_object_scale_set(btn, 0.5);
|
|
|
|
evas_object_smart_callback_add(btn, "clicked", programs_btn_clicked_cb,
|
|
|
|
pit);
|
|
|
|
evas_object_show(btn);
|
|
|
|
|
|
|
|
//Image
|
|
|
|
Evas_Object *img = elm_image_add(btn);
|
|
|
|
elm_image_file_set(img, EDJE_PATH, "navi_stop");
|
|
|
|
elm_object_content_set(btn, img);
|
|
|
|
|
|
|
|
elm_box_pack_end(box, btn);
|
|
|
|
|
2016-04-22 21:53:37 -07:00
|
|
|
pit->content = box;
|
|
|
|
|
2016-04-22 21:14:49 -07:00
|
|
|
return box;
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
|
|
|
|
/* Part Related */
|
|
|
|
|
2016-02-27 00:31:12 -08:00
|
|
|
static char *
|
|
|
|
gl_part_text_get_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
part_it *pit = data;
|
|
|
|
return strdup(pit->name);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
2016-02-27 00:31:12 -08:00
|
|
|
static Evas_Object *
|
|
|
|
gl_part_content_get_cb(void *data, Evas_Object *obj, const char *part)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-02-27 00:31:12 -08:00
|
|
|
if (strcmp("elm.swallow.icon", part)) return NULL;
|
2016-04-21 23:39:24 -07:00
|
|
|
part_it *pit = data;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-02-27 00:31:12 -08:00
|
|
|
Evas_Object *image = elm_image_add(obj);
|
|
|
|
const char *group;
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
switch (pit->type)
|
2016-02-27 00:31:12 -08:00
|
|
|
{
|
|
|
|
case EDJE_PART_TYPE_RECTANGLE:
|
|
|
|
group = "navi_rect";
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_TEXT:
|
|
|
|
group = "navi_text";
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_IMAGE:
|
|
|
|
group = "navi_image";
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_SWALLOW:
|
|
|
|
group = "navi_swallow";
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_TEXTBLOCK:
|
|
|
|
group = "navi_textblock";
|
|
|
|
break;
|
|
|
|
case EDJE_PART_TYPE_SPACER:
|
|
|
|
group = "navi_spacer";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
group = "navi_unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
elm_image_file_set(image, EDJE_PATH, group);
|
|
|
|
|
|
|
|
return image;
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
gl_part_selected_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
part_it *pit = data;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Find text cursor position
|
|
|
|
const char *part_type = part_type_get(pit);
|
|
|
|
find_part_proc(pit->git->name, pit->name, part_type);
|
|
|
|
}
|
2016-02-29 00:36:45 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static void
|
|
|
|
parts_update(navi_data *nd, group_it *git)
|
|
|
|
{
|
|
|
|
Evas_Object *enventor = base_enventor_get();
|
|
|
|
Eina_List *part_list = enventor_object_parts_list_get(enventor);
|
|
|
|
Eina_List *l, *ll;
|
|
|
|
part_it *pit;
|
|
|
|
char *name;
|
|
|
|
int idx = 0;
|
2016-02-29 03:19:10 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//1. Prepare for validation.
|
|
|
|
EINA_LIST_FOREACH(git->parts, l, pit)
|
|
|
|
{
|
|
|
|
pit->discarded = EINA_TRUE;
|
|
|
|
pit->tag.idx = IDX_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
//2. New parts
|
|
|
|
EINA_LIST_FOREACH(part_list, l, name)
|
|
|
|
{
|
|
|
|
Eina_Bool new_part = EINA_TRUE;
|
|
|
|
idx++;
|
2016-02-29 04:32:30 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Check if it is existed?
|
|
|
|
EINA_LIST_FOREACH(git->parts, ll, pit)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, pit->name) &&
|
|
|
|
(strlen(name) == strlen(pit->name)))
|
|
|
|
{
|
|
|
|
pit->discarded = EINA_FALSE;
|
|
|
|
new_part = EINA_FALSE;
|
|
|
|
//update index of the item
|
|
|
|
pit->tag.idx = idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
if (!new_part) continue;
|
|
|
|
|
|
|
|
//Ok, this part is newly added.
|
|
|
|
pit = calloc(1, sizeof(part_it));
|
|
|
|
if (!pit)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR(_("Failed to allocate Memory!"));
|
|
|
|
continue;
|
|
|
|
}
|
2016-02-29 04:32:30 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
pit->tag.type = Item_Type_Part;
|
|
|
|
pit->tag.idx = idx;
|
|
|
|
pit->name = strdup(name);
|
|
|
|
pit->type = enventor_object_part_type_get(enventor, name);
|
|
|
|
pit->git = git;
|
|
|
|
pit->it = elm_genlist_item_sorted_insert(nd->genlist,
|
|
|
|
nd->part_itc,
|
|
|
|
pit,
|
|
|
|
git->it,
|
|
|
|
ELM_GENLIST_ITEM_TREE,
|
|
|
|
gl_comp_func,
|
|
|
|
gl_part_selected_cb,
|
|
|
|
pit);
|
|
|
|
git->parts = eina_list_append(git->parts, pit);
|
|
|
|
}
|
|
|
|
|
|
|
|
//3. Update parts
|
|
|
|
EINA_LIST_FOREACH_SAFE(git->parts, l, ll, pit)
|
|
|
|
{
|
|
|
|
//Remove them from the previous list.
|
|
|
|
if (pit->discarded)
|
|
|
|
{
|
|
|
|
git->parts = eina_list_remove_list(git->parts, l);
|
|
|
|
navigator_part_free(pit);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Update parts states only if they are expanded.
|
|
|
|
if (!elm_genlist_item_expanded_get(pit->it)) continue;
|
|
|
|
|
|
|
|
states_update(nd, pit);
|
|
|
|
}
|
|
|
|
|
|
|
|
edje_edit_string_list_free(part_list);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
static void
|
2016-04-21 23:39:24 -07:00
|
|
|
part_expand(part_it *pit)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
if (elm_genlist_item_expanded_get(pit->it)) return;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
elm_genlist_item_expanded_set(pit->it, EINA_TRUE);
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
states_update(pit->git->nd, pit);
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//If auto contraction is enabled, then close other parts and programs
|
2016-04-22 00:22:53 -07:00
|
|
|
if (!config_auto_contract_get()) return;
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
//Contract other part states
|
|
|
|
part_it *pit2;
|
|
|
|
Eina_List *l;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
EINA_LIST_FOREACH(pit->git->parts, l, pit2)
|
2016-02-29 00:24:49 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
if (pit2 == pit) continue;
|
|
|
|
part_contract(pit2);
|
2016-02-29 00:24:49 -08:00
|
|
|
}
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
//Contract programs
|
|
|
|
programs_contract(&pit->git->programs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
part_contract(part_it *pit)
|
|
|
|
{
|
|
|
|
if (!elm_genlist_item_expanded_get(pit->it)) return;
|
|
|
|
|
|
|
|
elm_genlist_item_expanded_set(pit->it, EINA_FALSE);
|
|
|
|
|
|
|
|
navigator_states_clear(pit);
|
2016-02-29 00:24:49 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Group Related */
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static void
|
|
|
|
group_update(navi_data *nd, group_it *git)
|
|
|
|
{
|
|
|
|
parts_update(nd, git);
|
|
|
|
programs_update(nd, git);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
group_expand(group_it *git)
|
|
|
|
{
|
|
|
|
if (elm_genlist_item_expanded_get(git->it)) return;
|
|
|
|
|
|
|
|
elm_genlist_item_expanded_set(git->it, EINA_TRUE);
|
|
|
|
|
|
|
|
group_update(git->nd, git);
|
|
|
|
|
|
|
|
//If auto contraction is enabled, then close other parts
|
2016-04-22 00:22:53 -07:00
|
|
|
if (!config_auto_contract_get()) return;
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
//Contract other groups
|
|
|
|
group_it *git2;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(git->nd->groups, l, git2)
|
|
|
|
{
|
|
|
|
if (git2 == git) continue;
|
|
|
|
group_contract(git2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
group_contract(group_it *git)
|
|
|
|
{
|
|
|
|
if (!elm_genlist_item_expanded_get(git->it)) return;
|
|
|
|
|
|
|
|
elm_genlist_item_expanded_set(git->it, EINA_FALSE);
|
|
|
|
navigator_parts_clear(git);
|
|
|
|
navigator_programs_clear(git);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
gl_group_text_get_cb(void *data, Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *part EINA_UNUSED)
|
|
|
|
{
|
|
|
|
group_it *git = data;
|
|
|
|
return strdup(git->name);
|
|
|
|
}
|
|
|
|
|
2016-02-27 00:31:12 -08:00
|
|
|
static Evas_Object *
|
2016-03-04 18:31:37 -08:00
|
|
|
gl_group_content_get_cb(void *data EINA_UNUSED, Evas_Object *obj,
|
|
|
|
const char *part)
|
2016-02-27 00:31:12 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
if (!strcmp("elm.swallow.icon", part))
|
|
|
|
{
|
|
|
|
Evas_Object *image = elm_image_add(obj);
|
|
|
|
elm_image_file_set(image, EDJE_PATH, "navi_group");
|
|
|
|
return image;
|
|
|
|
}
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
return NULL;
|
2016-02-27 00:31:12 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gl_group_selected_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
|
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
group_it *git = data;
|
|
|
|
find_group_proc(git->name);
|
|
|
|
}
|
2016-02-29 00:36:45 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static void
|
|
|
|
gl_expand_request_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
2016-02-27 00:31:12 -08:00
|
|
|
Elm_Object_Item *it = event_info;
|
2016-04-21 23:39:24 -07:00
|
|
|
list_it *_it = (list_it *)elm_object_item_data_get(it);
|
2016-02-27 00:31:12 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
switch(_it->type)
|
|
|
|
{
|
|
|
|
case Item_Type_Group:
|
|
|
|
group_expand((group_it*)_it);
|
|
|
|
break;
|
|
|
|
case Item_Type_Part:
|
|
|
|
part_expand((part_it*)_it);
|
|
|
|
break;
|
|
|
|
case Item_Type_Programs:
|
|
|
|
programs_expand((programs_it*)_it);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-02-29 00:36:45 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
static void
|
|
|
|
gl_contract_request_cb(void *data, Evas_Object *obj, void *event_info)
|
|
|
|
{
|
|
|
|
Elm_Object_Item *it = event_info;
|
|
|
|
list_it *_it = (list_it *)elm_object_item_data_get(it);
|
|
|
|
|
|
|
|
switch(_it->type)
|
|
|
|
{
|
|
|
|
case Item_Type_Group:
|
|
|
|
group_contract((group_it*)_it);
|
|
|
|
break;
|
|
|
|
case Item_Type_Part:
|
|
|
|
part_contract((part_it*)_it);
|
|
|
|
break;
|
|
|
|
case Item_Type_Programs:
|
|
|
|
programs_contract((programs_it*)_it);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2016-02-27 00:31:12 -08:00
|
|
|
}
|
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
/*****************************************************************************/
|
|
|
|
/* Externally accessible calls */
|
|
|
|
/*****************************************************************************/
|
2016-04-22 01:38:23 -07:00
|
|
|
void
|
|
|
|
edc_navigator_deselect(void)
|
|
|
|
{
|
|
|
|
navi_data *nd = g_nd;
|
|
|
|
if (!nd || !nd->selected) return;
|
|
|
|
navigator_item_deselect(nd);
|
|
|
|
}
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
void
|
2016-02-27 00:31:12 -08:00
|
|
|
edc_navigator_group_update(const char *cur_group)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
|
|
|
navi_data *nd = g_nd;
|
|
|
|
if (!nd) return;
|
|
|
|
|
2016-04-22 03:31:07 -07:00
|
|
|
//FIXME: This function is unnecessarily called... why?
|
|
|
|
|
2016-02-28 07:05:44 -08:00
|
|
|
//Cancel item selection if group was not indicated.
|
2016-04-22 01:38:23 -07:00
|
|
|
if (!cur_group) navigator_item_deselect(nd);
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_List *group_list = edje_file_collection_list(config_output_path_get());
|
|
|
|
unsigned int cur_group_len = 0;
|
|
|
|
group_it *git;
|
|
|
|
Eina_List *l, *ll;
|
|
|
|
char *name;
|
|
|
|
int idx = 0;
|
|
|
|
|
|
|
|
//1. Prepare for validation.
|
|
|
|
EINA_LIST_FOREACH(nd->groups, l, git)
|
2016-02-28 07:05:44 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
git->discarded = EINA_TRUE;
|
|
|
|
git->tag.idx = IDX_MAX;
|
2016-02-27 00:31:12 -08:00
|
|
|
}
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//2. New groups
|
|
|
|
EINA_LIST_FOREACH(group_list, l, name)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
idx++;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
Eina_Bool new_group = EINA_TRUE;
|
2016-03-16 04:02:32 -07:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Check if it is existed?
|
|
|
|
EINA_LIST_FOREACH(nd->groups, ll, git)
|
|
|
|
{
|
|
|
|
if (!strcmp(name, git->name) &&
|
|
|
|
(strlen(name) == strlen(git->name)))
|
|
|
|
{
|
|
|
|
git->discarded = EINA_FALSE;
|
|
|
|
new_group = EINA_FALSE;
|
|
|
|
//update index of the item
|
|
|
|
git->tag.idx = idx;
|
|
|
|
break;
|
|
|
|
}
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
2016-04-21 23:39:24 -07:00
|
|
|
if (!new_group) continue;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Ok, this group is newly added.
|
|
|
|
group_it *git = calloc(1, sizeof(group_it));
|
|
|
|
if (!git)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR(_("Failed to allocate Memory!"));
|
|
|
|
continue;
|
|
|
|
}
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
git->tag.type = Item_Type_Group;
|
|
|
|
git->tag.idx = idx;
|
|
|
|
git->name = strdup(name);
|
|
|
|
git->nd = nd;
|
2016-04-22 02:32:10 -07:00
|
|
|
git->it = elm_genlist_item_append(nd->genlist,
|
|
|
|
nd->group_itc,
|
|
|
|
git,
|
|
|
|
NULL,
|
|
|
|
ELM_GENLIST_ITEM_TREE,
|
|
|
|
gl_group_selected_cb,
|
|
|
|
git);
|
2016-04-21 23:39:24 -07:00
|
|
|
nd->groups = eina_list_append(nd->groups, git);
|
2016-02-28 07:05:44 -08:00
|
|
|
}
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//3. Update groups
|
|
|
|
if (cur_group) cur_group_len = strlen(cur_group);
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
EINA_LIST_FOREACH_SAFE(nd->groups, l, ll, git)
|
2016-02-26 05:22:29 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
//remove them from the previous list.
|
|
|
|
if (git->discarded)
|
2016-02-28 07:05:44 -08:00
|
|
|
{
|
2016-04-21 23:39:24 -07:00
|
|
|
nd->groups = eina_list_remove_list(nd->groups, l);
|
|
|
|
navigator_group_free(git);
|
|
|
|
continue;
|
2016-02-28 07:05:44 -08:00
|
|
|
}
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
//Update group parts only if they are expanded.
|
|
|
|
if (!elm_genlist_item_expanded_get(git->it)) continue;
|
|
|
|
|
|
|
|
//update only current group
|
|
|
|
if (cur_group && !strcmp(cur_group, git->name) &&
|
|
|
|
(cur_group_len == strlen(git->name)))
|
|
|
|
group_update(nd, git);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
2016-04-21 23:39:24 -07:00
|
|
|
|
|
|
|
edje_file_collection_list_free(group_list);
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
Evas_Object *
|
|
|
|
edc_navigator_init(Evas_Object *parent)
|
|
|
|
{
|
|
|
|
navi_data *nd = calloc(1, sizeof(navi_data));
|
|
|
|
if (!nd)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR("Failed to allocate Memory!");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
g_nd = nd;
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
//Box
|
|
|
|
Evas_Object *box = elm_box_add(parent);
|
|
|
|
elm_object_focus_allow_set(box, EINA_FALSE);
|
|
|
|
|
|
|
|
//Genlist
|
|
|
|
Evas_Object *genlist = elm_genlist_add(box);
|
2016-02-27 00:31:12 -08:00
|
|
|
elm_object_focus_allow_set(genlist, EINA_FALSE);
|
2016-04-21 23:39:24 -07:00
|
|
|
evas_object_smart_callback_add(genlist, "expand,request",
|
|
|
|
gl_expand_request_cb, nd);
|
|
|
|
evas_object_smart_callback_add(genlist, "contract,request",
|
|
|
|
gl_contract_request_cb, nd);
|
2016-04-22 01:38:23 -07:00
|
|
|
evas_object_smart_callback_add(genlist, "selected",
|
|
|
|
gl_selected_cb, nd);
|
|
|
|
evas_object_smart_callback_add(genlist, "selected",
|
|
|
|
gl_unselected_cb, nd);
|
2016-04-21 23:39:24 -07:00
|
|
|
evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND,
|
|
|
|
EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
|
|
|
evas_object_show(genlist);
|
|
|
|
elm_box_pack_end(box, genlist);
|
|
|
|
|
|
|
|
//Check for genlist option
|
|
|
|
Evas_Object *check = elm_check_add(box);
|
|
|
|
elm_object_text_set(check, "Automatic Contraction");
|
2016-04-22 00:22:53 -07:00
|
|
|
elm_check_state_set(check, config_auto_contract_get());
|
2016-04-22 19:22:48 -07:00
|
|
|
elm_object_tooltip_text_set(check, "Automatic Contraction contracts items</br> when other items are expanded");
|
|
|
|
elm_object_tooltip_orient_set(check, ELM_TOOLTIP_ORIENT_TOP);
|
2016-04-21 23:39:24 -07:00
|
|
|
evas_object_smart_callback_add(check, "changed", check_changed_cb, nd);
|
|
|
|
elm_object_focus_allow_set(check, EINA_FALSE);
|
|
|
|
evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, 0);
|
|
|
|
evas_object_size_hint_align_set(check, 0.05, EVAS_HINT_FILL);
|
|
|
|
evas_object_show(check);
|
|
|
|
elm_box_pack_end(box, check);
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
//Group Item Class
|
|
|
|
Elm_Genlist_Item_Class *itc;
|
|
|
|
|
|
|
|
itc = elm_genlist_item_class_new();
|
2016-04-22 02:32:10 -07:00
|
|
|
itc->item_style = "default";
|
2016-04-21 23:39:24 -07:00
|
|
|
itc->func.text_get = gl_group_text_get_cb;
|
2016-02-27 00:31:12 -08:00
|
|
|
itc->func.content_get = gl_group_content_get_cb;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
nd->group_itc = itc;
|
|
|
|
|
|
|
|
//Part Item Class
|
|
|
|
itc = elm_genlist_item_class_new();
|
2016-04-22 02:32:10 -07:00
|
|
|
itc->item_style = "default";
|
2016-02-27 00:31:12 -08:00
|
|
|
itc->func.text_get = gl_part_text_get_cb;
|
|
|
|
itc->func.content_get = gl_part_content_get_cb;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
nd->part_itc = itc;
|
|
|
|
|
|
|
|
//State Item Class
|
|
|
|
itc = elm_genlist_item_class_new();
|
|
|
|
itc->item_style = "default";
|
2016-02-29 03:19:10 -08:00
|
|
|
itc->func.text_get = gl_state_text_get_cb;
|
2016-02-27 00:31:12 -08:00
|
|
|
itc->func.content_get = gl_state_content_get_cb;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
|
|
|
nd->state_itc = itc;
|
|
|
|
|
2016-02-29 00:24:49 -08:00
|
|
|
//Programs Item Class
|
|
|
|
itc = elm_genlist_item_class_new();
|
2016-04-22 02:32:10 -07:00
|
|
|
itc->item_style = "default";
|
2016-02-29 00:24:49 -08:00
|
|
|
itc->func.text_get = gl_programs_text_get_cb;
|
|
|
|
itc->func.content_get = gl_programs_content_get_cb;
|
2016-04-22 21:53:37 -07:00
|
|
|
itc->func.del = gl_programs_del_cb;
|
2016-02-29 00:24:49 -08:00
|
|
|
|
|
|
|
nd->programs_itc = itc;
|
|
|
|
|
2016-02-28 07:05:44 -08:00
|
|
|
//Program Item Class
|
|
|
|
itc = elm_genlist_item_class_new();
|
|
|
|
itc->item_style = "default";
|
2016-04-21 23:39:24 -07:00
|
|
|
itc->func.text_get = gl_program_text_get_cb;
|
2016-02-28 07:05:44 -08:00
|
|
|
itc->func.content_get = gl_program_content_get_cb;
|
2016-04-22 21:53:37 -07:00
|
|
|
itc->func.del = gl_program_del_cb;
|
2016-02-28 07:05:44 -08:00
|
|
|
|
|
|
|
nd->program_itc = itc;
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
nd->box = box;
|
2016-02-26 05:22:29 -08:00
|
|
|
nd->genlist = genlist;
|
2016-04-21 23:39:24 -07:00
|
|
|
nd->check = check;
|
2016-02-26 05:22:29 -08:00
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
return box;
|
2016-02-26 05:22:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
edc_navigator_term(void)
|
|
|
|
{
|
|
|
|
navi_data *nd = g_nd;
|
|
|
|
if (!nd) return;
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
navigator_groups_clear(nd);
|
2016-02-28 07:05:44 -08:00
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
elm_genlist_item_class_free(nd->group_itc);
|
|
|
|
elm_genlist_item_class_free(nd->part_itc);
|
|
|
|
elm_genlist_item_class_free(nd->state_itc);
|
2016-02-29 00:24:49 -08:00
|
|
|
elm_genlist_item_class_free(nd->programs_itc);
|
2016-02-28 07:05:44 -08:00
|
|
|
elm_genlist_item_class_free(nd->program_itc);
|
|
|
|
|
2016-04-21 23:39:24 -07:00
|
|
|
evas_object_del(nd->box);
|
|
|
|
|
2016-02-26 05:22:29 -08:00
|
|
|
free(nd);
|
|
|
|
g_nd = NULL;
|
|
|
|
}
|