pkg_check_modules(pkgs REQUIRED
capi-appfw-application
bundle
- eldbus
- elementary
- ecore
atspi-2
gobject-2.0
- ecore-x
dlog
vconf
tts
#define FLAT_NAVI_H_
#include <atspi/atspi.h>
-#include <Eina.h>
typedef struct _FlatNaviContext FlatNaviContext;
*
* @return EINA_TRUE is operation successed, EINA_FALSE otherwise
*/
-Eina_Bool flat_navi_context_current_set(FlatNaviContext *ctx, AtspiAccessible *target);
+gboolean flat_navi_context_current_set(FlatNaviContext *ctx, AtspiAccessible *target);
/**
* Advances to previous line in natural reading order and returns
#define SMART_NAVI_POSITION_SORT_H_
#include <atspi/atspi.h>
-#include <Eina.h>
+#include <glib.h>
/**
*
* @ret list List of lists
*/
-Eina_List *position_sort(const Eina_List *obj);
+GList *position_sort(const GList *obj);
#endif /* end of include guard: POSITION_SORT_H_ */
#define __screen_reader_H__
#include <atspi/atspi.h>
-#include <Eldbus.h>
#include <tts.h>
#define LAN_NAME 6
//Set by tts
tts_h tts;
- Eina_List *available_languages;
+ GList *available_languages;
char *text_to_say_info;
char *current_value;
AtspiAccessible *clicked_widget;
//Set by dbus
- Eldbus_Proxy *proxy;
char **last_tokens;
char *available_requests;
char **available_apps;
bool tts_init(void *data);
void state_changed_cb(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data);
-Eina_Bool tts_speak(char *text_to_speak, Eina_Bool flush_switch);
+gboolean tts_speak(char *text_to_speak, gboolean flush_switch);
void spi_stop(void *data);
#endif /* SCREEN_READER_TTS_H_ */
BuildRequires: at-spi2-core-devel
BuildRequires: cmake
BuildRequires: pkgconfig(capi-appfw-application)
-BuildRequires: pkgconfig(ecore)
-BuildRequires: pkgconfig(ecore-x)
-BuildRequires: pkgconfig(eina)
-BuildRequires: pkgconfig(eldbus)
-BuildRequires: pkgconfig(elementary)
BuildRequires: pkgconfig(capi-system-device)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(vconf)
#include "position_sort.h"
#include "object_cache.h"
#include "logger.h"
+#include <glib.h>
+#include <stdlib.h>
struct _FlatNaviContext {
AtspiAccessible *root;
- Eina_List *current;
- Eina_List *current_line;
- Eina_List *lines;
- Eina_List *candidates;
+ GList *current;
+ GList *current_line;
+ GList *lines;
+ GList *candidates;
};
static const AtspiStateType required_states[] = {
/**
* @brief Returns a list of all descendants objects
*
- * @return Eina_List of AtspiAccessible* type. List Should be
+ * @return GList of AtspiAccessible* type. List Should be
* be free with _accessible_list_free after usage
*
* @note obj parameter will also be included (in list head)
* @note every obj has increased ref. call g_object_unref on every
* object after usage.
*/
-static Eina_List*
+static GList*
_descendants_list_get(AtspiAccessible *obj)
{
- Eina_List *ret = NULL, *toprocess = NULL;
+ GList *ret = NULL, *toprocess = NULL;
int i;
if (!obj) return NULL;
// to keep all refcounts in ret list +1
g_object_ref(obj);
- toprocess = eina_list_append(toprocess, obj);
+ toprocess = g_list_append(toprocess, obj);
while (toprocess)
{
- AtspiAccessible *obj = eina_list_data_get(toprocess);
- toprocess = eina_list_remove_list(toprocess, toprocess);
+ AtspiAccessible *obj = toprocess->data;
+ toprocess = g_list_delete_link(toprocess, toprocess);
int n = atspi_accessible_get_child_count(obj, NULL);
for (i = 0; i < n; i++)
{
AtspiAccessible *child = atspi_accessible_get_child_at_index(obj, i, NULL);
- if (child) toprocess = eina_list_append(toprocess, child);
+ if (child) toprocess = g_list_append(toprocess, child);
}
- ret = eina_list_append(ret, obj);
+ ret = g_list_append(ret, obj);
}
return ret;
}
static void
-_accessible_list_free(Eina_List *d)
+_accessible_list_free(GList *d)
{
- AtspiAccessible *obj;
-
- EINA_LIST_FREE(d, obj)
- g_object_unref(obj);
+ for (; d != NULL; d = d->next)
+ g_object_unref(d->data);
}
typedef struct {
- Eina_List *success;
- Eina_List *failure;
+ GList *success;
+ GList *failure;
} FilterResult;
+typedef gboolean (*Filter_Each_Cb)(const void *container, void *data, void *fdata);
+
static FilterResult
-_accessible_list_split_with_filter(Eina_List *list, Eina_Each_Cb cb, void *user_data)
+_accessible_list_split_with_filter(GList *list, Filter_Each_Cb cb, void *user_data)
{
FilterResult ret = { NULL, NULL};
- Eina_List *l, *ln;
+ GList *l;
AtspiAccessible *obj;
- EINA_LIST_FOREACH_SAFE(list, l, ln, obj)
+ for (l = list; l; l = l->next)
{
- Eina_Bool res = cb(NULL, user_data, obj);
+ obj = l->data;
+ gboolean res = cb(NULL, user_data, obj);
if (res)
- eina_list_move_list(&ret.success, &list, l);
+ ret.success = g_list_append(ret.success, obj);
else
- eina_list_move_list(&ret.failure, &list, l);
+ ret.failure = g_list_append(ret.failure, obj);
}
+ g_list_free(list);
return ret;
}
-static Eina_Bool
+static gboolean
_filter_state_cb(const void *container, void *data, void *fdata)
{
AtspiStateType *state = data;
- Eina_Bool ret = EINA_TRUE;
+ gboolean ret = TRUE;
AtspiAccessible *obj = fdata;
AtspiStateSet *ss = atspi_accessible_get_state_set(obj);
{
if (!atspi_state_set_contains(ss, *state))
{
- ret = EINA_FALSE;
+ ret = FALSE;
break;
}
state++;
return ret;
}
-static Eina_Bool
+static gboolean
_filter_role_cb(const void *container, void *data, void *fdata)
{
AtspiRole *role = data;
- Eina_Bool ret = EINA_FALSE;
+ gboolean ret = FALSE;
AtspiAccessible *obj = fdata;
while (*role != ATSPI_ROLE_LAST_DEFINED)
{
if (atspi_accessible_get_role(obj, NULL) == *role)
{
- ret = EINA_TRUE;
+ ret = TRUE;
break;
}
role++;
return ret;
}
-static inline Eina_Bool
+static inline gboolean
_rectangle_intersect(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2)
{
return !(((y1 + h1) <= y2) || (y1 >= (y2 + h2)) || ((x1 + w1) <= x2) || (x1 >= (x2 + w2)));
}
-static Eina_Bool
+static gboolean
_filter_viewport_cb(const void *container, void *data, void *fdata)
{
const ObjectCache *oc, *ocr = data;
oc = object_cache_get(obj);
if (!oc || !oc->bounds || (oc->bounds->height < 0) || (oc->bounds->width < 0))
- return EINA_FALSE;
+ return FALSE;
// at least one pixel of child have to be in viewport
return _rectangle_intersect(ocr->bounds->x, ocr->bounds->y, ocr->bounds->width, ocr->bounds->height,
oc->bounds->x, oc->bounds->y, oc->bounds->width, oc->bounds->height);
}
-static Eina_List*
+static GList*
_flat_review_candidates_get(AtspiAccessible *root)
{
- Eina_List *desc, *ret = NULL;
+ GList *desc, *ret = NULL;
FilterResult fr0;
desc = _descendants_list_get(root);
- DEBUG("Descendants: %d", eina_list_count(desc));
+ DEBUG("Descendants: %d", g_list_length(desc));
// remove object that are not in root's viewport
const ObjectCache *oc = object_cache_get(root);
// get 'interesting' objects
FilterResult fr2 = _accessible_list_split_with_filter(fr1.success, _filter_role_cb, (void*)interesting_roles);
- ret = eina_list_merge(ret, fr2.success);
+ ret = g_list_concat(ret, fr2.success);
_accessible_list_free(fr2.failure);
- DEBUG("Candidates: %d", eina_list_count(ret));
+ DEBUG("Candidates: %d", g_list_length(ret));
return ret;
}
static void
debug(FlatNaviContext *ctx)
{
- Eina_List *l1, *l2, *line;
+ GList *l1, *l2, *line;
AtspiAccessible *obj;
int i, l = 0;
DEBUG("===============================");
- EINA_LIST_FOREACH(ctx->lines, l1, line)
+ for (l1 = ctx->lines; l1 != NULL; l1 = l1->next)
{
+ line = l1->data;
i = 0;
DEBUG("==== Line %d ====", l);
- EINA_LIST_FOREACH(line, l2, obj)
+ for (l2 = line; l2 != NULL; l2 = l2->next)
{
+ obj = l2->data;
char *name = atspi_accessible_get_name(obj, NULL);
char *role = atspi_accessible_get_role_name(obj, NULL);
const ObjectCache *oc = object_cache_get(obj);
+ if (oc) {
DEBUG("%d %s %s, (%d %d %d %d)", i++, name, role,
oc->bounds->x, oc->bounds->y, oc->bounds->width, oc->bounds->height);
+ }
if (name) g_free(name);
if (role) g_free(role);
}
ret->candidates = _flat_review_candidates_get(root);
ret->lines = position_sort(ret->candidates);
ret->current_line = ret->lines;
- ret->current = eina_list_data_get(ret->current_line);
+ ret->current = ret->current_line ? ret->current_line->data : NULL;
debug(ret);
void flat_navi_context_free(FlatNaviContext *ctx)
{
- Eina_List *l;
- EINA_LIST_FREE(ctx->lines, l)
- eina_list_free(l);
+ GList *l;
+ for (l = ctx->lines; l != NULL; l = l->next)
+ g_list_free((GList*)l->data);
_accessible_list_free(ctx->candidates);
free(ctx);
}
AtspiAccessible *flat_navi_context_current_get(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
-
- return eina_list_data_get(ctx->current);
+ if (!ctx || !ctx->lines) return NULL;
+ return ctx->current->data;
}
-Eina_Bool flat_navi_context_current_set(FlatNaviContext *ctx, AtspiAccessible *target)
+gboolean flat_navi_context_current_set(FlatNaviContext *ctx, AtspiAccessible *target)
{
- if(!ctx || !target) return EINA_FALSE;
+ if(!ctx || !target) return FALSE;
- Eina_List *l, *l2, *line;
+ GList *l, *l2, *line;
AtspiAccessible *obj;
- Eina_Bool found = EINA_FALSE;
+ gboolean found = FALSE;
- EINA_LIST_FOREACH(ctx->lines, l, line)
+ for (l = ctx->lines; l; l = l->next)
{
- EINA_LIST_FOREACH(line, l2, obj)
- if (obj == target)
- {
- found = EINA_TRUE;
- break;
- }
+ line = l->data;
+ for (l2 = line; l2; l2 = l2->next)
+ {
+ obj = l2->data;
+ if (obj == target)
+ {
+ found = TRUE;
+ break;
+ }
+ }
if (found)
{
ctx->current_line = l;
AtspiAccessible *flat_navi_context_next(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
-
- Eina_List *ret = eina_list_next(ctx->current);
+ if (!ctx || !ctx->lines) return NULL;
+ GList *ret = ctx->current->next;
if (ret)
{
ctx->current = ret;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
return NULL;
}
AtspiAccessible *flat_navi_context_prev(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
-
- Eina_List *ret = eina_list_prev(ctx->current);
+ if (!ctx || !ctx->lines) return NULL;
+ GList *ret = ctx->current->prev;
if (ret)
{
ctx->current = ret;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
return NULL;
}
AtspiAccessible *flat_navi_context_first(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
-
- Eina_List *ret = eina_list_data_get(ctx->current_line);
+ if (!ctx || !ctx->lines) return NULL;
+ GList *ret = ctx->current_line->data;
if (ret)
{
ctx->current = ret;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
return NULL;
}
AtspiAccessible *flat_navi_context_last(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
-
- Eina_List *ret = eina_list_last(ctx->current);
+ if (!ctx || !ctx->lines) return NULL;
+ GList *ret = g_list_last(ctx->current);
if (ret)
{
ctx->current = ret;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
return NULL;
}
AtspiAccessible *flat_navi_context_line_next(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
+ if (!ctx || !ctx->lines) return NULL;
- Eina_List *ret = eina_list_next(ctx->current_line);
+ GList *ret = ctx->current_line->next;
if (!ret) return NULL;
ctx->current_line = ret;
- ctx->current = eina_list_data_get(ctx->current_line);
+ ctx->current = ctx->current_line->data;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
AtspiAccessible *flat_navi_context_line_prev(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
+ if (!ctx || !ctx->lines) return NULL;
- Eina_List *ret = eina_list_prev(ctx->current_line);
+ GList *ret = ctx->current_line->prev;
if (!ret) return NULL;
ctx->current_line = ret;
- ctx->current = eina_list_data_get(ctx->current_line);
+ ctx->current = ctx->current_line->data;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
AtspiAccessible *flat_navi_context_line_first(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
+ if (!ctx || !ctx->lines) return NULL;
- Eina_List *ret = ctx->lines;
+ ctx->current_line = ctx->lines;
+ ctx->current = ctx->current_line->data;
- ctx->current_line = ret;
- ctx->current = eina_list_data_get(ctx->current_line);
-
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
AtspiAccessible *flat_navi_context_line_last(FlatNaviContext *ctx)
{
- if(!ctx) return NULL;
+ if (!ctx || !ctx->lines) return NULL;
- Eina_List *ret = eina_list_last(ctx->current_line);
-
- ctx->current_line = ret;
- ctx->current = eina_list_data_get(ctx->current_line);
+ ctx->current_line = g_list_last(ctx->current_line);
+ ctx->current = ctx->current_line->data;
- return eina_list_data_get(ctx->current);
+ return ctx->current->data;
}
#include <app.h>
-#include <eldbus-1/Eldbus.h>
-#include <Elementary.h>
#include "navigator.h"
#include "window_tracker.h"
#include "logger.h"
#include "screen_reader.h"
-#define A11Y_BUS "org.a11y.Bus"
-#define A11Y_INTERFACE "org.a11y.Bus"
-#define A11Y_PATH "/org/a11y/bus"
-#define A11Y_GET_ADDRESS "GetAddress"
-
static bool app_create(void *data)
{
atspi_init();
- elm_init(0, NULL);
navigator_init();
screen_reader_create_service(data);
int main(int argc, char **argv)
{
app_create(get_pointer_to_service_data_struct());
- elm_run();
+
+ GMainLoop *ml = g_main_loop_new(NULL, FALSE);
+ g_main_loop_run (ml);
+
app_terminate(get_pointer_to_service_data_struct());
return 0;
-#include <Ecore_X.h>
-#include <Ecore.h>
#include <math.h>
#include <atspi/atspi.h>
#include "logger.h"
}
static AtspiAccessible *top_window;
-static Eina_Bool _window_cache_builded;
+static gboolean _window_cache_builded;
static FlatNaviContext *context;
static void
_on_cache_builded(void *data)
{
DEBUG("Cache building");
- _window_cache_builded = EINA_TRUE;
+ _window_cache_builded = TRUE;
AtspiAccessible *pivot = NULL;
if (context)
{
_view_content_changed(AppTrackerEventType type, void *user_data)
{
DEBUG("View content changed");
- _window_cache_builded = EINA_FALSE;
+ _window_cache_builded = FALSE;
if (top_window)
object_cache_build_async(top_window, 5, _on_cache_builded, NULL);
}
app_tracker_callback_register(window, APP_TRACKER_EVENT_VIEW_CHANGED, _view_content_changed, NULL);
name = atspi_accessible_get_name(window, NULL);
ERROR("Window name: %s", name);
- _window_cache_builded = EINA_FALSE;
+ _window_cache_builded = FALSE;
object_cache_build_async(window, 5, _on_cache_builded, NULL);
g_free(name);
}
-#include <Eina.h>
-#include <Ecore.h>
-
#include "object_cache.h"
#include "logger.h"
-static Eina_Hash *cache;
-static Ecore_Idler *idler;
-static Eina_List *toprocess;
+#include <glib.h>
+
+static GHashTable *cache;
+static int idler = -1;
+static GList *toprocess;
static void *user_data;
static ObjectCacheReadyCb callback;
static int bulk;
static void
-_cache_item_free_cb(void *data)
+_cache_item_free_cb(gpointer data)
{
+ if (!data) return;
ObjectCache *co = data;
g_free(co->bounds);
- free(co);
+ g_free(co);
}
static void
-_list_obj_unref_and_free(Eina_List *toprocess)
+_list_obj_unref_and_free(GList *toprocess)
{
- AtspiAccessible *obj;
- EINA_LIST_FREE(toprocess, obj)
- g_object_unref(obj);
+ for (; toprocess; toprocess = toprocess->next)
+ g_object_unref(toprocess->data);
}
static void
_object_cache_free_internal(void)
{
- if (idler)
+ if (idler > 0)
{
- ecore_idler_del(idler);
- idler = NULL;
+ g_source_remove(idler);
+ idler = -1;
}
if (toprocess)
{
}
if (cache)
{
- eina_hash_free(cache);
+ g_hash_table_destroy(cache);
cache = NULL;
}
}
/**
* Returnes a list of all accessible object implementing AtkCompoment interface
- * Eina_List should be free with eina_list_free function.
+ * GList should be free with g_list_Free function.
* Every AtspiAccessible in list should be unrefed with g_object_unref.
*/
-static Eina_List*
+static GList*
_cache_candidates_list_prepare(AtspiAccessible *root)
{
- Eina_List *toprocess = NULL, *ret = NULL;
+ GList *toprocess = NULL, *ret = NULL;
int n, i;
if (!root) return NULL;
// Keep ref counter +1 on every object in returned list
g_object_ref(root);
- toprocess = eina_list_append(toprocess, root);
+ toprocess = g_list_append(toprocess, root);
while (toprocess)
{
- AtspiAccessible *obj = eina_list_data_get(toprocess);
- toprocess = eina_list_remove_list(toprocess, toprocess);
+ AtspiAccessible *obj = toprocess->data;
+ toprocess = g_list_delete_link(toprocess, toprocess);
if (!obj)
continue;
n = atspi_accessible_get_child_count(obj, NULL);
{
AtspiAccessible *cand = atspi_accessible_get_child_at_index(obj, i, NULL);
if(cand)
- toprocess = eina_list_append(toprocess, cand);
+ toprocess = g_list_append(toprocess, cand);
}
- ret = eina_list_append(ret, obj);
+ ret = g_list_append(ret, obj);
}
return ret;
if (!obj)
return NULL;
- ret = calloc(1, sizeof(ObjectCache));
+ ret = g_new0(ObjectCache, 1);
if (!ret)
{
ERROR("out-of memory");
return ret;
}
-static Eina_List*
-_cache_item_n_cache(Eina_List *objs, int count)
+static GList*
+_cache_item_n_cache(GList *objs, int count)
{
int i = 0;
- Eina_List *ret = objs;
+ GList *ret = objs;
ObjectCache *oc;
AtspiAccessible *obj;
for (i = 0; (i < count) && ret; i++)
{
- obj = eina_list_data_get(ret);
- ret = eina_list_remove_list(ret, ret);
+ obj = ret->data;
+ ret = g_list_delete_link(ret, ret);
oc = _cache_item_construct(obj);
if (!oc) break;
- eina_hash_add(cache, &obj, oc);
+ g_hash_table_insert (cache, obj, oc);
+
g_object_unref(obj);
}
return ret;
}
-static Eina_Hash*
+static GHashTable*
_object_cache_new(void)
{
- return eina_hash_pointer_new(_cache_item_free_cb);
+ return g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, _cache_item_free_cb);
}
void
object_cache_build(AtspiAccessible *root)
{
- Eina_List *objs;
+ GList *objs;
_object_cache_free_internal();
cache = _object_cache_new();
}
objs = _cache_candidates_list_prepare(root);
- _cache_item_n_cache(objs, eina_list_count(objs));
+ _cache_item_n_cache(objs, g_list_length(objs));
return;
}
-static Eina_Bool
+static gboolean
_do_cache(void *data)
{
toprocess = _cache_item_n_cache(toprocess, bulk);
- idler = NULL;
+ idler = -1;
if (toprocess)
- idler = ecore_idler_add(_do_cache, NULL);
+ idler = g_idle_add(_do_cache, NULL);
else if (callback) callback(user_data);
- return EINA_FALSE;
+ return FALSE;
}
void
}
toprocess = _cache_candidates_list_prepare(root);
- idler = ecore_idler_add(_do_cache, NULL);
+ idler = g_idle_add(_do_cache, NULL);
return;
}
object_cache_get(AtspiAccessible *obj)
{
ObjectCache *ret = NULL;
- if (idler)
+ if (idler > 0)
{
ERROR("Invalid usage. Async cache build is ongoing...");
return NULL;
}
}
- ret = eina_hash_find(cache, &obj);
+ ret = g_hash_table_lookup(cache, obj);
if (!ret)
{
// fallback to blocking d-bus call
ret = _cache_item_construct(obj);
- eina_hash_add(cache, &obj, ret);
+ g_hash_table_insert(cache, obj, ret);
}
return ret;
#include <atspi/atspi.h>
#include "logger.h"
-#include <Eina.h>
-
/**
* @brief Finds first leaf in object hierarchy with given states,
static AtspiAccessible*
_pivot_with_state_flat_find(AtspiAccessible *parent, AtspiStateType type)
{
- Eina_List *candidates = NULL, *queue = NULL;
+ GList *candidates = NULL, *queue = NULL;
// ref object to keep same ref count
g_object_ref(parent);
- queue = eina_list_append(queue, parent);
+ queue = g_list_append(queue, parent);
while (queue)
{
- AtspiAccessible *obj = eina_list_data_get(queue);
- queue = eina_list_remove_list(queue, queue);
+ AtspiAccessible *obj = queue->data;
+ queue = g_list_delete_link(queue, queue);
int n = atspi_accessible_get_child_count(obj, NULL);
if (n == 0)
- candidates = eina_list_append(candidates, obj);
+ candidates = g_list_append(candidates, obj);
else
{
int i;
{
AtspiAccessible *child = atspi_accessible_get_child_at_index(obj, i, NULL);
if (child)
- queue = eina_list_append(queue, child);
+ queue = g_list_append(queue, child);
}
g_object_unref(obj);
}
// FIXME sort by (x,y) first ??
while (candidates)
{
- AtspiAccessible *obj = eina_list_data_get(candidates);
- candidates = eina_list_remove_list(candidates, candidates);
+ AtspiAccessible *obj = candidates->data;
+ candidates = g_list_delete_link(candidates, candidates);
AtspiStateSet *states = atspi_accessible_get_state_set(obj);
if (states && atspi_state_set_contains(states, type))
{
g_object_unref(states);
g_object_unref(obj);
- eina_list_free(candidates);
+ g_list_free(candidates);
return obj;
}
return -1;
}
-static Eina_List*
-_get_zones(const Eina_List *objs)
+static GList*
+_get_zones(const GList *objs)
{
- Eina_List *candidates = NULL;
- const Eina_List *l;
+ GList *candidates = NULL;
+ const GList *l;
AtspiAccessible *obj;
AtspiComponent *comp;
const ObjectCache *oc;
- EINA_LIST_FOREACH(objs, l, obj)
+ for (l = objs; l; l = l->next)
{
+ obj = l->data;
if ((comp = atspi_accessible_get_component(obj)) != NULL)
{
oc = object_cache_get(obj);
atspi_accessible_get_role_name(obj, NULL));
continue;
}
- candidates = eina_list_append(candidates, obj);
+ candidates = g_list_append(candidates, obj);
}
else
DEBUG("No component interface: skipping %s %s",
}
// Sort object by y - coordinate
- return eina_list_sort(candidates, 0, _sort_vertically);
+ return g_list_sort(candidates, _sort_vertically);
}
-static Eina_List*
-_get_lines(const Eina_List *objs)
+static GList*
+_get_lines(const GList *objs)
{
- Eina_List *line = NULL, *lines = NULL;
- const Eina_List *l;
+ GList *line = NULL, *lines = NULL;
+ const GList *l;
AtspiAccessible *obj;
const ObjectCache *line_beg;
- EINA_LIST_FOREACH(objs, l, obj)
+ for (l = objs; l; l = l->next)
{
+ obj = l->data;
if (!line) {
// set first object in line
- line = eina_list_append(line, obj);
+ line = g_list_append(line, obj);
line_beg = object_cache_get(obj);
continue;
}
if ((line_beg->bounds->y + (int)(0.25 * (double)line_beg->bounds->height)) >
oc->bounds->y)
{
- line = eina_list_append(line, obj);
+ line = g_list_append(line, obj);
continue;
}
else
{
//finish line & set new line leader
- lines = eina_list_append(lines, line);
+ lines = g_list_append(lines, line);
line = NULL;
- line = eina_list_append(line, obj);
+ line = g_list_append(line, obj);
line_beg = object_cache_get(obj);
}
}
// finish last line
- if (line) lines = eina_list_append(lines, line);
+ if (line) lines = g_list_append(lines, line);
return lines;
}
-Eina_List *position_sort(const Eina_List *objs)
+GList *position_sort(const GList *objs)
{
- Eina_List *l, *line, *zones, *lines = NULL;
+ GList *l, *line, *zones, *lines = NULL;
int i = 0;
// Get list of objects occupying place on the screen
- DEBUG("PositionSort: Candidates; %d", eina_list_count(objs));
+ DEBUG("PositionSort: Candidates; %d", g_list_length((GList*)objs));
zones = _get_zones(objs);
// Cluster all zones into lines - verticaly
- DEBUG("PositionSort: Zones; %d", eina_list_count(zones));
+ DEBUG("PositionSort: Zones; %d", g_list_length(zones));
lines = _get_lines(zones);
// sort all zones in line - horizontaly
- DEBUG("PositionSort: Lines; %d", eina_list_count(lines));
- EINA_LIST_FOREACH(lines, l, line)
+ DEBUG("PositionSort: Lines; %d", g_list_length(lines));
+ for (l = lines; l; l = l->next)
{
- DEBUG("PositionSort: Line %d: %d items", i++, eina_list_count(line));
- line = eina_list_sort(line, 0, _sort_horizontally);
- eina_list_data_set(l, line);
+ line = l->data;
+ DEBUG("PositionSort: Line %d: %d items", i++, g_list_length(line));
+ line = g_list_sort(line, _sort_horizontally);
+ l->data = line;
}
- if (zones) eina_list_free(zones);
+ if (zones) g_list_free(zones);
return lines;
}
Service_Data *service_data = data;
- int vconf_ret = vconf_set_bool("db/setting/accessibility/screen_reader", EINA_FALSE);
+ int vconf_ret = vconf_set_bool("db/setting/accessibility/screen_reader", FALSE);
if(vconf_ret == 0)
{
DEBUG("TTS key set to false");
}
- vconf_ret = vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, EINA_FALSE);
+ vconf_ret = vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, FALSE);
if(vconf_ret == 0)
{
DEBUG("TTS key set to false");
#ifdef RUN_IPC_TEST_SUIT
#include "test_suite/test_suite.h"
#endif
+#include <stdlib.h>
#define MEMORY_ERROR "Memory allocation failed"
#define NO_VALUE_INTERFACE "No value interface present"
DEBUG("--------------------------------------------------------");
}
-Eina_Bool double_click_timer_cb(void *data)
+gboolean double_click_timer_cb(void *data)
{
Service_Data *sd = data;
sd->clicked_widget = NULL;
- return EINA_FALSE;
+ return FALSE;
}
static char *spi_get_atspi_accessible_basic_text_description(AtspiAccessible *obj)
ERROR("Can not prepare text to read");
return;
}
- tts_speak(text_to_read, EINA_FALSE);
+ tts_speak(text_to_read, FALSE);
free(text_to_read);
}
if(status == DEVICE_BATTERY_LEVEL_LOW)
{
- tts_speak(BATTERY_LOW, EINA_TRUE);
+ tts_speak(BATTERY_LOW, TRUE);
}
else if(status == DEVICE_BATTERY_LEVEL_CRITICAL)
{
- tts_speak(BATTERY_CRITICAL, EINA_TRUE);
+ tts_speak(BATTERY_CRITICAL, TRUE);
}
else if(status == DEVICE_BATTERY_LEVEL_FULL)
{
- tts_speak(BATTERY_FULL, EINA_TRUE);
+ tts_speak(BATTERY_FULL, TRUE);
}
}
else if(type == DEVICE_CALLBACK_BATTERY_CHARGING)
if(charging)
{
- tts_speak(CHARGING, EINA_FALSE);
+ tts_speak(CHARGING, FALSE);
}
else
{
- tts_speak(NOT_CHARGING, EINA_FALSE);
+ tts_speak(NOT_CHARGING, FALSE);
}
}
else if(type == DEVICE_CALLBACK_DISPLAY_STATE)
if(state == DISPLAY_STATE_NORMAL)
{
- tts_speak(SCREEN_ON, EINA_FALSE);
+ tts_speak(SCREEN_ON, FALSE);
}
else if(state == DISPLAY_STATE_SCREEN_OFF)
{
- tts_speak(SCREEN_OFF, EINA_FALSE);
+ tts_speak(SCREEN_OFF, FALSE);
}
}
}
*/
#define _GNU_SOURCE
-#include <Ecore.h>
#include "screen_reader_tts.h"
#include "logger.h"
+#include <stdlib.h>
+#include <stdio.h>
#define MEMORY_ERROR "Memory allocation failed"
// ---------------------------- DEBUG HELPERS ------------------------------
#define FLUSH_LIMIT 1
static int last_utt_id;
-static Eina_Bool pause_state = EINA_FALSE;
-static Eina_Bool flush_flag = EINA_FALSE;
+static gboolean pause_state = FALSE;
+static gboolean flush_flag = FALSE;
static char * get_tts_error( int r )
{
{
free(vi);
ERROR(MEMORY_ERROR);
- return ECORE_CALLBACK_CANCEL;
+ return FALSE;
}
vi->voice_type = voice_type;
- sd->available_languages = eina_list_append(sd->available_languages, vi);
+ sd->available_languages = g_list_append(sd->available_languages, vi);
- return ECORE_CALLBACK_RENEW;
+ return TRUE;
}
static void __tts_test_utt_started_cb(tts_h tts, int utt_id, void* user_data)
{
DEBUG("Utterance completed : utt id(%d) \n", utt_id);
if(last_utt_id - utt_id > FLUSH_LIMIT)
- flush_flag = EINA_TRUE;
+ flush_flag = TRUE;
else
{
if(flush_flag)
- flush_flag = EINA_FALSE;
+ flush_flag = FALSE;
}
return;
}
return true;
}
-Eina_Bool tts_pause_set(Eina_Bool pause_switch)
+gboolean tts_pause_set(gboolean pause_switch)
{
Service_Data *sd = get_pointer_to_service_data_struct();
if(!sd)
- return EINA_FALSE;
+ return FALSE;
if(pause_switch)
{
if(!tts_pause(sd->tts))
- pause_state = EINA_TRUE;
+ pause_state = TRUE;
else
- return EINA_FALSE;
+ return FALSE;
}
else if(!pause_switch)
{
if(!tts_play(sd->tts))
- pause_state = EINA_FALSE;
+ pause_state = FALSE;
else
- return EINA_FALSE;
+ return FALSE;
}
- return EINA_TRUE;
+ return TRUE;
}
-Eina_Bool tts_speak(char *text_to_speak, Eina_Bool flush_switch)
+gboolean tts_speak(char *text_to_speak, gboolean flush_switch)
{
Service_Data *sd = get_pointer_to_service_data_struct();
int speak_id;
if(!sd)
- return EINA_FALSE;
+ return FALSE;
if(flush_flag || flush_switch)
tts_stop(sd->tts);
DEBUG( "tts_speak\n");
DEBUG( "text to say:%s\n", text_to_speak);
- if ( !text_to_speak ) return EINA_FALSE;
- if ( !text_to_speak[0] ) return EINA_FALSE;
+ if ( !text_to_speak ) return FALSE;
+ if ( !text_to_speak[0] ) return FALSE;
if(tts_add_text( sd->tts, text_to_speak, sd->language, TTS_VOICE_TYPE_AUTO, TTS_SPEED_AUTO, &speak_id))
- return EINA_FALSE;
+ return FALSE;
DEBUG("added id to:%d\n", speak_id);
last_utt_id = speak_id;
- return EINA_TRUE;
+ return TRUE;
}
-Eina_Bool update_supported_voices(void *data)
+gboolean update_supported_voices(void *data)
{
DEBUG("START");
tts_state_e state;
if(res != TTS_ERROR_NONE)
{
DEBUG("CANNOT RETRIVE STATE");
- return EINA_FALSE;
+ return FALSE;
}
if(state == TTS_STATE_READY)
}
else
{
- sd->update_language_list = EINA_TRUE;
+ sd->update_language_list = TRUE;
}
DEBUG("END");
- return EINA_TRUE;
+ return TRUE;
}
void state_changed_cb(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data)
* Created on: Feb 19, 2014
* Author: m.skorupinsk
*/
-#include <Elementary.h>
#include <vconf.h>
#include "screen_reader_vconf.h"
#include "screen_reader_spi.h"
#include "logger.h"
+#include <stdio.h>
#ifdef RUN_IPC_TEST_SUIT
#include "test_suite/test_suite.h"
{
DEBUG("START");
- Eina_List *l;
+ GList *l;
Voice_Info *vi;
if(strncmp(sd->language, new_language, LAN_NAME - 1) == 0 && sd->voice_type == new_voice)
return true;
}
- EINA_LIST_FOREACH(sd->available_languages, l, vi)
+ for (l = sd->available_languages; l; l = l->next)
{
+ vi = l->data;
DEBUG("foreach %s <- %s", vi->language, new_language);
if(strncmp(vi->language, new_language, LAN_NAME - 1) == 0 &&
vi->voice_type == new_voice)
if(service_data->run_service == 0)
{
- elm_exit();
+ atspi_exit();
}
DEBUG("END");
-#include <Ecore.h>
-#include <Ecore_Evas.h>
-#include <Evas.h>
#include <atspi/atspi.h>
+#include <stdio.h>
#include "logger.h"
#include "screen_reader_tts.h"
#include "screen_reader_haptic.h"
#define ITEMS_NOTIFICATION "Visible items from %d to %d"
-static Eina_Bool status = EINA_FALSE;
+static gboolean status = FALSE;
static void _smart_notification_focus_chain_end(void);
static void _smart_notification_realized_items(int start_idx, int end_idx);
if (!strcmp(event->type, "object:scroll-start"))
{
DEBUG("Scrolling started");
- tts_speak("Scrolling started", EINA_TRUE);
+ tts_speak("Scrolling started", TRUE);
}
else if (!strcmp(event->type, "object:scroll-end"))
{
DEBUG("Scrolling finished");
- tts_speak("Scrolling finished", EINA_FALSE);
+ tts_speak("Scrolling finished", FALSE);
get_realized_items_count((AtspiAccessible *)event->source, &start_index, &end_index);
_smart_notification_realized_items(start_index, end_index);
}
haptic_module_init();
- status = EINA_TRUE;
+ status = TRUE;
}
/**
*/
void smart_notification_shutdown(void)
{
- status = EINA_FALSE;
+ status = FALSE;
}
/**
snprintf(buf, sizeof(buf), ITEMS_NOTIFICATION, start_idx, end_idx);
- tts_speak(strdup(buf), EINA_FALSE);
+ tts_speak(strdup(buf), FALSE);
}
#include "position_sort.h"
#include "logger.h"
-static Eina_List*
+static GList*
_atspi_children_list_get(AtspiAccessible *parent)
{
- Eina_List *ret = NULL;
+ GList *ret = NULL;
int count = atspi_accessible_get_child_count(parent, NULL);
int i;
for (i = 0; i < count; i++)
{
AtspiAccessible *child = atspi_accessible_get_child_at_index(parent, i, NULL);
- if (child) ret = eina_list_append(ret, child);
+ if (child) ret = g_list_append(ret, child);
}
return ret;
}
static void
-_atspi_children_list_free(Eina_List *children)
+_atspi_children_list_free(GList *children)
{
- AtspiAccessible *obj;
-
- EINA_LIST_FREE(children, obj)
- g_object_unref(obj);
+ for (; children; children = children->next)
+ g_object_unref(children->data);
}
-static Eina_List*
-_flat_review_get(Eina_List *tosort)
+static GList*
+_flat_review_get(GList *tosort)
{
- Eina_List *ret = NULL, *lines, *l, *line;
+ GList *ret = NULL, *lines, *l, *line;
lines = position_sort(tosort);
- EINA_LIST_FOREACH(lines, l, line)
+ for (l = lines; l; l = l->next)
{
- ret = eina_list_merge(ret, line);
+ line = l->data;
+ ret = g_list_concat(ret, line);
}
- eina_list_free(lines);
+ g_list_free(lines);
return ret;
}
AtspiAccessible *structural_navi_same_level_next(AtspiAccessible *current)
{
- AtspiAccessible *parent;
+ AtspiAccessible *parent, *ret = NULL;
AtspiRole role;
parent = atspi_accessible_get_parent(current, NULL);
role = atspi_accessible_get_role(parent, NULL);
if (role != ATSPI_ROLE_DESKTOP_FRAME)
{
- Eina_List *children = _atspi_children_list_get(parent);
- Eina_List *me = eina_list_data_find_list(children, current);
- Eina_List *sorted = _flat_review_get(children);
- me = eina_list_data_find_list(sorted, current);
- AtspiAccessible *ret = eina_list_data_get(eina_list_next(me));
+ GList *children = _atspi_children_list_get(parent);
+ GList *sorted = _flat_review_get(children);
+ GList *me = g_list_find(sorted, current);
+ if (me)
+ ret = me->next ? me->next->data : NULL;
- eina_list_free(sorted);
+ if (sorted) g_list_free(sorted);
_atspi_children_list_free(children);
return ret;
AtspiAccessible *structural_navi_same_level_prev(AtspiAccessible *current)
{
- AtspiAccessible *parent;
+ AtspiAccessible *parent, *ret = NULL;
AtspiRole role;
parent = atspi_accessible_get_parent(current, NULL);
role = atspi_accessible_get_role(parent, NULL);
if (role != ATSPI_ROLE_DESKTOP_FRAME)
{
- Eina_List *children = _atspi_children_list_get(parent);
- Eina_List *sorted = _flat_review_get(children);
- Eina_List *me = eina_list_data_find_list(sorted, current);
- AtspiAccessible *ret = eina_list_data_get(eina_list_prev(me));
+ GList *children = _atspi_children_list_get(parent);
+ GList *sorted = _flat_review_get(children);
+ GList *me = g_list_find(sorted, current);
+ if (me)
+ ret = me->prev ? me->prev->data : NULL;
- eina_list_free(sorted);
+ if (sorted) g_list_free(sorted);
_atspi_children_list_free(children);
return ret;
{
AtspiAccessible *ret;
- Eina_List *children = _atspi_children_list_get(current);
- Eina_List *sorted = _flat_review_get(children);
+ GList *children = _atspi_children_list_get(current);
+ GList *sorted = _flat_review_get(children);
- ret = eina_list_data_get(sorted);
+ ret = sorted ? sorted->data : NULL;
- eina_list_free(sorted);
+ if (sorted) g_list_free(sorted);
_atspi_children_list_free(children);
return ret;
gobject-2.0
dlog
dbus-1
- ecore
- eldbus
- eina
tts
check
vconf
- elementary
)
FOREACH(flag ${tests_CFLAGS})
AtspiAccessible *atspi_create_accessible()
{
- g_type_init();
AtspiAccessible *obj = g_object_new(ATSPI_ACCESSIBLE_OBJECT_TYPE, 0);
obj->children = NULL;
return obj;
{
return NULL;
}
+
+int atspi_exit(void)
+{
+ return 1;
+}
AtspiRelationType atspi_relation_get_relation_type (AtspiRelation *obj);
gint atspi_relation_get_n_targets (AtspiRelation *obj);
AtspiAccessible * atspi_relation_get_target (AtspiRelation *obj, gint i);
+int atspi_exit(void);
#endif /*__ATSPI_H__*/
#include "flat_navi.h"
#include <check.h>
#include <stdio.h>
+#include <stdlib.h>
#include <atspi/atspi.h>
-#include <Eina.h>
static AtspiAccessible *root;
static AtspiAccessible *child1;
atspi_accessible_add_child(root, child2);
atspi_accessible_add_child(root, child3);
atspi_accessible_add_child(root, child4);
- eina_init();
atspi_alloc_memory();
ctx = flat_navi_context_create(root);
}
{
flat_navi_context_free(ctx);
atspi_free_memory();
- eina_shutdown();
atspi_delete_accessible(root);
teardown();
}
START_TEST(spi_flat_navi_context_current_set_null_parameters)
{
- Eina_Bool ret = flat_navi_context_current_set(NULL, NULL);
- fail_if(ret != EINA_FALSE);
+ gboolean ret = flat_navi_context_current_set(NULL, NULL);
+ fail_if(ret != FALSE);
ret = flat_navi_context_current_set(ctx, NULL);
- fail_if(ret != EINA_FALSE);
+ fail_if(ret != FALSE);
AtspiAccessible *last = flat_navi_context_last(ctx);
ret = flat_navi_context_current_set(NULL, last);
- fail_if(ret != EINA_FALSE);
+ fail_if(ret != FALSE);
}
END_TEST
START_TEST(spi_flat_navi_context_current_set_valid_parameters)
{
AtspiAccessible *last = flat_navi_context_last(ctx);
- Eina_Bool ret = flat_navi_context_current_set(ctx, last);
+ gboolean ret = flat_navi_context_current_set(ctx, last);
AtspiAccessible *current = flat_navi_context_current_get(ctx);
- fail_if(ret != EINA_TRUE || current != last);
+ fail_if(ret != TRUE || current != last);
}
END_TEST
projects / profile / tv / apps / native / screen-reader.git / commitdiff