if (!l_button) return -1;
if (!elm_object_style_set (l_button, "naviframe/end_btn/default"))
- LOGW ("Failed to set style of button\n");
+ LOGW ("Failed to set style of button");
evas_object_smart_callback_add (l_button, "clicked", _quit_cb, NULL);
win_del, NULL);
elm_win_screen_size_get (eo, NULL, NULL, &w, &h);
- LOGD ("resize window as %d x %d\n", w, h);
+ LOGD ("resize window as %d x %d", w, h);
evas_object_resize (eo, w, h);
}
struct appdata *ad = (struct appdata *)data;
if (ad == NULL) return;
- LOGD ("input panel is shown\n");
+ LOGD ("input panel is shown");
ad->vkbd_state = EINA_TRUE;
}
struct appdata *ad = (struct appdata *)data;
if (ad == NULL) return;
- LOGD ("input panel is hidden\n");
+ LOGD ("input panel is hidden");
ad->vkbd_state = EINA_FALSE;
}
struct appdata *ad = (struct appdata *)data;
if (ad == NULL || ev == NULL) return ECORE_CALLBACK_PASS_ON;
- LOGD ("[ecore key down] keyname : '%s', key : '%s', string : '%s', compose : '%s'\n", ev->keyname, ev->key, ev->string, ev->compose);
+ LOGD ("[ecore key down] keyname : '%s', key : '%s', string : '%s', compose : '%s'", ev->keyname, ev->key, ev->string, ev->compose);
return ECORE_CALLBACK_PASS_ON;
}
Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
if (ev == NULL) return ECORE_CALLBACK_PASS_ON;
- LOGD ("[ecore key up] keyname : '%s', key : '%s', string : '%s', compose : '%s'\n", ev->keyname, ev->key, ev->string, ev->compose);
+ LOGD ("[ecore key up] keyname : '%s', key : '%s', string : '%s', compose : '%s'", ev->keyname, ev->key, ev->string, ev->compose);
if (strcmp (ev->keyname, "XF86Send") == 0 ||
strcmp (ev->keyname, "XF86Menu") == 0) {
switch (sip_status) {
case VCONFKEY_ISF_INPUT_PANEL_STATE_HIDE:
- LOGD ("state : hide\n");
+ LOGD ("state : hide");
break;
case VCONFKEY_ISF_INPUT_PANEL_STATE_WILL_HIDE:
- LOGD ("state : will_hide\n");
+ LOGD ("state : will_hide");
break;
case VCONFKEY_ISF_INPUT_PANEL_STATE_SHOW:
- LOGD ("state : show\n");
+ LOGD ("state : show");
break;
case VCONFKEY_ISF_INPUT_PANEL_STATE_WILL_SHOW:
- LOGD ("state : will_show\n");
+ LOGD ("state : will_show");
break;
default :
- LOGD ("sip_status error!\n");
+ LOGD ("sip_status error!");
break;
}
}
ad->win_main = create_win ("isf-demo-efl");
if (!ad->win_main) {
- LOGE ("Failed to create window\n");
+ LOGE ("Failed to create window");
return -1;
}
{
Evas_Object *back_btn = elm_button_add (ad->naviframe);
if (!elm_object_style_set (back_btn, "naviframe/end_btn/default"))
- LOGW ("Failed to set style of button\n");
+ LOGW ("Failed to set style of button");
evas_object_smart_callback_add (back_btn, "clicked", _back_btn_clicked_cb, ad);
{
autotest_demo_param *demo_param = (autotest_demo_param*)param;
if (demo_param) {
- isf_demo_autotest_log("Executing Demo item : %s\n", demo_param->name.c_str());
+ isf_demo_autotest_log("Executing Demo item : %s", demo_param->name.c_str());
switch (demo_param->cmd) {
case autotest_demo_cmd_open:
isf_demo_menu_its[demo_param->index].func(demo_param->ad, NULL, NULL);
static void _input_panel_event_callback (void *data, Ecore_IMF_Context *ctx, int value)
{
if (value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
- LOGD ("ECORE_IMF_INPUT_PANEL_STATE_SHOW\n");
+ LOGD ("ECORE_IMF_INPUT_PANEL_STATE_SHOW");
} else if (value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
- LOGD ("ECORE_IMF_INPUT_PANEL_STATE_HIDE\n");
+ LOGD ("ECORE_IMF_INPUT_PANEL_STATE_HIDE");
}
}
const char *ctx_id = ecore_imf_context_default_id_get ();
if (!ctx_id) {
- LOGW ("Cannot create imf context\n");
+ LOGW ("Cannot create imf context");
return;
}
int x, y, w, h;
if (imf_context != NULL) {
ecore_imf_context_input_panel_geometry_get (imf_context, &x, &y, &w, &h);
- LOGD ("x : %d, y : %d, w : %d, h : %d\n", x, y, w, h);
+ LOGD ("x : %d, y : %d, w : %d, h : %d", x, y, w, h);
}
}
if (buf != NULL) {
if (imf_context != NULL) {
ecore_imf_context_input_panel_imdata_get (imf_context, buf, &len);
- LOGD ("get imdata %s, and len is %d ...\n", (char *)buf, len);
+ LOGD ("get imdata %s, and len is %d", (char *)buf, len);
}
free (buf);
}
Ecore_IMF_Input_Panel_Layout layout;
if (imf_context != NULL) {
layout = ecore_imf_context_input_panel_layout_get (imf_context);
- LOGD ("get layout : %d ...\n", (int)layout);
+ LOGD ("get layout : %d", (int)layout);
}
}
if (imf_context != NULL) {
state = ecore_imf_context_input_panel_state_get (imf_context);
- LOGD ("ise state : %d \n", (int)state);
+ LOGD ("ise state : %d", (int)state);
}
}
if (imf_context != NULL) {
ecore_imf_context_input_panel_language_locale_get (imf_context, &locale);
- LOGD ("locale : %s\n", locale);
+ LOGD ("locale : \"%s\"", locale);
}
if (locale)
char *uuid = NULL;
int ret = isf_control_get_active_ise (&uuid);
if (ret > 0 && uuid)
- LOGD ("Get active ISE: %s\n", uuid);
+ LOGD ("Get active ISE: \"%s\"", uuid);
if (uuid)
free (uuid);
}
{
char **iselist = NULL;
int count = isf_control_get_ise_list (&iselist);
- LOGD ("Count : %d\n", count);
+ LOGD ("Count : %d", count);
for (int i = 0; i < count; i++) {
if (iselist[i]) {
- LOGD ("[%d : %s]\n", i, iselist[i]);
+ LOGD ("[%d : %s]", i, iselist[i]);
free (iselist[i]);
}
else {
- LOGD ("[%d] No data\n", i);
+ LOGD ("[%d] No data", i);
}
}
if (iselist)
int option = 0;
ret = isf_control_get_ise_info (uuid, &name, &language, &type, &option);
if (ret == 0 && name && language) {
- LOGD ("Active ISE: uuid[%s], name[%s], language[%s], type[%d], option[%d]\n", uuid, name, language, type, option);
+ LOGD ("Active ISE: uuid[%s], name[%s], language[%s], type[%d], option[%d]", uuid, name, language, type, option);
}
if (name)
free (name);
static void test_get_ise_count (void *data, Evas_Object *obj, void *event_info)
{
- LOGD ("S/W keyboard : %d, H/W keyboard : %d\n", isf_control_get_ise_count (SOFTWARE_KEYBOARD_ISE), isf_control_get_ise_count (HARDWARE_KEYBOARD_ISE));
+ LOGD ("S/W keyboard : %d, H/W keyboard : %d", isf_control_get_ise_count (SOFTWARE_KEYBOARD_ISE), isf_control_get_ise_count (HARDWARE_KEYBOARD_ISE));
}
static void test_reset_default_ise (void *data, Evas_Object *obj, void *event_info)
{
int ret = isf_control_set_active_ise_to_default ();
if (ret == 0)
- LOGD ("Reset default ISE is successful!\n");
+ LOGD ("Reset default ISE is successful!");
else
- LOGW ("Reset default ISE is failed!!!\n");
+ LOGW ("Reset default ISE is failed!!!");
}
static void test_show_ime_list (void *data, Evas_Object *obj, void *event_info)
{
int ret = isf_control_show_ime_list ();
if (ret == 0)
- LOGD ("Show IME list is successful!\n");
+ LOGD ("Show IME list is successful!");
else
- LOGW ("Show IME list is failed!!!\n");
+ LOGW ("Show IME list is failed!!!");
}
static void test_show_ise_selector (void *data, Evas_Object *obj, void *event_info)
{
int ret = isf_control_show_ise_selector ();
if (ret == 0)
- LOGD ("Show ISE selector is successful!\n");
+ LOGD ("Show ISE selector is successful!");
else
- LOGW ("Show ISE selector is failed!!!\n");
+ LOGW ("Show ISE selector is failed!!!");
}
static void test_show_ise_option (void *data, Evas_Object *obj, void *event_info)
{
int ret = isf_control_show_ise_option_window ();
if (ret == 0)
- LOGD ("Show ISE option window is successful!\n");
+ LOGD ("Show ISE option window is successful!");
else
- LOGW ("Show ISE option window is failed!!!\n");
+ LOGW ("Show ISE option window is failed!!!");
}
static void test_is_ime_enabled (void *data, Evas_Object *obj, void *event_info)
bool enabled;
int ret = isf_control_get_initial_ise (&uuid);
if (ret > 0 && uuid) {
- LOGD ("Get initial ISE: %s\n", uuid);
+ LOGD ("Get initial ISE: %s", uuid);
int ret = isf_control_is_ime_enabled (uuid, &enabled);
if (ret == 0) {
- LOGD ("is_ime_enabled is successful! enabled : %d\n", enabled);
+ LOGD ("is_ime_enabled is successful! enabled : %d", enabled);
}
else {
- LOGW ("is_ime_enabled is failed!\n");
+ LOGW ("is_ime_enabled is failed!");
}
}
else
- LOGW ("Failed to get initial ISE\n");
+ LOGW ("Failed to get initial ISE");
if (uuid)
free (uuid);
char *uuid = NULL;
int ret = isf_control_get_initial_ise (&uuid);
if (ret > 0 && uuid)
- LOGD ("Get initial ISE: %s\n", uuid);
+ LOGD ("Get initial ISE: %s", uuid);
else
- LOGW ("Failed to get initial ISE\n");
+ LOGW ("Failed to get initial ISE");
if (uuid)
free (uuid);
{
int x, y, w, h;
if (isf_control_get_recent_ime_geometry (&x, &y, &w, &h) == 0) {
- LOGD ("x : %d, y : %d, width : %d, height : %d\n", x, y, w, h);
+ LOGD ("x : %d, y : %d, width : %d, height : %d", x, y, w, h);
}
else {
- LOGW ("Failed to get recent ime geometry\n");
+ LOGW ("Failed to get recent ime geometry");
}
int angle = elm_win_rotation_get (win);
if (isf_control_get_recent_ime_geometry_with_rotation_angle (angle, &x, &y, &w, &h) == 0) {
- LOGD ("angle : %d, x : %d, y : %d, width : %d, height : %d\n", angle, x, y, w, h);
+ LOGD ("angle : %d, x : %d, y : %d, width : %d, height : %d", angle, x, y, w, h);
}
else {
- LOGW ("Failed to get recent ime geometry with rotation angle\n");
+ LOGW ("Failed to get recent ime geometry with rotation angle");
}
}
if (imf_context != NULL) {
mode = ecore_imf_context_keyboard_mode_get (imf_context);
- LOGD ("get keyboard mode : %d\n", (int)mode);
+ LOGD ("get keyboard mode : %d", (int)mode);
}
}
int angle = elm_win_rotation_get (ad->win_main);
- LOGD ("rotate. angle : %d\n", angle);
+ LOGD ("rotate. angle : %d", angle);
if (isf_control_get_recent_ime_geometry (&x, &y, &w, &h) == 0) {
- LOGD ("x : %d, y : %d, width : %d, height : %d\n", x, y, w, h);
+ LOGD ("x : %d, y : %d, width : %d, height : %d", x, y, w, h);
}
else {
- LOGW ("Failed to get recent ime geometry\n");
+ LOGW ("Failed to get recent ime geometry");
}
if (isf_control_get_recent_ime_geometry_with_rotation_angle (angle, &x, &y, &w, &h) == 0) {
- LOGD ("angle : %d, x : %d, y : %d, width : %d, height : %d\n", angle, x, y, w, h);
+ LOGD ("angle : %d, x : %d, y : %d, width : %d, height : %d", angle, x, y, w, h);
}
else {
- LOGW ("Failed to get recent ime geometry with rotation angle\n");
+ LOGW ("Failed to get recent ime geometry with rotation angle");
}
}
if (ctx_id != NULL) {
imf_context = ecore_imf_context_add (ctx_id);
} else {
- LOGW ("Cannot create imf context\n");
+ LOGW ("Cannot create imf context");
ecore_imf_shutdown ();
return;
}
if (value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
ecore_imf_context_input_panel_geometry_get (ctx, &x, &y, &w, &h);
- LOGD ("Input panel is shown. ctx : %p\n", ctx);
- LOGD ("x : %d, y : %d, w : %d, h : %d\n", x, y, w, h);
+ LOGD ("Input panel is shown. ctx : %p", ctx);
+ LOGD ("x : %d, y : %d, w : %d, h : %d", x, y, w, h);
} else if (value == ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
- LOGD ("Input panel is hidden. ctx : %p\n", ctx);
+ LOGD ("Input panel is hidden. ctx : %p", ctx);
} else if (value == ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW) {
- LOGD ("Input panel will be shown. ctx : %p\n", ctx);
+ LOGD ("Input panel will be shown. ctx : %p", ctx);
}
}
int x, y, w, h;
ecore_imf_context_input_panel_geometry_get (ctx, &x, &y, &w, &h);
- LOGD ("x : %d, y : %d, w : %d, h : %d\n", x, y, w, h);
+ LOGD ("x : %d, y : %d, w : %d, h : %d", x, y, w, h);
}
static void _shift_mode_cb (void *data, Ecore_IMF_Context *ctx, int value)
{
if (value == ECORE_IMF_INPUT_PANEL_SHIFT_MODE_OFF) {
- LOGD ("Shift Mode : OFF\n");
+ LOGD ("Shift Mode : OFF");
} else if (value == ECORE_IMF_INPUT_PANEL_SHIFT_MODE_ON) {
- LOGD ("Shift Mode : ON\n");
+ LOGD ("Shift Mode : ON");
}
}
ecore_imf_context_input_panel_language_locale_get (ctx, &locale);
- LOGD ("language : %s\n", locale);
+ LOGD ("language : %s", locale);
if (locale)
free (locale);
if (value == ECORE_IMF_CANDIDATE_PANEL_SHOW) {
ecore_imf_context_candidate_panel_geometry_get (ctx, &x, &y, &w, &h);
- LOGD ("Candidate window is shown\n");
- LOGD ("x : %d, y : %d, w : %d, h : %d\n", x, y, w, h);
+ LOGD ("Candidate window is shown");
+ LOGD ("x : %d, y : %d, w : %d, h : %d", x, y, w, h);
} else if (value == ECORE_IMF_CANDIDATE_PANEL_HIDE) {
- LOGD ("Candidate window is hidden\n");
+ LOGD ("Candidate window is hidden");
}
}
int x, y, w, h;
ecore_imf_context_candidate_panel_geometry_get (ctx, &x, &y, &w, &h);
- LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d\n", ctx, x, y, w, h);
+ LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d", ctx, x, y, w, h);
}
static void
_key_down_cb (void *data, Evas *e, Evas_Object *obj, void *event_info)
{
Evas_Event_Key_Down *ev = (Evas_Event_Key_Down *)event_info;
- LOGD ("[evas key down] keyname : '%s', key : '%s', string : '%s', compose : '%s'\n", ev->keyname, ev->key, ev->string, ev->compose);
- LOGD ("[evas key down] capslock : %d, num lock : %d\n", evas_key_lock_is_set(ev->locks, "Caps_Lock"), evas_key_lock_is_set(ev->locks, "Num_Lock"));
+ LOGD ("[evas key down] keyname : '%s', key : '%s', string : '%s', compose : '%s'", ev->keyname, ev->key, ev->string, ev->compose);
+ LOGD ("[evas key down] capslock : %d, num lock : %d", evas_key_lock_is_set(ev->locks, "Caps_Lock"), evas_key_lock_is_set(ev->locks, "Num_Lock"));
}
static void
_key_up_cb (void *data, Evas *e, Evas_Object *obj, void *event_info)
{
Evas_Event_Key_Up *ev = (Evas_Event_Key_Up *)event_info;
- LOGD ("[evas key up] keyname : '%s', key : '%s', string : '%s', compose : '%s'\n", ev->keyname, ev->key, ev->string, ev->compose);
- LOGD ("[evas key up] capslock : %d, num lock : %d\n", evas_key_lock_is_set(ev->locks, "Caps_Lock"), evas_key_lock_is_set(ev->locks, "Num_Lock"));
+ LOGD ("[evas key up] keyname : '%s', key : '%s', string : '%s', compose : '%s'", ev->keyname, ev->key, ev->string, ev->compose);
+ LOGD ("[evas key up] capslock : %d, num lock : %d", evas_key_lock_is_set(ev->locks, "Caps_Lock"), evas_key_lock_is_set(ev->locks, "Num_Lock"));
}
#ifndef WAYLAND
if (!ecore_x_e_illume_keyboard_geometry_get (zone, &sx, &sy, &sw, &sh))
sx = sy = sw = sh = 0;
- LOGD ("Keyboard geometry x : %d, y : %d, w : %d, h : %d\n", sx, sy, sw, sh);
+ LOGD ("Keyboard geometry x : %d, y : %d, w : %d, h : %d", sx, sy, sw, sh);
}
static Eina_Bool
static void entry_changed_cb (void *data, Evas_Object *obj, void *event_info)
{
- LOGD ("The text within the entry was changed.\n");
+ LOGD ("The text within the entry was changed.");
}
static void entry_preedit_changed_cb (void *data, Evas_Object *obj, void *event_info)
{
- LOGD ("The preedit string has changed.\n");
+ LOGD ("The preedit string has changed.");
}
static void entry_cursor_changed_cb (void *data, Evas_Object *obj, void *event_info)
{
- LOGD ("cursor pos : %d\n", elm_entry_cursor_pos_get (obj));
+ LOGD ("cursor pos : %d", elm_entry_cursor_pos_get (obj));
}
static void _commit_content_cb (void *data, Ecore_IMF_Context *ctx, void *event)
Ecore_IMF_Event_Commit_Content *commit_content = (Ecore_IMF_Event_Commit_Content *)event;
if (!commit_content) return;
- LOGD ("content : %s, description : %s, mime types : %s\n", commit_content->content_uri, commit_content->description, commit_content->mime_types);
+ LOGD ("content : %s, description : %s, mime types : %s", commit_content->content_uri, commit_content->description, commit_content->mime_types);
}
static Evas_Object *_create_ef_layout (Evas_Object *parent, const char *label, const char *guide_text, Elm_Input_Panel_Layout layout, int layout_variation = 0)
if (ecore_imf_context_input_panel_state_get (active_ctx) == ECORE_IMF_INPUT_PANEL_STATE_HIDE)
return EINA_TRUE;
}
- LOGD ("%s key is pressed.\n", ev->keyname);
+ LOGD ("%s key is pressed.", ev->keyname);
if (_active_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
KeyEvent key;
scim_string_to_key (key, ev->key);
- LOGD ("process hide_ise_key_event to handle it in the helper: %s\n", ev->keyname);
+ LOGD ("process hide_ise_key_event to handle it in the helper: %s", ev->keyname);
void *pvoid = &ret;
_panel_client.prepare (ic->id);
_panel_client.process_key_event (key, (int*) pvoid);
if (ecore_imf_context_input_panel_state_get (active_ctx) == ECORE_IMF_INPUT_PANEL_STATE_HIDE)
return EINA_TRUE;
}
- LOGD ("%s key is released.\n", ev->keyname);
+ LOGD ("%s key is released.", ev->keyname);
if (_active_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
KeyEvent key;
scim_string_to_key (key, ev->key);
key.mask = SCIM_KEY_ReleaseMask;
key.mask &= _valid_key_mask;
- LOGD ("process hide_ise_key_event to handle it in the helper: %s\n", ev->keyname);
+ LOGD ("process hide_ise_key_event to handle it in the helper: %s", ev->keyname);
void *pvoid = &ret;
_panel_client.prepare (ic->id);
_panel_client.process_key_event (key, (int*) pvoid);
}
_click_timer = ecore_timer_add (0.4, _click_check, NULL);
} else {
- LOGD ("Skip toggle key input\n");
+ LOGD ("Skip toggle key input");
ecore_timer_del (_click_timer);
_click_timer = ecore_timer_add (0.4, _click_check, NULL);
}
if (_scim_initialized) {
_scim_initialized = false;
- LOGD ("immodule shutdown\n");
+ LOGD ("immodule shutdown");
vconf_ignore_key_changed (VCONFKEY_AUTOPERIOD_ALLOW_BOOL, autoperiod_allow_changed_cb);
vconf_ignore_key_changed (VCONFKEY_AUTOCAPITAL_ALLOW_BOOL, autocapital_allow_changed_cb);
if (_config)
context_scim->impl->is_on = _config->read (String (SCIM_CONFIG_FRONTEND_IM_OPENED_BY_DEFAULT), context_scim->impl->is_on);
else
- LOGW ("Failed to read in config\n");
+ LOGW ("Failed to read in config");
SCIM_DEBUG_FRONTEND(2) << "input context created: id = " << context_scim->id << "\n";
}
_panel_client.prepare (context_scim->id);
if (input_panel_ctx == ctx && _scim_initialized) {
- LOGD ("ctx : %p\n", ctx);
+ LOGD ("ctx : %p", ctx);
Ecore_IMF_Input_Panel_State l_input_panel_state = ecore_imf_context_input_panel_state_get (ctx);
if (l_input_panel_state == ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW ||
l_input_panel_state == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
//if h/w keyboard mode, keyboard mode will be changed to s/w mode when the entry get the focus.
if (kbd_mode == TOOLBAR_KEYBOARD_MODE) {
- LOGD ("Keyboard mode is changed H/W->S/W because of focus_in.\n");
+ LOGD ("Keyboard mode is changed H/W->S/W because of focus_in.");
isf_imf_context_set_keyboard_mode (ctx, TOOLBAR_HELPER_MODE);
}
}
context_scim->impl->shift_mode_enabled = 0;
}
- LOGD ("ctx : %p. on demand : %d\n", ctx, ecore_imf_context_input_panel_show_on_demand_get (ctx));
+ LOGD ("ctx : %p. on demand : %d", ctx, ecore_imf_context_input_panel_show_on_demand_get (ctx));
if (ecore_imf_context_input_panel_enabled_get (ctx)) {
if (!ecore_imf_context_input_panel_show_on_demand_get (ctx))
ecore_imf_context_input_panel_show (ctx);
else
- LOGD ("ctx : %p input panel on demand mode : TRUE\n", ctx);
+ LOGD ("ctx : %p input panel on demand mode : TRUE", ctx);
}
else
- LOGD ("ctx : %p input panel enable : FALSE\n", ctx);
+ LOGD ("ctx : %p input panel enable : FALSE", ctx);
if (get_keyboard_mode () == TOOLBAR_KEYBOARD_MODE)
clear_hide_request ();
if (context_scim && context_scim->impl && context_scim == _focused_ic) {
WideString wstr = context_scim->impl->preedit_string;
- LOGD ("ctx : %p\n", ctx);
+ LOGD ("ctx : %p", ctx);
if (ecore_imf_context_input_panel_enabled_get (ctx)) {
if (!check_focus_out_by_popup_win (ctx))
if (context_scim && context_scim->impl && context_scim == _focused_ic) {
if (context_scim->impl->cursor_pos != cursor_pos) {
- LOGD ("ctx : %p, cursor pos : %d\n", ctx, cursor_pos);
+ LOGD ("ctx : %p, cursor pos : %d", ctx, cursor_pos);
context_scim->impl->cursor_pos = cursor_pos;
caps_mode_check (ctx, EINA_FALSE, EINA_TRUE);
context_scim->impl->autocapital_type = autocapital_type;
if (context_scim == _focused_ic) {
- LOGD ("ctx : %p. set autocapital type : %d\n", ctx, autocapital_type);
+ LOGD ("ctx : %p. set autocapital type : %d", ctx, autocapital_type);
_panel_client.prepare (context_scim->id);
//FIXME: must add this function for panelclient
//context_scim->impl->si->set_autocapital_type (autocapital_type);
Eina_Bool ret = EINA_FALSE;
if (ic == NULL || ic->impl == NULL) {
- LOGW ("ic is NULL\n");
+ LOGW ("ic is NULL");
return ret;
}
KeyEvent key;
_panel_client.prepare (ic->id);
_panel_client.get_active_helper_option (&_active_helper_option);
_panel_client.send ();
- ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, name: %s)\n", key.code, ev->keyname);
+ ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, name: %s)", key.code, ev->keyname);
LOGD ("Hardware keyboard mode, active helper option: %d", _active_helper_option);
}
}
if (type == ECORE_IMF_EVENT_KEY_DOWN || type == ECORE_IMF_EVENT_KEY_UP) {
if ((timestamp == 0) && !_x_key_event_is_valid) {
std::cerr << " S/W key event is not valid!!!\n";
- LOGW ("S/W key event is not valid\n");
+ LOGW ("S/W key event is not valid");
return EINA_TRUE;
}
}
if (type == ECORE_IMF_EVENT_KEY_DOWN) {
Ecore_IMF_Event_Key_Down *ev = (Ecore_IMF_Event_Key_Down *)event;
- SECURE_LOGD ("[Key-down event] ctx : %p, key_name: %s \n", ctx, ev->keyname);
+ SECURE_LOGD ("[Key-down event] ctx : %p, key_name: %s", ctx, ev->keyname);
timestamp = ev->timestamp;
scim_string_to_key (key, ev->key);
scim_set_device_info (key, ev->dev_name ? ev->dev_name : "", ev->dev_class, ev->dev_subclass);
key.mask |= _ecore_imf_lock_to_scim_mask (ev->locks);
} else if (type == ECORE_IMF_EVENT_KEY_UP) {
Ecore_IMF_Event_Key_Up *ev = (Ecore_IMF_Event_Key_Up *)event;
- SECURE_LOGD ("[Key-up event] ctx : %p, key_name: %s \n", ctx, ev->keyname);
+ SECURE_LOGD ("[Key-up event] ctx : %p, key_name: %s", ctx, ev->keyname);
timestamp = ev->timestamp;
scim_string_to_key (key, ev->key);
scim_set_device_info (key, ev->dev_name ? ev->dev_name : "", ev->dev_class, ev->dev_subclass);
key.mask |= _ecore_imf_lock_to_scim_mask (ev->locks);
} else if (type == ECORE_IMF_EVENT_MOUSE_UP) {
if (ecore_imf_context_input_panel_enabled_get (ctx)) {
- LOGD ("[Mouse-up event] ctx : %p\n", ctx);
+ LOGD ("[Mouse-up event] ctx : %p", ctx);
if (ic == _focused_ic) {
if (_change_keyboard_mode_by_touch && get_keyboard_mode () == TOOLBAR_KEYBOARD_MODE) {
isf_imf_context_set_keyboard_mode (ctx, TOOLBAR_HELPER_MODE);
- LOGD ("S/W keyboard mode by enabling ChangeKeyboardModeByTouch\n");
+ LOGD ("S/W keyboard mode by enabling ChangeKeyboardModeByTouch");
} else {
ecore_imf_context_input_panel_show (ctx);
}
}
else
- LOGE ("Can't show IME because there is no focus. ctx : %p\n", ctx);
+ LOGE ("Can't show IME because there is no focus. ctx : %p", ctx);
}
return EINA_FALSE;
} else {
context_scim->impl->input_hint = hint;
if (context_scim == _focused_ic) {
- LOGD ("ctx : %p, input hint : %#x\n", ctx, hint);
+ LOGD ("ctx : %p, input hint : %#x", ctx, hint);
_panel_client.prepare (context_scim->id);
_panel_client.set_input_hint (context_scim->id, hint);
_panel_client.send ();
context_scim->impl->bidi_direction = direction;
if (context_scim == _focused_ic) {
- LOGD ("ctx : %p, bidi direction : %#x\n", ctx, direction);
+ LOGD ("ctx : %p, bidi direction : %#x", ctx, direction);
_panel_client.prepare (context_scim->id);
_panel_client.update_bidi_direction (context_scim->id, direction);
_panel_client.send ();
send_x_key_event (key, fake);
return EINA_TRUE;
} else {
- LOGW ("Unknown key code : %d\n", key.code);
+ LOGW ("Unknown key code : %d", key.code);
return EINA_FALSE;
}
}
if (ic && ic->impl) {
if (_focused_ic != ic) {
- LOGW ("focused_ic is different from ic\n");
+ LOGW ("focused_ic is different from ic");
return;
}
ecore_imf_context_commit_event_add (ic->ctx, utf8_wcstombs (wstr).c_str ());
ecore_imf_context_event_callback_call (ic->ctx, ECORE_IMF_CALLBACK_COMMIT, const_cast<char*>(utf8_wcstombs (wstr).c_str ()));
} else {
- LOGW ("No ic\n");
+ LOGW ("No ic");
}
}
{
EcoreIMFContextISF *ic = find_ic (context);
SCIM_DEBUG_FRONTEND(1) << __FUNCTION__ << " context=" << context << " key=" << key.get_key_string () << " ic=" << ic << "\n";
- LOGD ("forward key event requested\n");
+ LOGD ("forward key event requested");
if (!(ic && ic->impl)) {
- LOGW ("No ic\n");
+ LOGW ("No ic");
return;
}
if ((_focused_ic != NULL) && (_focused_ic != ic)) {
- LOGW ("focused_ic : %p, ic : %p\n", _focused_ic, ic);
+ LOGW ("focused_ic : %p, ic : %p", _focused_ic, ic);
return;
}
if (key.get_key_string ().length () >= 116) {
- LOGW ("the length of key string is too long\n");
+ LOGW ("the length of key string is too long");
return;
}
String config_module_name = "socket";
int ret = -1;
- LOGD ("Initializing Ecore ISF IMModule...\n");
+ LOGD ("Initializing Ecore ISF IMModule...");
// Get system language.
_language = scim_get_locale_language (scim_get_current_locale ());
}
if (_config.null ()) {
- LOGW ("Config module cannot be loaded, using dummy Config.\n");
+ LOGW ("Config module cannot be loaded, using dummy Config.");
_config = new DummyConfig ();
config_module_name = "dummy";
}
ret = ecore_x_window_prop_xid_get (ecore_x_window_root_first_get (), atom, ECORE_X_ATOM_WINDOW, &_input_win, 1);
if (_input_win == 0 || ret < 1)
{
- LOGW ("Input window is NULL!\n");
+ LOGW ("Input window is NULL!");
}
// Attach Panel Client signal.
//FIXME:remove this signal
static void
finalize (void)
{
- LOGD ("Finalizing Ecore ISF IMModule...\n");
+ LOGD ("Finalizing Ecore ISF IMModule...");
SCIM_DEBUG_FRONTEND(2) << "Finalize all IC partially.\n";
while (_used_ic_impl_list) {
Display *display = (Display *)ecore_x_display_get ();
if (display == NULL) {
std::cerr << "ecore_x_display_get () failed\n";
- LOGW ("ecore_x_display_get () failed\n");
+ LOGW ("ecore_x_display_get () failed");
return;
}
// Check focus window
XGetInputFocus (display, &focus_win, &revert);
if (focus_win == None) {
- LOGW ("Input focus window is None\n");
+ LOGW ("Input focus window is None");
return;
}
// get x keysym, keycode, keyname, and key
keysym = XStringToKeysym (keysym_str);
if (keysym == NoSymbol) {
- LOGW ("NoSymbol\n");
+ LOGW ("NoSymbol");
return;
}
}
if (keycode == 0) {
- LOGW ("No Key code in the current keymap table\n");
+ LOGW ("No Key code in the current keymap table");
return;
}
static void _render_post_cb (void *data, Evas *e, void *event_info)
{
- LOGD ("[_render_post_cb], conformant_reset_done = 1\n");
+ LOGD ("[_render_post_cb], conformant_reset_done = 1");
evas_event_callback_del_full (e, EVAS_CALLBACK_RENDER_POST, _render_post_cb, NULL);
conformant_reset_done = EINA_TRUE;
isf_imf_context_input_panel_send_will_hide_ack (get_using_ic (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_SHOW));
static void _candidate_render_post_cb (void *data, Evas *e, void *event_info)
{
- LOGD ("[%s], candidate_conformant_reset_done = 1\n", __func__);
+ LOGD ("[%s], candidate_conformant_reset_done = 1", __func__);
evas_event_callback_del_full (e, EVAS_CALLBACK_RENDER_POST, _candidate_render_post_cb, NULL);
candidate_conformant_reset_done = EINA_TRUE;
isf_imf_context_input_panel_send_candidate_will_hide_ack (get_using_ic (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_SHOW));
sx = sy = sw = sh = 0;
if (state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) {
- LOGD ("conformant_reset_done = 0, candidate_conformant_reset_done = 0, registering _render_post_cb\n");
+ LOGD ("conformant_reset_done = 0, candidate_conformant_reset_done = 0, registering _render_post_cb");
conformant_reset_done = EINA_FALSE;
candidate_conformant_reset_done = EINA_FALSE;
if (active_context_canvas && _conformant_get ()) {
evas_event_callback_add (active_context_canvas, EVAS_CALLBACK_RENDER_POST, _render_post_cb, NULL);
}
- LOGD ("[ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF] geometry x : %d, y : %d, w : %d, h : %d\n", sx, sy, sw, sh);
+ LOGD ("[ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF] geometry x : %d, y : %d, w : %d, h : %d", sx, sy, sw, sh);
}
else if (state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ON) {
- LOGD ("conformant_reset_done = 0, candidate_conformant_reset_done = 0, registering _candidate_render_post_cb\n");
+ LOGD ("conformant_reset_done = 0, candidate_conformant_reset_done = 0, registering _candidate_render_post_cb");
conformant_reset_done = EINA_FALSE;
candidate_conformant_reset_done = EINA_FALSE;
_clear_will_show_timer ();
if (active_context_canvas && _conformant_get ()) {
evas_event_callback_add (active_context_canvas, EVAS_CALLBACK_RENDER_POST, _candidate_render_post_cb, NULL);
}
- LOGD ("[ECORE_X_VIRTUAL_KEYBOARD_STATE_ON] geometry x : %d, y : %d, w : %d, h : %d\n", sx, sy, sw, sh);
+ LOGD ("[ECORE_X_VIRTUAL_KEYBOARD_STATE_ON] geometry x : %d, y : %d, w : %d, h : %d", sx, sy, sw, sh);
}
}
} else {
case ECORE_IMF_INPUT_PANEL_STATE_EVENT:
switch (value) {
case ECORE_IMF_INPUT_PANEL_STATE_HIDE:
- SECURE_LOGD ("[input panel has been hidden] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[input panel has been hidden] ctx : %p", using_ic);
if (hide_req_ic == show_req_ic)
show_req_ic = NULL;
will_hide = EINA_FALSE;
break;
case ECORE_IMF_INPUT_PANEL_STATE_SHOW:
- SECURE_LOGD ("[input panel has been shown] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[input panel has been shown] ctx : %p", using_ic);
break;
case ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW:
- SECURE_LOGD ("[input panel will be shown] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[input panel will be shown] ctx : %p", using_ic);
break;
default:
break;
notified_state = (Ecore_IMF_Input_Panel_State)value;
break;
case ECORE_IMF_INPUT_PANEL_LANGUAGE_EVENT:
- SECURE_LOGD ("[language is changed] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[language is changed] ctx : %p", using_ic);
break;
case ECORE_IMF_INPUT_PANEL_SHIFT_MODE_EVENT:
- SECURE_LOGD ("[shift mode is changed] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[shift mode is changed] ctx : %p", using_ic);
break;
case ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT:
- SECURE_LOGD ("[input panel geometry is changed] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[input panel geometry is changed] ctx : %p", using_ic);
break;
case ECORE_IMF_CANDIDATE_PANEL_STATE_EVENT:
- SECURE_LOGD ("[candidate state is changed] ctx : %p, %d\n", using_ic, value);
+ SECURE_LOGD ("[candidate state is changed] ctx : %p, %d", using_ic, value);
break;
case ECORE_IMF_CANDIDATE_PANEL_GEOMETRY_EVENT:
- SECURE_LOGD ("[candidate geometry is changed] ctx : %p\n", using_ic);
+ SECURE_LOGD ("[candidate geometry is changed] ctx : %p", using_ic);
break;
case ECORE_IMF_INPUT_PANEL_KEYBOARD_MODE_EVENT:
- SECURE_LOGD ("[keyboard mode is changed] ctx : %p, mode(0:S/W, 1:H/W): %d \n", using_ic, value);
+ SECURE_LOGD ("[keyboard mode is changed] ctx : %p, mode(0:S/W, 1:H/W): %d ", using_ic, value);
break;
default:
break;
if (type == ECORE_IMF_CANDIDATE_PANEL_STATE_EVENT) {
if (value == ECORE_IMF_CANDIDATE_PANEL_HIDE) {
if (notified_state != ECORE_IMF_INPUT_PANEL_STATE_HIDE) {
- SECURE_LOGD ("received_candidate_will_hide_event = 1\n");
+ SECURE_LOGD ("received_candidate_will_hide_event = 1");
received_candidate_will_hide_event = TRUE;
isf_imf_context_input_panel_send_candidate_will_hide_ack (using_ic);
} else {
- SECURE_LOGD ("received_candidate_will_hide_event != 1, due to notified_state\n");
+ SECURE_LOGD ("received_candidate_will_hide_event != 1, due to notified_state");
}
} else if (value == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
- SECURE_LOGD ("received_candidate_will_hide_event = 0\n");
+ SECURE_LOGD ("received_candidate_will_hide_event = 0");
received_candidate_will_hide_event = EINA_FALSE;
}
}
_win_focus_out_handler_del ();
- SECURE_LOGD ("Send input panel hide request\n");
+ SECURE_LOGD ("Send input panel hide request");
_isf_imf_context_input_panel_hide (get_panel_client_id (), hide_context_id);
hide_context_id = -1;
static Eina_Bool _will_show_timer_handler (void *data)
{
- SECURE_LOGD ("reset input panel state as HIDE\n");
+ SECURE_LOGD ("reset input panel state as HIDE");
input_panel_state = ECORE_IMF_INPUT_PANEL_STATE_HIDE;
will_show_timer = NULL;
Ecore_X_Window focus_out_win = e->win;
Ecore_X_Window focus_in_win = ecore_x_window_focus_get ();
- LOGD ("ctx : %p, client_window : %#x, focus-out win : %#x, focus-in win : %#x\n", ctx, client_win, focus_out_win, focus_in_win);
+ LOGD ("ctx : %p, client_window : %#x, focus-out win : %#x, focus-in win : %#x", ctx, client_win, focus_out_win, focus_in_win);
if (check_focus_out_by_popup_win (ctx))
return ECORE_CALLBACK_PASS_ON;
if (!ecore_x_netwm_window_type_get (focus_win, &win_type))
return EINA_FALSE;
- LOGD ("win type : %d\n", win_type);
+ LOGD ("win type : %d", win_type);
if (win_type == ECORE_X_WINDOW_TYPE_POPUP_MENU ||
win_type == ECORE_X_WINDOW_TYPE_NOTIFICATION) {
- LOGD ("client window : %#x, focus window : %#x\n", client_win, focus_win);
+ LOGD ("client window : %#x, focus window : %#x", client_win, focus_win);
if (client_win != focus_win) {
ret = EINA_TRUE;
ecore_x_icccm_name_class_get (focus_win, NULL, &class_name);
if (class_name) {
- LOGD ("window class name : %s\n", class_name);
+ LOGD ("window class name : %s", class_name);
for (unsigned int i = 0; i < lock_screen_class_names.size (); ++i) {
if (!strcmp (class_name, lock_screen_class_names [i].c_str ())) {
ret = EINA_FALSE;
kbd_mode = TOOLBAR_HELPER_MODE;
}
}
- LOGD ("keyboard mode(0:H/W Keyboard, 1:S/W Keyboard): %d\n", kbd_mode);
+ LOGD ("keyboard mode(0:H/W Keyboard, 1:S/W Keyboard): %d", kbd_mode);
}
void isf_imf_input_panel_shutdown (void)
_send_input_panel_hide_request ();
}
else
- LOGD ("No hide timer\n");
+ LOGD ("No hide timer");
}
candidate_conformant_reset_done = TRUE;
- SECURE_LOGD ("candidate_conformant_reset_done = 1\n");
+ SECURE_LOGD ("candidate_conformant_reset_done = 1");
Ecore_IMF_Context *active_ctx = get_using_ic (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_SHOW);
if (active_ctx) {
save_current_xid (ctx);
if (kbd_mode == TOOLBAR_KEYBOARD_MODE) {
- LOGD ("H/W keyboard is existed.\n");
+ LOGD ("H/W keyboard is existed.");
return;
}
Ecore_IMF_Input_Panel_State state = ecore_imf_context_input_panel_state_get (ctx);
if (state == ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW ||
state == ECORE_IMF_INPUT_PANEL_STATE_SHOW) {
- LOGD ("already show\n");
+ LOGD ("already show");
return;
}
}
iseContext.bidi_direction = ecore_imf_context_bidi_direction_get (ctx);
- SECURE_LOGD ("ctx : %p, layout : %d, layout variation : %d\n", ctx, iseContext.layout, iseContext.layout_variation);
- SECURE_LOGD ("language : %d, cursor position : %d, caps mode : %d\n", iseContext.language, iseContext.cursor_pos, iseContext.caps_mode);
- SECURE_LOGD ("return_key_type : %d, return_key_disabled : %d, autocapital type : %d\n", iseContext.return_key_type, iseContext.return_key_disabled, iseContext.autocapital_type);
- SECURE_LOGD ("client_window : %#x, password mode : %d, prediction_allow : %d\n", iseContext.client_window, iseContext.password_mode, iseContext.prediction_allow);
- SECURE_LOGD ("input hint : %#x\n", iseContext.input_hint);
- SECURE_LOGD ("bidi direction : %d\n", iseContext.bidi_direction);
+ SECURE_LOGD ("ctx : %p, layout : %d, layout variation : %d", ctx, iseContext.layout, iseContext.layout_variation);
+ SECURE_LOGD ("language : %d, cursor position : %d, caps mode : %d", iseContext.language, iseContext.cursor_pos, iseContext.caps_mode);
+ SECURE_LOGD ("return_key_type : %d, return_key_disabled : %d, autocapital type : %d", iseContext.return_key_type, iseContext.return_key_disabled, iseContext.autocapital_type);
+ SECURE_LOGD ("client_window : %#x, password mode : %d, prediction_allow : %d", iseContext.client_window, iseContext.password_mode, iseContext.prediction_allow);
+ SECURE_LOGD ("input hint : %#x", iseContext.input_hint);
+ SECURE_LOGD ("bidi direction : %d", iseContext.bidi_direction);
if (iseContext.client_window != ecore_x_window_focus_get ()) {
- LOGW ("Client window is different from focus window. client win : %#x, focus win : %#x\n", iseContext.client_window, ecore_x_window_focus_get ());
+ LOGW ("Client window is different from focus window. client win : %#x, focus win : %#x", iseContext.client_window, ecore_x_window_focus_get ());
}
/* calculate packet size */
void isf_imf_context_input_panel_hide (Ecore_IMF_Context *ctx)
{
- SECURE_LOGD ("ctx : %p\n", ctx);
+ SECURE_LOGD ("ctx : %p", ctx);
_input_panel_hide (ctx, EINA_FALSE);
}
EcoreIMFContextISF *context_scim = (EcoreIMFContextISF *)ecore_imf_context_data_get (ctx);
if (context_scim == get_focused_ic ()) {
- SECURE_LOGD ("language mode : %d\n", language);
+ SECURE_LOGD ("language mode : %d", language);
_isf_imf_context_input_panel_language_set (_get_context_id (ctx), language);
}
}
void isf_imf_context_input_panel_caps_mode_set (Ecore_IMF_Context *ctx, unsigned int mode)
{
- SECURE_LOGD ("ctx : %p, mode : %d\n", ctx, mode);
+ SECURE_LOGD ("ctx : %p, mode : %d", ctx, mode);
_isf_imf_context_input_panel_caps_mode_set (_get_context_id (ctx), mode);
}
{
_isf_imf_context_input_panel_geometry_get (_get_context_id (ctx), x, y, w, h);
- SECURE_LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d\n", ctx, *x, *y, *w, *h);
+ SECURE_LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d", ctx, *x, *y, *w, *h);
}
/**
EcoreIMFContextISF *context_scim = (EcoreIMFContextISF *)ecore_imf_context_data_get (ctx);
if (context_scim == get_focused_ic ()) {
- SECURE_LOGD ("Return key type : %d\n", type);
+ SECURE_LOGD ("Return key type : %d", type);
_isf_imf_context_input_panel_return_key_type_set (_get_context_id (ctx), type);
}
}
EcoreIMFContextISF *context_scim = (EcoreIMFContextISF *)ecore_imf_context_data_get (ctx);
if (context_scim == get_focused_ic ()) {
- SECURE_LOGD ("Return key disabled : %d\n", disabled);
+ SECURE_LOGD ("Return key disabled : %d", disabled);
_isf_imf_context_input_panel_return_key_disabled_set (_get_context_id (ctx), disabled);
}
}
EcoreIMFContextISF *context_scim = (EcoreIMFContextISF *)ecore_imf_context_data_get (ctx);
if (context_scim == get_focused_ic ()) {
- SECURE_LOGD ("layout type : %d\n", layout);
+ SECURE_LOGD ("layout type : %d", layout);
_isf_imf_context_input_panel_layout_set (_get_context_id (ctx), layout);
imengine_layout_set (ctx, layout);
}
{
Ecore_IMF_Input_Panel_State state;
_isf_imf_context_input_panel_state_get (_get_context_id (ctx), state);
- LOGD (" state:%d\n", state);
+ LOGD ("state:%d", state);
return state;
}
{
_isf_imf_context_candidate_window_geometry_get (_get_context_id (ctx), x, y, w, h);
- SECURE_LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d\n", ctx, *x, *y, *w, *h);
+ SECURE_LOGD ("ctx : %p, x : %d, y : %d, w : %d, h : %d", ctx, *x, *y, *w, *h);
}
void isf_imf_context_input_panel_send_will_show_ack (Ecore_IMF_Context *ctx)
{
if (_conformant_get ()) {
if (conformant_reset_done && received_will_hide_event) {
- LOGD ("Send will hide ack, conformant_reset_done = 0, received_will_hide_event = 0\n");
+ LOGD ("Send will hide ack, conformant_reset_done = 0, received_will_hide_event = 0");
_isf_imf_context_input_panel_send_will_hide_ack (_get_context_id (ctx));
conformant_reset_done = EINA_FALSE;
received_will_hide_event = EINA_FALSE;
} else {
- LOGD ("conformant_reset_done=%d, received_will_hide_event=%d\n",
+ LOGD ("conformant_reset_done=%d, received_will_hide_event=%d",
conformant_reset_done, received_will_hide_event);
}
} else {
if (_support_hw_keyboard_mode) {
kbd_mode = mode;
- SECURE_LOGD ("keyboard mode : %d\n", kbd_mode);
+ SECURE_LOGD ("keyboard mode : %d", kbd_mode);
will_hide = EINA_TRUE;
hide_req_ic = ctx;
_isf_imf_context_set_keyboard_mode (_get_context_id (ctx), mode);
{
if (_conformant_get ()) {
if (candidate_conformant_reset_done && received_candidate_will_hide_event) {
- LOGD ("Send candidate will hide ack, cand_conf_reset_done = 0, recv_cand_will_hide = 0\n");
+ LOGD ("Send candidate will hide ack, cand_conf_reset_done = 0, recv_cand_will_hide = 0");
_isf_imf_context_input_panel_send_candidate_will_hide_ack (_get_context_id (ctx));
candidate_conformant_reset_done = EINA_FALSE;
received_candidate_will_hide_event = EINA_FALSE;
}
else {
- LOGD ("isf_imf_context_input_panel_send_will_hide_ack, cand_conf_reset_done=%d recv_cand_will_hide=%d\n",
+ LOGD ("isf_imf_context_input_panel_send_will_hide_ack, cand_conf_reset_done=%d recv_cand_will_hide=%d",
candidate_conformant_reset_done, received_candidate_will_hide_event);
}
} else {
EcoreIMFContextISF *context_scim = (EcoreIMFContextISF *)ecore_imf_context_data_get (ctx);
if (context_scim == get_focused_ic ()) {
- SECURE_LOGD ("input mode : %d\n", input_mode);
+ SECURE_LOGD ("input mode : %d", input_mode);
_isf_imf_context_input_panel_input_mode_set (_get_context_id (ctx), input_mode);
}
}
_event_callback_call (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_SHOW);
received_will_hide_event = EINA_FALSE;
- LOGD ("received_will_hide_event = 0\n");
+ LOGD ("received_will_hide_event = 0");
return true;
}
_event_callback_call (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_HIDE);
received_will_hide_event = EINA_TRUE;
- LOGD ("received_will_hide_event = 1\n");
+ LOGD ("received_will_hide_event = 1");
isf_imf_context_input_panel_send_will_hide_ack (get_using_ic (ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_HIDE));
return true;
ctxd = isf_imf_context_new ();
if (!ctxd) {
- LOGW ("isf_imf_context_new () failed!!!\n");
+ LOGW ("isf_imf_context_new () failed!!!");
return NULL;
}
atom = ecore_x_atom_get (E_PROP_DEVICEMGR_INPUTWIN);
win_ret = ecore_x_window_prop_window_get (ecore_x_window_root_first_get (), atom, &_input_win, 1);
if (_input_win == 0 || win_ret < 1) {
- LOGW ("Input window is NULL!\n");
+ LOGW ("Input window is NULL!");
} else {
ecore_x_event_mask_set (_input_win, ECORE_X_EVENT_MASK_WINDOW_PROPERTY);
}
/* Try to get in global packages */
ret = pkgmgrinfo_appinfo_get_appinfo (appid, handle);
if (ret != PMINFO_R_OK) {
- LOGW ("[pkgmgrinfo_appinfo_get_appinfo] appid : '%s', ret : %d\n", appid, ret);
+ LOGW ("[pkgmgrinfo_appinfo_get_appinfo] appid : '%s', ret : %d", appid, ret);
/* Try to get in user packages */
ret = pkgmgrinfo_appinfo_get_usr_appinfo (appid, getuid (), handle);
if (ret != PMINFO_R_OK)
- LOGW ("[pkgmgrinfo_appinfo_get_usr_appinfo] appid : '%s', ret : %d\n", appid, ret);
+ LOGW ("[pkgmgrinfo_appinfo_get_usr_appinfo] appid : '%s', ret : %d", appid, ret);
}
return ret;
char *str = NULL;
if (!msg) {
- LOGW ("No Message\n");
+ LOGW ("No Message");
return;
}
if (dbus_message_is_signal (msg, HOST_INTERFACE_NAME, HOST_KEYBOARD_SIGNAL) == 0) {
- LOGW ("HOST_KEYBOARD_SIGNAL\n");
+ LOGW ("HOST_KEYBOARD_SIGNAL");
return;
}
dbus_error_init (&err);
if (dbus_message_get_args (msg, &err, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID) == 0) {
- LOGW ("DBUS_TYPE_INVALID\n");
+ LOGW ("DBUS_TYPE_INVALID");
return;
}
if (!str) return;
if (!strncmp (str, HOST_ADDED, strlen (HOST_ADDED))) {
- LOGD ("HOST_ADDED\n");
+ LOGD ("HOST_ADDED");
return;
}
if (!strncmp (str, HOST_REMOVED, strlen (HOST_REMOVED))) {
- LOGD ("HOST_REMOVED\n");
+ LOGD ("HOST_REMOVED");
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_KEYBOARD_MODE) {
change_keyboard_mode (TOOLBAR_HELPER_MODE);
}
return;
}
- LOGW ("ERROR: msg (%s) is improper\n", str);
+ LOGW ("ERROR: msg (%s) is improper", str);
}
static void unregister_edbus_signal_handler (void)
{
if (edbus_conn) {
- LOGD ("unregister signal handler for keyboard\n");
+ LOGD ("unregister signal handler for keyboard");
if (edbus_handler) {
e_dbus_signal_handler_del (edbus_conn, edbus_handler);
edbus_handler = NULL;
static int register_edbus_signal_handler (void)
{
int retry;
- LOGD ("start register_edbus_signal_handler\n");
+ LOGD ("start register_edbus_signal_handler");
retry = 0;
while (e_dbus_init () == 0) {
retry++;
if (retry >= 10) {
- LOGW ("retry fail\n");
+ LOGW ("retry fail");
return -1;
}
}
edbus_conn = e_dbus_bus_get (DBUS_BUS_SYSTEM);
if (!edbus_conn) {
- LOGW ("connection fail\n");
+ LOGW ("connection fail");
return -1;
}
edbus_handler = e_dbus_signal_handler_add (edbus_conn, NULL, HOST_OBJECT_PATH, HOST_INTERFACE_NAME, HOST_KEYBOARD_SIGNAL, usb_keyboard_signal_cb, NULL);
if (!edbus_handler) {
- LOGW ("cannot register signal\n");
+ LOGW ("cannot register signal");
return -1;
}
- LOGD ("Success register\n");
+ LOGD ("Success register");
return 0;
}
if (noti_data->noti_id != 0) {
notification_delete_by_priv_id ("isf-panel-efl", NOTIFICATION_TYPE_ONGOING, noti_data->noti_id);
- LOGD ("deleted notification : %s\n", noti_data->launch_app.c_str ());
+ LOGD ("deleted notification : %s", noti_data->launch_app.c_str ());
noti_data->noti_id = 0;
}
}
notification_set_launch_option (notification, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL, (void *)service);
ret = notification_insert (notification, ¬i_data->noti_id);
if (ret != NOTIFICATION_ERROR_NONE) {
- LOGW ("Failed to insert notification. error code : %d\n", ret);
+ LOGW ("Failed to insert notification. error code : %d", ret);
}
app_control_destroy (service);
}
else {
- LOGW ("Failed to create appcontrol\n");
+ LOGW ("Failed to create appcontrol");
}
notification_free (notification);
}
else {
- LOGW ("Failed to create notification\n");
+ LOGW ("Failed to create notification");
}
}
#endif /* HAVE_NOTIFICATION */
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " str=" << str << ", length=" << str.length () << "\n";
if (str.length () <= 0) {
- LOGW ("str is empty!!!\n");
+ LOGW ("str is empty!!!");
return false;
}
if (i - 1 < EMOJI_IMAGE_END)
image_token->emoji_option [i - 1] = atoi (tag_str[i]);
else
- LOGW ("emoji option is more than EMOJI_IMAGE_END!!!\n");
+ LOGW ("emoji option is more than EMOJI_IMAGE_END!!!");
}
}
elm_image_animated_set (_candidate_image [_candidate_image_count], EINA_TRUE);
elm_image_animated_play_set (_candidate_image [_candidate_image_count], EINA_TRUE);
elm_image_object_size_get (_candidate_image [_candidate_image_count], &image_get_width, &image_get_height);
- LOGD ("image_path=%s, key=%s\n", image_data.path.c_str (), image_key);
+ LOGD ("image_path=%s, key=%s", image_data.path.c_str (), image_key);
if (image_get_height > image_get_width)
image_rate = ((double)candidate_image_height / (double)image_get_width);
}
}
- LOGD ("angle : %d, w_angle : %d, mode : %d, Geometry : %d %d %d %d\n",
+ LOGD ("angle : %d, w_angle : %d, mode : %d, Geometry : %d %d %d %d",
angle, _ise_angle,
_info_manager->get_current_toolbar_mode (),
info.pos_x, info.pos_y, info.width, info.height);
}
ecore_x_e_illume_keyboard_geometry_set (window, ise_rect.pos_x, ise_rect.pos_y, ise_rect.width, ise_rect.height);
- LOGD ("KEYBOARD_GEOMETRY_SET : %d %d %d %d\n", ise_rect.pos_x, ise_rect.pos_y, ise_rect.width, ise_rect.height);
+ LOGD ("KEYBOARD_GEOMETRY_SET : %d %d %d %d", ise_rect.pos_x, ise_rect.pos_y, ise_rect.width, ise_rect.height);
SCIM_DEBUG_MAIN (3) << " KEYBOARD_GEOMETRY x=" << ise_rect.pos_x << " y=" << ise_rect.pos_y
<< " width=" << ise_rect.width << " height=" << ise_rect.height << "\n";
bool user = false;
if (!pkgid) {
- LOGW ("pkgid is null.\n");
+ LOGW ("pkgid is null.");
return 0;
}
/* Try to get in user packages */
ret = pkgmgrinfo_pkginfo_get_usr_pkginfo (pkgid, uid, &handle);
if (ret != PMINFO_R_OK) {
- LOGW ("Failed to call pkgmgrinfo_pkginfo_get_pkginfo & get_usr_pkginfo(\"%s\",~) returned %d\n", pkgid, ret);
+ LOGW ("Failed to call pkgmgrinfo_pkginfo_get_pkginfo & get_usr_pkginfo(\"%s\",~) returned %d", pkgid, ret);
return 0;
}
else {
}
if (ret != PMINFO_R_OK) {
- LOGW ("Failed to call %s failed(%d)\n", user ? "pkgmgrinfo_appinfo_get_usr_list" : "pkgmgrinfo_appinfo_get_list", ret);
+ LOGW ("Failed to call %s failed(%d)", user ? "pkgmgrinfo_appinfo_get_usr_list" : "pkgmgrinfo_appinfo_get_list", ret);
ret = 0;
}
if (total_appids.size() > 0)
_info_manager->update_ise_list (total_appids);
- LOGD ("Try to start the initial helper\n");
+ LOGD ("Try to start the initial helper");
set_active_ise(_initial_ise_uuid, true);
for (iter = g_pkgids_to_be_uninstalled.begin (); iter != g_pkgids_to_be_uninstalled.end (); iter++) {
if (ret > 1 && _soft_keyboard_launched) { // If the previous appid of pkgid is the current IME, restart it with new appid.
current_ime_appid = scim_global_config_read(String(SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), _initial_ise_uuid);
if (current_ime_appid.compare (appids.front ()) == 0) {
- LOGD ("Stop IME(%s)\n", current_ime_appid.c_str ());
+ LOGD ("Stop IME(%s)", current_ime_appid.c_str ());
_info_manager->hide_helper (current_ime_appid);
_info_manager->stop_helper (current_ime_appid);
- LOGD ("Start IME(%s)\n", appids.back ().c_str ());
+ LOGD ("Start IME(%s)", appids.back ().c_str ());
scim_global_config_write (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), appids.back ());
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
_info_manager->start_helper (appids.back ());
if (std::find(appids.begin(), appids.end(), current_ime_appid) != appids.end()) { // If the current ISE package is updated, restart it.
for (it = _ime_info.begin (); it != _ime_info.end (); it++) {
if (it->mode == TOOLBAR_HELPER_MODE && it->appid.compare(current_ime_appid) == 0) { // Make sure it's Helper ISE...
- LOGD ("Restart IME(%s)\n", current_ime_appid.c_str ());
+ LOGD ("Restart IME(%s)", current_ime_appid.c_str ());
_info_manager->hide_helper (current_ime_appid);
_info_manager->stop_helper (current_ime_appid);
_info_manager->start_helper (current_ime_appid);
if (_soft_keyboard_launched && std::find(appids.begin(), appids.end(), current_ime_appid) != appids.end()) { // If the updated IME is the current ISE...
for (it = _ime_info.begin (); it != _ime_info.end (); it++) {
if (it->appid.compare(current_ime_appid) == 0 && it->mode == TOOLBAR_HELPER_MODE) { // Make sure it's Helper ISE...
- LOGD ("Stop IME(%s)\n", current_ime_appid.c_str ());
+ LOGD ("Stop IME(%s)", current_ime_appid.c_str ());
_info_manager->hide_helper (current_ime_appid);
_info_manager->stop_helper (current_ime_appid);
_soft_keyboard_launched = false;
}
if (appids.size () > 0) // Probably appids size is 1.
- LOGD ("Delete IME(%s)\n", appids[0].c_str ());
+ LOGD ("Delete IME(%s)", appids[0].c_str ());
if (isf_db_delete_ime_info_by_pkgid(package)) { // Delete package from ime_info db.
_update_ime_info();
}
}
else {
- LOGW ("isf_db_select_appids_by_pkgid returned %d.\n", ret);
+ LOGW ("isf_db_select_appids_by_pkgid returned %d.", ret);
}
}
}
}
else if (event_type == PACKAGE_MANAGER_EVENT_TYPE_INSTALL) {
if (event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED) {
- LOGD ("type=%s package=%s event_type=INSTALL event_state=COMPLETED progress=%d error=%d\n", type, package, progress, error);
+ LOGD ("type=%s package=%s event_type=INSTALL event_state=COMPLETED progress=%d error=%d", type, package, progress, error);
///////////////// UNINSTALL -> INSTALL and if the uninstalled IME is reinstalled /////////////////
if (g_stopped_helper_pkgid.compare(package) == 0 && g_start_default_helper_timer) {
- LOGD ("Cancel timer to start the default IME\n");
+ LOGD ("Cancel timer to start the default IME");
ecore_timer_del(g_start_default_helper_timer);
g_start_default_helper_timer = NULL;
g_stopped_helper_pkgid = "";
if (total_appids.size() > 0)
_info_manager->update_ise_list (total_appids);
- LOGD ("Restart IME(%s)\n", appids[0].c_str ());
+ LOGD ("Restart IME(%s)", appids[0].c_str ());
scim_global_config_write (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), appids[0]);
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
_info_manager->start_helper (appids[0]);
}
}
else {
- LOGW ("isf_db_select_appids_by_pkgid returned %d.\n", ret);
+ LOGW ("isf_db_select_appids_by_pkgid returned %d.", ret);
_update_ime_info();
}
}
else {
- LOGW ("_isf_insert_ime_info_by_pkgid returned %d.\n", ret);
+ LOGW ("_isf_insert_ime_info_by_pkgid returned %d.", ret);
}
}
else { // If new package is installed...
if (g_updated_helper_pkgid.compare(package) == 0) {
for (it = _ime_info.begin(); it != _ime_info.end(); it++) {
if (it->mode == TOOLBAR_HELPER_MODE && it->pkgid.compare(package) == 0) {
- LOGD ("Start IME(%s)\n", it->appid.c_str ());
+ LOGD ("Start IME(%s)", it->appid.c_str ());
scim_global_config_write (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), it->appid);
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
_info_manager->start_helper (it->appid);
///////////////// END /////////////////
}
else if (ret == 0) {
- LOGW ("_isf_insert_ime_info_by_pkgid returned %d.\n", ret);
+ LOGW ("_isf_insert_ime_info_by_pkgid returned %d.", ret);
}
}
}
else if (event_type == PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL) {
switch (event_state) {
case PACKAGE_MANAGER_EVENT_STATE_STARTED:
- LOGD ("type=%s package=%s event_type=UNINSTALL event_state=STARTED progress=%d error=%d\n", type, package, progress, error);
+ LOGD ("type=%s package=%s event_type=UNINSTALL event_state=STARTED progress=%d error=%d", type, package, progress, error);
{
// Need to check if there is "http://tizen.org/category/ime" category; it can be done by comparing pkgid with ime_info db.
int imeCnt = 0;
if (imeCnt > 0) {
// There might be more than one appid for one pkgid, but let's assume Helper always has one appid per a pkgid. Stop Helper ISE, but not delete it from ime_info db.
- LOGD ("%s for pkgid(\"%s\") is about to be deleted\n", it->appid.c_str (), package);
+ LOGD ("%s for pkgid(\"%s\") is about to be deleted", it->appid.c_str (), package);
g_pkgids_to_be_uninstalled.push_back(std::make_pair (String(package), it->is_enabled));
if (_soft_keyboard_launched && isf_db_select_appids_by_pkgid(package, appids)) {
if (std::find(appids.begin(), appids.end(), current_ime_appid) != appids.end()) { // If the uninstalled IME is the current ISE... appids size is probably 1.
for (it = _ime_info.begin (); it != _ime_info.end (); it++) {
if (it->appid.compare(current_ime_appid) == 0 && it->mode == TOOLBAR_HELPER_MODE) { // Make sure it's Helper ISE...
- LOGD ("Stop IME(%s)\n", current_ime_appid.c_str ());
+ LOGD ("Stop IME(%s)", current_ime_appid.c_str ());
_info_manager->hide_helper (current_ime_appid);
_info_manager->stop_helper (current_ime_appid);
_soft_keyboard_launched = false;
break;
case PACKAGE_MANAGER_EVENT_STATE_COMPLETED:
- LOGD ("type=%s package=%s event_type=UNINSTALL event_state=COMPLETED progress=%d error=%d\n", type, package, progress, error);
+ LOGD ("type=%s package=%s event_type=UNINSTALL event_state=COMPLETED progress=%d error=%d", type, package, progress, error);
for (it3 = g_pkgids_to_be_uninstalled.begin (); it3 != g_pkgids_to_be_uninstalled.end (); it3++) {
if (it3->first.compare(package) == 0) {
if (g_stopped_helper_pkgid.compare(package) == 0) { // If the uninstalled ISE is the current ISE, start the initial helper ISE by timer.
if (g_start_default_helper_timer)
ecore_timer_del(g_start_default_helper_timer);
- LOGD ("Add timer to start the default IME\n");
+ LOGD ("Add timer to start the default IME");
g_start_default_helper_timer = ecore_timer_add(3.0, _start_default_helper_timer, NULL);
}
else { // Need to clean up g_pkgids_to_be_uninstalled info unless the same package is installed again; e.g., UNINSTALL -> INSTALL case.
if (g_release_uninstalled_ime_info_timer)
ecore_timer_del(g_release_uninstalled_ime_info_timer);
- LOGD ("Add timer to release uninstalled IME pkg info\n");
+ LOGD ("Add timer to release uninstalled IME pkg info");
g_release_uninstalled_ime_info_timer = ecore_timer_add(7.0, _release_uninstalled_pkginfo_timer, NULL);
}
break;
case PACKAGE_MANAGER_EVENT_STATE_FAILED:
- LOGD ("type=%s package=%s event_type=UNINSTALL event_state=FAILED progress=%d error=%d\n", type, package, progress, error);
+ LOGD ("type=%s package=%s event_type=UNINSTALL event_state=FAILED progress=%d error=%d", type, package, progress, error);
for (it3 = g_pkgids_to_be_uninstalled.begin (); it3 != g_pkgids_to_be_uninstalled.end (); it3++) {
if (it3->first.compare(package) == 0) {
if (ret == 1 && appids.size () == 1) {
for (it = _ime_info.begin (); it != _ime_info.end (); it++) {
if (it->appid.compare(appids[0]) == 0 && it->mode == TOOLBAR_HELPER_MODE) { // Make sure it's Helper ISE...
- LOGD ("Restart IME(%s)\n", appids[0].c_str ());
+ LOGD ("Restart IME(%s)", appids[0].c_str ());
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
_info_manager->start_helper (appids[0]);
_soft_keyboard_launched = true;
}
}
else {
- LOGW ("isf_db_select_appids_by_pkgid returned %d.\n", ret);
+ LOGW ("isf_db_select_appids_by_pkgid returned %d.", ret);
}
g_stopped_helper_pkgid = "";
}
TOOLBAR_MODE_T mode = _info_manager->get_current_toolbar_mode ();
String pre_uuid = _info_manager->get_current_helper_uuid ();
- LOGD ("pre_appid=%s, appid=%s, launch_ise=%d, %d\n", pre_uuid.c_str(), uuid.c_str(), launch_ise, _soft_keyboard_launched);
+ LOGD ("pre_appid=%s, appid=%s, launch_ise=%d, %d", pre_uuid.c_str(), uuid.c_str(), launch_ise, _soft_keyboard_launched);
if (pre_uuid == uuid && _soft_keyboard_launched)
return true;
_info_manager->hide_helper (pre_uuid);
_info_manager->stop_helper (pre_uuid);
_soft_keyboard_launched = false;
- LOGD ("stop helper : %s\n", pre_uuid.c_str ());
+ LOGD ("stop helper : %s", pre_uuid.c_str ());
}
if (launch_ise) {
- LOGD ("Start helper (%s)\n", uuid.c_str ());
+ LOGD ("Start helper (%s)", uuid.c_str ());
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
if (_info_manager->start_helper (uuid))
static bool set_active_ise (const String &uuid, bool launch_ise)
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
- LOGD ("set ISE (%s) %d\n", uuid.c_str(), launch_ise);
+ LOGD ("set ISE (%s) %d", uuid.c_str(), launch_ise);
if (uuid.length () <= 0)
return false;
if (ret == PMINFO_R_OK) {
ret = pkgmgrinfo_appinfo_filter_count(handle, &ime_num);
if (ret != PMINFO_R_OK) {
- LOGW("pkgmgrinfo_appinfo_filter_count failed(%d)\n", ret);
+ LOGW("pkgmgrinfo_appinfo_filter_count failed(%d)", ret);
}
}
pkgmgrinfo_appinfo_filter_destroy (handle);
if (valid)
ise_changed = set_helper_ise (_ime_info[i].appid, launch_ise);
else
- LOGW ("Helper ISE(appid=\"%s\",module_name=\"%s\") is not valid.\n", _ime_info[i].appid.c_str (), _ime_info[i].module_name.c_str ());
+ LOGW ("Helper ISE(appid=\"%s\",module_name=\"%s\") is not valid.", _ime_info[i].appid.c_str (), _ime_info[i].module_name.c_str ());
}
else {
- LOGW ("Helper ISE(appid=\"%s\") is not enabled.\n", _ime_info[i].appid.c_str ());
+ LOGW ("Helper ISE(appid=\"%s\") is not enabled.", _ime_info[i].appid.c_str ());
}
}
_info_manager->set_current_toolbar_mode (_ime_info[i].mode);
#endif
}
else {
- LOGW ("Failed to launch IME (%s)\n", uuid.c_str ());
+ LOGW ("Failed to launch IME (%s)", uuid.c_str ());
}
return ise_changed;
}
}
- LOGW ("Failed to launch IME (%s)\n", uuid.c_str ());
+ LOGW ("Failed to launch IME (%s)", uuid.c_str ());
return false;
}
int height;
- LOGD ("%s (w: %d, h: %d)\n", __func__, new_width, new_height);
+ LOGD ("%s (w: %d, h: %d)", __func__, new_width, new_height);
evas_object_resize (_aux_line, new_width, 2);
_candidate_width = new_width;
_candidate_height = new_height;
}
}
- LOGD ("window_rotation_geometry_set (_candidate_window), port (%d, %d), land (%d, %d)\n",
+ LOGD ("window_rotation_geometry_set (_candidate_window), port (%d, %d), land (%d, %d)",
port_width, port_height, land_width, land_height);
#ifdef HAVE_ECOREX
// WILL_HIDE_REQUEST_DONE Ack to WM
Ecore_X_Window root_window = ecore_x_window_root_get (_control_window);
//ecore_x_e_virtual_keyboard_off_prepare_done_send (root_window, _control_window);
- LOGD ("_ecore_x_e_virtual_keyboard_off_prepare_done_send (%x, %x)\n",
+ LOGD ("_ecore_x_e_virtual_keyboard_off_prepare_done_send (%x, %x)",
root_window, _control_window);
_off_prepare_done_timer = NULL;
*/
static void delete_candidate_hide_timer (void)
{
- LOGD ("deleting candidate_hide_timer\n");
+ LOGD ("deleting candidate_hide_timer");
if (_candidate_hide_timer) {
ecore_timer_del (_candidate_hide_timer);
_candidate_hide_timer = NULL;
delete_candidate_hide_timer ();
_candidate_state = WINDOW_STATE_HIDE;
- LOGD ("evas_object_hide (_candidate_window, %p)\n", elm_win_xwindow_get (_candidate_window));
+ LOGD ("evas_object_hide (_candidate_window, %p)", elm_win_xwindow_get (_candidate_window));
if (_candidate_window) {
/* There are cases that when there are rapid ISE_HIDE and ISE_SHOW requests,
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
- LOGD ("calling candidate_window_hide ()\n");
+ LOGD ("calling candidate_window_hide ()");
candidate_window_hide ();
return ECORE_CALLBACK_CANCEL;
Ecore_X_Event_Window_Show *e = (Ecore_X_Event_Window_Show*)event;
if (_candidate_state == WINDOW_STATE_WILL_SHOW) {
if (e->win == elm_win_xwindow_get (_candidate_window)) {
- LOGD ("Candidate window show callback\n");
+ LOGD ("Candidate window show callback");
/* If our candidate window is in WILL_SHOW state and this show callback was called,
now we are finally displayed on to the screen */
}
} else {
if (e->win == elm_win_xwindow_get (_candidate_window)) {
- LOGD ("Candidate window show callback, but _candidate_state is %d\n", _candidate_state);
+ LOGD ("Candidate window show callback, but _candidate_state is %d", _candidate_state);
}
}
/* If the ISE is not visible currently, wait for the ISE to be opened and then show our candidate window */
_candidate_show_requested = true;
if ((_info_manager->get_current_toolbar_mode () == TOOLBAR_HELPER_MODE) && (_ise_state != WINDOW_STATE_SHOW)) {
- LOGD ("setting _show_candidate_requested to TRUE\n");
+ LOGD ("setting _show_candidate_requested to TRUE");
return;
}
struct rectinfo info = {0, 0, 0, 0};
info.pos_y = _screen_width > _screen_height ? _screen_width : _screen_height;
set_keyboard_geometry_atom_info (_app_window, info);
- LOGD ("Conformant reset for window %x\n", _app_window);
+ LOGD ("Conformant reset for window %x", _app_window);
_app_window = current_app_window;
}
}
/* If we are in hardware keyboard mode, this candidate window is now considered to be a input panel */
if (_candidate_mode == FIXED_CANDIDATE_WINDOW) {
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_KEYBOARD_MODE) {
- LOGD ("sending ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW\n");
+ LOGD ("sending ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW");
_info_manager->update_input_panel_event ((uint32)ECORE_IMF_INPUT_PANEL_STATE_EVENT, (uint32)ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW);
}
}
if (_candidate_state != WINDOW_STATE_SHOW) {
#ifdef HAVE_ECOREX
if (_candidate_show_handler) {
- LOGD ("Was still waiting for CANDIDATE_WINDOW_SHOW....\n");
+ LOGD ("Was still waiting for CANDIDATE_WINDOW_SHOW....");
} else {
delete_candidate_show_handler ();
- LOGD ("Registering ECORE_X_EVENT_WINDOW_SHOW event, %d\n", _candidate_state);
+ LOGD ("Registering ECORE_X_EVENT_WINDOW_SHOW event, %d", _candidate_state);
_candidate_show_handler = ecore_event_handler_add (ECORE_X_EVENT_WINDOW_SHOW, x_event_window_show_cb, NULL);
}
#endif
} else {
- LOGD ("The candidate window was already in SHOW state, update geometry information\n");
+ LOGD ("The candidate window was already in SHOW state, update geometry information");
_info_manager->update_input_panel_event (ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, 0);
_info_manager->update_input_panel_event (ECORE_IMF_CANDIDATE_PANEL_GEOMETRY_EVENT, 0);
if (bForce || ui_candidate_can_be_hide ()) {
if (will_hide) {
- LOGD ("candidate_state = WILL_HIDE\n");
+ LOGD ("candidate_state = WILL_HIDE");
_candidate_state = WINDOW_STATE_WILL_HIDE;
delete_candidate_hide_timer ();
if (_candidate_angle == 180) {
Ecore_Evas *ee = ecore_evas_ecore_evas_get (evas_object_evas_get (_candidate_window));
ecore_evas_move_resize (ee, 0, 0, 0, 0);
- LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)\n", ee, 0, 0, 0, 0);
+ LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)", ee, 0, 0, 0, 0);
} else if (_candidate_mode == FIXED_CANDIDATE_WINDOW && _candidate_angle == 270) {
/*
* when screen rotate 270 degrees, candidate have to move then resize for expanding more
*/
Ecore_Evas *ee = ecore_evas_ecore_evas_get (evas_object_evas_get (_candidate_window));
ecore_evas_move_resize (ee, 0, 0, _screen_height, ui_candidate_get_valid_height () + _ise_height);
- LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)\n",
+ LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)",
ee, 0, 0, _screen_height, ui_candidate_get_valid_height () + _ise_height);
}
if (_candidate_angle == 180) {
Ecore_Evas *ee= ecore_evas_ecore_evas_get (evas_object_evas_get (_candidate_window));
ecore_evas_move_resize (ee, 0, 0, 0, 0);
- LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)\n", ee, 0, 0, 0, 0);
+ LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)", ee, 0, 0, 0, 0);
} else if (_candidate_mode == FIXED_CANDIDATE_WINDOW && _candidate_angle == 270) {
/*
* when screen rotate 270 degrees, candidate have to move then resize for expanding more
*/
Ecore_Evas *ee = ecore_evas_ecore_evas_get (evas_object_evas_get (_candidate_window));
ecore_evas_move_resize (ee, _ise_height, 0, _screen_height, ui_candidate_get_valid_height ());
- LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)\n",
+ LOGD ("ecore_evas_move_resize (%p, %d, %d, %d, %d)",
ee, _ise_height, 0, _screen_height, ui_candidate_get_valid_height ());
}
feedback_result = feedback_play_type (FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_SIP);
if (FEEDBACK_ERROR_NONE == feedback_result)
- LOGD ("Sound play successful\n");
+ LOGD ("Sound play successful");
else
- LOGW ("Cannot play feedback sound : %d\n", feedback_result);
+ LOGW ("Cannot play feedback sound : %d", feedback_result);
}
bool vibrate_feedback = _config->read (SCIM_GLOBAL_CONFIG_PANEL_VIBRATION_FEEDBACK, false);
feedback_result = feedback_play_type (FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_SIP);
if (FEEDBACK_ERROR_NONE == feedback_result)
- LOGD ("Vibration play successful\n");
+ LOGD ("Vibration play successful");
else
- LOGW ("Cannot play feedback vibration : %d\n", feedback_result);
+ LOGW ("Cannot play feedback vibration : %d", feedback_result);
}
}
#endif
int r = tts_create (&_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_create FAILED : result (%d)\n", r);
+ LOGW ("tts_create FAILED : result (%d)", r);
_tts = NULL;
return false;
}
r = tts_set_mode (_tts, TTS_MODE_SCREEN_READER);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_set_mode FAILED : result (%d)\n", r);
+ LOGW ("tts_set_mode FAILED : result (%d)", r);
}
tts_state_e current_state;
r = tts_get_state (_tts, ¤t_state);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_get_state FAILED : result (%d)\n", r);
+ LOGW ("tts_get_state FAILED : result (%d)", r);
}
if (TTS_STATE_CREATED == current_state) {
r = tts_prepare (_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_prepare FAILED : ret (%d)\n", r);
+ LOGW ("tts_prepare FAILED : ret (%d)", r);
}
}
return true;
if (_tts) {
int r = tts_unprepare (_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_unprepare FAILED : result (%d)\n", r);
+ LOGW ("tts_unprepare FAILED : result (%d)", r);
}
r = tts_destroy (_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("tts_destroy FAILED : result (%d)\n", r);
+ LOGW ("tts_destroy FAILED : result (%d)", r);
}
}
}
r = tts_get_state (_tts, ¤t_state);
if (TTS_ERROR_NONE != r) {
- LOGW ("Fail to get state from TTS : ret (%d)\n", r);
+ LOGW ("Fail to get state from TTS : ret (%d)", r);
}
if (TTS_STATE_PLAYING == current_state) {
r = tts_stop (_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("Fail to stop TTS : ret (%d)\n", r);
+ LOGW ("Fail to stop TTS : ret (%d)", r);
}
}
language = ise_langs[0];
}
}
- LOGD ("TTS language:%s, str:%s\n", language.c_str (), str);
+ LOGD ("TTS language:%s, str:%s", language.c_str (), str);
r = tts_add_text (_tts, str, language.c_str (), TTS_VOICE_TYPE_AUTO, TTS_SPEED_AUTO, &utt_id);
if (TTS_ERROR_NONE == r) {
r = tts_play (_tts);
if (TTS_ERROR_NONE != r) {
- LOGW ("Fail to play TTS : ret (%d)\n", r);
+ LOGW ("Fail to play TTS : ret (%d)", r);
}
}
}
_aux_seperates.clear ();
/* Delete candidate window */
if (_candidate_window) {
- LOGD ("calling ui_candidate_hide (true)\n");
+ LOGD ("calling ui_candidate_hide (true)");
ui_candidate_hide (true);
evas_object_del (_candidate_window);
_candidate_x = spot_x;
_candidate_y = spot_y;
evas_object_move (_candidate_window, spot_x, spot_y);
- LOGD ("Moving candidate window to : %d %d\n", spot_x, spot_y);
+ LOGD ("Moving candidate window to : %d %d", spot_x, spot_y);
if (_preedit_window) {
if (_candidate_angle == 90) {
spot_x -= _preedit_height;
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " x:" << x << " y:" << y << " width:" << width << " height:" << height << "...\n";
- LOGD ("candidate geometry x: %d , y: %d , width: %d , height: %d, _ise_state: %d, candidate_mode: %d\n", x, y, width, height, _ise_state, _candidate_mode);
+ LOGD ("candidate geometry x: %d , y: %d , width: %d , height: %d, _ise_state: %d, candidate_mode: %d", x, y, width, height, _ise_state, _candidate_mode);
if ((_candidate_mode != SOFT_CANDIDATE_WINDOW) || (_info_manager->get_current_toolbar_mode () != TOOLBAR_KEYBOARD_MODE))
return;
Ecore_X_Window xAppWindow = efl_get_app_window ();
ecore_x_icccm_transient_for_set (window, xAppWindow);
- LOGD ("win : %x, forwin : %x\n", window, xAppWindow);
+ LOGD ("win : %x, forwin : %x", window, xAppWindow);
}
static int efl_get_window_rotate_angle (Ecore_X_Window win)
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE, ECORE_X_ATOM_CARDINAL, 32, &prop_data, &count);
if (ret && prop_data) {
memcpy (&angle, prop_data, sizeof (int));
- LOGD ("WINDOW angle of %p is %d\n", win, angle);
+ LOGD ("WINDOW angle of %p is %d", win, angle);
} else {
std::cerr << "ecore_x_window_prop_property_get () is failed!!!\n";
- LOGW ("WINDOW angle of %p FAILED!\n", win);
+ LOGW ("WINDOW angle of %p FAILED!", win);
}
if (prop_data)
XFree (prop_data);
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
- LOGD ("initializing panel agent\n");
+ LOGD ("initializing panel agent");
_info_manager = new InfoManager ();
if (!_info_manager || !_info_manager->initialize (_info_manager, config, display, resident)) {
- ISF_SAVE_LOG ("panel_agent initialize fail!\n");
+ ISF_SAVE_LOG ("panel_agent initialize fail!");
return false;
}
_info_manager->signal_connect_run_helper (slot (slot_run_helper));
_info_manager->signal_connect_launch_option_application (slot (slot_launch_option_application));
- LOGD ("initializing panel agent succeeded\n");
+ LOGD ("initializing panel agent succeeded");
return true;
}
static void delete_ise_hide_timer (void)
{
- LOGD ("deleting ise_hide_timer\n");
+ LOGD ("deleting ise_hide_timer");
if (_ise_hide_timer) {
ecore_timer_del (_ise_hide_timer);
_ise_hide_timer = NULL;
static void hide_ise ()
{
- LOGD ("send request to hide helper\n");
+ LOGD ("send request to hide helper");
String uuid = _info_manager->get_current_helper_uuid ();
_info_manager->hide_helper (uuid);
if (set_active_ise (active_uuid, _soft_keyboard_launched) == false) {
if (_initial_ise_uuid.compare (active_uuid)) {
- LOGD ("Trying to launch initial IME (%s)\n", _initial_ise_uuid.c_str ());
+ LOGD ("Trying to launch initial IME (%s)", _initial_ise_uuid.c_str ());
set_active_ise (_initial_ise_uuid, _soft_keyboard_launched);
}
}
#endif
}
else
- LOGW ("No IME list\n");
+ LOGW ("No IME list");
#ifdef HAVE_PKGMGR_INFO
if (!pkgmgr) {
if (ret == PACKAGE_MANAGER_ERROR_NONE) {
ret = package_manager_set_event_cb (pkgmgr, _package_manager_event_cb, NULL);
if (ret == PACKAGE_MANAGER_ERROR_NONE) {
- LOGD ("package_manager_set_event_cb succeeded.\n");
+ LOGD ("package_manager_set_event_cb succeeded.");
}
else {
- LOGE ("package_manager_set_event_cb failed(%d)\n", ret);
+ LOGE ("package_manager_set_event_cb failed(%d)", ret);
}
}
else {
- LOGE ("package_manager_create failed(%d)\n", ret);
+ LOGE ("package_manager_create failed(%d)", ret);
}
}
#endif
if (_launch_ise_on_request && !_soft_keyboard_launched) {
String uuid = _config->read (SCIM_CONFIG_DEFAULT_HELPER_ISE, String (""));
if (uuid.length () > 0 && (_ime_info[get_ise_index(uuid)].options & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)) {
- LOGD ("Start helper (%s)\n", uuid.c_str ());
+ LOGD ("Start helper (%s)", uuid.c_str ());
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
if (_info_manager->start_helper (uuid))
char noti_msg[256] = {0};
unsigned int keyboard_ise_count = get_ise_count (TOOLBAR_KEYBOARD_MODE, false);
if (keyboard_ise_count == 0) {
- LOGD ("the number of keyboard ise is %d\n", keyboard_ise_count);
+ LOGD ("the number of keyboard ise is %d", keyboard_ise_count);
return;
}
else if (keyboard_ise_count >= 2) {
}
notification_status_message_post (noti_msg);
- LOGD ("%s\n", noti_msg);
+ LOGD ("%s", noti_msg);
}
}
}
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " x:" << x << " y:" << y << " width:" << width << " height:" << height << "...\n";
- LOGD ("x : %d , y : %d , width : %d , height : %d, _ise_state : %d\n", x, y, width, height, _ise_state);
+ LOGD ("x : %d , y : %d , width : %d , height : %d, _ise_state : %d", x, y, width, height, _ise_state);
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_KEYBOARD_MODE) {
if (_candidate_mode == SOFT_CANDIDATE_WINDOW) {
_aux_area_visible = true;
ui_candidate_window_adjust ();
- LOGD ("calling ui_candidate_show ()\n");
+ LOGD ("calling ui_candidate_show ()");
ui_candidate_show ();
ui_settle_candidate_window ();
ui_candidate_delete_destroy_timer ();
_candidate_area_1_visible = true;
ui_candidate_window_adjust ();
- LOGD ("calling ui_candidate_show ()\n");
+ LOGD ("calling ui_candidate_show ()");
ui_candidate_show ();
ui_settle_candidate_window ();
ui_candidate_delete_destroy_timer ();
int feedback_result = feedback_initialize ();
if (FEEDBACK_ERROR_NONE == feedback_result) {
- LOGD ("Feedback initialize successful\n");
+ LOGD ("Feedback initialize successful");
feedback_initialized = true;
} else {
- LOGW ("Feedback initialize fail : %d\n", feedback_result);
+ LOGW ("Feedback initialize fail : %d", feedback_result);
feedback_initialized = false;
}
#endif /* HAVE_FEEDBACK */
elm_scroller_region_show (_aux_area, 0, 0, 10, 10);
ui_candidate_window_adjust ();
- LOGD ("calling ui_candidate_hide (false, true, true)\n");
+ LOGD ("calling ui_candidate_hide (false, true, true)");
ui_candidate_hide (false, true, true);
ui_settle_candidate_window ();
if (ui_candidate_can_be_hide ()) {
_candidate_show_requested = false;
- LOGD ("setting _show_candidate_requested to FALSE\n");
+ LOGD ("setting _show_candidate_requested to FALSE");
}
#endif /* CANDIDATE */
}
}
ui_candidate_window_adjust ();
- LOGD ("calling ui_candidate_hide (%d, true, true)\n", bForce);
+ LOGD ("calling ui_candidate_hide (%d, true, true)", bForce);
ui_candidate_hide (bForce, true, true);
ui_settle_candidate_window ();
}
int feedback_result = feedback_deinitialize ();
if (FEEDBACK_ERROR_NONE == feedback_result)
- LOGD ("Feedback deinitialize successful\n");
+ LOGD ("Feedback deinitialize successful");
else
- LOGW ("Feedback deinitialize fail : %d\n", feedback_result);
+ LOGW ("Feedback deinitialize fail : %d", feedback_result);
feedback_initialized = false;
#endif
if (ui_candidate_can_be_hide ()) {
_candidate_show_requested = false;
- LOGD ("setting _show_candidate_requested to FALSE\n");
+ LOGD ("setting _show_candidate_requested to FALSE");
}
#endif /* CANDIDATE */
}
return;
if (!_aux_area_visible) {
- LOGD ("calling ui_candidate_show ()\n");
+ LOGD ("calling ui_candidate_show ()");
ui_candidate_show ();
slot_show_aux_string ();
}
info.width = width;
info.height = height;
- LOGD ("%d %d %d %d\n", info.pos_x, info.pos_y, info.width, info.height);
+ LOGD ("%d %d %d %d", info.pos_x, info.pos_y, info.width, info.height);
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " x:" << info.pos_x << " y:" << info.pos_y
<< " width:" << info.width << " height:" << info.height << "\n";
}
#endif /* CANDIDATE */
}
- LOGD ("%d %d %d %d\n", info.pos_x, info.pos_y, info.width, info.height);
+ LOGD ("%d %d %d %d", info.pos_x, info.pos_y, info.width, info.height);
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " x:" << info.pos_x << " y:" << info.pos_y
<< " width:" << info.width << " height:" << info.height << "\n";
}
*/
static void slot_get_recent_ise_geometry (int angle, struct rectinfo &info)
{
- LOGD ("slot_get_recent_ise_geometry\n");
+ LOGD ("slot_get_recent_ise_geometry");
/* If we have geometry reported by ISE, use the geometry information */
if (angle < 0) {
bool priv_ret = privilegeChecker.checkPrivilege (privilege.c_str ());
if (priv_ret == false)
- LOGW ("Failed to check privilege (%s)\n", privilege.c_str ());
+ LOGW ("Failed to check privilege (%s)", privilege.c_str ());
else
- LOGD ("Succeeded to check privilege (%s)\n", privilege.c_str ());
+ LOGD ("Succeeded to check privilege (%s)", privilege.c_str ());
return priv_ret;
}
/* Try to get in global packages */
int ret = pkgmgr_get_appinfo (uuid.c_str (), &handle);
if (ret != PMINFO_R_OK) {
- LOGW ("appid \"%s\" is invalid.\n", uuid.c_str ());
+ LOGW ("appid \"%s\" is invalid.", uuid.c_str ());
/* This might happen if IME is uninstalled while the panel process is inactive.
The variable uuid would be invalid, so set_active_ise() would return false. */
invalid = true;
static void slot_set_has_option_helper_ise_info (const String &appid, bool has_option)
{
if (appid.length() == 0) {
- LOGW ("Invalid appid\n");
+ LOGW ("Invalid appid");
return;
}
static void slot_set_enable_helper_ise_info (const String &appid, bool is_enabled)
{
if (appid.length() == 0) {
- LOGW ("Invalid appid\n");
+ LOGW ("Invalid appid");
return;
}
*result = strdup (appid);
}
else {
- LOGW ("pkgmgrinfo_appinfo_get_appid failed!\n");
+ LOGW ("pkgmgrinfo_appinfo_get_appid failed!");
}
}
else {
- LOGW ("user_data is null!\n");
+ LOGW ("user_data is null!");
}
return -1; // This callback is no longer called.
free(app_id);
}
else {
- SECURE_LOGW ("AppID with http://tizen.org/category/ime-list category is not available.\n");
+ SECURE_LOGW ("AppID with http://tizen.org/category/ime-list category is not available.");
}
}
free(app_id);
}
else {
- SECURE_LOGW ("AppID with http://tizen.org/category/ime-selector category is not available.\n");
+ SECURE_LOGW ("AppID with http://tizen.org/category/ime-selector category is not available.");
}
}
bool is_enabled = false;
if (appid.length() == 0) {
- LOGW ("Invalid appid.\n");
+ LOGW ("Invalid appid.");
return false;
}
static void slot_exit (void)
{
std::cerr << __FUNCTION__ << "...\n";
- ISF_SAVE_LOG ("exit\n");
+ ISF_SAVE_LOG ("exit");
#if ISF_BUILD_CANDIDATE_UI
elm_exit ();
static void delete_ise_check_pid_alive_timer(void)
{
- LOGD("deleting ise_check_alive_timer\n");
+ LOGD("deleting ise_check_alive_timer");
if (_ise_check_pid_alive_timer) {
ecore_timer_del(_ise_check_pid_alive_timer);
_ise_check_pid_alive_timer = NULL;
if (prop.get_label ().compare ("XID") == 0) {
Ecore_X_Window xwindow = atoi (prop.get_key ().c_str ());
_ise_window = xwindow;
- LOGD ("ISE XID : %x\n", _ise_window);
+ LOGD ("ISE XID : %x", _ise_window);
/* Just in case for the helper sent this message later than show_ise request */
if (_ise_state == WINDOW_STATE_SHOW || _ise_state == WINDOW_STATE_WILL_SHOW) {
/* If the current toolbar mode is not HELPER_MODE, do not proceed */
if (_info_manager->get_current_toolbar_mode () != TOOLBAR_HELPER_MODE) {
- LOGD ("Current toolbar mode should be TOOLBAR_HELPER_MODE but is %d, returning\n",
+ LOGD ("Current toolbar mode should be TOOLBAR_HELPER_MODE but is %d, returning",
_info_manager->get_current_toolbar_mode ());
return;
}
- LOGD ("slot_show_ise ()\n");
+ LOGD ("slot_show_ise ()");
delete_ise_hide_timer ();
#ifdef HAVE_ECOREX
info.pos_y = _screen_width > _screen_height ? _screen_width : _screen_height;
set_keyboard_geometry_atom_info (_app_window, info);
ecore_x_event_mask_unset (_app_window, ECORE_X_EVENT_MASK_WINDOW_FOCUS_CHANGE);
- LOGD ("Conformant reset for window %x\n", _app_window);
+ LOGD ("Conformant reset for window %x", _app_window);
_app_window = current_app_window;
/* If the target window has changed but our ISE is still in visible state,
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
- LOGD ("slot_hide_ise ()\n");
+ LOGD ("slot_hide_ise ()");
if (!_ise_hide_timer)
hide_ise ();
// WILL_HIDE_REQUEST_DONE Ack to WM
Ecore_X_Window root_window = ecore_x_window_root_get (_control_window);
//ecore_x_e_virtual_keyboard_off_prepare_done_send (root_window, _control_window);
- LOGD ("_ecore_x_e_virtual_keyboard_off_prepare_done_send (%x, %x)\n",
+ LOGD ("_ecore_x_e_virtual_keyboard_off_prepare_done_send (%x, %x)",
root_window, _control_window);
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_HELPER_MODE) {
- LOGD ("calling ui_candidate_hide (true, false)\n");
+ LOGD ("calling ui_candidate_hide (true, false)");
ui_candidate_hide (true, false);
}
{
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
#ifdef HAVE_ECOREX
- LOGD ("candidate_will_hide_ack\n");
+ LOGD ("candidate_will_hide_ack");
if (_candidate_state == WINDOW_STATE_WILL_HIDE) {
candidate_window_hide ();
}
static void slot_set_keyboard_mode (int mode)
{
- LOGD ("slot_set_keyboard_mode called (TOOLBAR_MODE : %d)\n", mode);
+ LOGD ("slot_set_keyboard_mode called (TOOLBAR_MODE : %d)", mode);
change_keyboard_mode ((TOOLBAR_MODE_T)mode);
}
state = ECORE_IMF_INPUT_PANEL_STATE_HIDE;
};
}
- LOGD ("state = %d\n", state);
+ LOGD ("state = %d", state);
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " state = " << state << "\n";
}
if (_launch_ise_on_request && !_soft_keyboard_launched) {
String uuid = _config->read (SCIM_CONFIG_DEFAULT_HELPER_ISE, String (""));
- LOGD ("Start helper (%s)\n", uuid.c_str ());
+ LOGD ("Start helper (%s)", uuid.c_str ());
set_keyboard_engine (String (SCIM_COMPOSE_KEY_FACTORY_UUID));
if (_info_manager->start_helper (uuid))
_soft_keyboard_launched = true;
else
- LOGW ("Failed to start helper (%s)\n", uuid.c_str ());
+ LOGW ("Failed to start helper (%s)", uuid.c_str ());
}
}
}
_info_manager->hide_helper (uuid);
_info_manager->stop_helper (uuid);
_soft_keyboard_launched = false;
- LOGD ("stop helper (%s)\n", uuid.c_str ());
+ LOGD ("stop helper (%s)", uuid.c_str ());
}
}
}
0};
SCIM_DEBUG_MAIN (2) << " Call scim-helper-launcher.\n";
- ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)\n", name, appid);
+ ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)", name, appid);
unsetenv ("ELM_THEME");
unsetenv ("ELM_SCALE");
setsid ();
- LOGD ("launch execpath : %s\n", exec);
+ LOGD ("launch execpath : %s", exec);
execv (exec, const_cast<char **>(argv));
#if ISF_BUILD_CANDIDATE_UI
elm_exit ();
ret = app_control_create (&app_control);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_create returned %08x\n", ret);
+ LOGW ("app_control_create returned %08x", ret);
return false;
}
ret = app_control_set_operation (app_control, APP_CONTROL_OPERATION_DEFAULT);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_set_operation returned %08x\n", ret);
+ LOGW ("app_control_set_operation returned %08x", ret);
app_control_destroy (app_control);
return false;
}
ret = app_control_set_app_id (app_control, app_id);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_set_app_id returned %08x\n", ret);
+ LOGW ("app_control_set_app_id returned %08x", ret);
app_control_destroy (app_control);
return false;
}
do {
if (tries != 0) usleep(1000000); /* If we are retrying to launch, pause for a while */
ret = app_control_send_launch_request(app_control, NULL, NULL);
- LOGW ("app_control_send_launch_request returned %08x, app_id=%s\n", ret, app_id);
+ LOGW ("app_control_send_launch_request returned %08x, app_id=%s", ret, app_id);
} while (ret != APP_CONTROL_ERROR_NONE && (++tries) < 3);
app_control_destroy (app_control);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("Failed to launch IME (%s)\n", app_id);
+ LOGW ("Failed to launch IME (%s)", app_id);
} else {
- LOGD ("Succeeded to launch IME (%s)\n", app_id);
+ LOGD ("Succeeded to launch IME (%s)", app_id);
}
return (ret == APP_CONTROL_ERROR_NONE);
static void slot_run_helper (const String &uuid, const String &config, const String &display)
{
- ISF_SAVE_LOG ("time:%ld pid:%d %s %s uuid(%s)\n",
+ ISF_SAVE_LOG ("time:%ld pid:%d %s %s uuid(%s)",
time (0), getpid (), __FILE__, __func__, uuid.c_str ());
String scim_helper_path;
/* Try to get in global packages */
ret = pkgmgr_get_appinfo (uuid.c_str (), &appinfo_handle);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_get_appinfo () & get_usr_appinfo () failed. appid : %s, ret : %d \n", uuid.c_str (), ret);
+ LOGW ("pkgmgrinfo_appinfo_get_appinfo () & get_usr_appinfo () failed. appid : %s, ret : %d ", uuid.c_str (), ret);
return;
}
return;
}
- LOGD ("exec path : %s\n", execpath);
+ LOGD ("exec path : %s", execpath);
scim_helper_path = String (execpath);
if (appinfo_handle) {
}
}
/* execute type IME */
- LOGD ("Try to launch IME (%s)\n", uuid.c_str ());
+ LOGD ("Try to launch IME (%s)", uuid.c_str ());
bool launched = app_control_launch (uuid.c_str ());
if (launched) {
{
String ime_setting_app = isf_pkg_get_setting_app (ime_appid);
- LOGD ("IME appid : %s, IME setting app id : %s\n", ime_appid.c_str (), ime_setting_app.c_str ());
+ LOGD ("IME appid : %s, IME setting app id : %s", ime_appid.c_str (), ime_setting_app.c_str ());
if (ime_setting_app.length () > 0) {
app_control_launch (ime_setting_app.c_str ());
static void signalhandler (int sig)
{
std::cerr << __FUNCTION__ << " Signal=" << sig << "\n";
- ISF_SAVE_LOG ("Signal=%d\n", sig);
+ ISF_SAVE_LOG ("Signal=%d", sig);
#if ISF_BUILD_CANDIDATE_UI
elm_exit ();
}
}
- LOGD ("update all ISE names according to display language : %s\n", strLang.c_str ());
+ LOGD ("update all ISE names according to display language : %s", strLang.c_str ());
set_language_and_locale (strLang.c_str ());
bool need_to_init_db = false;
char language[256];
if (lang_str) {
- LOGD ("language : %s\n", lang_str);
+ LOGD ("language : %s", lang_str);
#if ISF_BUILD_CANDIDATE_UI
elm_language_set (lang_str);
#endif /* CANDIDATE */
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << "...\n";
char *lang_str = vconf_keynode_get_str (key);
- LOGD ("lang : %s\n", lang_str);
+ LOGD ("lang : %s", lang_str);
set_language_and_locale (lang_str);
/* Update all ISE names according to display language */
if (mode == TOOLBAR_KEYBOARD_MODE && _support_hw_keyboard_mode) {
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_KEYBOARD_MODE) {
- LOGD ("HARDWARE_KEYBOARD_MODE return\n");
+ LOGD ("HARDWARE_KEYBOARD_MODE return");
return;
}
- LOGD ("HARDWARE KEYBOARD MODE\n");
+ LOGD ("HARDWARE KEYBOARD MODE");
_config->write (ISF_CONFIG_HARDWARE_KEYBOARD_DETECT, 1);
_config->flush ();
/* Read configuations for notification app (isf-kbd-mode-changer) */
String kbd_mode_changer = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_KBD_MODE_CHANGER_PROGRAM), String (""));
hwkbd_module_noti.launch_app = kbd_mode_changer;
- LOGD ("Create kbd_mode_changer notification with : %s\n", kbd_mode_changer.c_str ());
+ LOGD ("Create kbd_mode_changer notification with : %s", kbd_mode_changer.c_str ());
create_notification (&hwkbd_module_noti);
}
#endif
if (!input_detect) {
if (vconf_set_bool (VCONFKEY_ISF_HW_KEYBOARD_INPUT_DETECTED, 1) != 0)
- LOGW ("Failed to set vconf key\n");
+ LOGW ("Failed to set vconf key");
else
- LOGD ("Succeeded to set vconf key\n");
+ LOGD ("Succeeded to set vconf key");
}
#endif
} else if (mode == TOOLBAR_HELPER_MODE) {
- LOGD ("SOFTWARE KEYBOARD MODE\n");
+ LOGD ("SOFTWARE KEYBOARD MODE");
/* When switching back to S/W keyboard mode, let's hide candidate window first */
#if ISF_BUILD_CANDIDATE_UI
- LOGD ("calling ui_candidate_hide (true, true, true)\n");
+ LOGD ("calling ui_candidate_hide (true, true, true)");
ui_candidate_hide (true, true, true);
#endif /* CANDIDATE */
_config->write (ISF_CONFIG_HARDWARE_KEYBOARD_DETECT, 0);
else {
if (set_active_ise (uuid, true) == false) {
if (_initial_ise_uuid.compare(uuid)) {
- LOGD ("Trying to launch initial IME (%s)\n", _initial_ise_uuid.c_str ());
+ LOGD ("Trying to launch initial IME (%s)", _initial_ise_uuid.c_str ());
set_active_ise (_initial_ise_uuid, true);
}
}
if (input_detect) {
if (vconf_set_bool (VCONFKEY_ISF_HW_KEYBOARD_INPUT_DETECTED, 0) != 0)
- LOGW ("Failed to set vconf key\n");
+ LOGW ("Failed to set vconf key");
else
- LOGD ("Succeeded to set vconf key\n");
+ LOGD ("Succeeded to set vconf key");
}
#endif
}
static void _bt_cb_hid_state_changed (int result, bool connected, const char *remote_address, void *user_data)
{
if (connected == false) {
- LOGD ("Bluetooth keyboard disconnected\n");
+ LOGD ("Bluetooth keyboard disconnected");
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_KEYBOARD_MODE) {
change_keyboard_mode (TOOLBAR_HELPER_MODE);
}
String noti_icon_path = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_QUICK_PANEL_ICON_PATH), String (SCIM_ICONDIR));
noti_icon_path += ISF_ISE_SELECTOR_ICON_FILE;
- LOGD("IME selector icon path : %s\n", noti_icon_path.c_str ());
+ LOGD("IME selector icon path : %s", noti_icon_path.c_str ());
ise_selector_module_noti.icon = noti_icon_path.c_str ();
ise_selector_module_noti.content = ise_name.c_str ();
if (ime_selector_app.length () > 0) {
ise_selector_module_noti.launch_app = ime_selector_app;
- LOGD ("Create ise_selector notification with : %s\n", ime_selector_app.c_str ());
+ LOGD ("Create ise_selector notification with : %s", ime_selector_app.c_str ());
create_notification (&ise_selector_module_noti);
}
else
- LOGW ("AppID with http://tizen.org/category/ime-selector category is not available\n");
+ LOGW ("AppID with http://tizen.org/category/ime-selector category is not available");
}
#endif
if (ev->atom == ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_STATE) {
if (ev->win == _control_window) {
/* WMSYNC, #6 The keyboard window is displayed fully so set the conformant geometry */
- LOGD ("ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_STATE : win : %p, atom : %d\n", ev->win, ev->atom);
+ LOGD ("ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_STATE : win : %p, atom : %d", ev->win, ev->atom);
Ecore_X_Virtual_Keyboard_State state;
state = ecore_x_e_virtual_keyboard_state_get (ev->win);
if (state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ON) {
- LOGD ("ECORE_X_VIRTUAL_KEYBOARD_STATE_ON\n");
+ LOGD ("ECORE_X_VIRTUAL_KEYBOARD_STATE_ON");
_ise_state = WINDOW_STATE_SHOW;
/* Make sure that we have the same rotation angle with the keyboard window */
}
if (_candidate_show_requested) {
- LOGD ("calling ui_candidate_show (true)\n");
+ LOGD ("calling ui_candidate_show (true)");
ui_candidate_show (true);
} else {
if (_candidate_area_1_visible) {
- LOGD ("calling ui_candidate_show (false)\n");
+ LOGD ("calling ui_candidate_show (false)");
ui_candidate_show (false);
}
}
ecore_x_e_virtual_keyboard_state_set (_ise_window, ECORE_X_VIRTUAL_KEYBOARD_STATE_ON);
} else if (state == ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF) {
/* WMSYNC, #9 The keyboard window is hidden fully so send HIDE state */
- LOGD ("ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF\n");
+ LOGD ("ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF");
// For now don't send HIDE signal here
//_info_manager->update_input_panel_event (
// ECORE_IMF_INPUT_PANEL_STATE_EVENT, ECORE_IMF_INPUT_PANEL_STATE_HIDE);
_updated_hide_state_geometry = true;
}
if (_info_manager->get_current_toolbar_mode () == TOOLBAR_HELPER_MODE) {
- LOGD ("calling ui_candidate_hide (true, false)\n");
+ LOGD ("calling ui_candidate_hide (true, false)");
ui_candidate_hide (true, false);
} else {
ui_settle_candidate_window ();
} else if (ev->atom == ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE) {
if (ev->win == efl_get_quickpanel_window ()) {
int angle = efl_get_quickpanel_window_angle ();
- LOGD ("ev->win : %p, change window angle : %d\n", ev->win, angle);
+ LOGD ("ev->win : %p, change window angle : %d", ev->win, angle);
}
}
if ((ev->win == _control_window)) {
if (ev->message_type == ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_ON_PREPARE_REQUEST) {
/* WMSYNC, #4 Send WILL_SHOW event when the keyboard window is about to displayed */
- LOGD ("_ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_ON_PREPARE_REQUEST\n");
+ LOGD ("_ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_ON_PREPARE_REQUEST");
/* WMSYNC, #5 Let the Window Manager to actually show keyboard window */
// WILL_SHOW_REQUEST_DONE Ack to WM
Ecore_X_Window root_window = ecore_x_window_root_get (_control_window);
ecore_x_e_virtual_keyboard_on_prepare_done_send (root_window, _control_window);
- LOGD ("_ecore_x_e_virtual_keyboard_on_prepare_done_send (%x, %x)\n",
+ LOGD ("_ecore_x_e_virtual_keyboard_on_prepare_done_send (%x, %x)",
root_window, _control_window);
_info_manager->update_input_panel_event (
} else if (ev->message_type == ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_OFF_PREPARE_REQUEST) {
_ise_state = WINDOW_STATE_WILL_HIDE;
/* WMSYNC, #7 Send WILL_HIDE event when the keyboard window is about to hidden */
- LOGD ("_ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_OFF_PREPARE_REQUEST\n");
+ LOGD ("_ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_OFF_PREPARE_REQUEST");
// Clear conformant geometry information first
if (_off_prepare_done_timer) {
// PRE_ROTATE_DONE Ack to WM
_candidate_angle = ev->data.l[1];
_ise_angle = ev->data.l[1];
- LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_PREPARE : %d\n", _candidate_angle);
+ LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_PREPARE : %d", _candidate_angle);
if (_candidate_angle == 90 || _candidate_angle == 270) {
ui_candidate_window_resize (_candidate_land_width, _candidate_land_height_min);
ui_settle_candidate_window ();
ui_candidate_window_rotate (_candidate_angle);
Ecore_X_Window root_window = ecore_x_window_root_get (_control_window);
- LOGD ("ecore_x_e_window_rotation_change_prepare_done_send (%d)\n", _candidate_angle);
+ LOGD ("ecore_x_e_window_rotation_change_prepare_done_send (%d)", _candidate_angle);
ecore_x_e_window_rotation_change_prepare_done_send (root_window,
_control_window, _candidate_angle);
} else if (ev->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST) {
int ise_angle = (int)ev->data.l[1];
- LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST for ISE WINDOW : ISE angle : %d, Candidate angle : %d\n", ise_angle, _candidate_angle);
+ LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST for ISE WINDOW : ISE angle : %d, Candidate angle : %d", ise_angle, _candidate_angle);
_candidate_angle = ise_angle;
_ise_angle = ise_angle;
if (_ise_state == WINDOW_STATE_SHOW) {
if (ev->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST) {
_candidate_angle = (int)ev->data.l[1];
ui_candidate_window_rotate (_candidate_angle);
- LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST : %d\n", _candidate_angle);
+ LOGD ("ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST : %d", _candidate_angle);
} else if (ev->message_type == ECORE_X_ATOM_E_ILLUME_ROTATE_ROOT_ANGLE &&
_ise_state != WINDOW_STATE_SHOW) {
ecore_x_e_window_rotation_app_set (elm_win_xwindow_get (_candidate_window), EINA_TRUE);
ui_candidate_window_rotate (_candidate_angle);
ui_settle_candidate_window ();
ecore_x_e_window_rotation_app_set (elm_win_xwindow_get (_candidate_window), EINA_FALSE);
- LOGD ("ECORE_X_ATOM_E_ILLUME_ROTATE_ROOT_ANGLE : %d\n", _candidate_angle);
+ LOGD ("ECORE_X_ATOM_E_ILLUME_ROTATE_ROOT_ANGLE : %d", _candidate_angle);
}
SCIM_DEBUG_MAIN (3) << __FUNCTION__ << " : ANGLE (" << _candidate_angle << ")\n";
}
strTts = String (_("close button"));
evas_object_geometry_get (_close_btn, &x, &y, &w, &h);
} else {
- LOGW ("TTS focus index = %d\n", _candidate_tts_focus_index);
+ LOGW ("TTS focus index = %d", _candidate_tts_focus_index);
ui_tts_focus_rect_hide ();
}
if (!ecore_x_netwm_window_type_get (focus_win, &win_type))
return EINA_FALSE;
- LOGD ("win type : %d\n", win_type);
+ LOGD ("win type : %d", win_type);
if (win_type == ECORE_X_WINDOW_TYPE_POPUP_MENU ||
win_type == ECORE_X_WINDOW_TYPE_NOTIFICATION) {
#if ENABLE_MULTIWINDOW_SUPPORT
unsigned int layout = 0;
- LOGD ("Application window focus OUT!\n");
+ LOGD ("Application window focus OUT!");
delete_ise_hide_timer ();
// Check multi window mode
if (ecore_x_window_prop_card32_get (efl_get_app_window (), ECORE_X_ATOM_E_WINDOW_DESKTOP_LAYOUT, &layout, 1) != -1) {
if (layout == 0 || layout == 1) {
// Split mode
- LOGD ("Multi window mode. start timer to hide IME\n");
+ LOGD ("Multi window mode. start timer to hide IME");
// Use timer not to hide and show IME again in focus-out and focus-in event between applications
_ise_hide_timer = ecore_timer_add (ISF_ISE_HIDE_DELAY, ise_hide_timeout, NULL);
}
if (!_ise_hide_timer) {
- LOGD ("Panel hides ISE\n");
+ LOGD ("Panel hides ISE");
_info_manager->hide_helper (_info_manager->get_current_helper_uuid ());
slot_hide_ise ();
ui_candidate_hide (true, false, false);
}
#else
- LOGD ("Application window focus OUT! Panel hides ISE\n");
+ LOGD ("Application window focus OUT! Panel hides ISE");
_info_manager->hide_helper (_info_manager->get_current_helper_uuid ());
slot_hide_ise ();
ui_candidate_hide (true, false, false);
#endif
check_time ("\nStarting ISF Panel EFL...... ");
- ISF_SAVE_LOG ("Starting ISF Panel EFL......\n");
+ ISF_SAVE_LOG ("Starting ISF Panel EFL......");
DebugOutput::disable_debug (SCIM_DEBUG_AllMask);
DebugOutput::enable_debug (SCIM_DEBUG_MainMask);
if (!initialize_panel_agent (_config, display_name, should_resident)) {
check_time ("Failed to initialize Panel Agent!");
std::cerr << "Failed to initialize Panel Agent!\n";
- LOGE ("Failed to initialize Panel Agent!\n");
+ LOGE ("Failed to initialize Panel Agent!");
ret = -1;
goto cleanup;
}
#ifdef HAVE_ECOREX
if (!efl_create_control_window ()) {
- LOGW ("Failed to create control window\n");
+ LOGW ("Failed to create control window");
goto cleanup;
}
#endif
#endif
if (0 != register_edbus_signal_handler ())
- LOGW ("register edbus signal fail\n");
+ LOGW ("register edbus signal fail");
try {
/* Update ISE list */
/* Register the callback function of Bluetooth connection */
ret = bt_initialize ();
if (ret != BT_ERROR_NONE)
- LOGW ("Fail to init Bluetooth\n");
+ LOGW ("Fail to init Bluetooth");
ret = bt_hid_host_initialize (_bt_cb_hid_state_changed, NULL);
if (ret != BT_ERROR_NONE)
- LOGW ("bt_hid_host_initialize failed\n");
+ LOGW ("bt_hid_host_initialize failed");
#endif
#if ENABLE_REMOTE_INPUT
check_time ("EFL Panel launch time");
if (!isf_cynara_initialize())
- LOGW ("Failed to initialize cynara\n");
+ LOGW ("Failed to initialize cynara");
#if ISF_BUILD_CANDIDATE_UI
elm_run ();
/* deinitialize the callback function of Bluetooth connection */
ret = bt_hid_host_deinitialize ();
if (ret != BT_ERROR_NONE)
- LOGW ("bt_hid_host_deinitialize failed: %d\n", ret);
+ LOGW ("bt_hid_host_deinitialize failed: %d", ret);
ret = bt_deinitialize ();
if (ret != BT_ERROR_NONE)
- LOGW ("bt_deinitialize failed: %d\n", ret);
+ LOGW ("bt_deinitialize failed: %d", ret);
#endif
#ifdef HAVE_ECOREX
delete []new_argv;
}
- ISF_SAVE_LOG ("ret=%d\n", ret);
+ ISF_SAVE_LOG ("ret=%d", ret);
if (ret == 0) {
std::cerr << "Successfully exited.\n";
return 0;
/* Close uinput device */
if (ioctl(fd_uinput_keyboard, UI_DEV_DESTROY) < 0) {
- LOGD ("error destroy\n");
+ LOGD ("error destroy");
}
close(fd_uinput_keyboard);
if (ioctl(fd_uinput_mouse, UI_DEV_DESTROY) < 0) {
- LOGD ("error destroy\n");
+ LOGD ("error destroy");
}
close(fd_uinput_mouse);
}
fd_uinput_keyboard = open_file(file_name);
if (fd_uinput_keyboard < 0) {
- LOGW ("Fail to open fd uinput_keyboard!\n");
+ LOGW ("Fail to open fd uinput_keyboard!");
return ECORE_CALLBACK_CANCEL;
}
device_key.id.version = 1;
if (write(fd_uinput_keyboard, &device_key, sizeof(device_key)) != sizeof(device_key)) {
- LOGW ("Fail to setup uinput structure on fd\n");
+ LOGW ("Fail to setup uinput structure on fd");
return ECORE_CALLBACK_CANCEL;
}
if (ioctl(fd_uinput_keyboard, UI_SET_EVBIT, EV_KEY) < 0) {
- LOGW ("Fail to enable EV_KEY event type\n");
+ LOGW ("Fail to enable EV_KEY event type");
return ECORE_CALLBACK_CANCEL;
}
if (ioctl(fd_uinput_keyboard, UI_SET_EVBIT, EV_SYN) < 0) {
- LOGW ("Fail to enable EV_SYN event type\n");
+ LOGW ("Fail to enable EV_SYN event type");
return ECORE_CALLBACK_CANCEL;
}
for (unsigned int i = 0; i < REMOTE_KEY_NAMES; i++) {
if (remote_key_names[i].value >= REMOTE_KEY_TV_POWER) {
int keycode = keycode_get_from_string((char *)remote_key_names[i].name);
- SECURE_LOGD("remote init Key name: %s, key code : %d\n", (char *)remote_key_names[i].name, keycode);
+ SECURE_LOGD("remote init Key name: %s, key code : %d", (char *)remote_key_names[i].name, keycode);
if (ioctl(fd_uinput_keyboard, UI_SET_KEYBIT, keycode) < 0) {
- LOGW ("Fail to register uinput event key\n");
+ LOGW ("Fail to register uinput event key");
return ECORE_CALLBACK_CANCEL;
}
}
}
if (ioctl(fd_uinput_keyboard, UI_DEV_CREATE) < 0) {
- LOGW ("Fail to create keyboard uinput device\n");
+ LOGW ("Fail to create keyboard uinput device");
return ECORE_CALLBACK_CANCEL;
}
keymap_update_handler = ecore_event_handler_add (ECORE_WL_EVENT_KEYMAP_UPDATE, _ecore_wl_keymap_update_cb, NULL);
if (!keymap_update_handler) {
- LOGD ("Add keymap update callback failed\n");
+ LOGD ("Add keymap update callback failed");
return false;
}
fd_uinput_mouse = open_file(file_name);
if (fd_uinput_mouse < 0) {
- LOGW ("Fail to open fd uinput_mouse!\n");
+ LOGW ("Fail to open fd uinput_mouse!");
return false;
}
device_mouse.id.version = 1;
if (write(fd_uinput_mouse, &device_mouse, sizeof(device_mouse)) != sizeof(device_mouse)) {
- LOGW ("Fail to setup uinput structure on fd\n");
+ LOGW ("Fail to setup uinput structure on fd");
return false;
}
if (ioctl(fd_uinput_mouse, UI_SET_EVBIT, EV_KEY) < 0) {
- LOGW ("Fail to enable EV_KEY event type\n");
+ LOGW ("Fail to enable EV_KEY event type");
return false;
}
for (unsigned int i = 0; i < sizeof(uinput_btns)/sizeof(uinput_btns[0]); i++) {
if (ioctl(fd_uinput_mouse, UI_SET_KEYBIT, uinput_btns[i]) < 0) {
- LOGW ("Fail to register uinput event key: %d\n", uinput_btns[i]);
+ LOGW ("Fail to register uinput event key: %d", uinput_btns[i]);
return false;
}
}
if (ioctl(fd_uinput_mouse, UI_SET_EVBIT, EV_REL) < 0) {
- LOGW ("Fail to enable EV_REL event type\n");
+ LOGW ("Fail to enable EV_REL event type");
return false;
}
for (unsigned int i = 0; i < sizeof(uinput_rel_axes)/sizeof(uinput_rel_axes[0]); i++) {
if (ioctl(fd_uinput_mouse, UI_SET_RELBIT, uinput_rel_axes[i]) < 0) {
- LOGW ("Fail to register uinput event key: %d\n", uinput_rel_axes[i]);
+ LOGW ("Fail to register uinput event key: %d", uinput_rel_axes[i]);
return false;
}
}
if (ioctl(fd_uinput_mouse, UI_SET_EVBIT, EV_SYN) < 0) {
- LOGW ("Fail to enable EV_SYN event type\n");
+ LOGW ("Fail to enable EV_SYN event type");
return false;
}
if (ioctl(fd_uinput_mouse, UI_DEV_CREATE) < 0) {
- LOGW ("Fail to create keyboard uinput device\n");
+ LOGW ("Fail to create keyboard uinput device");
return false;
}
static bool app_create (void *user_data)
{
- LOGD ("app create\n");
+ LOGD ("app create");
return true;
}
static void app_control (app_control_h app_control, void *user_data)
{
- LOGD ("%s\n", __func__);
+ LOGD ("%s", __func__);
- LOGD ("isf_extra_hwkbd_module start\n");
+ LOGD ("isf_extra_hwkbd_module start");
/* Toggle input mode */
#ifdef HAVE_VCONF
int val = 1;
if (vconf_get_bool (VCONFKEY_ISF_HW_KEYBOARD_INPUT_DETECTED, &val) != 0)
- LOGW ("Failed to get vconf key\n");
+ LOGW ("Failed to get vconf key");
if (vconf_set_bool (VCONFKEY_ISF_HW_KEYBOARD_INPUT_DETECTED, !val) != 0)
- LOGW ("Failed to set vconf key\n");
+ LOGW ("Failed to set vconf key");
else
- LOGD ("Succeeded to set vconf key\n");
+ LOGD ("Succeeded to set vconf key");
#endif
ui_app_exit ();
static void app_terminate (void *user_data)
{
- LOGD ("app terminated\n");
+ LOGD ("app terminated");
}
EXAPI int main (int argc, char *argv [])
event_callback.terminate = app_terminate;
event_callback.app_control = app_control;
- LOGD ("start org.tizen.isf-kbd-mode-changer\n");
+ LOGD ("start org.tizen.isf-kbd-mode-changer");
return ui_app_main (argc, argv, &event_callback, NULL);
}
ret = pkgmgrinfo_appinfo_get_appinfo(appid, &appinfo_handle);
if (ret != PMINFO_R_OK) {
- LOGW("pkgmgrinfo_appinfo_get_appinfo() failed\n");
+ LOGW("pkgmgrinfo_appinfo_get_appinfo() failed");
return -1;
}
ret = pkgmgrinfo_appinfo_get_exec(appinfo_handle, &exec_path);
if (ret != PMINFO_R_OK) {
- LOGW("pkgmgrinfo_appinfo_get_exec() failed\n");
+ LOGW("pkgmgrinfo_appinfo_get_exec() failed");
pkgmgrinfo_appinfo_destroy_appinfo(appinfo_handle);
return -1;
}
/* Try to get in global packages */
ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &pkginfo_handle);
if (ret != PMINFO_R_OK) {
- LOGW("pkgmgrinfo_pkginfo_get_pkginfo() failed\n");
+ LOGW("pkgmgrinfo_pkginfo_get_pkginfo() failed");
pkgmgrinfo_appinfo_destroy_appinfo(appinfo_handle);
return -1;
}
/* In case of no executable in bin directory of package's root path */
/* Create symbolic link for launching and supporting application FW APIs */
if (symlink (SCIM_HELPER_LAUNCHER_PROGRAM, exec_path) != 0)
- LOGW("Failed to create symbolic link : %s\n", exec_path);
+ LOGW("Failed to create symbolic link : %s", exec_path);
else
- LOGD("Succeeded to create symbolic link : %s\n", exec_path);
+ LOGD("Succeeded to create symbolic link : %s", exec_path);
}
else {
- LOGW("Can't create symbolic link. %s is existed\n", exec_path);
+ LOGW("Can't create symbolic link. %s is existed", exec_path);
}
}
char *input_lang = vconf_keynode_get_str (key);
if (input_lang) {
set_input_language (input_lang);
- LOGD("input lang : %s\n", input_lang);
+ LOGD("input lang : %s", input_lang);
}
}
ulen = eina_unicode_strlen (ustr);
if (cursor_pos < 2 || cursor_pos > (int)ulen) {
- LOGD ("invalid range. cursor pos : %d, length : %d\n", cursor_pos, ulen);
+ LOGD ("invalid range. cursor pos : %d, length : %d", cursor_pos, ulen);
goto done;
}
uppercase = analyze_surrounding_text (ctx);
}
- SECURE_LOGD ("ctx : %p, auto capital : %d\n", ctx, uppercase);
+ SECURE_LOGD ("ctx : %p, auto capital : %d", ctx, uppercase);
wl_text_input_set_capital_mode (imcontext->text_input, uppercase);
}
_input_panel_state == ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW) &&
check_hide_key(ev->keyname)) {
- SECURE_LOGD ("%s key is pressed.\n", ev->keyname);
+ SECURE_LOGD ("%s key is pressed.", ev->keyname);
Ecore_IMF_Event_Key_Down imf_event;
Eina_Bool filter_ret = EINA_FALSE;
if (_focused_ctx)
filter_ret = ecore_imf_context_filter_event(_focused_ctx, ECORE_IMF_EVENT_KEY_DOWN, (Ecore_IMF_Event *)&imf_event);
else
- LOGD("no focus\n");
+ LOGD("no focus");
- SECURE_LOGD ("%s key is pressed. ret : %d\n", ev->keyname, filter_ret);
+ SECURE_LOGD ("%s key is pressed. ret : %d", ev->keyname, filter_ret);
if (filter_ret) {
return EINA_FALSE; /* the event is removed from the queue */
}
!check_hide_key(ev->keyname))
return EINA_TRUE; /* the event is kept */
- SECURE_LOGD ("%s key is released.\n", ev->keyname);
+ SECURE_LOGD ("%s key is released.", ev->keyname);
Ecore_IMF_Event_Key_Up imf_event;
Eina_Bool filter_ret = EINA_FALSE;
if (_focused_ctx)
filter_ret = ecore_imf_context_filter_event(_focused_ctx, ECORE_IMF_EVENT_KEY_UP, (Ecore_IMF_Event *)&imf_event);
else
- LOGD("no focus\n");
+ LOGD("no focus");
- SECURE_LOGD ("%s key is released. ret : %d\n", ev->keyname, filter_ret);
+ SECURE_LOGD ("%s key is released. ret : %d", ev->keyname, filter_ret);
if (filter_ret) {
return EINA_FALSE; /* the event is removed from the queue */
}
if (imcontext && imcontext->text_input) {
wl_text_input_hide_input_panel(imcontext->text_input);
} else {
- LOGD("creating temporary context for sending hide request\n");
+ LOGD("creating temporary context for sending hide request");
const char *ctx_id = ecore_imf_context_default_id_get();
Ecore_IMF_Context *temp_context = ecore_imf_context_add(ctx_id);
if (temp_context) {
if (!imcontext) return EINA_FALSE;
if (!imcontext->window) {
- LOGW("window is not given\n");
+ LOGW("window is not given");
return EINA_FALSE;
}
Ecore_Wl_Input *input = ecore_wl_window_keyboard_get(imcontext->window);
if (!input) {
- LOGW("ctx : %p, Can't get Wl_Input\n", ctx);
+ LOGW("ctx : %p, Can't get Wl_Input", ctx);
return EINA_FALSE;
}
struct wl_seat *seat = ecore_wl_input_seat_get(input);
if (!seat) {
- LOGW("ctx : %p, Can't get Wl_seat\n", ctx);
+ LOGW("ctx : %p, Can't get Wl_seat", ctx);
return EINA_FALSE;
}
unsigned int client_win_id = ecore_wl_window_id_get (imcontext->window);
- LOGD ("ctx : %p, client_window id : %#x, focus-out win : %#x\n", ctx, client_win_id, e->win);
+ LOGD ("ctx : %p, client_window id : %#x, focus-out win : %#x", ctx, client_win_id, e->win);
if (client_win_id > 0) {
if (e->win == client_win_id) {
- LOGD ("window focus out\n");
+ LOGD ("window focus out");
if (_focused_ctx == ctx) {
wayland_im_context_focus_out (ctx);
WaylandIMContext *imcontext = NULL;
if (!ctx) {
- LOGD("ctx is NULL\n");
+ LOGD("ctx is NULL");
need_temporary_context = EINA_TRUE;
} else {
imcontext = (WaylandIMContext *)ecore_imf_context_data_get(ctx);
if (!imcontext) {
- LOGD("imcontext is NULL :%p\n", ctx);
+ LOGD("imcontext is NULL :%p", ctx);
need_temporary_context = EINA_TRUE;
} else {
has_conformant = imcontext->has_conformant;
meaning that there is no connection available for communicating with the window manager.
So we are creating a temporary context for sending WILL_HIDE_ACK message */
if (need_temporary_context) {
- LOGD("creating temporary context for sending WILL_HIDE_ACK\n");
+ LOGD("creating temporary context for sending WILL_HIDE_ACK");
const char *ctx_id = ecore_imf_context_default_id_get();
ctx = ecore_imf_context_add(ctx_id);
if (ctx) {
if (ctx && imcontext) {
if (ecore_imf_context_client_canvas_get(ctx) && has_conformant) {
if (_conformant_reset_done && _received_will_hide_event) {
- LOGD("Send will hide ack, _conformant_reset_done = 1, received_will_hide_event = 1\n");
+ LOGD("Send will hide ack, _conformant_reset_done = 1, received_will_hide_event = 1");
_send_will_hide_ack(imcontext);
_conformant_reset_done = EINA_FALSE;
_received_will_hide_event = EINA_FALSE;
} else {
- LOGD ("_conformant_reset_done=%d, received_will_hide_event=%d\n",
+ LOGD ("_conformant_reset_done=%d, received_will_hide_event=%d",
_conformant_reset_done, _received_will_hide_event);
}
} else {
- LOGD("Send will hide ack right away, since there is no conformant available : %p %d\n",
+ LOGD("Send will hide ack right away, since there is no conformant available : %p %d",
ecore_imf_context_client_canvas_get(ctx), has_conformant);
_send_will_hide_ack (imcontext);
}
void *callback = evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, _render_post_cb);
_conformant_reset_done = EINA_TRUE;
_conformant_reset_started = EINA_FALSE;
- LOGD("[_render_post_cb], _conformant_reset_done = 1 , %p\n", callback);
+ LOGD("[_render_post_cb], _conformant_reset_done = 1 , %p", callback);
send_will_hide_ack(NULL);
}
if (!window) return ECORE_CALLBACK_PASS_ON;
if (!(e->state)) {
- LOGD("_conformant_reset_done = 0, registering _render_post_cb : %p %p\n", _active_context_canvas, window);
+ LOGD("_conformant_reset_done = 0, registering _render_post_cb : %p %p", _active_context_canvas, window);
_conformant_reset_done = EINA_FALSE;
if (_active_context_canvas && ecore_wl_window_conformant_get(window) && !_custom_conformant_event) {
evas_event_callback_del(_active_context_canvas, EVAS_CALLBACK_RENDER_POST, _render_post_cb);
_keyboard_geometry.h = h;
}
LOGD("[KEYPAD]: scr %dx%d, rot %d, orig (%d,%d, %dx%d)", scr_w, scr_h, rot, x, y, w, h);
- LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d\n", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
+ LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
ecore_imf_context_input_panel_event_callback_call(ctx, ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, 0);
}
}
get_purpose(ctx));
if (ecore_imf_context_surrounding_get(imcontext->ctx, &surrounding, &cursor_pos)) {
- SECURE_LOGD ("surrounding text : %s\n", surrounding);
+ SECURE_LOGD ("surrounding text : %s", surrounding);
if (surrounding)
free (surrounding);
wl_text_input_set_input_panel_position(imcontext->text_input,
imcontext->input_panel_position.x, imcontext->input_panel_position.y);
- SECURE_LOGD ("ctx : %p, layout : %d, layout variation : %d\n", ctx,
+ SECURE_LOGD ("ctx : %p, layout : %d, layout variation : %d", ctx,
layout, layout_variation);
- SECURE_LOGD ("language : %d, cursor position : %d, input hint : %#x, bidi direction : %d\n",
+ SECURE_LOGD ("language : %d, cursor position : %d, input hint : %#x, bidi direction : %d",
ecore_imf_context_input_panel_language_get (ctx),
cursor_pos,
ecore_imf_context_input_hint_get (ctx),
imcontext->bidi_direction);
- SECURE_LOGD ("return key type : %d, return key disabled : %d, autocapital type : %d\n",
+ SECURE_LOGD ("return key type : %d, return key disabled : %d, autocapital type : %d",
ecore_imf_context_input_panel_return_key_type_get (ctx),
ecore_imf_context_input_panel_return_key_disabled_get (ctx),
ecore_imf_context_autocapital_type_get (ctx));
- SECURE_LOGD ("client_window : %#x, password mode : %d, prediction_allow : %d\n",
+ SECURE_LOGD ("client_window : %#x, password mode : %d, prediction_allow : %d",
(unsigned long int)ecore_imf_context_client_window_get (ctx),
(imcontext->content_hint & WL_TEXT_INPUT_CONTENT_HINT_SENSITIVE_DATA) ? 1 : 0,
ecore_imf_context_prediction_allow_get (ctx));
- SECURE_LOGD ("mime_type : %s, input panel position x : %d, y : %d\n",
+ SECURE_LOGD ("mime_type : %s, input panel position x : %d, y : %d",
imcontext->mime_type, imcontext->input_panel_position.x, imcontext->input_panel_position.y);
if (_active_context_canvas && !evas_focus_state_get (_active_context_canvas)) {
- LOGW ("Canvas does not have focus!\n");
+ LOGW ("Canvas does not have focus!");
}
//
will_hide = EINA_FALSE;
_received_will_hide_event = EINA_TRUE;
- LOGD("_received_will_hide_event = 1\n");
+ LOGD("_received_will_hide_event = 1");
send_will_hide_ack(imcontext->ctx);
break;
case WL_TEXT_INPUT_INPUT_PANEL_STATE_SHOW:
_received_will_hide_event = EINA_FALSE;
if (!_show_req_ctx)
_show_req_ctx = imcontext->ctx;
- LOGD("_received_will_hide_event = 0\n");
+ LOGD("_received_will_hide_event = 0");
break;
default:
_input_panel_state = (Ecore_IMF_Input_Panel_State)state;
if (state == WL_TEXT_INPUT_INPUT_PANEL_STATE_HIDE) {
reset_keyboard_geometry();
- LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d\n", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
+ LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
ecore_imf_context_input_panel_event_callback_call(imcontext->ctx, ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, 0);
}
//
_keyboard_geometry.y = y;
_keyboard_geometry.w = w;
_keyboard_geometry.h = h;
- LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d\n", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
+ LOGD ("IME geometry x : %d, y : %d, w : %d, h : %d", _keyboard_geometry.x, _keyboard_geometry.y, _keyboard_geometry.w, _keyboard_geometry.h);
ecore_imf_context_input_panel_event_callback_call(imcontext->ctx, ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, 0);
}
}
ev.mime_types = mime_types;
ev.description = description;
- SECURE_LOGD("commit content : %s, description : %s, mime types : %s\n", content, description, mime_types);
+ SECURE_LOGD("commit content : %s, description : %s, mime types : %s", content, description, mime_types);
ecore_imf_context_event_callback_call(imcontext->ctx, ECORE_IMF_CALLBACK_COMMIT_CONTENT, (void *)&ev);
}
WaylandIMContext *imcontext = (WaylandIMContext *)data;
if (!imcontext || !imcontext->ctx) return;
- LOGD("event type : %d, value : %d\n", event_type, value);
+ LOGD("event type : %d, value : %d", event_type, value);
ecore_imf_context_input_panel_event_callback_call(imcontext->ctx, event_type, value);
}
hw_keyboard_mode = vconf_keynode_get_bool (key);
Ecore_IMF_Context *active_ctx = get_using_ctx ();
if (active_ctx) {
- LOGD ("ctx : %p, input detect : %d\n", active_ctx, hw_keyboard_mode);
+ LOGD ("ctx : %p, input detect : %d", active_ctx, hw_keyboard_mode);
Ecore_IMF_Input_Panel_Keyboard_Mode input_mode = hw_keyboard_mode ? ECORE_IMF_INPUT_PANEL_HW_KEYBOARD_MODE : ECORE_IMF_INPUT_PANEL_SW_KEYBOARD_MODE;
ecore_imf_context_input_panel_event_callback_call (active_ctx, ECORE_IMF_INPUT_PANEL_KEYBOARD_MODE_EVENT, input_mode);
void
wayland_im_context_focus_in(Ecore_IMF_Context *ctx)
{
- LOGD ("ctx : %p. enable : %d, on demand : %d\n", ctx,
+ LOGD ("ctx : %p. enable : %d, on demand : %d", ctx,
ecore_imf_context_input_panel_enabled_get(ctx),
ecore_imf_context_input_panel_show_on_demand_get (ctx));
if (!ecore_imf_context_input_panel_show_on_demand_get (ctx))
show_input_panel(ctx);
else
- LOGD ("ctx : %p input panel on demand mode : TRUE\n", ctx);
+ LOGD ("ctx : %p input panel on demand mode : TRUE", ctx);
else
- LOGD ("ctx : %p input panel enable : FALSE\n", ctx);
+ LOGD ("ctx : %p input panel enable : FALSE", ctx);
}
void
imcontext->cursor_position = cursor_pos;
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p, cursor pos : %d\n", ctx, cursor_pos);
+ LOGD ("ctx : %p, cursor pos : %d", ctx, cursor_pos);
set_autocapital (ctx);
#endif
if (type == ECORE_IMF_EVENT_MOUSE_UP) {
if (ecore_imf_context_input_panel_enabled_get(ctx)) {
- LOGD ("[Mouse-up event] ctx : %p\n", ctx);
+ LOGD ("[Mouse-up event] ctx : %p", ctx);
if (ctx == _focused_ctx) {
ecore_imf_context_input_panel_show(ctx);
}
else
- LOGE ("Can't show IME because there is no focus. ctx : %p\n", ctx);
+ LOGE ("Can't show IME because there is no focus. ctx : %p", ctx);
}
}
#if !(ENABLE_GRAB_KEYBOARD)
return EINA_FALSE;
if (!_focused_ctx) {
- LOGW ("no focus\n");
+ LOGW ("no focus");
return EINA_FALSE;
}
if (_focused_ctx != ctx) {
- LOGW ("focused context is different from the context used in ecore_imf_context_filter_event.\n");
- LOGW ("focus context : %p, context : %p\n", _focused_ctx, ctx);
+ LOGW ("focused context is different from the context used in ecore_imf_context_filter_event.");
+ LOGW ("focus context : %p, context : %p", _focused_ctx, ctx);
return EINA_FALSE;
}
imcontext->content_hint |= WL_TEXT_INPUT_CONTENT_HINT_LOWERCASE;
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p. set autocapital type : %d\n", ctx, autocapital_type);
+ LOGD ("ctx : %p. set autocapital type : %d", ctx, autocapital_type);
wl_text_input_set_content_type(imcontext->text_input,
imcontext->content_hint,
get_purpose(ctx));
}
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p, layout type : %d\n", ctx, layout);
+ LOGD ("ctx : %p, layout type : %d", ctx, layout);
wl_text_input_set_content_type(imcontext->text_input,
imcontext->content_hint,
get_purpose(ctx));
imcontext->content_hint &= ~(WL_TEXT_INPUT_CONTENT_HINT_SENSITIVE_DATA | WL_TEXT_INPUT_CONTENT_HINT_PASSWORD);
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p, input mode : %d\n", ctx, input_mode);
+ LOGD ("ctx : %p, input mode : %d", ctx, input_mode);
wl_text_input_set_content_type(imcontext->text_input,
imcontext->content_hint,
get_purpose(ctx));
imcontext->content_hint &= ~WL_TEXT_INPUT_CONTENT_HINT_MULTILINE;
if (imcontext->input && imcontext->text_input) {
- LOGD("ctx : %p, input hint : %#x\n", ctx, input_hints);
+ LOGD("ctx : %p, input hint : %#x", ctx, input_hints);
wl_text_input_set_content_type(imcontext->text_input,
imcontext->content_hint,
get_purpose(ctx));
if (strncmp(data, custom_conformant_finished, strlen(custom_conformant_finished)) == 0) {
if (_custom_conformant_event) {
_conformant_reset_done = EINA_TRUE;
- LOGD("[conformant:custom,finished], _conformant_reset_done = 1\n");
+ LOGD("[conformant:custom,finished], _conformant_reset_done = 1");
send_will_hide_ack(NULL);
}
return;
imcontext->bidi_direction = bidi_direction;
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p, bidi direction : %#x\n", ctx, bidi_direction);
+ LOGD ("ctx : %p, bidi direction : %#x", ctx, bidi_direction);
wl_text_input_bidi_direction(imcontext->text_input, imcontext->bidi_direction);
}
}
imcontext->prediction_hint = strdup(prediction_hint ? prediction_hint : "");
if (imcontext->input && imcontext->text_input) {
- SECURE_LOGD ("ctx : %p, prediction_hint : %s\n", ctx, imcontext->prediction_hint);
+ SECURE_LOGD ("ctx : %p, prediction_hint : %s", ctx, imcontext->prediction_hint);
wl_text_input_prediction_hint(imcontext->text_input, imcontext->prediction_hint);
}
}
imcontext->mime_type = strdup(mime_type);
if (imcontext->input && imcontext->text_input && (strlen(mime_type) > 0)) {
- LOGD ("ctx : %p, mime_type : %s\n", ctx, imcontext->mime_type);
+ LOGD ("ctx : %p, mime_type : %s", ctx, imcontext->mime_type);
wl_text_input_set_mime_type(imcontext->text_input, imcontext->mime_type);
}
}
}
if (imcontext->input && imcontext->text_input) {
- LOGD ("ctx : %p, x = %d, y = %d\n", ctx, x, y);
+ LOGD ("ctx : %p, x = %d, y = %d", ctx, x, y);
wl_text_input_set_input_panel_position(imcontext->text_input,
imcontext->input_panel_position.x, imcontext->input_panel_position.y);
}
trans.get_data (*pStr) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK)
return true;
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
*pl = val;
return true;
}
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
*val = strtod (str.c_str (), NULL);
return true;
}
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
*val = (bool)tmp;
return true;
}
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
return true;
}
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
val->push_back ((int) vec[i]);
return true;
}
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGW ("Failed, reconnect again");
if (m_socket_client.connect (socket_address))
break;
scim_usleep (100000);
- LOGW (" Re-connecting to ISF(scim) server. SocketConfig connect count : %d\n", i+1);
+ LOGW (" Re-connecting to ISF(scim) server. SocketConfig connect count : %d", i+1);
}
}
if (!m_socket_client.is_connected ()) {
- LOGW (" Cannot connect to SocketServer (%s).\n", m_socket_address.c_str ());
+ LOGW (" Cannot connect to SocketServer (%s).", m_socket_address.c_str ());
return false;
}
m_socket_client,
m_socket_timeout)) {
m_socket_client.close ();
- LOGE (" Connect to SocketServer (%s) failed.\n", m_socket_address.c_str ());
+ LOGE (" Connect to SocketServer (%s) failed.", m_socket_address.c_str ());
return false;
}
- LOGD (" Connect to SocketServer (%s).\n", m_socket_address.c_str ());
+ LOGD (" Connect to SocketServer (%s).", m_socket_address.c_str ());
m_connected = true;
gettimeofday (&m_update_timestamp, 0);
return true;
0};
SCIM_DEBUG_MAIN (2) << " Call scim-helper-launcher.\n";
- ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)\n", name, appid);
+ ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)", name, appid);
setsid ();
- LOGD ("launch execpath : %s\n", scim_helper_path.c_str ());
+ LOGD ("launch execpath : %s", scim_helper_path.c_str ());
execv (scim_helper_path.c_str (), const_cast<char **>(argv));
exit (-1);
}
ret = app_control_create (&app_control);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_create returned %d\n", ret);
+ LOGW ("app_control_create returned %d", ret);
return;
}
ret = app_control_set_operation (app_control, APP_CONTROL_OPERATION_DEFAULT);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_set_operation returned %d\n", ret);
+ LOGW ("app_control_set_operation returned %d", ret);
app_control_destroy (app_control);
return;
}
ret = app_control_set_app_id (app_control, app_id);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_set_app_id returned %d\n", ret);
+ LOGW ("app_control_set_app_id returned %d", ret);
app_control_destroy (app_control);
return;
}
ret = app_control_send_launch_request (app_control, NULL, NULL);
if (ret != APP_CONTROL_ERROR_NONE) {
- LOGW ("app_control_send_launch_request returned %d, app_id=%s\n", ret, app_id);
+ LOGW ("app_control_send_launch_request returned %d, app_id=%s", ret, app_id);
app_control_destroy (app_control);
return;
}
app_control_destroy (app_control);
- LOGD ("Launch %s\n", app_id);
+ LOGD ("Launch %s", app_id);
}
void SocketFrontEnd::run_helper (const Socket &client)
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
return;
}
- ISF_SAVE_LOG ("uuid(%s), config(%s), display(%s)\n", uuid.c_str (), config.c_str (), display.c_str ());
+ ISF_SAVE_LOG ("uuid(%s), config(%s), display(%s)", uuid.c_str (), config.c_str (), display.c_str ());
#ifdef HAVE_PKGMGR_INFO
char *execpath = NULL;
ret = pkgmgrinfo_appinfo_get_usr_appinfo (uuid.c_str (), getuid (), &appinfo_handle);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_get_appinfo () & get_usr_appinfo () failed. appid : %s, ret : %d \n", uuid.c_str (), ret);
+ LOGW ("pkgmgrinfo_appinfo_get_appinfo () & get_usr_appinfo () failed. appid : %s, ret : %d", uuid.c_str (), ret);
return;
}
}
return;
}
- LOGD ("exec path : %s\n", execpath);
+ LOGD ("exec path : %s", execpath);
scim_helper_path = String (execpath);
if (appinfo_handle) {
}
if (i > 0 && i == __helpers.size ()) {
- ISF_SAVE_LOG ("Can't find and exec scim_helper_launcher appid=\"%s\"\n", uuid.c_str ());
+ ISF_SAVE_LOG ("Can't find and exec scim_helper_launcher appid=\"%s\"", uuid.c_str ());
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
}
else
if (m_receive_trans.get_data (strName) && strName.length () > 0) {
//std::cout << "ISE name list:" << strName << "\n";
//scim_split_string_list (name_list, strName);
- LOGD ("%s\n", strName.c_str ());
+ LOGD ("%s", strName.c_str ());
/* The strName has all appids but here module name is necessary. */
HelperInfo info;
std::vector<ImeInfoDB> ime_info;
socklen_t len = sizeof(struct ucred);
if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
int ret = aul_update_freezer_status((long)ucred.pid, "wakeup");
- LOGD("aul_update_freezer_status : %d %d\n", ucred.pid, ret);
+ LOGD("aul_update_freezer_status : %d %d", ucred.pid, ret);
} else {
- LOGD("getsockopt failed : %d\n", errno);
+ LOGD("getsockopt failed : %d", errno);
}
}
#define DEFAULT_CONTEXT_VALUE 0xfff
_read_handler_list.push_back(panel_agent_read_handler);
return true;
}
- LOGE("create server failed\n");
+ LOGE("create server failed");
return false;
}
}
private:
void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void move_preedit_caret(int client, uint32 context_id, uint32 position) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
#endif
void reset_keyboard_ise(int client, uint32 context_id) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void update_keyboard_ise_list(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void change_factory(int client, uint32 context, const String& uuid) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_candidate_show(int client, uint32 context, const String& uuid) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void helper_candidate_hide(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void candidate_more_window_show(int client, uint32 context) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void candidate_more_window_hide(int client, uint32 context) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void select_aux(int client, uint32 contextid, uint32 item) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void select_candidate(int client, uint32 context, uint32 item) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void lookup_table_page_up(int client, uint32 context) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void lookup_table_page_down(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void select_associate(int client, uint32 context, uint32 item) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void associate_table_page_up(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void associate_table_page_down(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_associate_table_page_size(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void send_longpress_event(int client, uint32 context, int index) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void trigger_property(int client, uint32 context, const String& property) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void focus_out_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void focus_in_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void hide_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_imdata(int client, uint32 context, const String& uuid, const char* imdata, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
Transaction trans;
SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
} else {
- LOGW ("read failed\n");
+ LOGW ("read failed");
}
}
void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void show_helper_option_window(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void resume_helper_option_window(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void set_helper_keyboard_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_prediction_hint(int client, uint32 context, const String& uuid, String& prediction_hint) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_mime_type(int client, uint32 context, const String& uuid, String& mime_type) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void finalize_content_helper(int client, uint32 context, const String& uuid, String& text, uint32& cursor_pos) {
- LOGD("client id:%d\n", client);
+ LOGD("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, uint32 serial) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
return true;
} else {
- LOGW ("read failed\n");
+ LOGW ("read failed");
}
return false;
}
bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
return true;
} else
- LOGW ("read failed\n");
+ LOGW ("read failed");
} else
- LOGW ("write failed\n");
+ LOGW ("write failed");
return false;
}
void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
Transaction trans;
trans.get_data(imdata, len);
LOGD ("length of imdata is %d", len);
} else {
- LOGW ("read imdata failed\n");
+ LOGW ("read imdata failed");
}
}
void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
&& trans.get_data(layout)) {
SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
} else
- LOGW ("failed\n");
+ LOGW ("failed");
}
void get_ise_language_locale(int client, uint32 context, String& uuid, char** data, size_t& len) {
SCIM_DEBUG_MAIN(4) << __func__ << "\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Transaction trans;
&& trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
&& trans.get_data(data, len)) {
} else {
- LOGW ("failed\n");
+ LOGW ("failed");
}
}
void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
int cmd;
Socket client_socket(client);
if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
!trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
!trans.get_data(avail)) {
- LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed\n");
+ LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed");
}
}
void reset_ise_option(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void reset_helper_context(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Transaction trans;
Socket client_socket(client);
m_send_trans.clear();
void reload_config(int client) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void exit(int client, uint32 context) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
bool process_input_device_event(int client, uint32 context, const String& uuid, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
- LOGD("client id:%d\n", client);
+ LOGD("client id:%d", client);
Socket client_socket(client);
return true;
}
else {
- LOGW("read failed\n");
+ LOGW("read failed");
}
return false;
void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void socket_remoteinput_focus_in (int client) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
bool ret;
ret = (client == -1) ? false : true;
void socket_remoteinput_focus_out (int client) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
bool ret;
ret = (client == -1) ? false : true;
void socket_remoteinput_entry_metadata (int client, uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
bool ret;
ret = (client == -1) ? false : true;
void socket_remoteinput_surrounding_text (int client, String& text, uint32 cursor) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
bool ret;
ret = (client == -1) ? false : true;
void socket_remoteinput_input_resource (int client, uint32 input_resource) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
bool ret;
ret = (client == -1) ? false : true;
}
void socket_update_selection(int client, uint32 context, String& uuid, String text) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_get_candidate_ui(int client, uint32 context, const String& uuid, int style, int mode) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
SCIM_DEBUG_MAIN(4) << __func__ << " \n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
}
void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
Socket socket_client(client);
}
void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void commit_string(int client, uint32 target_context, const WideString& wstr) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_get_selection(int client, uint32 context_id) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
}
void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void show_preedit_string(int client, uint32 target_context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void hide_preedit_string(int client, uint32 target_context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void update_preedit_string(int client, uint32 target_context, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
}
void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void send_private_command(int client, uint32 focused_context, String command) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void commit_content(int client, uint32 focused_context, String content, String description, String mime_types) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void set_autocapital_type(int client, uint32 context, String uuid, int mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void remote_update_preedit_string (int client, uint32 target_context, const WideString str, const WideString commit, const AttributeList &attrs, uint32 caret) {
- LOGD("client id:%d\n", client);
+ LOGD("client id:%d", client);
Socket client_socket(client);
lock();
}
void remote_send_key_event (int client, uint32 target_context, const KeyEvent &key) {
- LOGD("client id:%d\n", client);
+ LOGD("client id:%d", client);
Socket client_socket(client);
lock();
}
void remote_forward_key_event (int client, uint32 target_context, const KeyEvent &key) {
- LOGD("client id:%d\n", client);
+ LOGD("client id:%d", client);
Socket client_socket(client);
lock();
}
void remote_commit_string (int client, uint32 target_context, const WideString& wstr) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void remote_delete_surrounding_text (int client, uint32 context_id, uint32 offset, uint32 len) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void set_prediction_allow (int client, uint32 context, String uuid, int mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void send_fail_reply (int client)
{
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket (client);
Transaction trans;
return true;
if (nbytes < 0) {
- LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
+ LOGW ("Error occurred when reading socket: %s", client.get_error_message().c_str());
} else {
- LOGW ("Timeout when reading socket\n");
+ LOGW ("Timeout when reading socket");
}
return false;
::close (fd);
ecore_main_fd_handler_del(fd_handler);
- ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
+ ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!", fd);
}
return ECORE_CALLBACK_RENEW;
::close (fd);
ecore_main_fd_handler_del(fd_handler);
- ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
+ ISF_SAVE_LOG("Received exception event (fd=%d)!!!", fd);
return ECORE_CALLBACK_RENEW;
}
/* If the connection is closed then close this client. */
if (!socket_check_client_connection(client)) {
- LOGW ("check client connection failed\n");
+ LOGW ("check client connection failed");
socket_close_connection(server, client);
return;
}
if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
!m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
!m_recv_trans.get_data(key) || key != (uint32) client_info.key) {
- LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
+ LOGW ("cmd:%d key:%d client info key: %d", cmd, key, client_info.key);
return;
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
uint32 id = 0;
if (m_recv_trans.get_data(id)) {
m_info_manager->register_panel_client(client_id, id);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->register_input_context(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->focus_in(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(isOn)) {
m_info_manager->socket_turn_on_log(isOn);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
ret = true;
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
m_info_manager->hide_ise_panel(client_id, client, context);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(language)) {
m_info_manager->set_ise_language(client_id, language);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(&imdata, len)) {
m_info_manager->set_ise_imdata(client_id, imdata, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
if (NULL != imdata)
if (m_recv_trans.get_data(type)) {
m_info_manager->set_ise_return_key_type(client_id, type);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(disabled)) {
m_info_manager->set_ise_return_key_disable(client_id, disabled);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(layout)) {
m_info_manager->set_ise_layout(client_id, layout);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(mode)) {
m_info_manager->set_ise_caps_mode(client_id, mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(mode)) {
m_info_manager->set_keyboard_mode(client_id, mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
ret = true;
m_info_manager->process_key_event(key, result);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
if (m_recv_trans.get_data(input_mode)) {
m_info_manager->set_ise_input_mode(client_id, input_mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(input_hint)) {
m_info_manager->set_ise_input_hint(client_id, input_hint);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(bidi_direction)) {
m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(uuid) && uuid.length()) {
m_info_manager->socket_start_helper(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
uuid.length() && m_nest_trans.valid()) {
m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(uuid) && uuid.length()) {
m_info_manager->socket_stop_helper(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(num))
m_info_manager->socket_update_screen(client_id, num);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
uint32 x, y, top_y;
if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
m_info_manager->socket_update_spot_location(x, y, top_y);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
uint32 cursor_pos;
if (m_recv_trans.get_data(cursor_pos)) {
m_info_manager->socket_update_cursor_position(cursor_pos);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
String text;
if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
m_info_manager->socket_update_surrounding_text(text, cursor);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
String text;
if (m_recv_trans.get_data(text)) {
m_info_manager->socket_update_selection(text);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
m_info_manager->expand_candidate();
if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
m_info_manager->socket_set_candidate_ui(portrait_line, mode);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
PanelFactoryInfo info;
m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
m_info_manager->socket_update_factory_info(info);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
m_info_manager->socket_show_preedit_string();
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
m_info_manager->socket_update_preedit_string(str, attrs, caret);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
uint32 caret;
if (m_recv_trans.get_data(caret))
m_info_manager->socket_update_preedit_caret(caret);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
String str;
AttributeList attrs;
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
m_info_manager->socket_update_aux_string(str, attrs);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
uint32 target_ic;
String target_uuid;
m_recv_trans.get_data(attrs)) {
m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table))
m_info_manager->socket_update_lookup_table(_isf_candidate_table);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
CommonLookupTable table;
if (m_recv_trans.get_data(table))
m_info_manager->socket_update_associate_table(table);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
PropertyList properties;
if (m_recv_trans.get_data(properties))
m_info_manager->socket_register_properties(properties);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
Property property;
if (m_recv_trans.get_data(property))
m_info_manager->socket_update_property(property);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
String help;
if (m_recv_trans.get_data(help))
m_info_manager->socket_show_help(help);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
PanelFactoryInfo info;
std::vector <PanelFactoryInfo> vec;
} else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
m_info_manager->focus_out(client_id, context);
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
Socket client_socket(client_id);
trans.write_to_socket(client_socket);
continue;
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
HelperInfo info;
m_info_manager->socket_helper_register_helper(client_id, info);
}
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
HelperInfo info;
info.uuid.length()) {
m_info_manager->socket_helper_register_helper_passive(client_id, info);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
/* Check whether application already requested the focus_in and showing input_panel
wstr.length()) {
m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
uint32 target_ic;
if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
m_info_manager->socket_show_aux_string();
if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
m_info_manager->socket_hide_aux_string();
m_recv_trans.get_data(caret)) {
m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
uint32 caret;
if (m_recv_trans.get_data(caret)) {
m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
String str;
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
m_info_manager->socket_update_aux_string(str, attrs);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table)) {
m_info_manager->socket_update_lookup_table(_isf_candidate_table);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table)) {
m_info_manager->socket_update_associate_table(_isf_candidate_table);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
!key.empty()) {
m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
uint32 target_ic;
!key.empty()) {
m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
uint32 target_ic;
m_nest_trans.valid()) {
m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
PropertyList properties;
if (m_recv_trans.get_data(properties))
m_info_manager->socket_helper_register_properties(client_id, properties);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
Property property;
if (m_recv_trans.get_data(property))
m_info_manager->socket_helper_update_property(client_id, property);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
uint32 type;
uint32 value;
if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
m_info_manager->socket_helper_update_input_context(client_id, type, value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_keyboard_ise_list(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
uint32 portrait_line, mode;
if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
m_info_manager->socket_set_candidate_ui(portrait_line, mode);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_candidate_ui(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
uint32 left, top;
if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
m_info_manager->socket_set_candidate_position(left, top);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
m_info_manager->socket_hide_candidate();
} else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_candidate_geometry(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
m_info_manager->reset_keyboard_ise();
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_set_keyboard_ise(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_keyboard_ise(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
uint32 x, y, width, height;
m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
m_info_manager->expand_candidate();
if (m_recv_trans.get_data(index))
m_info_manager->socket_helper_select_candidate(index);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
String uuid;
uint32 maxlen_before;
m_recv_trans.get_data(maxlen_after)) {
m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
uint32 offset;
if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_helper_get_selection(client_id, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
uint32 start;
if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
m_info_manager->socket_helper_set_selection(client_id, start, end);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
String command;
if (m_recv_trans.get_data(command)) {
m_info_manager->socket_helper_send_private_command(client_id, command);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
//FIXME: useless
//} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
m_recv_trans.get_data(mime_types)) {
m_info_manager->socket_helper_commit_content(client_id, content, description, mime_types);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
KeyEvent key;
if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
m_info_manager->process_key_event_done(key, ret, serial);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_REQUEST_ISE_HIDE) {
m_info_manager->request_ise_hide();
m_recv_trans.get_data(attrs)) {
m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get active ise\n");
+ LOGW ("Access denied to get active ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
if (m_recv_trans.get_data(&buf, len)) {
ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
delete[] buf;
}
else {
- LOGW ("Access denied to set active ise\n");
+ LOGW ("Access denied to set active ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
if (m_recv_trans.get_data(&buf, len)) {
m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
delete[] buf;
}
else {
- LOGW ("Access denied to set initial ise\n");
+ LOGW ("Access denied to set initial ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get ise list\n");
+ LOGW ("Access denied to get ise list");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
} while (0);
}
else {
- LOGW ("Access denied to get all helper ise info\n");
+ LOGW ("Access denied to get all helper ise info");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
ret = true;
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to set enable helper ise info\n");
+ LOGW ("Access denied to set enable helper ise info");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
if (m_recv_trans.get_data(strUuid)) {
m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get ise information\n");
+ LOGW ("Access denied to get ise information");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
m_info_manager->reset_ise_option(client_id);
}
else {
- LOGW ("Access denied to reset ise option\n");
+ LOGW ("Access denied to reset ise option");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
m_info_manager->reset_default_ise(client_id);
}
else {
- LOGW ("Access denied to reset default ise\n");
+ LOGW ("Access denied to reset default ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
m_info_manager->show_isf_panel(client_id);
}
else {
- LOGW ("Access denied to show isf control\n");
+ LOGW ("Access denied to show isf control");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
m_info_manager->show_ise_option_window(client_id);
}
else {
- LOGW ("Access denied to show ise option window\n");
+ LOGW ("Access denied to show ise option window");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
m_info_manager->resume_ise_option_window(client_id);
}
else {
- LOGW ("Access denied to resume ise option window\n");
+ LOGW ("Access denied to resume ise option window");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
m_info_manager->show_helper_ise_list(client_id);
}
else {
- LOGW ("Access denied to show helper ise list\n");
+ LOGW ("Access denied to show helper ise list");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
m_info_manager->show_helper_ise_selector(client_id);
}
else {
- LOGW ("Access denied to show helper ise selector\n");
+ LOGW ("Access denied to show helper ise selector");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to check helper ise enabled\n");
+ LOGW ("Access denied to check helper ise enabled");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
trans.write_to_socket(client_socket);
m_info_manager->hide_helper_ise ();
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
} else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_REMOTE_TRANS_CMD_SEND_INPUT_MESSAGE) {
char* buf = NULL;
size_t len;
if (m_recv_trans.get_data(&buf, len)) {
ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
ret = m_info_manager->remoteinput_delete_surrounding_text(offset, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
trans.write_to_socket(client_socket);
} else {
- LOGW ("unknown cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
void socket_exception_callback(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
socket_close_connection(server, client);
}
bool socket_open_connection(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
uint32 key;
String type = scim_socket_accept_connection(key,
String("Panel"),
unlock();
return true;
}
- LOGW ("open_connection failed\n");
+ LOGW ("open_connection failed");
SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
server->close_connection(client);
void socket_close_connection(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
int i = 0;
std::vector<Ecore_Fd_Handler *>::iterator IterPos;
return true;
}
- LOGE ("create socketconfig server failed\n");
+ LOGE ("create socketconfig server failed");
return false;
}
return true;
if (nbytes < 0) {
- LOGW ("Error occurred when reading socket: %s\n", client.get_error_message ().c_str());
+ LOGW ("Error occurred when reading socket: %s", client.get_error_message ().c_str());
} else {
- LOGW ("Timeout when reading socket\n");
+ LOGW ("Timeout when reading socket");
}
return false;
/* If the connection is closed then close this client. */
if (!socket_check_client_connection (client)) {
- LOGW ("check client connection failed\n");
+ LOGW ("check client connection failed");
socket_close_connection (server, client);
return;
}
if (!m_recv_trans.read_from_socket (client, m_socket_timeout) ||
!m_recv_trans.get_command (cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
!m_recv_trans.get_data (key) || key != (uint32) client_info.key) {
- LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
+ LOGW ("cmd:%d key:%d client info key: %d", cmd, key, client_info.key);
return;
}
{
socket_transaction_start ();
while (m_recv_trans.get_command (cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == SCIM_TRANS_CMD_FLUSH_CONFIG) {
if (m_config_readonly) {
}
_config->erase (key);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
} else if (cmd == SCIM_TRANS_CMD_RELOAD_CONFIG) {
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str ());
+ LOGW ("read config key = %s failed", key.c_str ());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
} else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_STRING) {
LOGD ("set %s:%s", key.c_str (), value.c_str ());
_config->write (key, value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
} else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_INT) {
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str ());
+ LOGW ("read config key = %s failed", key.c_str ());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
LOGD ("set %s:%d", key.c_str (), value);
_config->write (key, (int) value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str ());
+ LOGW ("read config key = %s failed", key.c_str ());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
}
_config->write (key, (bool) value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
} else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_DOUBLE) {
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str());
+ LOGW ("read config key = %s failed", key.c_str());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
}
_config->write (key, value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str());
+ LOGW ("read config key = %s failed", key.c_str());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
}
_config->write (key, vec);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
} else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_VECTOR_INT) {
m_send_trans.put_command (SCIM_TRANS_CMD_OK);
} else {
m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s failed\n", key.c_str());
+ LOGW ("read config key = %s failed", key.c_str());
}
m_send_trans.write_to_socket (client_socket);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
_config->write (key, req);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
}
void socket_exception_callback (SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id ());
+ LOGD ("client id:%d", client.get_id ());
socket_close_connection (server, client);
}
bool socket_open_connection (SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
uint32 key;
String type = scim_socket_accept_connection (key,
String ("Panel"),
m_clients [client.get_id ()] = info;
return true;
}
- LOGW ("open_connection failed\n");
+ LOGW ("open_connection failed");
SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id () << "\n";
server->close_connection (client);
void socket_close_connection (SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id () << ")\n";
- LOGD ("client id:%d\n", client.get_id ());
+ LOGD ("client id:%d", client.get_id ());
ClientRepository::iterator it = m_clients.find (client.get_id ());
if (it != m_clients.end ()) {
{
int val;
if (vconf_get_bool (VCONFKEY_ISF_HW_KEYBOARD_INPUT_DETECTED, &val) != 0) {
- LOGW ("Failed to get input detect\n");
+ LOGW ("Failed to get input detect");
return;
}
iseContext.bidi_direction = wsc_context_bidi_direction_get (wsc_ctx);
- LOGD ("ctx : %p, layout : %d, layout variation : %d\n", wsc_ctx, iseContext.layout, iseContext.layout_variation);
- LOGD ("language : %d, cursor position : %d, caps mode : %d\n", iseContext.language, iseContext.cursor_pos, iseContext.caps_mode);
- LOGD ("return_key_type : %d, return_key_disabled : %d, autocapital type : %d\n", iseContext.return_key_type, iseContext.return_key_disabled, iseContext.autocapital_type);
- LOGD ("password mode : %d, prediction_allow : %d\n", iseContext.password_mode, iseContext.prediction_allow);
- LOGD ("input hint : %#x\n", iseContext.input_hint);
- LOGD ("bidi direction : %d\n", iseContext.bidi_direction);
+ LOGD ("ctx : %p, layout : %d, layout variation : %d", wsc_ctx, iseContext.layout, iseContext.layout_variation);
+ LOGD ("language : %d, cursor position : %d, caps mode : %d", iseContext.language, iseContext.cursor_pos, iseContext.caps_mode);
+ LOGD ("return_key_type : %d, return_key_disabled : %d, autocapital type : %d", iseContext.return_key_type, iseContext.return_key_disabled, iseContext.autocapital_type);
+ LOGD ("password mode : %d, prediction_allow : %d", iseContext.password_mode, iseContext.prediction_allow);
+ LOGD ("input hint : %#x", iseContext.input_hint);
+ LOGD ("bidi direction : %d", iseContext.bidi_direction);
int mime_type_size = strlen (mime_types);
if (mime_type_size > 0) {
if (_support_hw_keyboard_mode) {
kbd_mode = mode;
- SECURE_LOGD ("keyboard mode : %d\n", kbd_mode);
+ SECURE_LOGD ("keyboard mode : %d", kbd_mode);
_isf_wsc_context_set_keyboard_mode (_get_context_id (ctx), mode);
}
}
WSCContextISF *context_scim = ctx;
if (context_scim == get_focused_ic ()) {
- LOGD ("layout type : %d\n", layout);
+ LOGD ("layout type : %d", layout);
_isf_wsc_context_input_panel_layout_set (_get_context_id (ctx), layout);
}
}
void isf_wsc_context_input_panel_caps_mode_set (WSCContextISF *ctx, unsigned int mode)
{
- LOGD ("ctx : %p, mode : %d\n", ctx, mode);
+ LOGD ("ctx : %p, mode : %d", ctx, mode);
_isf_wsc_context_input_panel_caps_mode_set (_get_context_id (ctx), mode);
}
WSCContextISF *context_scim = ctx;
if (context_scim == get_focused_ic ()) {
- LOGD ("language mode : %d\n", language);
+ LOGD ("language mode : %d", language);
_isf_wsc_context_input_panel_language_set (_get_context_id (ctx), language);
}
}
void isf_wsc_context_input_panel_return_key_type_set (WSCContextISF *ctx, Ecore_IMF_Input_Panel_Return_Key_Type return_key_type)
{
- LOGD ("ctx : %p, return key type : %d\n", ctx, return_key_type);
+ LOGD ("ctx : %p, return key type : %d", ctx, return_key_type);
_isf_wsc_context_input_panel_return_key_type_set (_get_context_id (ctx), return_key_type);
}
void isf_wsc_context_input_panel_return_key_disabled_set (WSCContextISF *ctx, Eina_Bool disabled)
{
- LOGD ("ctx : %p, disabled : %d\n", ctx, disabled);
+ LOGD ("ctx : %p, disabled : %d", ctx, disabled);
_isf_wsc_context_input_panel_return_key_disabled_set (_get_context_id (ctx), disabled);
}
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
if (!wsc_ctx) return;
- LOGD ("im_context = %p hint = %04x purpose = %d\n", im_ctx, hint, purpose);
+ LOGD ("im_context = %p hint = %04x purpose = %d", im_ctx, hint, purpose);
// Set layout
if (wsc_ctx->content_purpose != purpose || !wsc_ctx->layout_initialized) {
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
if (!wsc_ctx) return;
- LOGD ("invoke action. button : %d\n", button);
+ LOGD ("invoke action. button : %d", button);
if (button != BTN_LEFT)
return;
if (language) {
wsc_ctx->language = strdup (language);
- LOGD ("Language changed, new: '%s'\n", language);
+ LOGD ("Language changed, new: '%s'", language);
}
}
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p return key type = %d\n", im_ctx, return_key_type);
+ LOGD ("im_context = %p return key type = %d", im_ctx, return_key_type);
if (!wsc_ctx) return;
if (wsc_ctx->return_key_type != return_key_type) {
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
Eina_Bool return_key_disabled = !!disabled;
- LOGD ("im_context = %p return key disabled = %d\n", im_ctx, return_key_disabled);
+ LOGD ("im_context = %p return key disabled = %d", im_ctx, return_key_disabled);
if (!wsc_ctx) return;
if (wsc_ctx->return_key_disabled != return_key_disabled) {
_wsc_im_ctx_input_panel_data (void *data, struct wl_input_method_context *im_ctx, const char *input_panel_data, uint32_t input_panel_data_length)
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p input panel data = %s len = %d\n", im_ctx, input_panel_data, input_panel_data_length);
+ LOGD ("im_context = %p input panel data = %s len = %d", im_ctx, input_panel_data, input_panel_data_length);
if (!wsc_ctx) return;
if (wsc_ctx->impl) {
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p bidi_direction = %d\n", im_ctx, bidi_direction);
+ LOGD ("im_context = %p bidi_direction = %d", im_ctx, bidi_direction);
if (!wsc_ctx) return;
if (wsc_ctx->bidi_direction != bidi_direction) {
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p cursor_pos = %d\n", im_ctx, cursor_pos);
+ LOGD ("im_context = %p cursor_pos = %d", im_ctx, cursor_pos);
if (!wsc_ctx || !wsc_ctx->impl) return;
wsc_ctx->impl->cursor_pos = cursor_pos;
wsc_ctx->surrounding_cursor = cursor_pos;
- LOGD ("wsc_ctx->surrounding_cursor = %d\n", wsc_ctx->surrounding_cursor);
+ LOGD ("wsc_ctx->surrounding_cursor = %d", wsc_ctx->surrounding_cursor);
g_info_manager->socket_update_cursor_position (cursor_pos);
if (_TV)
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD("im_context = %p type = %d, data = (%p) %d\n", im_ctx, type, input_data, input_data_len);
+ LOGD("im_context = %p type = %d, data = (%p) %d", im_ctx, type, input_data, input_data_len);
if (!wsc_ctx) return;
isf_wsc_context_process_input_device_event (wsc_ctx, type, input_data, input_data_len);
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p, prediction hint = %s\n", im_ctx, prediction_hint);
+ LOGD ("im_context = %p, prediction hint = %s", im_ctx, prediction_hint);
if (!wsc_ctx) return;
isf_wsc_context_input_panel_prediction_hint_set (wsc_ctx, prediction_hint);
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- LOGD ("im_context = %p, mime_type = %s\n", im_ctx, mime_type);
+ LOGD ("im_context = %p, mime_type = %s", im_ctx, mime_type);
if (!wsc_ctx) return;
if (wsc_ctx->impl) {
{
WSCContextISF *wsc_ctx = (WSCContextISF*)data;
- SECURE_LOGD ("im_context = %p, text = %s, cursor_pos = %d\n", im_ctx, text, cursor_pos);
+ SECURE_LOGD ("im_context = %p, text = %s, cursor_pos = %d", im_ctx, text, cursor_pos);
if (!wsc_ctx) return;
isf_wsc_context_input_panel_finalize_content (wsc_ctx, text, cursor_pos);
close (fd);
if (!wsc_ctx->keymap) {
- LOGW ("failed to compile keymap\n");
+ LOGW ("failed to compile keymap");
return;
}
wsc_ctx->state = xkb_state_new (wsc_ctx->keymap);
if (!wsc_ctx->state) {
- LOGW ("failed to create XKB state\n");
+ LOGW ("failed to create XKB state");
xkb_map_unref (wsc_ctx->keymap);
return;
}
wsc_ctx->shift_mask =
1 << xkb_map_mod_get_index (wsc_ctx->keymap, "Shift");
- LOGD ("create _keysym2keycode\n");
+ LOGD ("create _keysym2keycode");
_init_keysym2keycode (wsc_ctx);
}
#if ENABLE_GRAB_KEYBOARD
wsc_ctx->xkb_context = xkb_context_new ((xkb_context_flags)0);
if (wsc_ctx->xkb_context == NULL) {
- LOGW ("Failed to create XKB context\n");
+ LOGW ("Failed to create XKB context");
delete wsc_ctx;
return;
}
wsc_ctx->surrounding_text = NULL;
wsc_ctx->remote_surrounding_text = NULL;
wsc_ctx->surrounding_cursor = 0;
- LOGD ("wsc_ctx->surrounding_cursor = %d\n", wsc_ctx->surrounding_cursor);
+ LOGD ("wsc_ctx->surrounding_cursor = %d", wsc_ctx->surrounding_cursor);
get_language (&wsc_ctx->language);
}
if (wsc->im == NULL) {
- LOGW ("Failed because wl_input_method is null\n");
+ LOGW ("Failed because wl_input_method is null");
return false;
}
/* Input method listener */
- LOGD ("Adding wl_input_method listener\n");
+ LOGD ("Adding wl_input_method listener");
if (wsc->im)
wl_input_method_add_listener (wsc->im, &wsc_im_listener, wsc);
else {
- LOGW ("Couldn't get wayland input method interface\n");
+ LOGW ("Couldn't get wayland input method interface");
return false;
}
check_input_resource (WSCContextISF *wsc_ctx, Input_Resource input_res)
{
WSCContextISF* context_scim = wsc_ctx;
- LOGD ("Input resource : %d\n", input_res);
+ LOGD ("Input resource : %d", input_res);
SCIM_DEBUG_FRONTEND (1) << __FUNCTION__ << "...\n";
if (context_scim && context_scim->impl) {
if (_change_keyboard_mode_by_focus_move) {
//if h/w keyboard mode, keyboard mode will be changed to s/w mode when the entry get the focus.
- LOGD ("Keyboard mode is changed H/W->S/W because of focus_in.\n");
+ LOGD ("Keyboard mode is changed H/W->S/W because of focus_in.");
isf_wsc_context_set_keyboard_mode (wsc_ctx, TOOLBAR_HELPER_MODE);
}
if (context_scim->impl->imdata)
context_scim->impl->si->set_imdata ((const char*)context_scim->impl->imdata, context_scim->impl->imdata_size);
#endif
- LOGD ("set autocapital type : %d\n", context_scim->impl->autocapital_type);
+ LOGD ("set autocapital type : %d", context_scim->impl->autocapital_type);
g_info_manager->set_autocapital_type ((int)context_scim->impl->autocapital_type);
} else {
g_info_manager->socket_turn_off ();
context_scim->impl->input_resource = INPUT_RESOURCE_NONE;
}
- LOGD ("ctx : %p\n", wsc_ctx);
+ LOGD ("ctx : %p", wsc_ctx);
}
void
SCIM_DEBUG_FRONTEND(1) << __FUNCTION__ << "(" << context_scim->id << ")...\n";
if (context_scim && context_scim->impl && context_scim == _focused_ic) {
- LOGD ("ctx : %p\n", wsc_ctx);
+ LOGD ("ctx : %p", wsc_ctx);
if (context_scim->impl->need_commit_preedit) {
_hide_preedit_string (context_scim->id, false);
if (context_scim && context_scim->impl && context_scim->impl->autocapital_type != autocapital_type) {
context_scim->impl->autocapital_type = autocapital_type;
- LOGD ("ctx : %p. set autocapital type : %d\n", wsc_ctx, autocapital_type);
+ LOGD ("ctx : %p. set autocapital type : %d", wsc_ctx, autocapital_type);
if (context_scim == _focused_ic) {
- LOGD ("ctx : %p. set autocapital type : %d\n", wsc_ctx, autocapital_type);
+ LOGD ("ctx : %p. set autocapital type : %d", wsc_ctx, autocapital_type);
g_info_manager->set_autocapital_type ((int)autocapital_type);
}
}
context_scim->impl->bidi_direction = direction;
if (context_scim == _focused_ic) {
- LOGD ("ctx : %p, bidi direction : %#x\n", wsc_ctx, direction);
+ LOGD ("ctx : %p, bidi direction : %#x", wsc_ctx, direction);
panel_req_update_bidi_direction (context_scim, direction);
}
}
return;
if (!context_scim->impl->init_remote_surrounding_text || strcmp (conv_text, text) != 0 || context_scim->impl->cursor_pos != cursor) {
- SECURE_LOGD("remote surrounding text : \"%s\"\n", text);
+ SECURE_LOGD("remote surrounding text : \"%s\"", text);
context_scim->impl->surrounding_text = utf8_mbstowcs (String (text));
context_scim->impl->cursor_pos = cursor;
if (hw_key_detect) {
isf_wsc_context_set_keyboard_mode (wsc_ctx, TOOLBAR_KEYBOARD_MODE);
- ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, name: %s)\n", key.code, keyname);
- LOGD ("Hardware keyboard mode, active helper option: %d\n", _active_helper_option);
+ ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, name: %s)", key.code, keyname);
+ LOGD ("Hardware keyboard mode, active helper option: %d", _active_helper_option);
}
}
}
if (!wsc_ctx) return;
if (!keysym) {
- LOGD("key is NULL\n");
+ LOGD("key is NULL");
return;
}
if (hw_key_detect) {
isf_wsc_context_set_keyboard_mode (wsc_ctx, TOOLBAR_KEYBOARD_MODE);
- ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, key : %s)\n", key.code, keysym);
- LOGD ("Hardware keyboard mode, active helper option: %d\n", _active_helper_option);
+ ISF_SAVE_LOG ("Changed keyboard mode from S/W to H/W (code: %x, key : %s)", key.code, keysym);
+ LOGD ("Hardware keyboard mode, active helper option: %d", _active_helper_option);
}
}
}
free (wsc_ctx->surrounding_text);
wsc_ctx->surrounding_text = surrounding_text;
wsc_ctx->surrounding_cursor += strlen (wsc_ctx->preedit_str);
- LOGD ("wsc_ctx->surrounding_cursor = %d\n", wsc_ctx->surrounding_cursor);
+ LOGD ("wsc_ctx->surrounding_cursor = %d", wsc_ctx->surrounding_cursor);
} else {
wsc_ctx->surrounding_text = strdup (wsc_ctx->preedit_str);
wsc_ctx->surrounding_cursor = strlen (wsc_ctx->preedit_str);
- LOGD ("wsc_ctx->surrounding_cursor = %d\n", wsc_ctx->surrounding_cursor);
+ LOGD ("wsc_ctx->surrounding_cursor = %d", wsc_ctx->surrounding_cursor);
}
if (wsc_ctx->preedit_str)
int len = read (fd, buff, sizeof (buff) - 1);
if (len == 0) {
- SECURE_LOGD ("remote_surrounding_text : %s, surrounding_cursor : %d\n", wsc_ctx->remote_surrounding_text, wsc_ctx->surrounding_cursor);
+ SECURE_LOGD ("remote_surrounding_text : %s, surrounding_cursor : %d", wsc_ctx->remote_surrounding_text, wsc_ctx->surrounding_cursor);
isf_wsc_context_send_surrounding_text (wsc_ctx, wsc_ctx->remote_surrounding_text ? wsc_ctx->remote_surrounding_text : "", wsc_ctx->surrounding_cursor);
} else if (len < 0) {
LOGW ("failed");
if (remote_mode) {
if (ic->impl->block_input_resource) {
- LOGW ("block remote input\n");
+ LOGW ("block remote input");
return;
}
check_input_resource (ic, INPUT_RESOURCE_REMOTE);
if (remote_mode) {
if (ic->impl->block_input_resource) {
- LOGW ("block remote input\n");
+ LOGW ("block remote input");
return;
}
check_input_resource (ic, INPUT_RESOURCE_REMOTE);
if (ic && ic->impl && _focused_ic == ic) {
if (remote_mode) {
if (ic->impl->block_input_resource) {
- LOGW ("block remote input\n");
+ LOGW ("block remote input");
return;
}
check_input_resource (ic, INPUT_RESOURCE_REMOTE);
void
initialize (void)
{
- LOGD ("Initializing Wayland ISF IMModule...\n");
+ LOGD ("Initializing Wayland ISF IMModule...");
// Get system language.
_language = scim_get_locale_language (scim_get_current_locale ());
static void
finalize (void)
{
- LOGD ("Finalizing Ecore ISF IMModule...\n");
+ LOGD ("Finalizing Ecore ISF IMModule...");
SCIM_DEBUG_FRONTEND(2) << "Finalize all IC partially.\n";
while (_used_ic_impl_list) {
_wl_im_ctx = new _wl_im;
if (!_wl_im_ctx) {
- LOGW ("Can not create wl_im_ctx\n");
+ LOGW ("Can not create wl_im_ctx");
return false;
}
char buff[512];
int len = read (fd, buff, sizeof (buff) - 1);
if (len == 0) {
- LOGD ("update, wsc_ctx->surrounding_cursor = %d\n", wsc_ctx->surrounding_cursor);
+ LOGD ("update, wsc_ctx->surrounding_cursor = %d", wsc_ctx->surrounding_cursor);
g_info_manager->socket_update_surrounding_text (wsc_ctx->surrounding_text ? wsc_ctx->surrounding_text : "", wsc_ctx->surrounding_cursor);
} else if (len < 0) {
LOGW ("failed");
m_current_helper_uuid = String ("");
m_panel_agent_manager.exit (it->second.id, ctx);
SCIM_DEBUG_MAIN (1) << "Stop helper\n";
- ISF_SAVE_LOG ("send SCIM_TRANS_CMD_EXIT message to %s\n", uuid.c_str ());
+ ISF_SAVE_LOG ("send SCIM_TRANS_CMD_EXIT message to %s", uuid.c_str ());
}
/* Since we are stopping this helper, erase information from start_helper_ic_index too */
LOGD ("Send ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW message");
if (!m_signal_launch_option_application (uuid)) {
- LOGD ("call show helper option\n");
+ LOGD ("call show helper option");
m_panel_agent_manager.show_helper_option_window (it->second.id, ctx, uuid);
}
static double clock_tiks = (double)sysconf (_SC_CLK_TCK);
clock_t curr_tiks = times (&tiks_buf);
double secs = (double) (curr_tiks - start_tiks) / clock_tiks;
- //LOGE ("time second:%f\n", secs);
+ //LOGE ("time second:%f", secs);
static String restart_uuid;
if (restart_uuid != uuid || secs > MIN_REPEAT_TIME) {
LOGE ("Auto restart soft ISE:%s", uuid.c_str ());
} else {
reset_default_ise (0);
- ISF_SAVE_LOG ("Auto restart is abnormal, reset default ISE\n");
+ ISF_SAVE_LOG ("Auto restart is abnormal, reset default ISE");
}
start_tiks = curr_tiks;
m_start_helper_ic_index.erase (icit);
result = true;
} else {
- LOGW ("Failed to register IME : %s\n", info.uuid.c_str ());
+ LOGW ("Failed to register IME : %s", info.uuid.c_str ());
m_panel_agent_manager.send_fail_reply(client);
}
} else {
- LOGW ("Failed to register IME : %s\n", info.uuid.c_str ());
+ LOGW ("Failed to register IME : %s", info.uuid.c_str ());
m_panel_agent_manager.send_fail_reply(client);
}
}
unlock ();
if (result) {
- LOGD ("Succeed to regster IME : %s\n", info.uuid.c_str ());
+ LOGD ("Succeed to regster IME : %s", info.uuid.c_str ());
m_signal_register_helper (client, info);
}
}
String ic_uuid;
if (!transaction.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY) {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
return true;
}
/* If there are ic and ic_uuid then read them. */
if (!(transaction.get_data_type() == SCIM_TRANS_DATA_COMMAND) &&
!(transaction.get_data(ic) && transaction.get_data(ic_uuid))) {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
return true;
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateScreen>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateSpotLocation>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateCursorPosition>(message);
}
}
message->get_ic_ref() = ic;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateSurroundingText>(message);
}
}
message->get_ic_ref() = ic;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateSelection>(message);
}
}
if (transaction.get_data(message->get_property_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemTriggerProperty>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemHelperProcessImengineEvent>(message);
}
}
message->get_ic_ref() = ic;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemShowISEPanel>(message);
}
}
if (transaction.get_data(message->get_mode_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetISEMode>(message);
}
}
if (transaction.get_data(message->get_language_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetISELanguage>(message);
}
}
if (transaction.get_data(message->get_imdata_ptr(), message->get_len_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetISEImData>(message);
}
}
if (transaction.get_data(message->get_disabled_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetReturnKeyDisable>(message);
}
}
transaction.get_data(message->get_serial_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemProcessKeyEvent>(message);
}
}
if (transaction.get_data(message->get_layout_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetLayout>(message);
}
}
if (transaction.get_data(message->get_input_mode_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetInputMode>(message);
}
}
if (transaction.get_data(message->get_mode_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetCapsMode>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateCandidateUI>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateCandidateGeometry>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateKeyboardISE>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateKeyboardISEList>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSelectAux>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSelectCandidate>(message);
}
}
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateLookupTablePageSize>(message);
}
}
if (transaction.get_data(message->get_candidate_table_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateLookupTable>(message);
}
}
if (transaction.get_data(message->get_row_items_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateCandidateItemLayout>(message);
}
break;
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSelectAssociate>(message);
}
break;
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateAssociateTablePageSize>(message);
}
break;
if (transaction.get_data(message->get_state_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemTurnOnLog>(message);
}
break;
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateDisplayedCandidate>(message);
}
break;
message->get_ic_uuid_ref() = ic_uuid;
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemLongpressCandidate>(message);
}
}
if (transaction.get_data(message->get_input_hint_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetInputHint>(message);
}
}
if (transaction.get_data(message->get_bidi_direction())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemUpdateBidiDirection>(message);
}
}
transaction.get_data(message->get_data_ptr(), message->get_len_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemProcessInputDeviceEvent>(message);
}
}
if (transaction.get_data(message->get_auto_capital_type_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetAutocapitalType>(message);
}
}
if (transaction.get_data(message->get_prediction_allow_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetPredictionAllow>(message);
}
}
if (transaction.get_data(message->get_mode_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetKeyboardMode>(message);
}
}
if (transaction.get_data(message->get_message_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetPredictionHint>(message);
}
}
if (transaction.get_data(message->get_mime_type_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemSetMimeType>(message);
}
}
transaction.get_data(message->get_cursor_pos_ref())) {
m_list_messages.push_back(message);
} else {
- LOGW("wrong format of transaction\n");
+ LOGW("wrong format of transaction");
dealloc_message<MessageItemFinalizeContent>(message);
}
}
isf_db_begin_transaction();
ret = pkgmgrinfo_appinfo_filter_foreach_appinfo (handle, isf_pkg_ime_app_list_cb, NULL);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_filter_foreach_appinfo failed(%d)\n", ret);
+ LOGW ("pkgmgrinfo_appinfo_filter_foreach_appinfo failed(%d)", ret);
isf_db_rollback_transaction();
} else {
isf_db_commit_transaction();
static int _find_ime_setting (const pkgmgrinfo_appinfo_h handle, void *user_data)
{
if (!user_data) {
- LOGW ("user_data is null!\n");
+ LOGW ("user_data is null!");
return -1;
}
char *ime_setting_pkgid = NULL;
int ret = 0;
- LOGD ("ime pkg id : %s\n", ime_pkgid.c_str ());
+ LOGD ("ime pkg id : %s", ime_pkgid.c_str ());
/* Get appid */
ret = pkgmgrinfo_appinfo_get_appid (handle, &ime_setting_appid);
if (ret == PMINFO_R_OK) {
ret = pkgmgrinfo_appinfo_get_pkgid (handle, &ime_setting_pkgid);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_get_pkgid failed!\n");
+ LOGW ("pkgmgrinfo_appinfo_get_pkgid failed!");
return -1;
}
- LOGD ("setting appid : %s, setting app pkg id : %s, ime_pkg id : %s\n", ime_setting_appid, ime_setting_pkgid, ime_pkgid.c_str ());
+ LOGD ("setting appid : %s, setting app pkg id : %s, ime_pkg id : %s", ime_setting_appid, ime_setting_pkgid, ime_pkgid.c_str ());
if (String (ime_setting_pkgid) == ime_pkgid) {
ime_setting_app = String (ime_setting_appid);
}
}
else {
- LOGW ("pkgmgrinfo_appinfo_get_appid failed!\n");
+ LOGW ("pkgmgrinfo_appinfo_get_appid failed!");
return -1;
}
/* Get pkgid */
ret = pkgmgrinfo_appinfo_get_appinfo (ime_appid.c_str (), &appinfo_handle);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_get_appinfo failed.\n");
+ LOGW ("pkgmgrinfo_appinfo_get_appinfo failed.");
return ime_setting_app;
}
ret = pkgmgrinfo_appinfo_get_pkgid (appinfo_handle, &pkgid);
if (ret != PMINFO_R_OK) {
- LOGW ("pkgmgrinfo_appinfo_get_pkgid failed! error code=%d\n", ret);
+ LOGW ("pkgmgrinfo_appinfo_get_pkgid failed! error code=%d", ret);
pkgmgrinfo_appinfo_destroy_appinfo (appinfo_handle);
return ime_setting_app;
}
if (databaseInfo.in_transaction != false)
{
- LOGE("Transaction already started\n");
+ LOGE("Transaction already started");
return EXIT_FAILURE;
}
int ret = sqlite3_prepare_v2(databaseInfo.pHandle, "BEGIN TRANSACTION", -1, &pStmt, NULL);
if (ret != SQLITE_OK)
{
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return EXIT_FAILURE;
}
if (sqlite3_step(pStmt) != SQLITE_DONE)
{
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
sqlite3_finalize(pStmt);
return EXIT_FAILURE;
}
if (databaseInfo.in_transaction != true)
{
- LOGE("Transaction not started\n");
+ LOGE("Transaction not started");
return EXIT_FAILURE;
}
int ret = sqlite3_prepare_v2(databaseInfo.pHandle, "ROLLBACK TRANSACTION", -1, &pStmt, NULL);
if (ret != SQLITE_OK)
{
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return EXIT_FAILURE;
}
if (sqlite3_step(pStmt) != SQLITE_DONE)
{
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
sqlite3_finalize(pStmt);
return EXIT_FAILURE;
}
if (databaseInfo.in_transaction != true)
{
- LOGE("Transaction not started\n");
+ LOGE("Transaction not started");
return EXIT_FAILURE;
}
int ret = sqlite3_prepare_v2(databaseInfo.pHandle, "COMMIT TRANSACTION", -1, &pStmt, NULL);
if (ret != SQLITE_OK)
{
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return EXIT_FAILURE;
}
if (sqlite3_step(pStmt) != SQLITE_DONE)
{
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
sqlite3_finalize(pStmt);
return EXIT_FAILURE;
}
std::transform(result_DB_check.begin(), result_DB_check.end(), result_DB_check.begin(), ::tolower);
if (result_DB_check != "ok") {
databaseInfo.need_reset = true;
- LOGE ("DB integrity check failed\n");
+ LOGE ("DB integrity check failed");
}
return 0;
static const char* pQuery = "CREATE TABLE ime_info (appid TEXT PRIMARY KEY NOT NULL, label TEXT, pkgid TEXT, pkgtype TEXT, exec TEXT, mname TEXT, mpath TEXT, mode INTEGER, options INTEGER, is_enabled INTEGER, is_preinstalled INTEGER, has_option INTEGER, disp_lang TEXT);";
int ret = sqlite3_exec(databaseInfo.pHandle, pQuery, NULL, NULL, &pException);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_exec returned %d: %s\n", ret, pException);
+ LOGE ("sqlite3_exec returned %d: %s", ret, pException);
sqlite3_free(pException);
databaseInfo.need_reset = true;
return -EIO;
struct stat stat;
int ret = db_util_open(databaseInfo.pPath, &databaseInfo.pHandle, DB_UTIL_REGISTER_HOOK_METHOD);
if (ret != SQLITE_OK) {
- LOGE ("db_util_open(\"%s\", ~) returned %d: %s\n", databaseInfo.pPath, ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("db_util_open(\"%s\", ~) returned %d: %s", databaseInfo.pPath, ret, sqlite3_errmsg(databaseInfo.pHandle));
if (databaseInfo.pHandle)
db_util_close(databaseInfo.pHandle);
databaseInfo.pHandle = NULL;
if (lstat(databaseInfo.pPath, &stat) < 0) {
char buf_err[256];
- LOGE("lstat failed. %s\n", strerror_r (errno, buf_err, sizeof (buf_err)));
+ LOGE("lstat failed. %s", strerror_r (errno, buf_err, sizeof (buf_err)));
if (databaseInfo.pHandle)
db_util_close(databaseInfo.pHandle);
databaseInfo.pHandle = NULL;
}
if (!S_ISREG(stat.st_mode)) {
- LOGE ("S_ISREG failed.\n");
+ LOGE ("S_ISREG failed.");
if (databaseInfo.pHandle)
db_util_close(databaseInfo.pHandle);
databaseInfo.pHandle = NULL;
int ret = sqlite3_exec(databaseInfo.pHandle, pQuery, NULL, NULL, &pException);
if (ret != SQLITE_OK) {
databaseInfo.need_reset = true;
- LOGE ("sqlite3_exec returned %d: %s\n", ret, pException);
+ LOGE ("sqlite3_exec returned %d: %s", ret, pException);
sqlite3_free(pException);
}
}
if (SQLITE_CORRUPT == sqlite3_exec(databaseInfo.pHandle, "pragma integrity_check", _db_integrity_check_cb, NULL, NULL)) {
databaseInfo.need_reset = true;
- LOGE ("DB has been corrupted.\n");
+ LOGE ("DB has been corrupted.");
}
return 0;
if (ret < 0)
{
- LOGE ("_db_init failed. error code=%d\n", ret);
+ LOGE ("_db_init failed. error code=%d", ret);
return -EIO;
}
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
db_text = (char *)sqlite3_column_text(pStmt, 12);
info.display_lang = String(db_text ? db_text : "");
- SECURE_LOGD ("appid=\"%s\", label=\"%s\", pkgid=\"%s\", pkgtype=\"%s\", exec=\"%s\", mname=\"%s\", mpath=\"%s\", mode=%d, options=%u, is_enabled=%u, is_preinstalled=%u, has_option=%d, disp_lang=\"%s\"\n",
+ SECURE_LOGD ("appid=\"%s\", label=\"%s\", pkgid=\"%s\", pkgtype=\"%s\", exec=\"%s\", mname=\"%s\", mpath=\"%s\", mode=%d, options=%u, is_enabled=%u, is_preinstalled=%u, has_option=%d, disp_lang=\"%s\"",
info.appid.c_str(),
info.label.c_str(),
info.pkgid.c_str(),
} while (ret == SQLITE_ROW);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
}
sqlite3_reset(pStmt);
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_text(pStmt, 1, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_ROW) {
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
i = 1;
db_text = (char*)sqlite3_column_text(pStmt, 12);
pImeInfo->display_lang = String(db_text ? db_text : "");
- SECURE_LOGD ("appid=\"%s\", label=\"%s\", pkgid=\"%s\", pkgtype=\"%s\", exec=\"%s\", mname=\"%s\", mpath=\"%s\", mode=%d, options=%u, is_enabled=%u, is_preinstalled=%u, has_option=%d, disp_lang=\"%s\"\n",
+ SECURE_LOGD ("appid=\"%s\", label=\"%s\", pkgid=\"%s\", pkgtype=\"%s\", exec=\"%s\", mname=\"%s\", mpath=\"%s\", mode=%d, options=%u, is_enabled=%u, is_preinstalled=%u, has_option=%d, disp_lang=\"%s\"",
pImeInfo->appid.c_str(),
pImeInfo->label.c_str(),
pImeInfo->pkgid.c_str(),
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_int(pStmt, 1, mode);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
if (ret == SQLITE_ROW) {
char *db_text = (char *)sqlite3_column_text(pStmt, 0);
mname.push_back(String(db_text ? db_text : ""));
- SECURE_LOGD ("%s: \"%s\"\n", (mode? "Helper": "IMEngine"), mname.back().c_str());
+ SECURE_LOGD ("%s: \"%s\"", (mode? "Helper": "IMEngine"), mname.back().c_str());
i++;
}
} while (ret == SQLITE_ROW);
if (ret != SQLITE_DONE) {
- LOGE("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
}
out:
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_int(pStmt, 1, mode);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
if (ret == SQLITE_ROW) {
char *db_text = (char *)sqlite3_column_text(pStmt, 0);
mpath.push_back(String(db_text ? db_text : ""));
- SECURE_LOGD ("%s: \"%s\"\n", (mode? "Helper": "IMEngine"), mpath.back().c_str());
+ SECURE_LOGD ("%s: \"%s\"", (mode? "Helper": "IMEngine"), mpath.back().c_str());
i++;
}
} while (ret == SQLITE_ROW);
if (ret != SQLITE_DONE) {
- LOGW ("sqlite3_step returned %d, mode=%d, %s\n", ret, mode, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGW ("sqlite3_step returned %d, mode=%d, %s", ret, mode, sqlite3_errmsg(databaseInfo.pHandle));
}
out:
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_text(pStmt, 1, pkgid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
if (ret == SQLITE_ROW) {
char *db_text = (char *)sqlite3_column_text(pStmt, 0);
appids.push_back(String(db_text ? db_text : ""));
- SECURE_LOGD ("appid=\"%s\"\n", appids.back().c_str());
+ SECURE_LOGD ("appid=\"%s\"", appids.back().c_str());
i++;
}
} while (ret == SQLITE_ROW);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
}
out:
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_bind_text(pStmt, 1, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_ROW) {
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
}
else {
*is_enabled = (bool)sqlite3_column_int(pStmt, 0);
i = 1;
- SECURE_LOGD ("is_enabled=%d by appid=\"%s\"\n", *is_enabled, appid);
+ SECURE_LOGD ("is_enabled=%d by appid=\"%s\"", *is_enabled, appid);
}
out:
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_text(pStmt, 1, module_name, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_ROW) {
- LOGE ("sqlite3_step: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step: %s", sqlite3_errmsg(databaseInfo.pHandle));
}
else {
i = sqlite3_column_int(pStmt, 0);
static const char* pQuery = "UPDATE ime_info SET label = ? WHERE appid = ?;";
if (appid == NULL || label == NULL) {
- LOGE ("input is NULL.\n");
+ LOGE ("input is NULL.");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_text(pStmt, 1, label, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
goto out;
}
ret = sqlite3_bind_text(pStmt, 2, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
}
else {
- SECURE_LOGD ("UPDATE ime_info SET label = %s WHERE appid = %s;\n", label, appid);
+ SECURE_LOGD ("UPDATE ime_info SET label = %s WHERE appid = %s;", label, appid);
ret = 1;
}
static const char* pQuery = "UPDATE ime_info SET disp_lang = ?;";
if (disp_lang == NULL) {
- LOGE ("input is NULL.\n");
+ LOGE ("input is NULL.");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_text(pStmt, 1, disp_lang, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
}
else {
- SECURE_LOGD ("UPDATE ime_info SET disp_lang = %s;\n", disp_lang);
+ SECURE_LOGD ("UPDATE ime_info SET disp_lang = %s;", disp_lang);
ret = 1;
}
static const char* pQuery = "UPDATE ime_info SET is_enabled = ? WHERE appid = ?;";
if (appid == NULL) {
- LOGE ("input is NULL.\n");
+ LOGE ("input is NULL.");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_int(pStmt, 1, (int)is_enabled);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 2, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
}
else {
- SECURE_LOGD ("UPDATE ime_info SET enabled = %d WHERE appid = %s;\n", is_enabled, appid);
+ SECURE_LOGD ("UPDATE ime_info SET enabled = %d WHERE appid = %s;", is_enabled, appid);
ret = 1;
}
static const char* pQuery = "UPDATE ime_info SET has_option = ? WHERE appid = ?;";
if (appid == NULL) {
- LOGE ("input is NULL.\n");
+ LOGE ("input is NULL.");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return 0;
}
ret = sqlite3_bind_int(pStmt, 1, (int)has_option);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 2, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
ret = 0;
}
else {
- SECURE_LOGD ("UPDATE ime_info SET enabled = %d WHERE appid = %s;\n", has_option, appid);
+ SECURE_LOGD ("UPDATE ime_info SET enabled = %d WHERE appid = %s;", has_option, appid);
ret = 1;
}
static const char* pQuery = "UPDATE ime_info SET label = ?, exec = ?, mname = ?, mpath = ?, has_option = ? WHERE appid = ?;";
if (!ime_db) {
- LOGE ("Input parameter is null\n");
+ LOGE ("Input parameter is null");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_bind_text(pStmt, 1, ime_db->label.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 2, ime_db->exec.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 3, ime_db->module_name.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 4, ime_db->module_path.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 5, has_option);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 6, ime_db->appid.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
goto out;
}
else {
- SECURE_LOGD ("Update \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
+ SECURE_LOGD ("Update \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
ime_db->appid.c_str(), ime_db->label.c_str(), ime_db->exec.c_str(), ime_db->module_name.c_str(), ime_db->module_path.c_str());
ret = SQLITE_OK;
i++;
static const char* pQuery = "INSERT INTO ime_info (appid, label, pkgid, pkgtype, exec, mname, mpath, mode, options, is_enabled, is_preinstalled, has_option, disp_lang) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
if (!ime_db) {
- LOGE ("Input parameter is null\n");
+ LOGE ("Input parameter is null");
return 0;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_bind_text(pStmt, 1, ime_db->appid.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 2, ime_db->label.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 3, ime_db->pkgid.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 4, ime_db->pkgtype.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 5, ime_db->exec.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 6, ime_db->module_name.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 7, ime_db->module_path.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 8, ime_db->mode);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 9, (int)ime_db->options);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 10, (int)ime_db->is_enabled);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 11, (int)ime_db->is_preinstalled);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_int(pStmt, 12, ime_db->has_option);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_int: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_int: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_bind_text(pStmt, 13, ime_db->display_lang.c_str(), -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGW ("sqlite3_step returned %d, appid=%s, %s\n", ret, ime_db->appid.c_str(), sqlite3_errmsg(databaseInfo.pHandle));
+ LOGW ("sqlite3_step returned %d, appid=%s, %s", ret, ime_db->appid.c_str(), sqlite3_errmsg(databaseInfo.pHandle));
ret = SQLITE_ERROR;
goto out;
}
else {
- SECURE_LOGD ("Insert \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" %d %u %u %u %d \"%s\"\n",
+ SECURE_LOGD ("Insert \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" %d %u %u %u %d \"%s\"",
ime_db->appid.c_str(), ime_db->label.c_str(), ime_db->pkgid.c_str(), ime_db->pkgtype.c_str(),
ime_db->module_name.c_str(), ime_db->exec.c_str(), ime_db->module_path.c_str(), ime_db->mode,
ime_db->options, ime_db->is_enabled, ime_db->is_preinstalled, ime_db->has_option, ime_db->display_lang.c_str());
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_bind_text(pStmt, 1, pkgid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
}
else {
// If there is no pkgid to delete, ret is still SQLITE_DONE.
- SECURE_LOGD ("DELETE FROM ime_info WHERE pkgid = %s;\n", pkgid);
+ SECURE_LOGD ("DELETE FROM ime_info WHERE pkgid = %s;", pkgid);
i = 1;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_bind_text(pStmt, 1, appid, -1, SQLITE_TRANSIENT);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_bind_text: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_bind_text: %s", sqlite3_errmsg(databaseInfo.pHandle));
goto out;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
}
else {
// If there is no appid to delete, ret is still SQLITE_DONE.
- SECURE_LOGD ("DELETE FROM ime_info WHERE appid = %s;\n", appid);
+ SECURE_LOGD ("DELETE FROM ime_info WHERE appid = %s;", appid);
i = 1;
}
ret = sqlite3_prepare_v2(databaseInfo.pHandle, pQuery, -1, &pStmt, NULL);
if (ret != SQLITE_OK) {
- LOGE ("sqlite3_prepare_v2: %s\n", sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_prepare_v2: %s", sqlite3_errmsg(databaseInfo.pHandle));
return i;
}
ret = sqlite3_step(pStmt);
if (ret != SQLITE_DONE) {
- LOGE ("sqlite3_step returned %d, %s\n", ret, sqlite3_errmsg(databaseInfo.pHandle));
+ LOGE ("sqlite3_step returned %d, %s", ret, sqlite3_errmsg(databaseInfo.pHandle));
}
else {
// If there is no pkgid to delete, ret is still SQLITE_DONE.
- SECURE_LOGD ("DELETE FROM ime_info;\n");
+ SECURE_LOGD ("DELETE FROM ime_info;");
i = 1;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid || !pImeInfo) {
- LOGW ("invalid parameter.\n");
+ LOGW ("invalid parameter.");
return 0;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
appids.clear();
if (!pkgid) {
- LOGW ("pkgid is null.\n");
+ LOGW ("pkgid is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid || !is_enabled) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!module_name) {
- LOGW ("module_name is null.\n");
+ LOGW ("module_name is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid || !label) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!disp_lang) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!ime_db) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
if (!in_transaction) _db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
if (!in_transaction) _db_disconnect();
}
else {
- LOGE ("_db_connect() failed\n");
- ISF_SAVE_LOG("_db_connect() failed\n");
+ LOGE ("_db_connect() failed");
+ ISF_SAVE_LOG("_db_connect() failed");
}
return ret;
int ret = 0;
if (!pkgid) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
int ret = 0;
if (!appid) {
- LOGW ("Input parameter is null.\n");
+ LOGW ("Input parameter is null.");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
_db_disconnect();
}
else
- LOGW ("failed\n");
+ LOGW ("failed");
return ret;
}
ret = _begin_transaction();
}
} else
- LOGW("failed\n");
+ LOGW("failed");
return (ret == EXIT_SUCCESS);
}
ret = _commit_transaction();
_db_disconnect();
} else
- LOGW("failed\n");
+ LOGW("failed");
return (ret == EXIT_SUCCESS);
}
ret = _rollback_transaction();
_db_disconnect();
} else
- LOGW("failed\n");
+ LOGW("failed");
return (ret == EXIT_SUCCESS);
}
m_trans.put_data (str, strlen (str)+1);
m_trans.write_to_socket (m_socket_remoteinput2panel);
if (!m_trans.read_from_socket (m_socket_remoteinput2panel, m_socket_timeout)) {
- LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT\n");
+ LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT");
return REMOTE_CLIENT_ERROR_TIMEOUT;
}
if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
} else {
- LOGE ("REMOTE_CLIENT_ERROR_REQUEST_DENIED\n");
+ LOGE ("REMOTE_CLIENT_ERROR_REQUEST_DENIED");
return REMOTE_CLIENT_ERROR_REQUEST_DENIED;
}
m_trans.put_command (ISM_REMOTE_TRANS_CMD_CHECK_PRIVILEGE);
m_trans.write_to_socket (m_socket_remoteinput2panel);
if (!m_trans.read_from_socket (m_socket_remoteinput2panel, m_socket_timeout)) {
- LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT\n");
+ LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT");
return REMOTE_CLIENT_ERROR_TIMEOUT;
}
if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
} else {
- LOGE ("REMOTE_CLIENT_ERROR_PERMISSION_DENIED\n");
+ LOGE ("REMOTE_CLIENT_ERROR_PERMISSION_DENIED");
return REMOTE_CLIENT_ERROR_PERMISSION_DENIED;
}
m_trans.put_data (len);
m_trans.write_to_socket (m_socket_remoteinput2panel);
if (!m_trans.read_from_socket (m_socket_remoteinput2panel, m_socket_timeout)) {
- LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT\n");
+ LOGE ("REMOTE_CLIENT_ERROR_TIMEOUT");
return REMOTE_CLIENT_ERROR_TIMEOUT;
}
if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
} else {
- LOGE ("REMOTE_CLIENT_ERROR_REQUEST_DENIED\n");
+ LOGE ("REMOTE_CLIENT_ERROR_REQUEST_DENIED");
return REMOTE_CLIENT_ERROR_REQUEST_DENIED;
}
int cmd;
if (! m_trans_recv.get_command (cmd) || cmd != SCIM_TRANS_CMD_REPLY) {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
return REMOTE_CONTROL_CALLBACK_ERROR;
}
remote_control_callback_type type = REMOTE_CONTROL_CALLBACK_ERROR;
while (m_trans_recv.get_command (cmd)) {
- LOGD ("RemoteInput_Client::cmd = %d\n", cmd);
+ LOGD ("RemoteInput_Client::cmd = %d", cmd);
switch (cmd) {
case ISM_REMOTE_TRANS_CMD_RECV_FOCUS_IN:
{
m_trans_recv.get_data (m_autocapital_type) && m_trans_recv.get_data (m_return_key_disabled)) {
}
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
case ISM_REMOTE_TRANS_CMD_RECV_SURROUNDING_TEXT:
if (m_trans_recv.get_data (m_surrounding_text) && m_trans_recv.get_data (m_cursor)) {
}
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
case ISM_REMOTE_TRANS_CMD_RECV_INPUT_RESOURCE:
if (m_trans_recv.get_data (m_input_resource)) {
}
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
break;
}
default:
break;
}
} else {
- LOGE ("Failed to receive callback message\n");
+ LOGE ("Failed to receive callback message");
return (gboolean)FALSE;
}
} else if (condition == G_IO_ERR || condition == G_IO_HUP) {
- LOGE ("Failed to receive callback message\n");
+ LOGE ("Failed to receive callback message");
return (gboolean)FALSE;
}
static void launch_helper (const char *name, const char *uuid)
{
if (!name || !uuid) {
- ISF_SAVE_LOG ("Invalid parameter\n");
+ ISF_SAVE_LOG ("Invalid parameter");
return;
}
_ise_uuid,
0};
- ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)\n", _ise_name, _ise_uuid);
+ ISF_SAVE_LOG ("Exec scim_helper_launcher(%s %s)", _ise_name, _ise_uuid);
setsid ();
execv (SCIM_HELPER_LAUNCHER_PROGRAM, const_cast<char **>(argv));
new_argv [new_argc] = 0;
- ISF_SAVE_LOG ("ppid:%d Starting SCIM......\n", getppid ());
+ ISF_SAVE_LOG ("ppid:%d Starting SCIM......", getppid ());
/* Get the imengine module list which should be loaded. */
if (exclude_engine_list.size ()) {
}
} catch (scim::Exception &e) {
cerr << e.what () << "\n";
- ISF_SAVE_LOG ("catch: %s\n", e.what ());
+ ISF_SAVE_LOG ("catch: %s", e.what ());
}
/* If there is one Socket FrontEnd running and it's not manual mode,
}
} catch (scim::Exception &e) {
cerr << e.what () << "\n";
- ISF_SAVE_LOG ("catch: %s\n", e.what ());
+ ISF_SAVE_LOG ("catch: %s", e.what ());
}
}
}
} catch (scim::Exception & e) {
cerr << e.what () << "\n";
- ISF_SAVE_LOG ("Fail to launch panel. error: %s\n", e.what ());
+ ISF_SAVE_LOG ("Fail to launch panel. error: %s", e.what ());
}
run_broker (argc, argv);
}
std::cerr << " Connected :" << i << "\n";
ISF_LOG (" Connected :%d\n", i);
- LOGD ("Connection to PanelAgent succeeded, %d\n", i);
+ LOGD ("Connection to PanelAgent succeeded, %d", i);
/* Let's retry 10 times when failed */
int open_connection_retries = 0;
m_impl->socket.close ();
std::cerr << "scim_socket_open_connection () is failed!!!\n";
ISF_LOG ("scim_socket_open_connection () is failed!!!\n");
- ISF_SAVE_LOG ("scim_socket_open_connection failed, %d\n", timeout);
+ ISF_SAVE_LOG ("scim_socket_open_connection failed, %d", timeout);
return -1;
}
}
ISF_LOG ("scim_socket_open_connection () is successful.\n");
- LOGD ("scim_socket_open_connection successful\n");
+ LOGD ("scim_socket_open_connection successful");
m_impl->send.clear ();
m_impl->send.put_command (SCIM_TRANS_CMD_REQUEST);
LOGW ("Attach input context and update screen failed");
}
- ISF_SAVE_LOG ("Trying connect() with Helper_Active\n");
+ ISF_SAVE_LOG ("Trying connect() with Helper_Active");
/* connect to the panel agent as the active helper client */
if (!m_impl->socket_active.connect (address)) return -1;
m_impl->socket_active.close ();
std::cerr << "Helper_Active scim_socket_open_connection () is failed!!!\n";
ISF_LOG ("Helper_Active scim_socket_open_connection () is failed!!!\n");
- ISF_SAVE_LOG ("Helper_Active scim_socket_open_connection failed, %d\n", timeout);
+ ISF_SAVE_LOG ("Helper_Active scim_socket_open_connection failed, %d", timeout);
return -1;
}
m_impl->send.put_data (info.option);
if (!m_impl->send.write_to_socket (m_impl->socket_active, magic)) {
- ISF_SAVE_LOG ("Helper_Active write_to_socket() failed\n");
+ ISF_SAVE_LOG ("Helper_Active write_to_socket() failed");
m_impl->socket_active.close ();
return -1;
}
return false;
int cmd = message->get_command_ref();
- LOGD ("HelperAgent::cmd = %d\n", cmd);
+ LOGD ("HelperAgent::cmd = %d", cmd);
switch (cmd) {
case SCIM_TRANS_CMD_EXIT:
{
MessageItemExit *subclass = static_cast<MessageItemExit*>(message);
- ISF_SAVE_LOG ("Helper ISE received SCIM_TRANS_CMD_EXIT message\n");
+ ISF_SAVE_LOG ("Helper ISE received SCIM_TRANS_CMD_EXIT message");
m_impl->signal_exit(this, subclass->get_ic_ref(), subclass->get_ic_uuid_ref());
break;
}
case ISM_TRANS_CMD_SHOW_ISE_PANEL:
{
MessageItemShowISEPanel *subclass = static_cast<MessageItemShowISEPanel*>(message);
- LOGD ("Helper ISE received ISM_TRANS_CMD_SHOW_ISE_PANEL message\n");
+ LOGD ("Helper ISE received ISM_TRANS_CMD_SHOW_ISE_PANEL message");
m_impl->signal_ise_show (this, subclass->get_ic_ref(), *(subclass->get_data_ptr()),
subclass->get_len_ref());
case ISM_TRANS_CMD_HIDE_ISE_PANEL:
{
MessageItemHideISEPanel *subclass = static_cast<MessageItemHideISEPanel*>(message);
- LOGD ("Helper ISE received ISM_TRANS_CMD_HIDE_ISE_PANEL message\n");
+ LOGD ("Helper ISE received ISM_TRANS_CMD_HIDE_ISE_PANEL message");
m_impl->signal_ise_hide (this, subclass->get_ic_ref(), subclass->get_ic_uuid_ref());
m_impl->ise_show_flag = false;
break;
static int instance_count = 1;
if ((!m_impl->si.null ()) && m_impl->si->get_factory_uuid () == uuid) {
- ISF_SAVE_LOG ("Already in UUID: %s\n", uuid.c_str());
+ ISF_SAVE_LOG ("Already in UUID: %s", uuid.c_str());
return;
}
}
SCIM_DEBUG_MAIN(1) << "scim-helper-launcher: " << config << " " << display << " " << helper << " " << appid << "\n";
- ISF_SAVE_LOG ("Helper ISE (%s %s) is launching...\n", helper.c_str (), appid.c_str ());
+ ISF_SAVE_LOG ("Helper ISE (%s %s) is launching...", helper.c_str (), appid.c_str ());
if (!helper.length ()) {
- ISF_SAVE_LOG ("Module name is missing\n");
+ ISF_SAVE_LOG ("Module name is missing");
std::cerr << "Module name is missing.\n";
return -1;
HelperModule helper_module (helper);
if (!helper_module.valid () || helper_module.number_of_helpers () == 0) {
- ISF_SAVE_LOG ("Unable to load helper module(%s)\n", helper.c_str ());
+ ISF_SAVE_LOG ("Unable to load helper module(%s)", helper.c_str ());
std::cerr << "Unable to load helper module(" << helper << ")\n";
return -1;
if (!config_pointer.null ())
config_pointer.reset ();
ConfigBase::set (0);
- ISF_SAVE_LOG ("Helper ISE (%s) is destroyed!!!\n", appid.c_str ());
+ ISF_SAVE_LOG ("Helper ISE (%s) is destroyed!!!", appid.c_str ());
}
/*
config_module = 0;
}
- ISF_SAVE_LOG ("sig:%d\n", sig);
+ ISF_SAVE_LOG ("sig:%d", sig);
std::cerr << "Successfully exited.\n";
exit (0);
new_argv [new_argc ++] = argv [0];
- ISF_SAVE_LOG ("Start scim-launcher\n");
+ ISF_SAVE_LOG ("Start scim-launcher");
while (i < argc) {
if (++i >= argc) break;
/* reset backend pointer, in order to destroy backend automatically. */
backend.reset ();
- ISF_SAVE_LOG ("now running frontend...\n");
+ ISF_SAVE_LOG ("now running frontend...");
frontend_module->run ();
if (fcntl (m_id, F_SETFL, flags | O_NONBLOCK) == -1) {
char buf_err[256];
m_err = errno;
- LOGW ("ppid : %d fcntl() failed, %d %s\n", getppid (), m_err, strerror_r (m_err, buf_err, sizeof (buf_err)));
+ LOGW ("ppid : %d fcntl() failed, %d %s", getppid (), m_err, strerror_r (m_err, buf_err, sizeof (buf_err)));
}
char proc_name[17] = {0}; /* the buffer provided shall at least be 16+1 bytes long */
if (-1 != prctl (PR_GET_NAME, proc_name, 0, 0, 0)) {
- LOGD ("ppid:%d trying connect() to %s, %s\n", getppid (), addr.get_address ().c_str (), proc_name);
+ LOGD ("ppid:%d trying connect() to %s, %s", getppid (), addr.get_address ().c_str (), proc_name);
}
if ((m_err = ::connect (m_id, data, len)) == 0) {
}
m_address = addr;
- LOGD ("connect() succeeded\n");
+ LOGD ("connect() succeeded");
return true;
}
tval.tv_sec = nsec;
tval.tv_usec = 0;
- LOGW ("EINPROGRESS, select() with timeout %d\n", nsec);
+ LOGW ("EINPROGRESS, select() with timeout %d", nsec);
if (select (m_id + 1, &rset, &wset, NULL, nsec ? &tval : NULL) == 0) {
m_err = ETIMEDOUT;
- LOGW ("timeout in select()\n");
+ LOGW ("timeout in select()");
} else {
// We've got something, connection succeeded
- LOGD ("finally connected\n");
+ LOGD ("finally connected");
if (fcntl (m_id, F_SETFL, flags) == -1) {
m_err = errno;
} else {
char buf_err[256];
m_err = errno;
- LOGW ("connect() failed with %d (%s)\n", m_err, strerror_r (m_err, buf_err, sizeof (buf_err)));
+ LOGW ("connect() failed with %d (%s)", m_err, strerror_r (m_err, buf_err, sizeof (buf_err)));
}
if (fcntl (m_id, F_SETFL, flags) == -1) {
m_err = errno;
if (trans.write_to_socket (socket))
return true;
else
- LOGW ("write_to_socket() failed\n");
+ LOGW ("write_to_socket() failed");
} else {
- LOGW ("read_from_socket() failed %d\n", timeout);
+ LOGW ("read_from_socket() failed %d", timeout);
trans.clear ();
trans.put_command (SCIM_TRANS_CMD_REPLY);
trans.write_to_socket (socket);
}
} else {
- LOGW ("write_to_socket() failed\n");
+ LOGW ("write_to_socket() failed");
}
return false;
// Client is ok, return the client type.
return (client_type == "ConnectionTester") ? String ("") : client_type;
} else {
- LOGW ("write_to_socket() failed\n");
+ LOGW ("write_to_socket() failed");
}
} else {
- LOGW ("wrong format of SCIM_TRANS_CMD_OPEN_CONNECTION transaction\n");
+ LOGW ("wrong format of SCIM_TRANS_CMD_OPEN_CONNECTION transaction");
}
} else {
- LOGW ("read_from_socket() failed %d\n", timeout);
+ LOGW ("read_from_socket() failed %d", timeout);
}
return String ("");
}
if (result && pw.pw_dir) {
home_dir = pw.pw_dir;
} else {
- LOGD ("Fail to getpwuid_r\n");
+ LOGD ("Fail to getpwuid_r");
}
if (!home_dir) {
child_pid = fork ();
- ISF_SAVE_LOG ("ppid: %d, fork result : %d, user %s\n", getppid (), child_pid, scim_get_user_name ().c_str ());
+ ISF_SAVE_LOG ("ppid: %d, fork result : %d, user %s", getppid (), child_pid, scim_get_user_name ().c_str ());
// Error fork.
if (child_pid < 0) {
child_pid = fork ();
- ISF_SAVE_LOG ("ppid : %d fork result : %d\n", getppid (), child_pid);
+ ISF_SAVE_LOG ("ppid : %d fork result : %d", getppid (), child_pid);
// Error fork.
if (child_pid < 0) {
EXAPI void scim_daemon ()
{
#if HAVE_DAEMON
- LOGD ("ppid:%d calling daemon()\n", getppid ());
+ LOGD ("ppid:%d calling daemon()", getppid ());
if (daemon (0, 0) == -1)
std::cerr << "Error to make SCIM into a daemon!\n";
- LOGD ("ppid:%d daemon() called\n", getppid ());
+ LOGD ("ppid:%d daemon() called", getppid ());
return;
#else
_exit (0);
}
- ISF_SAVE_LOG ("ppid:%d fork result : %d\n", getppid (), id);
+ ISF_SAVE_LOG ("ppid:%d fork result : %d", getppid (), id);
id = fork ();
if (id == -1) {
_exit (0);
}
- ISF_SAVE_LOG ("ppid:%d fork result : %d\n", getppid (), id);
+ ISF_SAVE_LOG ("ppid:%d fork result : %d", getppid (), id);
return;
#endif
if (ret == 0 || (ret == -1 && errno == ENOENT)) {
if (st.st_size < MAX_LOG_FILE_SIZE) {
std::ofstream isf_log_file (strLogFile.c_str (), std::ios::app);
- isf_log_file << buf;
+ isf_log_file << buf << std::endl;
isf_log_file.flush ();
} else {
size_exceeded = true;
}
}
- LOGD ("%s\n", buf);
+ LOGD ("%s", buf);
}
static struct timeval _t0 = {0, 0};
projects / platform / core / uifw / isf.git / commitdiff