enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 24 Pull Requests 2 Projects Releases Wiki Activity
enlightenment/src/modules/everything/evry.c

2636 lines
59 KiB
C
Raw Blame History

#include "e.h"
#include "e_mod_main.h"
/* TODO */
/* - animations
* - mouse handlers
* - show item descriptions
* - keybinding configuration
* - shortcuts for plugins
*/
#define INPUTLEN 40
#define MATCH_LAG 0.33
#define MAX_FUZZ 150
typedef struct _Evry_State Evry_State;
typedef struct _Evry_Window Evry_Window;
typedef struct _Evry_List_Window Evry_List_Window;
typedef struct _Evry_Selector Evry_Selector;
struct _Evry_State
{
char *input;
/* all available plugins for current state */
Eina_List *plugins;
/* currently active plugins, i.e. those that provide items */
Eina_List *cur_plugins;
/* active plugin */
Evry_Plugin *plugin;
/* selected item */
Evry_Item *sel_item;
/* Eina_List *sel_items; */
/* this is for the case when the current plugin was not selected
manually and a higher priority (async) plugin retrieves
candidates, the higher priority plugin is made current */
Eina_Bool plugin_auto_selected;
Eina_Bool item_auto_selected;
Eina_List *items;
};
/* */
struct _Evry_Selector
{
Evas_Object *o_main;
Evas_Object *o_icon;
/* current state */
Evry_State *state;
/* stack of states (for browseable plugins) */
Eina_List *states;
/* provides collection of items from other plugins */
Evry_Plugin *aggregator;
/* */
Eina_List *actions;
/* all plugins that belong to this selector*/
Eina_List *plugins;
};
struct _Evry_Window
{
E_Popup *popup;
Evas_Object *o_main;
Eina_Bool request_selection;
/* E_Popup *input_win; */
};
struct _Evry_List_Window
{
E_Popup *popup;
Evas_Object *o_main;
Evas_Object *o_list;
Evas_Object *o_tabs;
int ev_last_is_mouse;
Evry_Item *item_mouseover;
Ecore_Animator *scroll_animator;
Ecore_Timer *scroll_timer;
double scroll_align_to;
double scroll_align;
Ecore_Idler *item_idler;
Eina_Bool visible;
};
static void _evry_matches_update(Evry_Selector *sel);
static void _evry_plugin_action(Evry_Selector *sel, int finished);
static void _evry_backspace(Evry_State *s);
static void _evry_update(Evry_State *s, int fetch);
static void _evry_clear(Evry_State *s);
static int _evry_update_timer(void *data);
static Evry_State *_evry_state_new(Evry_Selector *sel, Eina_List *plugins);
static void _evry_state_pop(Evry_Selector *sel);
static void _evry_select_plugin(Evry_State *s, Evry_Plugin *p);
static void _evry_update_text_label(Evry_State *s);
static void _evry_browse_item(Evry_Selector *sel);
static void _evry_browse_back(Evry_Selector *sel);
static void _evry_selectors_switch(void);
static void _evry_plugin_list_insert(Evry_State *s, Evry_Plugin *p);
static Evry_Window *_evry_window_new(E_Zone *zone);
static void _evry_window_free(Evry_Window *win);
static Evry_Selector *_evry_selector_new(int type);
static void _evry_selector_free(Evry_Selector *sel);
static void _evry_selector_activate(Evry_Selector *sel);
static void _evry_selector_update(Evry_Selector *sel);
static void _evry_selector_icon_set(Evry_Selector *sel);
static int _evry_selector_subjects_get(void);
static int _evry_selector_actions_get(Evry_Item *it);
static int _evry_selector_objects_get(const char *type);
static Evry_List_Window *_evry_list_win_new(E_Zone *zone);
static void _evry_list_win_free(Evry_List_Window *win);
static void _evry_list_win_show(void);
static void _evry_list_win_hide(void);
static void _evry_list_clear_list(Evry_State *s);
static void _evry_list_update(Evry_State *s);
static void _evry_list_show_items(Evry_State *s, Evry_Plugin *plugin);
static void _evry_list_item_next(Evry_State *s);
static void _evry_list_item_prev(Evry_State *s);
static void _evry_list_item_first(Evry_State *s);
static void _evry_list_item_last(Evry_State *s);
static void _evry_list_plugin_next(Evry_State *s);
static void _evry_list_plugin_prev(Evry_State *s);
static void _evry_list_plugin_next_by_name(Evry_State *s, const char *key);
static void _evry_list_scroll_to(Evry_State *s, Evry_Item *it);
static void _evry_list_item_desel(Evry_State *s, Evry_Item *it);
static void _evry_list_item_sel(Evry_State *s, Evry_Item *it);
static void _evry_list_tab_scroll_to(Evry_State *s, Evry_Plugin *p);
static void _evry_list_tab_show(Evry_State *s, Evry_Plugin *p);
static void _evry_list_tabs_update(Evry_State *s);
static int _evry_list_animator(void *data);
static int _evry_list_scroll_timer(void *data);
static int _evry_list_item_idler(void *data);
static int _evry_plug_actions_init(void);
static void _evry_plug_actions_free(void);
static int _evry_plug_actions_begin(Evry_Plugin *p, const Evry_Item *it);
static int _evry_plug_actions_fetch(Evry_Plugin *p, const char *input);
static void _evry_plug_actions_cleanup(Evry_Plugin *p);
static Evas_Object *_evry_plug_actions_item_icon_get(Evry_Plugin *p, const Evry_Item *it, Evas *e);
static Evry_Plugin *_evry_plug_aggregator_new(void);
static void _evry_plug_aggregator_free(Evry_Plugin *p);
static int _evry_plug_aggregator_fetch(Evry_Plugin *p, const char *input);
static int _evry_plug_aggregator_action(Evry_Plugin *p, const Evry_Item *item, const char *input);
static void _evry_plug_aggregator_cleanup(Evry_Plugin *p);
static Evas_Object *_evry_plug_aggregator_item_icon_get(Evry_Plugin *p, const Evry_Item *it, Evas *e);
static int _evry_cb_key_down(void *data, int type, void *event);
static int _evry_cb_selection_notify(void *data, int type, void *event);
/* static int _evry_cb_mouse_down(void *data, int type, void *event);
* static int _evry_cb_mouse_up(void *data, int type, void *event);
* static int _evry_cb_mouse_move(void *data, int type, void *event);
* static int _evry_cb_mouse_wheel(void *data, int type, void *event);
* static void _evry_cb_item_mouse_in(void *data, Evas *evas, Evas_Object *obj, void *event_info);
* static void _evry_cb_item_mouse_out(void *data, Evas *evas, Evas_Object *obj, void *event_info); */
/* local subsystem globals */
static Evry_Window *win = NULL;
static Evry_List_Window *list = NULL;
static Ecore_X_Window input_window = 0;
static Eina_List *handlers = NULL;
static Ecore_Timer *update_timer = NULL;
static Evry_Selector *selectors[3];
static Evry_Selector *selector = NULL;
static Evry_Plugin *action_selector = NULL;
/* externally accessible functions */
int
evry_init(void)
{
_evry_plug_actions_init();
return 1;
}
int
evry_shutdown(void)
{
evry_hide();
_evry_plug_actions_free();
return 1;
}
int
evry_show(E_Zone *zone)
{
if (win) return 0;
E_OBJECT_CHECK_RETURN(zone, 0);
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, 0);
input_window = ecore_x_window_input_new(zone->container->win, zone->x,
zone->y, zone->w, zone->h);
ecore_x_window_show(input_window);
if (!e_grabinput_get(input_window, 1, input_window))
goto error;
win = _evry_window_new(zone);
if (!win) goto error;
list = _evry_list_win_new(zone);
if (!list) goto error;
list->visible = EINA_FALSE;
/* TODO check NULL */
selectors[0] = _evry_selector_new(type_subject);
selectors[1] = _evry_selector_new(type_action);
selectors[2] = _evry_selector_new(type_object);
_evry_selector_subjects_get();
_evry_selector_activate(selectors[0]);
_evry_selector_update(selector);
e_popup_layer_set(list->popup, 255);
e_popup_layer_set(win->popup, 255);
e_popup_show(win->popup);
e_popup_show(list->popup);
if (list->visible)
{
e_popup_show(list->popup);
_evry_list_update(selector->state);
}
e_box_align_set(list->o_tabs, 0.0, 0.5);
handlers = eina_list_append
(handlers, ecore_event_handler_add
(ECORE_EVENT_KEY_DOWN, _evry_cb_key_down, NULL));
handlers = eina_list_append
(handlers, ecore_event_handler_add
(ECORE_X_EVENT_SELECTION_NOTIFY,
_evry_cb_selection_notify, win));
/* handlers = eina_list_append
* (handlers, ecore_event_handler_add
* (ECORE_EVENT_MOUSE_BUTTON_DOWN, _evry_cb_mouse_down, NULL));
* handlers = eina_list_append
* (handlers, ecore_event_handler_add
* (ECORE_EVENT_MOUSE_BUTTON_UP, _evry_cb_mouse_up, NULL));
* handlers = eina_list_append
* (handlers, ecore_event_handler_add
* (ECORE_EVENT_MOUSE_MOVE, _evry_cb_mouse_move, NULL));
* handlers = eina_list_append
* (handlers, ecore_event_handler_add
* (ECORE_EVENT_MOUSE_WHEEL, _evry_cb_mouse_wheel, NULL)); */
return 1;
error:
if (win && selectors[0])
_evry_selector_free(selectors[0]);
if (win && selectors[1])
_evry_selector_free(selectors[1]);
if (win && selectors[2])
_evry_selector_free(selectors[2]);
if (win)
_evry_window_free(win);
if (list)
_evry_list_win_free(list);
win = NULL;
list = NULL;
ecore_x_window_free(input_window);
input_window = 0;
return 0;
}
void
evry_hide(void)
{
Ecore_Event *ev;
if (!win) return;
_evry_list_clear_list(selector->state);
if (update_timer)
ecore_timer_del(update_timer);
update_timer = NULL;
list->visible = EINA_FALSE;
_evry_selector_free(selectors[0]);
_evry_selector_free(selectors[1]);
_evry_selector_free(selectors[2]);
selectors[0] = NULL;
selectors[1] = NULL;
selectors[2] = NULL;
selector = NULL;
_evry_list_win_free(list);
list = NULL;
_evry_window_free(win);
win = NULL;
EINA_LIST_FREE(handlers, ev)
ecore_event_handler_del(ev);
ecore_x_window_free(input_window);
e_grabinput_release(input_window, input_window);
input_window = 0;
}
void
evry_clear_input(void)
{
Evry_State *s = selector->state;
if (s->input[0] != 0)
{
s->input[0] = 0;
}
}
/* static int item_cnt = 0; */
Evry_Item *
evry_item_new(Evry_Plugin *p, const char *label, void (*cb_free) (Evry_Item *item))
{
Evry_Item *it;
it = E_NEW(Evry_Item, 1);
if (!it) return NULL;
it->plugin = p;
if (label) it->label = eina_stringshare_add(label);
it->ref = 1;
/* item_cnt++; */
return it;
}
void
evry_item_free(Evry_Item *it)
{
if (!it) return;
it->ref--;
if (it->ref > 0) return;
/* printf("%d, %d\t 0x%x 0x%x 0x%x free: %s\n",
* it->ref, item_cnt - 1,
* it->label, it->uri, it->mime,
* it->label); */
/* item_cnt--; */
if (it->cb_free) it->cb_free(it);
if (it->label) eina_stringshare_del(it->label);
if (it->uri) eina_stringshare_del(it->uri);
if (it->mime) eina_stringshare_del(it->mime);
if (it->o_bg) evas_object_del(it->o_bg);
if (it->o_icon) evas_object_del(it->o_icon);
E_FREE(it);
}
void
_evry_item_ref(Evry_Item *it)
{
it->ref++;
}
void
evry_plugin_async_update(Evry_Plugin *p, int action)
{
Evry_State *s;
Evry_Plugin *agg;
if (!win) return;
s = selector->state;
agg = selector->aggregator;
/* received data from a plugin of the current selector ? */
if (!s || !eina_list_data_find(s->plugins, p)) return;
if (action == EVRY_ASYNC_UPDATE_ADD)
{
if (!p->items)
{
/* remove plugin */
if (!eina_list_data_find(s->cur_plugins, p)) return;
s->cur_plugins = eina_list_remove(s->cur_plugins, p);
if (s->plugin == p)
_evry_select_plugin(s, NULL);
}
else
{
/* add plugin to current plugins*/
_evry_plugin_list_insert(s, p);
if (!s->plugin || !eina_list_data_find_list(s->cur_plugins, s->plugin))
_evry_select_plugin(s, NULL);
}
/* update aggregator */
if (eina_list_count(s->cur_plugins) > 1)
{
agg->fetch(agg, s->input);
/* add aggregator */
if (!(s->cur_plugins->data == agg))
{
s->cur_plugins = eina_list_prepend(s->cur_plugins, agg);
if (s->plugin_auto_selected)
_evry_select_plugin(s, agg);
}
}
/* plugin is visible */
if ((s->plugin == p) || (s->plugin == agg))
{
_evry_selector_update(selector);
p = s->plugin;
_evry_list_clear_list(s);
_evry_list_show_items(s, p);
_evry_list_scroll_to(s, s->sel_item);
}
/* plugin box was updated: realign */
if (s->plugin)
{
_evry_list_tabs_update(s);
_evry_list_tab_scroll_to(s, s->plugin);
}
}
}
int
evry_fuzzy_match(const char *str, const char *match)
{
const char *p, *m, *next;
char mc, pc;
int sum = 0;
unsigned int last = 0;
unsigned int offset = 0;
unsigned int min = 0;
unsigned char first = 0;
/* words in match */
unsigned int words = 1;
unsigned int word = 0;
unsigned int word_min[64];
if (!match || !str) return 0;
/* remove white spaces at the beginning */
for (; (*match != 0) && isspace(*match); match++);
for (; (*str != 0) && isspace(*str); str++);
/* count words in match */
word_min[0] = MAX_FUZZ;
for (m = match; *m != 0 && *(m+1) != 0; m++)
{
if (isspace(*m) && !isspace(*(m+1)))
{
word_min[words++] = MAX_FUZZ;
}
}
next = str;
m = match;
for (word = 0; word < words && *next != 0; )
{
/* reset match */
if (word == 0) m = match;
/* end of matching */
if (*m == 0) break;
mc = tolower(*m);
offset = 0;
last = 0;
min = 1;
first = 0;
/* match current word of string against current match */
for (p = next; *next != 0; p++)
{
/* new word of string begins */
if (*p == 0 || isspace(*p))
{
if (word < words - 1)
{
/* test next match */
for (; (*m != 0) && !isspace(*m); m++);
for (; (*m != 0) && isspace(*m); m++);
word++;
break;
}
else
{
/* go to next word */
for (; (*p != 0) && isspace(*p); p++);
next = p;
word = 0;
break;
}
}
pc = tolower(*p);
/* current char matches? */
if (pc != mc)
{
offset++;
continue;
}
/* first offset of match in word */
if (!first)
{
offset *= 10;
last = offset;
first = 1;
}
min += offset + (offset - last) * 10;
last = offset;
/* try next char of match */
m++;
if (*m != 0 && !isspace(*m))
{
mc = tolower(*m);
continue;
}
/* end of match: store min weight of match */
if (min < word_min[word])
word_min[word] = min;
if (word < words - 1)
{
/* test next match */
for (; (*m != 0) && isspace(*m); m++);
word++;
break;
}
else if(*p != 0)
{
/* go to next word */
for (; (*p != 0) && !isspace(*p); p++);
for (; (*p != 0) && isspace(*p); p++);
next = p;
word = 0;
break;
}
else
{
next = p;
break;
}
}
}
for (word = 0; word < words; word++)
{
if (word_min[word] >= MAX_FUZZ)
{
sum = 0;
break;
}
sum += word_min[word];
}
/* if (sum)
* printf("min %d >> %s - %s\n", sum, match, str); */
return sum;
}
/* local subsystem functions */
static Evry_List_Window *
_evry_list_win_new(E_Zone *zone)
{
int x, y;
Evry_List_Window *list_win;
E_Popup *popup;
Evas_Object *o;
x = (zone->w / 2) - (win->popup->w / 3);
y = (zone->h / 2);
/* TODO get offsets from theme */
popup = e_popup_new(zone, x + 50, y - 4,
win->popup->w * 2/3 - 100,
evry_conf->height);
if (!popup) return NULL;
list_win = E_NEW(Evry_List_Window, 1);
if (!list_win)
{
e_object_del(E_OBJECT(popup));
return NULL;
}
list_win->popup = popup;
evas_event_freeze(popup->evas);
evas_event_feed_mouse_in(popup->evas, ecore_x_current_time_get(), NULL);
evas_event_feed_mouse_move(popup->evas, -1000000, -1000000, ecore_x_current_time_get(), NULL);
o = edje_object_add(popup->evas);
list_win->o_main = o;
e_theme_edje_object_set(o, "base/theme/everything",
"e/widgets/everything/list");
o = e_box_add(popup->evas);
list_win->o_list = o;
e_box_orientation_set(o, 0);
e_box_homogenous_set(o, 1);
edje_object_part_swallow(list_win->o_main, "e.swallow.list", o);
evas_object_show(o);
o = list_win->o_main;
evas_object_move(o, 0, 0);
evas_object_resize(o, list_win->popup->w, list_win->popup->h);
evas_object_show(o);
e_popup_edje_bg_object_set(popup, o);
o = e_box_add(popup->evas);
e_box_orientation_set(o, 1);
/* e_box_homogenous_set(o, 1); */
edje_object_part_swallow(list_win->o_main, "e.swallow.bar", o);
evas_object_show(o);
list_win->o_tabs = o;
evas_event_thaw(popup->evas);
return list_win;
}
static void
_evry_list_win_free(Evry_List_Window *list_win)
{
if (list_win->scroll_timer)
ecore_timer_del(list_win->scroll_timer);
if (list_win->scroll_animator)
ecore_animator_del(list_win->scroll_animator);
if (list_win->item_idler)
ecore_idler_del(list_win->item_idler);
e_popup_hide(list_win->popup);
evas_event_freeze(list_win->popup->evas);
evas_object_del(list_win->o_list);
evas_object_del(list_win->o_tabs);
evas_object_del(list_win->o_main);
/* evas_event_thaw(list_win->popup->evas); */
e_object_del(E_OBJECT(list_win->popup));
E_FREE(list_win);
}
static void
_evry_list_win_show(void)
{
if (list->visible) return;
list->visible = EINA_TRUE;
_evry_list_update(selector->state);
edje_object_signal_emit(list->o_main, "e,state,list_show", "e");
}
static void
_evry_list_win_hide(void)
{
Eina_List *l;
Evry_Plugin *p;
if (!list->visible) return;
list->visible = EINA_FALSE;
EINA_LIST_FOREACH(selector->plugins, l, p)
{
e_box_unpack(p->tab);
evas_object_del(p->tab);
p->tab = NULL;
}
_evry_list_clear_list(selector->state);
edje_object_signal_emit(list->o_main, "e,state,list_hide", "e");
/* e_popup_hide(list->popup); */
}
static Evry_Window *
_evry_window_new(E_Zone *zone)
{
int x, y, mw, mh;
Evry_Window *win;
E_Popup *popup;
Evas_Object *o;
popup = e_popup_new(zone, 100, 100, 1, 1);
if (!popup) return NULL;
win = E_NEW(Evry_Window, 1);
if (!win)
{
e_object_del(E_OBJECT(popup));
return NULL;
}
win->popup = popup;
o = edje_object_add(popup->evas);
win->o_main = o;
e_theme_edje_object_set(o, "base/theme/everything",
"e/widgets/everything/main");
edje_object_size_min_get(o, &mw, &mh);
x = (zone->w / 2) - (mw / 2);
y = (zone->h / 2) - mh;
e_popup_move_resize(popup, x, y, mw, mh);
o = win->o_main;
e_popup_edje_bg_object_set(win->popup, o);
evas_object_move(o, 0, 0);
evas_object_resize(o, mw, mh);
evas_object_show(o);
ecore_x_netwm_window_type_set(popup->evas_win, ECORE_X_WINDOW_TYPE_UTILITY);
return win;
}
static void
_evry_window_free(Evry_Window *win)
{
e_popup_hide(win->popup);
evas_event_freeze(win->popup->evas);
evas_object_del(win->o_main);
/* evas_event_thaw(win->popup->evas); */
e_object_del(E_OBJECT(win->popup));
E_FREE(win);
}
static Evry_Selector *
_evry_selector_new(int type)
{
Evry_Plugin *p;
Eina_List *l;
Evry_Selector *sel = E_NEW(Evry_Selector, 1);
Evas_Object *o = edje_object_add(win->popup->evas);
sel->o_main = o;
e_theme_edje_object_set(o, "base/theme/everything",
"e/widgets/everything/selector_item");
evas_object_show(o);
if (type == type_subject)
edje_object_part_swallow(win->o_main, "e.swallow.subject_selector", o);
else if (type == type_action)
edje_object_part_swallow(win->o_main, "e.swallow.action_selector", o);
else if (type == type_object)
edje_object_part_swallow(win->o_main, "e.swallow.object_selector", o);
p = _evry_plug_aggregator_new();
p->private = sel;
sel->plugins = eina_list_append(sel->plugins, p);
sel->aggregator = p;
EINA_LIST_FOREACH(evry_conf->plugins, l, p)
{
if (!p->config->enabled) continue;
if (p->type != type) continue;
sel->plugins = eina_list_append(sel->plugins, p);
}
if (type == type_action)
sel->plugins = eina_list_append(sel->plugins, action_selector);
return sel;
}
static void
_evry_selector_free(Evry_Selector *sel)
{
Evry_Plugin *p;
if (sel->o_icon)
evas_object_del(sel->o_icon);
evas_object_del(sel->o_main);
if (list->visible && (sel == selector))
_evry_list_clear_list(sel->state);
while (sel->states)
_evry_state_pop(sel);
EINA_LIST_FREE(sel->plugins, p)
{
if (p->tab) evas_object_del(p->tab);
p->tab = NULL;
}
_evry_plug_aggregator_free(sel->aggregator);
if (sel->plugins) eina_list_free(sel->plugins);
E_FREE(sel);
}
static void
_evry_selector_activate(Evry_Selector *sel)
{
if (selector)
{
Evry_Plugin *p;
Eina_List *l;
edje_object_signal_emit(selector->o_main, "e,state,unselected", "e");
edje_object_part_text_set(selector->o_main, "e.text.plugin", "");
EINA_LIST_FOREACH(selector->plugins, l, p)
{
e_box_unpack(p->tab);
evas_object_del(p->tab);
p->tab = NULL;
}
_evry_list_win_hide();
}
selector = sel;
edje_object_signal_emit(sel->o_main, "e,state,selected", "e");
if (sel->state)
{
_evry_update_text_label(sel->state);
if (sel->state->sel_item)
edje_object_part_text_set(sel->o_main, "e.text.plugin",
sel->state->sel_item->plugin->name);
if (list->visible && sel->state->plugin)
{
_evry_list_tabs_update(sel->state);
_evry_list_show_items(sel->state, sel->state->plugin);
}
}
}
static void
_evry_selector_icon_set(Evry_Selector *sel)
{
Evry_State *s = sel->state;
Evry_Item *it;
Evas_Object *o;
if (!edje_object_part_exists(sel->o_main, "e.swallow.icons")) return;
if (sel->o_icon)
{
evas_object_del(sel->o_icon);
sel->o_icon = NULL;
}
if (!s) return;
it = s->sel_item;
if (it && it->plugin && it->plugin->icon_get)
{
o = it->plugin->icon_get(it->plugin, it, win->popup->evas);
if (o)
{
edje_object_part_swallow(sel->o_main, "e.swallow.icons", o);
evas_object_show(o);
sel->o_icon = o;
}
}
else if (s->plugin && s->plugin->icon)
{
o = e_icon_add(win->popup->evas);
evry_icon_theme_set(o, s->plugin->icon);
edje_object_part_swallow(sel->o_main, "e.swallow.icons", o);
evas_object_show(o);
sel->o_icon = o;
}
}
static void
_evry_selector_update(Evry_Selector *sel)
{
Evry_State *s = sel->state;
Evry_Item *it = NULL;
if (s)
{
it = s->sel_item;
if (!s->plugin && it)
_evry_list_item_desel(s, NULL);
else if (it && !eina_list_data_find_list(s->plugin->items, it))
_evry_list_item_desel(s, NULL);
it = s->sel_item;
if (s->plugin && (!it || s->item_auto_selected))
{
/* get first item */
if (s->plugin->items)
{
it = s->plugin->items->data;
s->item_auto_selected = EINA_TRUE;
_evry_list_item_sel(s, it);
}
}
}
_evry_selector_icon_set(sel);
if (it)
{
edje_object_part_text_set(sel->o_main, "e.text.label", it->label);
if (sel == selector)
edje_object_part_text_set(sel->o_main, "e.text.plugin", it->plugin->name);
else
edje_object_part_text_set(sel->o_main, "e.text.plugin", "");
}
else
{
/* no items for this state - clear selector */
edje_object_part_text_set(sel->o_main, "e.text.label", "");
if (sel == selector && s && s->plugin)
edje_object_part_text_set(sel->o_main, "e.text.plugin", s->plugin->name);
else
edje_object_part_text_set(sel->o_main, "e.text.plugin", "");
}
if (sel == selectors[0])
{
_evry_selector_actions_get(it);
_evry_selector_update(selectors[1]);
}
}
static void
_evry_list_update(Evry_State *s)
{
if (!list->visible) return;
_evry_list_clear_list(s);
_evry_list_tabs_update(s);
if (!s->plugin) return;
_evry_list_show_items(s, s->plugin);
_evry_list_scroll_to(s, s->sel_item);
}
static int
_evry_selector_subjects_get(void)
{
Eina_List *l, *plugins = NULL;
Evry_Plugin *p;
Evry_Selector *sel = selectors[0];
EINA_LIST_FOREACH(sel->plugins, l, p)
{
if (p->begin)
{
if (p->begin(p, NULL))
plugins = eina_list_append(plugins, p);
}
else
plugins = eina_list_append(plugins, p);
}
if (!plugins) return 0;
_evry_state_new(sel, plugins);
_evry_matches_update(sel);
return 1;
}
static int
_evry_selector_actions_get(Evry_Item *it)
{
Eina_List *l, *plugins = NULL;
Evry_Plugin *p;
Evry_Selector *sel = selectors[1];
while (sel->state)
_evry_state_pop(sel);
if (!it) return 0;
EINA_LIST_FOREACH(sel->plugins, l, p)
{
if (strcmp(p->type_in, it->plugin->type_out) &&
(p != action_selector) &&
(p != sel->aggregator)) continue;
if (p->begin)
{
if (p->begin(p, it))
plugins = eina_list_append(plugins, p);
}
else
plugins = eina_list_append(plugins, p);
}
if (!plugins) return 0;
_evry_state_new(sel, plugins);
_evry_matches_update(sel);
return 1;
}
static int
_evry_selector_objects_get(const char *type)
{
Eina_List *l, *plugins = NULL;
Evry_Plugin *p;
Evry_Selector *sel = selectors[2];
Evry_Item *it;
while (sel->state)
_evry_state_pop(sel);
it = selectors[0]->state->sel_item;
EINA_LIST_FOREACH(sel->plugins, l, p)
{
if (strcmp(p->type_out, type) &&
(p != sel->aggregator)) continue;
if (p->begin)
{
if (p->begin(p, it))
plugins = eina_list_append(plugins, p);
}
else
plugins = eina_list_append(plugins, p);
}
if (!plugins) return 0;
_evry_state_new(sel, plugins);
_evry_matches_update(sel);
return 1;
}
static Evry_State *
_evry_state_new(Evry_Selector *sel, Eina_List *plugins)
{
Evry_State *s = E_NEW(Evry_State, 1);
s->input = malloc(INPUTLEN);
s->input[0] = 0;
s->plugins = plugins;
sel->states = eina_list_prepend(sel->states, s);
sel->state = s;
return s;
}
static void
_evry_state_pop(Evry_Selector *sel)
{
Evry_Plugin *p;
Evry_State *s;
s = sel->state;
_evry_list_item_desel(s, NULL);
free(s->input);
EINA_LIST_FREE(s->plugins, p)
p->cleanup(p);
E_FREE(s);
sel->states = eina_list_remove_list(sel->states, sel->states);
if (sel->states)
sel->state = sel->states->data;
else
sel->state = NULL;
}
static void
_evry_browse_item(Evry_Selector *sel)
{
Evry_State *s = sel->state;
Evry_Item *it;
Eina_List *l, *plugins = NULL;
Evry_Plugin *p;
it = s->sel_item;
if (!it || !it->browseable) return;
_evry_list_clear_list(sel->state);
EINA_LIST_FOREACH(sel->plugins, l, p)
{
if (!p->browse) continue;
if (!strstr(p->type_in, it->plugin->type_out)) continue;
if (p->browse(p, it))
plugins = eina_list_append(plugins, p);
}
if (plugins)
{
_evry_list_win_show();
_evry_state_new(sel, plugins);
_evry_matches_update(sel);
_evry_selector_update(sel);
}
_evry_list_update(sel->state);
_evry_update_text_label(sel->state);
}
static void
_evry_browse_back(Evry_Selector *sel)
{
Evry_State *s = sel->state;
if (!s || !sel->states->next) return;
_evry_list_clear_list(s);
_evry_state_pop(sel);
sel->aggregator->fetch(sel->aggregator, sel->state->input);
_evry_selector_update(sel);
_evry_list_update(sel->state);
_evry_update_text_label(sel->state);
}
static void
_evry_selectors_switch(void)
{
Evry_State *s = selector->state;
if (update_timer)
{
if ((s && !s->plugin->async_query) &&
((selector == selectors[0]) ||
(selector == selectors[1])))
{
_evry_list_clear_list(s);
_evry_matches_update(selector);
_evry_selector_update(selector);
}
ecore_timer_del(update_timer);
update_timer = NULL;
}
if (selector == selectors[0])
{
if (s->sel_item)
_evry_selector_activate(selectors[1]);
}
else if (selector == selectors[1])
{
int next_selector = 0;
if (s->sel_item && s->sel_item->plugin == action_selector)
{
Evry_Action *act = s->sel_item->data[0];
if (act && act->type_in2)
{
_evry_selector_objects_get(act->type_in2);
_evry_selector_update(selectors[2]);
edje_object_signal_emit(win->o_main,
"e,state,object_selector_show", "e");
next_selector = 2;
}
}
_evry_selector_activate(selectors[next_selector]);
}
else if (selector == selectors[2])
{
_evry_list_clear_list(s);
while (selector->states)
_evry_state_pop(selector);
edje_object_signal_emit(win->o_main,
"e,state,object_selector_hide", "e");
_evry_selector_activate(selectors[0]);
}
}
static int
_evry_cb_key_down(void *data __UNUSED__, int type __UNUSED__, void *event)
{
Ecore_Event_Key *ev;
Evry_State *s = selector->state;
/* ev_last_is_mouse = 0;
* item_mouseover = NULL; */
win->request_selection = EINA_FALSE;
ev = event;
if (ev->event_window != input_window) return 1;
if (!strcmp(ev->key, "Up"))
_evry_list_item_prev(s);
else if (!strcmp(ev->key, "Down"))
_evry_list_item_next(s);
else if (!strcmp(ev->key, "Right") &&
((ev->modifiers & ECORE_EVENT_MODIFIER_CTRL) ||
(ev->modifiers & ECORE_EVENT_MODIFIER_SHIFT)))
_evry_list_plugin_next(s);
else if (!strcmp(ev->key, "Left") &&
((ev->modifiers & ECORE_EVENT_MODIFIER_CTRL) ||
(ev->modifiers & ECORE_EVENT_MODIFIER_SHIFT)))
_evry_list_plugin_prev(s);
else if (!strcmp(ev->key, "Right"))
_evry_browse_item(selector);
else if (!strcmp(ev->key, "Left"))
_evry_browse_back(selector);
else if ((!strcmp(ev->key, "Return")) &&
((ev->modifiers & ECORE_EVENT_MODIFIER_CTRL) ||
(ev->modifiers & ECORE_EVENT_MODIFIER_SHIFT)))
_evry_plugin_action(selector, 0);
else if (!strcmp(ev->key, "Return"))
_evry_plugin_action(selector, 1);
else if (!strcmp(ev->key, "Tab") &&
((ev->modifiers & ECORE_EVENT_MODIFIER_ALT) ||
(ev->modifiers & ECORE_EVENT_MODIFIER_CTRL)))
_evry_list_plugin_next(s);
else if (!strcmp(ev->key, "Tab"))
_evry_selectors_switch();
else if (!strcmp(ev->key, "u") &&
(ev->modifiers & ECORE_EVENT_MODIFIER_CTRL))
_evry_clear(s);
else if ((!strcmp(ev->key, "Escape")) ||
(!strcmp(ev->key, "e") &&
(ev->modifiers & ECORE_EVENT_MODIFIER_CTRL)))
evry_hide();
else if ((!strcmp(ev->key, "BackSpace")) ||
(!strcmp(ev->key, "Delete")))
_evry_backspace(s);
else if (!strcmp(ev->key, "End"))
_evry_list_item_last(s);
else if (!strcmp(ev->key, "Home"))
_evry_list_item_first(s);
else if (!strcmp(ev->key, "v") &&
(ev->modifiers & ECORE_EVENT_MODIFIER_CTRL))
{
win->request_selection = EINA_TRUE;
ecore_x_selection_primary_request(win->popup->evas_win,
ECORE_X_SELECTION_TARGET_UTF8_STRING);
}
else if ((ev->key) &&
(ev->modifiers & ECORE_EVENT_MODIFIER_CTRL))
_evry_list_plugin_next_by_name(s, ev->key);
else if ((ev->compose) &&
(!(ev->modifiers & ECORE_EVENT_MODIFIER_ALT) ||
(ev->modifiers & ECORE_EVENT_MODIFIER_WIN)))
{
if (strlen(s->input) < (INPUTLEN - strlen(ev->compose)))
{
strcat(s->input, ev->compose);
if (isspace(*ev->compose))
_evry_update(s, 0);
else
_evry_update(s, 1);
}
}
return 1;
}
static void
_evry_backspace(Evry_State *s)
{
int len, val, pos;
len = strlen(s->input);
if (len > 0)
{
pos = evas_string_char_prev_get(s->input, len, &val);
if ((pos < len) && (pos >= 0))
{
s->input[pos] = 0;
_evry_update(s, 1);
}
}
}
static void
_evry_update_text_label(Evry_State *s)
{
if (strlen(s->input) > 0)
edje_object_signal_emit(list->o_main, "e,state,entry_show", "e");
else
edje_object_signal_emit(list->o_main, "e,state,entry_hide", "e");
edje_object_part_text_set(win->o_main, "e.text.label", s->input);
edje_object_part_text_set(list->o_main, "e.text.label", s->input);
}
static void
_evry_update(Evry_State *s, int fetch)
{
_evry_update_text_label(s);
if (fetch)
{
if (update_timer) ecore_timer_del(update_timer);
update_timer = ecore_timer_add(MATCH_LAG, _evry_update_timer, s);
}
}
static int
_evry_update_timer(void *data)
{
/* XXX pass selector as data? */
_evry_matches_update(selector);
_evry_selector_update(selector);
_evry_list_update(selector->state);
_evry_list_tabs_update(selector->state);
update_timer = NULL;
return 0;
}
static void
_evry_clear(Evry_State *s)
{
if ((s->plugin && s->plugin->trigger && s->input) &&
(!strncmp(s->plugin->trigger, s->input, strlen(s->plugin->trigger))))
{
s->input[strlen(s->plugin->trigger)] = 0;
_evry_update(s, 1);
}
else if (s->input[0] != 0)
{
s->input[0] = 0;
_evry_update(s, 1);
edje_object_signal_emit(list->o_main, "e,state,entry_hide", "e");
}
}
static void
_evry_plugin_action(Evry_Selector *sel, int finished)
{
Evry_State *s_subject, *s_action, *s_object;
s_subject = selectors[0]->state;
s_action = selectors[1]->state;
s_object = NULL;
if (!s_subject || !s_action) return;
if (update_timer)
{
if ((selector->state->plugin) &&
(!selector->state->plugin->async_query))
{
_evry_matches_update(selector);
_evry_selector_update(selector);
}
ecore_timer_del(update_timer);
update_timer = NULL;
}
if (!s_subject->sel_item || !s_action->sel_item) return;
if (s_action->sel_item->plugin == action_selector)
{
Evry_Action *act = s_action->sel_item->data[0];
Evry_Item *it_object = NULL;
if (selectors[2] == selector) /* && selector->state ? */
it_object = selector->state->sel_item;
if (act->type_in2 && !it_object) return;
act->action(act, s_subject->sel_item, it_object, NULL);
}
else
{
Evry_Item *it = s_action->sel_item;
s_action->plugin->action(s_action->plugin, it, selector->state->input);
}
if (s_subject->plugin->action)
s_subject->plugin->action(s_subject->plugin,
s_subject->sel_item,
s_subject->input);
if (s_object && s_object->plugin->action)
s_object->plugin->action(s_object->plugin,
s_object->sel_item,
s_object->input);
if (finished)
evry_hide();
}
static void
_evry_list_show_items(Evry_State *s, Evry_Plugin *p)
{
Evry_Item *it;
Eina_List *l;
int mw, mh, h;
Evas_Object *o;
if (!p) return;
if (p->realize_items) p->realize_items(p, list->popup->evas);
if (list->scroll_timer)
{
ecore_timer_del(list->scroll_timer);
list->scroll_timer = NULL;
}
if (list->scroll_animator)
{
ecore_animator_del(list->scroll_animator);
list->scroll_animator = NULL;
}
if (!list->visible) return;
list->scroll_align = 0;
evas_event_freeze(list->popup->evas);
e_box_freeze(list->o_list);
EINA_LIST_FOREACH(p->items, l, it)
{
o = it->o_bg;
if (!o)
{
o = edje_object_add(list->popup->evas);
it->o_bg = o;
e_theme_edje_object_set(o, "base/theme/everything",
"e/widgets/everything/item");
edje_object_part_text_set(o, "e.text.title", it->label);
/* evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_IN,
* _evry_cb_item_mouse_in, it);
* evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_OUT,
* _evry_cb_item_mouse_out, it); */
}
edje_object_size_min_calc(o, &mw, &mh);
e_box_pack_end(list->o_list, o);
e_box_pack_options_set(o, 1, 1, 1, 0, 0.5, 0.5, mw, mh, 9999, mh);
evas_object_show(o);
if (it->o_icon && edje_object_part_exists(o, "e.swallow.icons"))
{
edje_object_part_swallow(o, "e.swallow.icons", it->o_icon);
evas_object_show(it->o_icon);
}
if (it == s->sel_item)
{
edje_object_signal_emit(it->o_bg, "e,state,selected", "e");
if (it->o_icon)
edje_object_signal_emit(it->o_icon, "e,state,selected", "e");
if (it->browseable)
edje_object_signal_emit(it->o_bg, "e,state,arrow_show", "e");
}
_evry_item_ref(it);
s->items = eina_list_append(s->items, it);
}
e_box_thaw(list->o_list);
list->item_idler = ecore_idler_add(_evry_list_item_idler, p);
e_box_min_size_get(list->o_list, NULL, &mh);
evas_object_geometry_get(list->o_list, NULL, NULL, NULL, &h);
if (mh <= h)
e_box_align_set(list->o_list, 0.5, 0.0);
else
e_box_align_set(list->o_list, 0.5, 1.0);
evas_event_thaw(list->popup->evas);
_evry_list_tab_scroll_to(s, p);
}
static void
_evry_list_clear_list(Evry_State *s)
{
Evry_Item *it;
if (list->item_idler)
{
ecore_idler_del(list->item_idler);
list->item_idler = NULL;
}
if (s && s->items)
{
evas_event_freeze(list->popup->evas);
e_box_freeze(list->o_list);
EINA_LIST_FREE(s->items, it)
{
if (it->o_bg)
{
e_box_unpack(it->o_bg);
evas_object_hide(it->o_bg);
}
if (it->o_icon)
evas_object_hide(it->o_icon);
evry_item_free(it);
}
}
e_box_thaw(list->o_list);
evas_event_thaw(list->popup->evas);
/* } */
}
static int
_evry_list_item_idler(void *data)
{
Evry_Plugin *p = data;
int cnt = 5;
Eina_List *l;
Evry_Item *it;
if (!list->item_idler) return 0;
if (!p->icon_get) goto end;
e_box_freeze(list->o_list);
EINA_LIST_FOREACH(p->items, l, it)
{
if (it->o_icon) continue;
it->o_icon = p->icon_get(p, it, list->popup->evas);
if (it->o_icon)
{
edje_object_part_swallow(it->o_bg, "e.swallow.icons", it->o_icon);
evas_object_show(it->o_icon);
cnt--;
}
if (cnt == 0) break;
}
e_box_thaw(list->o_list);
if (cnt == 0) return 1;
end:
list->item_idler = NULL;
return 0;
}
static void
_evry_matches_update(Evry_Selector *sel)
{
Evry_State *s = sel->state;
Evry_Plugin *p;
Eina_List *l;
Eina_Bool has_items = EINA_FALSE;
EINA_LIST_FREE(s->cur_plugins, p);
if (s->input)
{
EINA_LIST_FOREACH(s->plugins, l, p)
{
/* input matches plugin trigger? */
if (!p->trigger) continue;
if ((strlen(s->input) >= strlen(p->trigger)) &&
(!strncmp(s->input, p->trigger, strlen(p->trigger))))
{
s->cur_plugins = eina_list_append(s->cur_plugins, p);
p->fetch(p, s->input);
break;
}
}
}
if (!s->cur_plugins)
{
EINA_LIST_FOREACH(s->plugins, l, p)
{
if (p->trigger) continue;
if (p == sel->aggregator) continue;
if (strlen(s->input) == 0)
{
if (!p->need_query)
has_items = p->fetch(p, NULL);
}
else
{
has_items = p->fetch(p, s->input);
}
if (has_items || sel->states->next)
s->cur_plugins = eina_list_append(s->cur_plugins, p);
}
if (eina_list_count(s->cur_plugins) > 1)
{
sel->aggregator->fetch(sel->aggregator, s->input);
s->cur_plugins = eina_list_prepend(s->cur_plugins, sel->aggregator);
}
else
sel->aggregator->cleanup(sel->aggregator);
}
if (s->plugin && !eina_list_data_find_list(s->cur_plugins, s->plugin))
s->plugin = NULL;
_evry_select_plugin(s, s->plugin);
}
static void
_evry_list_scroll_to(Evry_State *s, Evry_Item *it)
{
int n, h, mh, i = 0;
Eina_List *l;
if (!it) return;
for(l = s->plugin->items; l; l = l->next, i++)
if (l->data == it) break;
n = eina_list_count(s->plugin->items);
e_box_min_size_get(list->o_list, NULL, &mh);
evas_object_geometry_get(list->o_list, NULL, NULL, NULL, &h);
/* edje_object_part_geometry_get(list->o_main, "e.swallow.list", NULL, NULL, &max_w, &max_h); */
/* printf("MAX %d %d %d\n", max_h, h, mh);
* if (max_h != h)
* evas_object_resize(list->o_list, max_w, max_h); */
if (i >= n || mh <= h)
{
e_box_align_set(list->o_list, 0.5, 0.0);
return;
}
if (n > 1)
{
list->scroll_align_to = (double)i / (double)(n - 1);
if (evry_conf->scroll_animate)
{
if (!list->scroll_timer)
list->scroll_timer = ecore_timer_add(0.01, _evry_list_scroll_timer, NULL);
if (!list->scroll_animator)
list->scroll_animator = ecore_animator_add(_evry_list_animator, NULL);
}
else
{
list->scroll_align = list->scroll_align_to;
e_box_align_set(list->o_list, 0.5, 1.0 - list->scroll_align);
}
}
else
e_box_align_set(list->o_list, 0.5, 1.0);
}
static void
_evry_list_tab_scroll_to(Evry_State *s, Evry_Plugin *p)
{
int n, w, mw, i;
double align;
Eina_List *l;
for(i = 0, l = s->cur_plugins; l; l = l->next, i++)
if (l->data == p) break;
n = eina_list_count(s->cur_plugins);
e_box_min_size_get(list->o_tabs, &mw, NULL);
evas_object_geometry_get(list->o_tabs, NULL, NULL, &w, NULL);
if (mw <= w)
{
e_box_align_set(list->o_tabs, 0.0, 0.5);
return;
}
if (n > 1)
{
align = (double)i / (double)(n - 1);
/* if (evry_conf->scroll_animate)
* {
* if (!scroll_timer)
* scroll_timer = ecore_timer_add(0.01, _evry_list_scroll_timer, NULL);
* if (!scroll_animator)
* scroll_animator = ecore_animator_add(_evry_list_animator, NULL);
* }
* else */
{
e_box_align_set(list->o_tabs, 1.0 - align, 0.5);
}
}
else
e_box_align_set(list->o_tabs, 1.0, 0.5);
}
static void
_evry_list_item_desel(Evry_State *s, Evry_Item *it)
{
if (s->sel_item)
{
it = s->sel_item;
if (list->visible)
{
if (it->o_bg)
edje_object_signal_emit(it->o_bg, "e,state,unselected", "e");
if (it->o_icon)
edje_object_signal_emit(it->o_icon, "e,state,unselected", "e");
}
evry_item_free(it);
s->sel_item = NULL;
}
}
static void
_evry_list_item_sel(Evry_State *s, Evry_Item *it)
{
if (s->sel_item == it) return;
_evry_list_item_desel(s, NULL);
if (list->visible)
{
if (it->o_bg)
edje_object_signal_emit(it->o_bg, "e,state,selected", "e");
if (it->o_icon)
edje_object_signal_emit(it->o_icon, "e,state,selected", "e");
if (it->browseable)
edje_object_signal_emit(it->o_bg, "e,state,arrow_show", "e");
if (s == selector->state)
_evry_list_scroll_to(s, it);
}
_evry_item_ref(it);
s->sel_item = it;
}
static void
_evry_list_item_next(Evry_State *s)
{
Eina_List *l;
Evry_Item *it;
if (!s->plugin || !s->plugin->items) return;
if (!list->visible)
{
_evry_list_win_show();
return;
}
s->plugin_auto_selected = EINA_FALSE;
s->item_auto_selected = EINA_FALSE;
if (!s->sel_item)
{
_evry_list_item_sel(s, s->plugin->items->data);
_evry_selector_update(selector);
return;
}
EINA_LIST_FOREACH (s->plugin->items, l, it)
{
if (it == s->sel_item)
{
if (l->next)
{
_evry_list_item_sel(s, l->next->data);
_evry_selector_update(selector);
}
break;
}
}
}
static void
_evry_list_item_prev(Evry_State *s)
{
Eina_List *l;
Evry_Item *it;
if (!s->plugin || !s->plugin->items) return;
s->plugin_auto_selected = EINA_FALSE;
s->item_auto_selected = EINA_FALSE;
if (!s->sel_item) return;
EINA_LIST_FOREACH (s->plugin->items, l, it)
{
if (it == s->sel_item)
{
if (l->prev)
{
_evry_list_item_sel(s, l->prev->data);
_evry_selector_update(selector);
return;
}
break;
}
}
_evry_list_win_hide();
}
static void
_evry_list_item_first(Evry_State *s)
{
if (!s->plugin || !s->plugin->items) return;
s->plugin_auto_selected = EINA_FALSE;
s->item_auto_selected = EINA_FALSE;
_evry_list_item_sel(s, s->plugin->items->data);
_evry_selector_update(selector);
}
static void
_evry_list_item_last(Evry_State *s)
{
if (!s->plugin || !s->plugin->items) return;
s->plugin_auto_selected = EINA_FALSE;
s->item_auto_selected = EINA_FALSE;
_evry_list_item_sel(s, eina_list_last(s->plugin->items)->data);
_evry_selector_update(selector);
}
static void
_evry_select_plugin(Evry_State *s, Evry_Plugin *p)
{
if (!s || !s->cur_plugins) return;
if (!p && s->cur_plugins)
{
p = s->cur_plugins->data;
s->plugin_auto_selected = EINA_TRUE;
}
if (p && list->visible)
{
if (s->plugin && s->plugin != p)
edje_object_signal_emit(s->plugin->tab, "e,state,unselected", "e");
edje_object_signal_emit(p->tab, "e,state,selected", "e");
}
if ((p || !s->plugin) && s->plugin != p)
{
_evry_list_item_desel(s, NULL);
s->plugin = p;
}
}
static void
_evry_list_plugin_next(Evry_State *s)
{
Eina_List *l;
Evry_Plugin *p = NULL;
if (!s->plugin) return;
/* _evry_list_win_show(); */
l = eina_list_data_find_list(s->cur_plugins, s->plugin);
if (l && l->next)
p = l->next->data;
else if (s->plugin != s->cur_plugins->data)
p = s->cur_plugins->data;
if (p)
{
s->plugin_auto_selected = EINA_FALSE;
_evry_list_clear_list(s);
_evry_select_plugin(s, p);
_evry_list_show_items(s, p);
_evry_selector_update(selector);
}
}
static void
_evry_list_plugin_next_by_name(Evry_State *s, const char *key)
{
Eina_List *l;
Evry_Plugin *p, *first = NULL, *next = NULL;
int found = 0;
if (!s->plugin) return;
EINA_LIST_FOREACH(s->cur_plugins, l, p)
{
if (p->name && (!strncasecmp(p->name, key, 1)))
{
if (!first) first = p;
if (found && !next)
next = p;
}
if (p == s->plugin) found = 1;
}
if (next)
p = next;
else if (first != s->plugin)
p = first;
else
p = NULL;
if (p)
{
s->plugin_auto_selected = EINA_FALSE;
_evry_list_clear_list(s);
_evry_select_plugin(s, p);
_evry_list_show_items(s, p);
_evry_selector_update(selector);
}
}
static void
_evry_list_plugin_prev(Evry_State *s)
{
Eina_List *l;
Evry_Plugin *p = NULL;
if (!s->plugin) return;
/* _evry_list_win_show(); */
l = eina_list_data_find_list(s->cur_plugins, s->plugin);
if (l && l->prev)
p = l->prev->data;
else
{
l = eina_list_last(s->cur_plugins);
if (s->plugin != l->data)
p = l->data;
}
if (p)
{
s->plugin_auto_selected = EINA_FALSE;
_evry_list_clear_list(s);
_evry_select_plugin(s, p);
_evry_list_show_items(s, p);
_evry_selector_update(selector);
}
}
static int
_evry_list_scroll_timer(void *data __UNUSED__)
{
if (list->scroll_animator)
{
double spd;
spd = evry_conf->scroll_speed;
list->scroll_align = (list->scroll_align * (1.0 - spd)) +
(list->scroll_align_to * spd);
return 1;
}
list->scroll_timer = NULL;
return 0;
}
static int
_evry_list_animator(void *data __UNUSED__)
{
double da;
Eina_Bool scroll_to = 1;
da = list->scroll_align - list->scroll_align_to;
if (da < 0.0) da = -da;
if (da < 0.01)
{
list->scroll_align = list->scroll_align_to;
scroll_to = 0;
}
e_box_align_set(list->o_list, 0.5, 1.0 - list->scroll_align);
if (scroll_to) return 1;
list->scroll_animator = NULL;
return 0;
}
static void
_evry_list_tabs_update(Evry_State *s)
{
Eina_List *l;
Evry_Plugin *p;
/* remove tabs for not active plugins */
EINA_LIST_FOREACH(selector->plugins, l, p)
{
if (p->tab && !eina_list_data_find(s->cur_plugins, p))
{
e_box_unpack(p->tab);
evas_object_del(p->tab);
p->tab = NULL;
}
}
/* show/update tabs of active plugins */
EINA_LIST_FOREACH(s->cur_plugins, l, p)
{
_evry_list_tab_show(s, p);
if (s->plugin == p)
edje_object_signal_emit(p->tab, "e,state,selected", "e");
else
edje_object_signal_emit(p->tab, "e,state,unselected", "e");
}
}
static void
_evry_list_tab_show(Evry_State *s, Evry_Plugin *p)
{
Evas_Object *o;
Evas_Coord mw = 0, mh = 0;
char buf[64];
Eina_List *l;
e_box_freeze(list->o_tabs);
if (p->tab)
{
o = p->tab;
e_box_unpack(p->tab);
}
else
{
o = edje_object_add(list->popup->evas);
e_theme_edje_object_set(o, "base/theme/everything",
"e/widgets/everything/tab_item");
}
snprintf(buf, 64, "%s (%d)", p->name, eina_list_count(p->items));
edje_object_part_text_set(o, "e.text.label", buf);
edje_object_size_min_calc(o, &mw, &mh);
l = eina_list_data_find_list(s->cur_plugins, p);
if (l && l->prev)
{
Evry_Plugin *p2 = l->prev->data;
e_box_pack_after(list->o_tabs, o, p2->tab);
}
else
e_box_pack_end(list->o_tabs, o);
evas_object_show(o);
e_box_pack_options_set(o, 1, 1, 0, 0, 0.5, 0.5, mw, mh, 9999, 9999);
e_box_thaw(list->o_tabs);
p->tab = o;
}
static int
_evry_fuzzy_sort_cb(const void *data1, const void *data2)
{
const Evry_Item *it1 = data1;
const Evry_Item *it2 = data2;
if ((it1->plugin == it2->plugin) &&
(it1->priority - it2->priority))
return (it1->priority - it2->priority);
if (it1->fuzzy_match && !it2->fuzzy_match)
return -1;
if (!it1->fuzzy_match && it2->fuzzy_match)
return 1;
if (it1->fuzzy_match - it2->fuzzy_match)
return (it1->fuzzy_match - it2->fuzzy_match);
if (it1->plugin->config->priority - it2->plugin->config->priority)
return (it1->plugin->config->priority - it2->plugin->config->priority);
return (it1->priority - it2->priority);
}
/* action selector plugin: provides list of actions registered for
candidate types provided by current plugin */
static int
_evry_plug_actions_init(void)
{
Plugin_Config *pc;
Evry_Plugin *p = E_NEW(Evry_Plugin, 1);
p->name = "Select Action";
p->type = type_action;
p->type_in = "ANY";
p->type_out = "NONE";
p->begin = &_evry_plug_actions_begin;
p->cleanup = &_evry_plug_actions_cleanup;
p->fetch = &_evry_plug_actions_fetch;
p->icon_get = &_evry_plug_actions_item_icon_get;
pc = E_NEW(Plugin_Config, 1);
pc->name = eina_stringshare_add(p->name);
pc->enabled = 1;
pc->priority = 1;
p->config = pc;
action_selector = p;
return 1;
}
static void
_evry_plug_actions_free(void)
{
Evry_Plugin *p = action_selector;
eina_stringshare_del(p->config->name);
E_FREE(p->config);
E_FREE(p);
}
static int
_evry_plug_actions_begin(Evry_Plugin *p, const Evry_Item *it)
{
Evry_Action *act;
Eina_List *l;
Evry_Selector *sel = selectors[1];
_evry_plug_actions_cleanup(p);
if (!it) return 0;
const char *type = it->plugin->type_out;
EINA_LIST_FOREACH(evry_conf->actions, l, act)
{
if ((strstr(act->type_in1, type)) &&
(!act->check_item || act->check_item(act, it)))
{
sel->actions = eina_list_append(sel->actions, act);
}
}
if (sel->actions) return 1;
return 0;
}
static int
_evry_plug_actions_fetch(Evry_Plugin *p, const char *input)
{
Evry_Action *act;
Eina_List *l;
Evry_Item *it;
Evry_Selector *sel = selectors[1];
int match = 0;
EINA_LIST_FREE(p->items, it)
evry_item_free(it);
EINA_LIST_FOREACH(sel->actions, l, act)
{
if (input)
match = evry_fuzzy_match(act->name, input);
if (!input || match)
{
it = evry_item_new(p, act->name, NULL);
it->fuzzy_match = match;
it->data[0] = act;
p->items = eina_list_append(p->items, it);
}
}
if (input)
p->items = eina_list_sort(p->items, eina_list_count(p->items), _evry_fuzzy_sort_cb);
if (p->items) return 1;
return 0;
}
static void
_evry_plug_actions_cleanup(Evry_Plugin *p)
{
Evry_Item *it;
Evry_Selector *sel = selectors[1];
EINA_LIST_FREE(p->items, it)
evry_item_free(it);
if (sel->actions) eina_list_free(sel->actions);
sel->actions = NULL;
}
static Evas_Object *
_evry_plug_actions_item_icon_get(Evry_Plugin *p __UNUSED__, const Evry_Item *it, Evas *e)
{
Evas_Object *o = NULL;
Evry_Action *act = it->data[0];
if (!act) return NULL;
if (act->icon_get)
o = act->icon_get(act, e);
else if (act->icon)
{
o = e_icon_add(e);
evry_icon_theme_set(o, act->icon);
}
return o;
}
static Evry_Plugin *
_evry_plug_aggregator_new(void)
{
Plugin_Config *pc;
Evry_Plugin *p = E_NEW(Evry_Plugin, 1);
p->name = "All";
p->type_in = "NONE";
p->type_out = "NONE";
p->cleanup = &_evry_plug_aggregator_cleanup;
p->fetch = &_evry_plug_aggregator_fetch;
p->action = &_evry_plug_aggregator_action;
p->icon_get = &_evry_plug_aggregator_item_icon_get;
pc = E_NEW(Plugin_Config, 1);
pc->name = eina_stringshare_add(p->name);
pc->enabled = 1;
pc->priority = -1;
p->config = pc;
return p;
}
static void
_evry_plug_aggregator_free(Evry_Plugin *p)
{
if (p->config->name) eina_stringshare_del(p->config->name);
E_FREE(p->config);
E_FREE(p);
}
static int
_evry_plug_aggregator_fetch(Evry_Plugin *p, const char *input)
{
Evry_Selector *selector = p->private;
Evry_State *s = selector->state;
Eina_List *l, *ll;
Evry_Plugin *plugin;
Evry_Item *it;
int cnt = 0;
Eina_List *items = NULL;
EINA_LIST_FREE(p->items, it)
evry_item_free(it);
EINA_LIST_FOREACH(s->cur_plugins, l, plugin)
cnt += eina_list_count(plugin->items);
if (input[0])
{
EINA_LIST_FOREACH(s->cur_plugins, l, plugin)
{
EINA_LIST_FOREACH(plugin->items, ll, it)
{
if (!it->fuzzy_match)
it->fuzzy_match = evry_fuzzy_match(it->label, input);
if (it->fuzzy_match)
{
_evry_item_ref(it);
items = eina_list_append(items, it);
p->items = eina_list_append(p->items, it);
}
}
}
}
if (!input[0] || eina_list_count(items) < 20)
{
EINA_LIST_FOREACH(s->cur_plugins, l, plugin)
{
for (cnt = 0, ll = plugin->items; ll && cnt < 15; ll = ll->next, cnt++)
{
if (!items || !eina_list_data_find_list(items, ll->data))
{
it = ll->data;
_evry_item_ref(it);
it->fuzzy_match = 0;
p->items = eina_list_append(p->items, it);
}
}
}
}
eina_list_free(items);
if (input[0])
p->items = eina_list_sort(p->items, eina_list_count(p->items), _evry_fuzzy_sort_cb);
return 1;
}
static int
_evry_plug_aggregator_action(Evry_Plugin *p, const Evry_Item *it, const char *input)
{
if (it->plugin && it->plugin->action)
return it->plugin->action(it->plugin, it, input);
return 0;
}
static void
_evry_plug_aggregator_cleanup(Evry_Plugin *p)
{
Evry_Item *it;
EINA_LIST_FREE(p->items, it)
evry_item_free(it);
}
static Evas_Object *
_evry_plug_aggregator_item_icon_get(Evry_Plugin *p, const Evry_Item *it, Evas *e)
{
if (it->plugin && it->plugin->icon_get)
return it->plugin->icon_get(it->plugin, it, e);
return NULL;
}
static void
_evry_plugin_list_insert(Evry_State *s, Evry_Plugin *p)
{
Eina_List *l;
Evry_Plugin *plugin;
EINA_LIST_FOREACH(s->cur_plugins, l, plugin)
if (p == plugin)
return;
else
if (p->config->priority < plugin->config->priority)
break;
if (l)
s->cur_plugins = eina_list_prepend_relative_list(s->cur_plugins, p, l);
else
s->cur_plugins = eina_list_append(s->cur_plugins, p);
}
/* taken from e_utils. just changed 48 to 72.. we need
evry_icon_theme_set(Evas_Object *obj, const char *icon,
size:small, mid, large) imo */
static int
_evry_icon_theme_set(Evas_Object *obj, const char *icon)
{
const char *file;
char buf[4096];
if ((!icon) || (!icon[0])) return 0;
snprintf(buf, sizeof(buf), "e/icons/%s", icon);
file = e_theme_edje_file_get("base/theme/icons", buf);
if (file[0])
{
e_icon_file_edje_set(obj, file, buf);
return 1;
}
return 0;
}
static int
_evry_icon_fdo_set(Evas_Object *obj, const char *icon)
{
char *path = NULL;
unsigned int size;
if ((!icon) || (!icon[0])) return 0;
size = e_util_icon_size_normalize(72 * e_scale);
path = efreet_icon_path_find(e_config->icon_theme, icon, size);
if (!path) return 0;
e_icon_file_set(obj, path);
E_FREE(path);
return 1;
}
EAPI int
evry_icon_theme_set(Evas_Object *obj, const char *icon)
{
if (e_config->icon_theme_overrides)
{
if (_evry_icon_fdo_set(obj, icon))
return 1;
return _evry_icon_theme_set(obj, icon);
}
else
{
if (_evry_icon_theme_set(obj, icon))
return 1;
return _evry_icon_fdo_set(obj, icon);
}
}
static int
_evry_cb_selection_notify(void *data, int type, void *event)
{
Ecore_X_Event_Selection_Notify *ev;
Evry_State *s = selector->state;
if (!s || (data != win)) return 1;
if (!win->request_selection) return 1;
win->request_selection = EINA_FALSE;
ev = event;
if ((ev->selection == ECORE_X_SELECTION_CLIPBOARD) ||
(ev->selection == ECORE_X_SELECTION_PRIMARY))
{
if (strcmp(ev->target, ECORE_X_SELECTION_TARGET_UTF8_STRING) == 0)
{
Ecore_X_Selection_Data_Text *text_data;
text_data = ev->data;
strncat(s->input, text_data->text, (INPUTLEN - strlen(s->input)) - 1);
_evry_update(s, 1);
}
}
return 1;
}
/* static int
* _evry_cb_mouse_down(void *data __UNUSED__, int type __UNUSED__, void *event)
* {
* Ecore_Event_Mouse_Button *ev;
* Evry_State *s =state;
*
* ev = event;
* if (ev->event_window != input_window) return 1;
*
* if (item_mouseover)
* {
* if (s->sel_item != item_mouseover)
* {
* if (s->sel_item) _evry_list_item_desel(s->sel_item);
* s->sel_item = item_mouseover;
* _evry_list_item_sel(s->sel_item);
* }
* }
* else
* {
* evas_event_feed_mouse_up(popup_list->evas, ev->buttons, 0, ev->timestamp, NULL);
* }
*
* return 1;
* }
*
* static int
* _evry_cb_mouse_up(void *data __UNUSED__, int type __UNUSED__, void *event)
* {
* Ecore_Event_Mouse_Button *ev;
*
* ev = event;
* if (ev->event_window != input_window) return 1;
*
* if (item_mouseover)
* {
* if (ev->buttons == 1)
* _evry_plugin_action(1);
* else if (ev->buttons == 3)
* _evry_plugin_action(0);
* }
* else
* {
* evas_event_feed_mouse_up(popup_list->evas, ev->buttons, 0, ev->timestamp, NULL);
* }
*
* return 1;
* }
*
* static int
* _evry_cb_mouse_move(void *data __UNUSED__, int type __UNUSED__, void *event)
* {
* Ecore_Event_Mouse_Move *ev;
* Evry_State *s =state;
*
* ev = event;
* if (ev->event_window != input_window) return 1;
*
* if (!ev_last_is_mouse)
* {
* ev_last_is_mouse = 1;
* if (item_mouseover)
* {
* if (s->sel_item && (s->sel_item != item_mouseover))
* _evry_list_item_desel(s->sel_item);
* if (!s->sel_item || (s->sel_item != item_mouseover))
* {
* s->sel_item = item_mouseover;
* _evry_list_item_sel(s->sel_item);
* }
* }
* }
*
* evas_event_feed_mouse_move(popup_list->evas, ev->x - popup_list->x,
* ev->y - popup_list->y, ev->timestamp, NULL);
*
* return 1;
* }
*
* static int
* _evry_cb_mouse_wheel(void *data __UNUSED__, int type __UNUSED__, void *event)
* {
* Ecore_Event_Mouse_Wheel *ev;
*
* ev = event;
* if (ev->event_window != input_window) return 1;
*
* ev_last_is_mouse = 0;
*
* if (ev->z < 0) /\* up *\/
* {
* int i;
*
* for (i = ev->z; i < 0; i++) _evry_list_item_prev();
* }
* else if (ev->z > 0) /\* down *\/
* {
* int i;
*
* for (i = ev->z; i > 0; i--) _evry_list_item_next();
* }
* return 1;
* }
*
* static void
* _evry_cb_item_mouse_in(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
* {
* Evry_State *s =state;
*
* if (!ev_last_is_mouse) return;
*
* item_mouseover = data;
*
* if (s->sel_item) _evry_list_item_desel(s->sel_item);
* if (!(s->sel_item = data)) return;
* _evry_list_item_sel(s->sel_item);
* }
*
* static void
* _evry_cb_item_mouse_out(void *data __UNUSED__, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
* {
* item_mouseover = NULL;
* } */
/* static int
* _evry_cb_plugin_sort_by_trigger(const void *data1, const void *data2)
* {
* const Evry_Plugin *p1 = data1;
* const Evry_Plugin *p2 = data2;
* if (p1->trigger)
* {
* if (!strncmp(state->input, p1->trigger, strlen(p1->trigger)))
* return 1;
* }
*
* return p1->config->priority - p2->config->priority;
* } */
Reference in New Issue View Git Blame Copy Permalink