#define dict_eng_destroy(engine) \
((engine) -> engine_close( (engine) ))
//------------------------------------------------------------------------------
-#define dict_eng_search_word_list(engine,pattern) \
+#define dict_eng_search_word_list(engine,pattern,data) \
((engine) -> engine_search_word_list( (engine), \
- (pattern) \
+ (pattern), \
+ (data) \
))
//------------------------------------------------------------------------------
-#define dict_eng_search_word_translation(engine,word) \
+#define dict_eng_search_word_translation(engine,word,data) \
((engine) -> engine_search_word_translation( (engine), \
- (word) \
+ (word), \
+ (data) \
))
//------------------------------------------------------------------------------
#define dict_eng_search_word_translation_extended(engine,word) \
gboolean (*engine_is_optimized)(Engine* engine);
void (*engine_optimize)(Engine* engine);
void (*engine_search_word_list)(Engine* engine,
- gchar* pattern);
+ gchar* pattern,
+ gpointer data);
void (*engine_search_word_translation)(Engine* engine,
- gchar* word);
+ gchar* word,
+ gpointer data);
void (*engine_close)(Engine* engine);
// engine status
EngineStatus (*engine_status)(Engine* engine);
#define TIMER_STOP FALSE
//------------------------------------------------------------------------------
// definitions of version and format which engine handles
-static const gchar* DIC_ENG_VERSION = "0.2";
+static const gchar* DIC_ENG_VERSION = "0.2";
static const gchar* DIC_ENG_FORMAT = "Users' Bookmarks";
-static const gchar* DIC_ENG_DESCRIPTION = "This module handles users' bookmarks. Based on Berkeley DB 1.85";
+static const gchar* DIC_ENG_DESCRIPTION = "This module handles users' "
+ "bookmarks. Based on Berkeley DB 1.85";
//------------------------------------------------------------------------------
// macro for "printing" gboolean statement - "TRUE" or "FALSE"
gdouble seed);
//------------------------------------------------------------------------------
// implementation ofdict_eng_search_word_list(engine,pattern) function
-void bm_engine_search_word_list(Engine* engine, gchar* pattern);
+void bm_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer data);
//------------------------------------------------------------------------------
// implementation of dict_eng_search_word_translation(engine,word) function
-void bm_engine_search_word_translation(Engine* engine, gchar* word);
+void bm_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer data);
//------------------------------------------------------------------------------
// implementation of dict_eng_get_last_state(engine) function
EngineStatus bm_engine_status(Engine* engine);
//------------------------------------------------------------------------------
// searching word by concrete engine
-void bm_engine_search_word_translation(Engine* engine, gchar* word)
+void bm_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer cb_data)
{
LOGS("Bookmark/%s->%s() called.\n-->PARAM:engine at adress=%p\n"
"-->PARAM:word=\'%s\'\n",
bm_timer(TIMER_START,"callback for returning word's translation START");
// calling callback for word translation
- data->cb_search_word_trans(tran, word, data->cb_search_word_trans_data, ENGINE_NO_ERROR);
+ if ( NULL == cb_data )
+ {
+ cb_data = data->cb_search_word_trans_data;
+ }
+ data->cb_search_word_trans(tran, word, cb_data, ENGINE_NO_ERROR);
bm_timer(TIMER_STOP,"callback for returning word's translation END");
// if(data->auto_free) {
}
//------------------------------------------------------------------------------
-void bm_engine_search_word_list(Engine* engine, gchar* pattern)
+void bm_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer cb_data)
{
LOGS("Bookmark/%s->%s() called. Searching words list\n"
"-->PARAM:engine at adress=%p\n"
bm_timer(TIMER_START,"callback for returning words LIST START");
// calling callback for word translation
- data->cb_search_word_list(result , pattern, data->cb_search_word_list_data, ENGINE_NO_ERROR);
+ if ( NULL == cb_data )
+ {
+ cb_data = data->cb_search_word_list_data;
+ }
+ data->cb_search_word_list(result, pattern, cb_data, ENGINE_NO_ERROR);
/* if(data->auto_free) {
extern "C" {
#endif
-
-
-//------------------
-//#include <gconf/gconf-client.h>
-//#include <glib/gstdio.h>
-
-
-//#include <string.h>
-// -------------------
-
-
-
#if SQLITE==0
#define LIBRARY "/usr/lib/libsqlite.so.0"
#elif SQLITE==3
GModule* bookmark_library;
};
-struct _search_t {
- WSMngSearchData *data;
- gchar *word;
- GThread *thread;
-
- GArray *word_list;
- gchar *trans;
-};
-typedef struct _search_t search_t;
-
-
-void ws_mng_init (WSMngSearchData *data);
-void ws_mng_init_dbus (WSMngSearchData *data);
-void ws_mng_close (WSMngSearchData *data);
#ifdef __cplusplus
*/
gint ws_mng_compare_strings (gconstpointer a, gconstpointer b);
-void ws_remove_multiple_words(WSMngSearchData* user_data);
+void ws_remove_multiple_words(WSMngSearchAtom* user_data);
#ifdef __cplusplus
}
extern "C" {
#endif
-/* functions for critical sections and thread handling */
-gboolean try_lock_was_locked(WSMngSearchData* data, gchar* fun);
-gboolean is_rec_locked(GStaticRecMutex* m);
-void stop_if_needed(WSMngSearchData* data);
+struct _WSMngSearchAtom {
+ WSMngSearchData *data;
+ gchar *word;
+ GThread *thread;
+
+ GArray *word_list;
+ gchar *trans;
+};
+typedef struct _WSMngSearchAtom WSMngSearchAtom;
+
+/* functions for critical sections and thread handling */
+gboolean try_lock_was_locked(WSMngSearchData* data, gchar* fun);
+gboolean is_rec_locked(GStaticRecMutex* m);
+void stop_if_needed(WSMngSearchAtom* data);
+void free_search_atom(WSMngSearchAtom* data);
+WSMngSearchAtom *create_search_atom(WSMngSearchData* app_data, gchar* word);
#ifdef __cplusplus
}
#endif
/* get the word passed by dbus */
osso_data = &g_array_index (word, osso_rpc_t, 0);
- search_t* tmp = (search_t*)g_try_malloc( sizeof(search_t) );
-
+ gchar* tmp = NULL;
if (( g_utf8_strchr(osso_data->value.s, -1, '*') == NULL ) &&
( g_utf8_strchr(osso_data->value.s, -1, '?') == NULL ))
{
- tmp->word = g_strconcat(osso_data->value.s, "*", NULL);
+ tmp = g_strconcat(osso_data->value.s, "*", NULL);
}
else
{
- tmp->word = g_strdup(osso_data->value.s);
+ tmp = g_strdup(osso_data->value.s);
+ }
+
+ /* create and init searching data - separate for each thread */
+ WSMngSearchAtom* search_data = NULL;
+ search_data = create_search_atom(search, tmp);
+ g_free(tmp);
+ if (NULL == search_data)
+ {
+ return;
}
- tmp->data = search;
- tmp->thread = NULL;
g_debug("[L-word] creating GThread object...");
- tmp->thread = g_thread_create (ws_mng_search_word, tmp, TRUE, NULL);
+ search_data->thread = g_thread_create (ws_mng_search_word,
+ search_data,
+ TRUE,
+ NULL);
g_debug("[L-word] GThread object created. Exiting from CREATOR.");
g_static_mutex_unlock( search->thread_creation );
* @param error error messages
* @param user_data user data passed to function
*/
-void ws_mng_on_search_translation (GError *error, GArray *word,
+void ws_mng_on_search_translation (GError *error,
+ GArray *word,
gpointer user_data)
{
g_debug("[L-tran] ->%s", __FUNCTION__);
/* ---> CRITICAL SECTION for this function */
g_static_mutex_lock(data->thread_creation);
- osso_rpc_t *osso_data;
/* get the data sended by dbus */
- osso_data = &g_array_index (word, osso_rpc_t, 0);
- /* get the word sended by dbus */
- data->word = g_strdup(osso_data->value.s);
+ osso_rpc_t *osso_data;
+ osso_data = &g_array_index (word, osso_rpc_t, 0);
+
+ /* create and init searching data - separate for each thread */
+ WSMngSearchAtom* search_data = NULL;
+ search_data = create_search_atom(data, osso_data->value.s);
+ if (NULL == search_data)
+ {
+ return;
+ }
g_debug("[L-tran] creating GThread object...");
- g_thread_create (ws_mng_search_translation, data, TRUE, NULL);
+ search_data->thread = g_thread_create (ws_mng_search_translation,
+ search_data,
+ TRUE,
+ NULL);
g_debug("[L-tran] GThread object created. Exiting from CREATOR.");
gpointer ws_mng_search_word (gpointer user_data)
{
g_debug("[T-word] %s: Entering thread...", __FUNCTION__);
- search_t* data = (search_t*)user_data;
- WSMngSearchData *search = data->data;
+ WSMngSearchAtom *search_atom = (WSMngSearchAtom*)user_data;
+ WSMngSearchData *search = search_atom->data;
/* enter into CRITICAL SECTION */
if (try_lock_was_locked(search,(gchar*)__FUNCTION__))
g_static_rec_mutex_unlock(search->action_stop);
/* if another thread was run after this one - exit */
- stop_if_needed(search);
+ stop_if_needed(search_atom);
g_debug("[T-word] %s - from now this thread is \'singleton\' ",
__FUNCTION__
);
ws_dbus_notify(search->dbus_data, WS_DBUS_WORDS_LIST_STARTED);
/* creating new GArray for word list */
- search->word_list = g_array_new(TRUE, TRUE, sizeof(gchar*));
+ search_atom->word_list = g_array_new(TRUE, TRUE, sizeof(gchar*));
g_debug("[T-word] %s - start searching... ",__FUNCTION__);
if (search->bookmark_mode)
{ /* search only in user bookmarks */
dict_eng_search_word_list(search->bookmark,
- data->word);
+ search_atom->word,
+ search_atom);
}
else
{ /* search for word in each dictionary */
continue;
}
- stop_if_needed(search);
+ stop_if_needed(search_atom);
Engine* dict = g_array_index(search->dict,Engine *,i);
- dict_eng_search_word_list(dict, data->word);
+ dict_eng_search_word_list(dict, search_atom->word, search_atom);
}
}
g_debug("[T-word] %s - searching finished.",__FUNCTION__);
/* if another thread was run after this one - exit */
- stop_if_needed(search);
+ stop_if_needed(search_atom);
/* sort and cleaning words list - only if there were more than one
* dictionary loaded */
if ((FALSE == search->bookmark_mode) || (1 < search->dict->len))
{
- g_array_sort(search->word_list, ws_mng_compare_strings);
- ws_remove_multiple_words(search);
+ g_array_sort(search_atom->word_list, ws_mng_compare_strings);
+ ws_remove_multiple_words(search_atom);
}
/* if another thread was run after this one - exit */
- stop_if_needed(search);
+ stop_if_needed(search_atom);
- ws_dbus_server_return_words(search->dbus_data, search->word_list);
+ ws_dbus_server_return_words(search->dbus_data, search_atom->word_list);
ws_dbus_notify(search->dbus_data, WS_DBUS_WORDS_LIST_FINISHED);
/* free memory used by each word from word list */
gint i = 0;
- for (; i < search->word_list->len; i++)
+ for (; i < search_atom->word_list->len; i++)
{
- g_free(g_array_index(search->word_list,gchar* ,i));
+ g_free(g_array_index(search_atom->word_list,gchar* ,i));
}
/* free memory used by GArray */
- g_array_free(search->word_list, TRUE);
- search->word_list = NULL;
+ g_array_free(search_atom->word_list, TRUE);
+ search_atom->word_list = NULL;
- g_free(data->word);
- g_free(data);
+ g_free(search_atom->word);
+ g_free(search_atom);
g_debug("[T-word] %s - leaving thread!", __FUNCTION__);
g_static_mutex_unlock(search->action_working);
return NULL;
{
g_debug("[T-word-ret]-> %s", __FUNCTION__);
- WSMngSearchData *data = (WSMngSearchData *) user_data;
+ WSMngSearchAtom* search_atom = (WSMngSearchAtom*)user_data;
static gint i = 0;
for (i = 0; i < list->len; i++)
{
/* copy word found by search engine */
gchar* new_word = g_strdup(g_array_index(list, gchar*, i));
- g_array_append_val(data->word_list, new_word);
+ g_array_append_val(search_atom->word_list, new_word);
}
gpointer ws_mng_search_translation (gpointer data)
{
g_debug("[T-tran] %s: Entering thread...", __FUNCTION__);
- WSMngSearchData *search = (WSMngSearchData *) data;
+ WSMngSearchAtom* search_atom = (WSMngSearchAtom*)data;
+ WSMngSearchData* search = search_atom->data;
/* ---> CRITICAL SECTION for this function */
if (try_lock_was_locked(search,(gchar*)__FUNCTION__))
}
g_static_rec_mutex_unlock(search->action_stop);
/* if another thread was run after this one - exit */
- stop_if_needed(search);
+ stop_if_needed(search_atom);
g_debug("[T-tran] %s - from now this thread is \'singleton\' ",
__FUNCTION__
if (search->bookmark_mode)
{
dict_eng_search_word_translation(search->bookmark,
- search->word);
+ search_atom->word,
+ search_atom);
}
else
{
gint i;
for (i = 0; i < search->dict->len; i++)
{
- stop_if_needed(search);
+ stop_if_needed(search_atom);
if (NULL == g_array_index(search->dict, Engine*, i) )
{
continue;
}
dict_eng_search_word_translation(
g_array_index(search->dict, Engine*, i),
- search->word
- );
+ search_atom->word,
+ search_atom);
}
}
g_debug("[T-tran] %s - searching finished.",__FUNCTION__);
/* if another thread was run after this one - exit */
- stop_if_needed(search);
+ stop_if_needed(search_atom);
/* send translation to gui */
- ws_dbus_server_return_translations(search->dbus_data, search->trans);
+ ws_dbus_server_return_translations(search->dbus_data, search_atom->trans);
ws_dbus_notify(search->dbus_data, WS_DBUS_TRANSLATION_FINISHED);
g_free(search->trans);
)
{
g_debug("->%s", __FUNCTION__);
- WSMngSearchData *data = (WSMngSearchData *) user_data;
-
- /* if user want to stop searching */
- stop_if_needed(data);
+ WSMngSearchAtom* search_atom = (WSMngSearchAtom*)user_data;
/* we get already the first translation */
- if ((NULL != translation) && (NULL == data->trans))
+ if ((NULL != translation) && (NULL == search_atom->trans))
{ /* concatenate tags and searched word and translation */
- data->trans = g_strconcat("<PATTERN_OPEN>",
+ search_atom->trans = g_strconcat("<PATTERN_OPEN>",
pattern,
"<PATTERN_CLOSED><TRANSLATION_OPEN>",
translation,
else if (NULL != translation)
{ /* if there was stored translation *
* copy stored translation to temporary variable*/
- gchar* tmp = g_strconcat(data->trans,
+ gchar* tmp = g_strconcat(search_atom->trans,
"<TRANSLATION_OPEN>",
translation,
"<TRANSLATION_CLOSED>",
NULL);
/* free memory used by stored old translation */
- gchar* loc_tmp = data->trans;
- data->trans = tmp;
+ gchar* loc_tmp = search_atom->trans;
+ search_atom->trans = tmp;
g_free(loc_tmp);
tmp = loc_tmp = NULL;
}
- /* if user want to stop searching */
- stop_if_needed(data);
-
g_debug("<-%s", __FUNCTION__);
}
return result;
}
-void ws_remove_multiple_words(WSMngSearchData* user_data)
+void ws_remove_multiple_words(WSMngSearchAtom* user_data)
{
- WSMngSearchData* search = (WSMngSearchData*)user_data;
+ WSMngSearchAtom* search = (WSMngSearchAtom*)user_data;
gint j = 0;
gint i = 0;
gint result = -1;
}
else
{
- ws_dbus_notify(search->dbus_data, WS_DBUS_WORDS_LIST_FULL);
+ ws_dbus_notify(search->data->dbus_data, WS_DBUS_WORDS_LIST_FULL);
}
for (i = 0; i < temp-1; i++)
/* added by Dariusz Wiechecki
* stop current thread if there is such a need - newer thread is waiting */
-void stop_if_needed(WSMngSearchData* data)
+void stop_if_needed(WSMngSearchAtom* data)
{
static GStaticMutex _loc;
static GStaticMutex* loc = NULL;
return;
}
+ WSMngSearchData* app_data = data->data;
/* critical section for calling is_rec_locked() function*/
g_static_mutex_lock(loc);
- if ( is_rec_locked(data->action_stop) )
+ if ( is_rec_locked(app_data->action_stop) )
{
g_debug("[T-leaving] <---- Leaving thread (not finished).\n");
- ws_dbus_notify(data->dbus_data, WS_DBUS_WORDS_LIST_FINISHED);
- ws_dbus_notify(data->dbus_data, WS_DBUS_TRANSLATION_FINISHED);
- /* TODO clean after this thread!!!! */
- g_static_mutex_unlock(data->action_working);
+ ws_dbus_notify(app_data->dbus_data, WS_DBUS_WORDS_LIST_FINISHED);
+ ws_dbus_notify(app_data->dbus_data, WS_DBUS_TRANSLATION_FINISHED);
+ free_search_atom(data);
+ g_static_mutex_unlock(app_data->action_working);
g_static_mutex_unlock(loc);
g_thread_exit (NULL);
}
g_static_mutex_unlock(loc);
}
+
+void free_search_atom(WSMngSearchAtom* data)
+{
+ g_debug("[T-clear] Cleaning after thread\n");
+ g_assert(NULL != data);
+ if (NULL != data->word)
+ {
+ g_free(data->word);
+ }
+ if (NULL != data->trans)
+ {
+ g_free(data->trans);
+ }
+ if (NULL != data->word_list)
+ {
+ /* free memory used by each word from word list */
+ gint i = 0;
+ for (; i < data->word_list->len; i++)
+ {
+ g_free(g_array_index(data->word_list,gchar* ,i));
+ }
+ /* free memory used by GArray */
+ g_array_free(data->word_list, TRUE);
+ data->word_list = NULL;
+ }
+ g_free(data);
+}
+
+WSMngSearchAtom *create_search_atom(WSMngSearchData* app_data, gchar* word)
+{
+ WSMngSearchAtom* search_data = NULL;
+ search_data = (WSMngSearchAtom*)g_try_malloc(sizeof(WSMngSearchAtom));
+ if (NULL == search_data)
+ {
+ g_debug("[L-*] allocatting memmory for data failed!");
+ return NULL;
+ }
+ /* get the word sended by dbus */
+ search_data->word = g_strdup(word);
+ search_data->data = app_data;
+ search_data->word_list = NULL;
+ search_data->trans = NULL;
+
+ return search_data;
+}
gdouble seed);
//------------------------------------------------------------------------------
// implementation ofdict_eng_search_word_list(engine,pattern) function
-void sd_engine_search_word_list(Engine* engine, gchar* pattern);
+void sd_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer cb_data);
//------------------------------------------------------------------------------
// implementation of dict_eng_search_word_translation(engine,word) function
-void sd_engine_search_word_translation(Engine* engine, gchar* word);
+void sd_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer cb_data);
//------------------------------------------------------------------------------
// implementation of dict_eng_get_last_state(engine) function
EngineStatus sd_engine_status(Engine* engine);
* @param engine <b>Engine*</b> to search in
* @param pattern <b>gchar*</b> to search for
*/
-void sd_engine_search_word_list(Engine* engine, gchar* pattern)
+void sd_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer cb_data)
{
eg_debug("-> %s() called. Searching words list\n"
"--->PARAM:engine at adress=%p\n"
sd_timer(TIMER_STOP,(gchar*)__FUNCTION__);
sd_timer(TIMER_START,"callback for returning words LIST START");
+ if (NULL == cb_data )
+ {
+ cb_data = data->cb_search_word_list_data;
+ }
data->cb_search_word_list(result,
pattern,
- data->cb_search_word_list_data,
+ cb_data,
ENGINE_NO_ERROR
);
sd_timer(TIMER_STOP,"callback for returning word LIST END");
* @param engine <b>Engine*</b> to search in
* @param word <b>gchar*</b> to search for
*/
-void sd_engine_search_word_translation(Engine* engine, gchar* word)
+void sd_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer cb_data)
{
eg_debug("-> %s() called.\n"
"-->PARAM:engine at adress=%p\n"
SDData* data = (SDData*)(engine->engine_data);
gchar* trans0 = NULL;
+ if (NULL == cb_data )
+ {
+ cb_data = data->cb_search_word_list_data;
+ }
+
FilePart* part = sd_find_file_part(data, word);
if(!part)
{
data->cb_search_word_trans(NULL,
word,
- data->cb_search_word_trans_data,
+ cb_data,
ENGINE_NO_ERROR
);
return;
data->cb_search_word_trans(NULL,
word,
- data->cb_search_word_trans_data,
+ cb_data,
ENGINE_NO_ERROR
);
return;
data->cb_search_word_trans(NULL,
word,
- data->cb_search_word_trans_data,
+ cb_data,
ENGINE_NO_ERROR
);
return;
data->cb_search_word_trans(trans,
word,
- data->cb_search_word_trans_data,
+ cb_data,
ENGINE_NO_ERROR
);
// return translation of word but using only xdxf dictionary file
static gchar* word_translation_xdxf(XDXFData* data, gchar* word);
//------------------------------------------------------------------------------
-
// return translation of word using cache file
-static void word_list_cache(XDXFData* data, gchar* pattern, GArray* result);
+static void word_list_cache(XDXFData* data,
+ gchar* pattern,
+ GArray* result,
+ gpointer cb_data);
//------------------------------------------------------------------------------
// return translation of word but using only xdxf dictionary file
-static void word_list_xdxf(XDXFData* data, gchar* pattern, GArray* result);
+static void word_list_xdxf(XDXFData* data,
+ gchar* pattern,
+ GArray* result,
+ gpointer cb_data);
//------------------------------------------------------------------------------
gdouble seed);
//------------------------------------------------------------------------------
// implementation ofdict_eng_search_word_list(engine,pattern) function
-void xdxf_engine_search_word_list(Engine* engine, gchar* pattern);
+void xdxf_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer data);
//------------------------------------------------------------------------------
// implementation of dict_eng_search_word_translation(engine,word) function
-void xdxf_engine_search_word_translation(Engine* engine, gchar* word);
+void xdxf_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer data);
//------------------------------------------------------------------------------
// implementation of dict_eng_search_word_translation_extended(engine,word)
// function
}
//------------------------------------------------------------------------------
// searching word by concrete engine
-void xdxf_engine_search_word_translation(Engine* engine, gchar* word)
+void xdxf_engine_search_word_translation(Engine* engine,
+ gchar* word,
+ gpointer user_data)
{
g_debug("XDXF/%s->%s() called.\n"
"-->PARAM:engine at adress=%p\n"
//timer(TIMER_STOP,(gchar*)__FUNCTION__);
//timer(TIMER_START,"callback for returning word's translation START");
// calling callback for word translation
+ gpointer tmp = user_data;
+ if (NULL == tmp)
+ {
+ tmp = data->cb_search_word_trans_data;
+ }
+
data->cb_search_word_trans(trans,
word,
- data->cb_search_word_trans_data,
+ tmp,
ENGINE_NO_ERROR
);
//timer(TIMER_STOP,"callback for returning word's translation END");
}
//------------------------------------------------------------------------------
// return translation of word using cache file
-static void word_list_cache(XDXFData* data, gchar* pattern, GArray* result) {
+static void word_list_cache(XDXFData* data,
+ gchar* pattern,
+ GArray* result,
+ gpointer cb_data) {
gnome_vfs_seek(data->cache, GNOME_VFS_SEEK_START, 0);
//GnomeVFSResult vfs_result;
GnomeVFSFileSize bytes_readed;
//timer(TIMER_START,"callback for returning words list START");
data->cb_search_word_list(result,
pattern,
- data->cb_search_word_list_data,
+ cb_data,
ENGINE_NO_ERROR
);
g_free(casefold_pattern); casefold_pattern = NULL;
}
//------------------------------------------------------------------------------
// return translation of word but using only xdxf dictionary file
-static void word_list_xdxf(XDXFData* data, gchar* pattern, GArray* result)
+static void word_list_xdxf(XDXFData* data,
+ gchar* pattern,
+ GArray* result,
+ gpointer cb_data)
{
gnome_vfs_seek(data->xdxf, GNOME_VFS_SEEK_START, 0);
GnomeVFSResult vfs_result;
//timer(TIMER_START,"callback for returning words list START");
data->cb_search_word_list(result,
pattern,
- data->cb_search_word_list_data,
+ cb_data,
ENGINE_NO_ERROR
);
//timer(TIMER_STOP,"callback for returning words list END");
}
//------------------------------------------------------------------------------
-void xdxf_engine_search_word_list(Engine* engine, gchar* pattern)
+void xdxf_engine_search_word_list(Engine* engine,
+ gchar* pattern,
+ gpointer user_data)
{
g_debug("XDXF/%s->%s() called. Searching words list\n"
"-->PARAM:engine at adress=%p\n"
//timer(TIMER_STOP,(gchar*)__FUNCTION__);
return;
};
+
+ gpointer cb_data = user_data;
+ if ( NULL == cb_data )
+ {
+ cb_data = data->cb_search_word_list_data;
+ }
GArray* result = g_array_new(TRUE,FALSE,sizeof(gchar*));
// dictionary is optimized so search in cache file
if(data->cache != NULL)
{
- word_list_cache(data, pattern, result);
+ word_list_cache(data, pattern, result, cb_data);
}
// dictionary is not optimized so search directly fom XDXF file
else
{
- word_list_xdxf(data, pattern, result);
+ word_list_xdxf(data, pattern, result, cb_data);
};
guint i = 0;
- /*if(data->auto_free == TRUE)
- {
- g_debug("XDXF/%s->%s() deleting all dynamic data because "
- "AUTO_FREE=TRUE\n",
- __FILE__,
- __FUNCTION__
- );
- gchar* tmp;
-
- while((tmp = g_array_index(result, gchar*, i)) != NULL)
- {
- g_free(tmp); tmp = NULL;
- i++;
- }
- g_array_free(result, TRUE);
- result = NULL;
- };*/
+
if (result!=NULL){
for (i=0; i<result->len; i++)
{
projects / mdictionary / commitdiff