master_rpc_clear_fault_package(pkgname);
lb_invoke_fault_handler(LB_FAULT_DEACTIVATED, pkgname, id, function);
- DbgPrint("%s(%s) is deactivated\n", pkgname, id);
return NULL;
}
goto out;
}
- DbgPrint("[HOLD] %s %d\n", id, seize);
+ DbgPrint("HOLD: %s %d\n", id, seize);
lb_invoke_event_handler(handler, seize ? LB_EVENT_HOLD_SCROLL : LB_EVENT_RELEASE_SCROLL);
out:
handler->deleted_cbdata = NULL;
}
- DbgPrint("Call the created cb with LB_STATUS_ERROR_CANCEL\n");
cb = handler->created_cb;
cbdata = handler->created_cbdata;
handler->deleted_cb = NULL;
handler->deleted_cbdata = NULL;
- DbgPrint("Call the deleted cb\n");
cb(handler, LB_STATUS_SUCCESS, cbdata);
} else {
- DbgPrint("Call the lb,deleted\n");
lb_invoke_event_handler(handler, LB_EVENT_DELETED);
}
}
- DbgPrint("[%p] %s(%s) is deleted\n", handler, pkgname, id);
-
/* Just try to delete it, if a user didn't remove it from the live box list */
lb_unref(handler);
}
if (handler->state != CREATE) {
- DbgPrint("(%s) is not created\n", id);
+ ErrPrint("(%s) is not created\n", id);
goto out;
}
}
if (handler->state != CREATE) {
- DbgPrint("[%s] is not created\n", id);
+ ErrPrint("[%s] is not created\n", id);
goto out;
}
}
if (handler->state != CREATE) {
- DbgPrint("[%s] is not created\n", id);
+ ErrPrint("[%s] is not created\n", id);
goto out;
}
}
if (handler->state != CREATE) {
- DbgPrint("[%s] is not created\n", id);
+ ErrPrint("[%s] is not created\n", id);
goto out;
}
- DbgPrint("Access status: %d\n", status);
-
if (handler->access_event_cb) {
ret_cb_t cb;
void *cbdata;
}
if (handler->state != CREATE) {
- DbgPrint("[%s] is not created\n", id);
+ ErrPrint("[%s] is not created\n", id);
goto out;
}
* Don't try to notice anything with this, Just ignore all events
* Beacuse the user doesn't wants know about this anymore
*/
- DbgPrint("(%s) is not exists, but updated\n", id);
+ ErrPrint("(%s) is not exists, but updated\n", id);
goto out;
}
handler->pd_created_cb = NULL;
handler->pd_created_cbdata = NULL;
- DbgPrint("pd_created_cb (%s) - %d\n", buf_id, status);
+ /*!
+ * Before call the Callback function,
+ * pd_create_cb must be reset.
+ * Because, in the create callback, user can call create_pd function again.
+ */
+ DbgPrint("CREATE_PD\n");
cb(handler, status, cbdata);
} else if (handler->is_pd_created) {
- DbgPrint("LB_EVENT_PD_CREATED (%s) - %d\n", buf_id, status);
lb_invoke_event_handler(handler, LB_EVENT_PD_CREATED);
}
handler->pd_destroyed_cb = NULL;
handler->pd_destroyed_cbdata = NULL;
- DbgPrint("Invoke the PD Destroyed CB\n");
+ /*!
+ * Before call the Callback function,
+ * pd_destroyed_cb must be reset.
+ * Because, in the create callback, user can call destroy_pd function again.
+ */
cb(handler, status, cbdata);
} else if (status == 0) {
- DbgPrint("Invoke the LB_EVENT_PD_DESTROYED event\n");
lb_invoke_event_handler(handler, LB_EVENT_PD_DESTROYED);
}
ret = fb_sync(lb_get_pd_fb(handler));
if (ret < 0)
- ErrPrint("Failed to do sync FB (%s - %s)\n", pkgname, util_basename(util_uri_to_path(id)));
+ ErrPrint("Failed to do sync FB (%s - %s), %d\n", pkgname, util_basename(util_uri_to_path(id)), ret);
else
lb_invoke_event_handler(handler, LB_EVENT_PD_UPDATED);
}
goto out;
}
- DbgPrint("Update mode is changed: %d, %d, %s\n", status, active_mode, id);
-
handler = lb_find_livebox(pkgname, id);
if (!handler) {
ErrPrint("Livebox(%s) is not found\n", id);
goto out;
}
- DbgPrint("Size is changed: %dx%d (%s), fb: [%s]\n", w, h, id, fbfile);
-
handler = lb_find_livebox(pkgname, id);
if (!handler) {
ErrPrint("Livebox(%s) is not found\n", id);
}
if (is_pd) {
- DbgPrint("PD is resized\n");
/*!
* \NOTE
* PD is not able to resized by the client.
}
} else {
if (status == 0) {
- DbgPrint("LB is successfully resized (%dx%d)\n", w, h);
lb_set_size(handler, w, h);
/*!
lb_invoke_event_handler(handler, LB_EVENT_LB_SIZE_CHANGED);
}
} else {
- DbgPrint("LB is not resized: %dx%d (%d)\n", w, h, status);
if (handler->size_changed_cb) {
ret_cb_t cb;
void *cbdata;
goto out;
}
- DbgPrint("Update period is changed? %lf (%d)\n", period, status);
if (status == 0)
lb_set_period(handler, period);
goto out;
}
- DbgPrint("Group is changed? [%s] / [%s] (%d)\n", cluster, category, status);
if (status == 0)
(void)lb_set_group(handler, cluster, category);
handler->created_cb = NULL;
handler->created_cbdata = NULL;
- DbgPrint("Invoke the created_cb\n");
cb(handler, ret, cbdata);
} else {
- DbgPrint("Invoke the lb,created\n");
lb_invoke_event_handler(handler, LB_EVENT_CREATED);
}
}
out:
if (ret == 0 && old_state == DELETE) {
- DbgPrint("Send the delete request\n");
lb_send_delete(handler, handler->created_cb, handler->created_cbdata);
/*!
}
if (ret < 0) {
- DbgPrint("Resize request is failed: %d\n", ret);
+ ErrPrint("Resize request is failed: %d\n", ret);
goto errout;
}
* after this request.
*/
if (ret < 0) {
- DbgPrint("Resize request is failed: %d\n", ret);
+ ErrPrint("Resize request is failed: %d\n", ret);
goto errout;
}
- DbgPrint("Resize request is successfully sent\n");
return;
errout:
if (ret < 0)
goto errout;
- DbgPrint("Succeed to send period change request, waiting result\n");
return;
errout:
}
if (ret == 0) {
- DbgPrint("Returns %d (waiting deleted event)\n", ret);
handler->deleted_cb = cb;
handler->deleted_cbdata = cbdata;
} else if (cb) {
}
if (ret >= 0) {
- DbgPrint("new request is sent, just waiting the created event\n");
handler->created_cb = cb;
handler->created_cbdata = cbdata;
}
if (ret < 0) {
- DbgPrint("Failed to create a PD\n");
+ ErrPrint("Failed to create a PD[%d]\n", ret);
goto errout;
}
destroy_cb_info(info);
if (!result) {
- DbgPrint("Result is NIL (may connection lost)\n");
+ ErrPrint("Result is NIL (may connection lost)\n");
ret = LB_STATUS_ERROR_FAULT;
} else if (packet_get(result, "i", &ret) != 1) {
- DbgPrint("Invalid parameter\n");
+ ErrPrint("Invalid parameter\n");
ret = LB_STATUS_ERROR_INVALID;
}
if (ret == 0) {
- DbgPrint("PD Destroyed callback prepared\n");
handler->pd_destroyed_cb = cb;
handler->pd_destroyed_cbdata = cbdata;
} else if (cb) {
- DbgPrint("PD is not desroyed (forcely reset, pd flag)\n");
handler->is_pd_created = 0;
cb(handler, ret, cbdata);
}
ret = LB_STATUS_ERROR_INVALID;
}
- DbgPrint("Delete category returns: %d\n", ret);
-
if (cb)
cb(handler, ret, cbdata);
}
else if (packet_get(result, "i", &ret) != 1)
ret = LB_STATUS_ERROR_INVALID;
- DbgPrint("Delete category returns: %d\n", ret);
-
if (cb)
cb(handler, ret, cbdata);
}
goto errout;
}
- DbgPrint("Access event is successfully sent. waiting result\n");
return;
errout:
return LB_STATUS_ERROR_FAULT;
}
- DbgPrint("Send: %dx%d\n", x, y);
-
return master_rpc_async_request(handler, packet, 0, access_ret_cb, NULL);
}
return LB_STATUS_ERROR_FAULT;
}
- DbgPrint("Send: %dx%d\n", x, y);
-
return master_rpc_request_only(handler, packet);
}
EAPI int livebox_fini(void)
{
if (s_info.init_count <= 0) {
- DbgPrint("Didn't initialized\n");
+ ErrPrint("Doesn't initialized\n");
return LB_STATUS_ERROR_INVALID;
}
s_info.init_count--;
if (s_info.init_count > 0) {
- DbgPrint("init count : %d\n", s_info.init_count);
+ ErrPrint("init count : %d\n", s_info.init_count);
return LB_STATUS_SUCCESS;
}
return NULL;
}
- DbgPrint("Successfully sent a new request ([%lf] %s)\n", handler->timestamp, handler->pkgname);
handler->state = CREATE;
return lb_ref(handler);
}
if (!cb)
cb = default_period_changed_cb;
- handler->period_changed_cb = cb;
- handler->period_cbdata = data;
-
ret = master_rpc_async_request(handler, packet, 0, period_ret_cb, NULL);
- if (ret < 0) {
- handler->period_changed_cb = NULL;
- handler->period_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->period_changed_cb = cb;
+ handler->period_cbdata = data;
}
return ret;
dlist_foreach(s_info.fault_list, l, info) {
if (info->handler == cb) {
void *data;
+
s_info.fault_list = dlist_remove(s_info.fault_list, l);
data = info->user_data;
free(info);
if (!cb)
cb = default_update_mode_cb;
- handler->update_mode_cb = cb;
- handler->update_mode_cbdata = data;
-
ret = master_rpc_async_request(handler, packet, 0, update_mode_cb, NULL);
- if (ret < 0) {
- handler->update_mode_cb = NULL;
- handler->update_mode_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->update_mode_cb = cb;
+ handler->update_mode_cbdata = data;
}
return ret;
if (!cb)
cb = default_lb_size_changed_cb;
- handler->size_changed_cb = cb;
- handler->size_cbdata = data;
-
ret = master_rpc_async_request(handler, packet, 0, resize_cb, NULL);
- if (ret < 0) {
- handler->size_changed_cb = NULL;
- handler->size_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->size_changed_cb = cb;
+ handler->size_cbdata = data;
}
return ret;
int ret;
timestamp = util_timestamp();
- DbgPrint("CLICKED: %lf\n", timestamp);
if (!handler) {
ErrPrint("Handler is NIL\n");
}
if (handler->lb.auto_launch) {
- DbgPrint("Auto-launch enabled: %s\n", handler->lb.auto_launch);
+ DbgPrint("AUTO_LAUNCH [%s]\n", handler->lb.auto_launch);
if (aul_launch_app(handler->lb.auto_launch, NULL) < 0)
ErrPrint("Failed to launch app %s\n", handler->lb.auto_launch);
}
return LB_STATUS_ERROR_FAULT;
}
+ DbgPrint("CLICKED: %lf\n", timestamp);
ret = master_rpc_request_only(handler, packet);
- DbgPrint("Click request: %d\n", ret);
if (!handler->lb.mouse_event && (handler->lb.type == _LB_TYPE_BUFFER || handler->lb.type == _LB_TYPE_SCRIPT)) {
int ret; /* Shadow variable */
ret = send_mouse_event(handler, "lb_mouse_down", x * handler->lb.width, y * handler->lb.height);
if (ret < 0)
- DbgPrint("Failed to send Down: %d\n", ret);
+ ErrPrint("Failed to send Down: %d\n", ret);
ret = send_mouse_event(handler, "lb_mouse_move", x * handler->lb.width, y * handler->lb.height);
if (ret < 0)
- DbgPrint("Failed to send Move: %d\n", ret);
+ ErrPrint("Failed to send Move: %d\n", ret);
ret = send_mouse_event(handler, "lb_mouse_up", x * handler->lb.width, y * handler->lb.height);
if (ret < 0)
- DbgPrint("Failed to send Up: %d\n", ret);
+ ErrPrint("Failed to send Up: %d\n", ret);
}
return ret;
if (!cb)
cb = default_pd_created_cb;
- handler->pd_created_cb = cb;
- handler->pd_created_cbdata = data;
-
+ DbgPrint("CREATE_PD\n");
ret = master_rpc_async_request(handler, packet, 0, pd_create_cb, NULL);
- if (ret < 0) {
- handler->pd_created_cb = NULL;
- handler->pd_created_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->pd_created_cb = cb;
+ handler->pd_created_cbdata = data;
}
return ret;
}
if (!handler->is_pd_created) {
- DbgPrint("PD is not created\n");
+ ErrPrint("PD is not created\n");
return LB_STATUS_ERROR_INVALID;
}
if (!cb)
cb = default_access_event_cb;
- handler->access_event_cb = cb;
- handler->access_event_cbdata = data;
-
ret = send_access_event(handler, cmd, x * w, y * h);
- if (ret < 0) {
- handler->access_event_cb = NULL;
- handler->access_event_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->access_event_cb = cb;
+ handler->access_event_cbdata = data;
}
return ret;
h = &_h;
if (!handler->is_pd_created) {
- DbgPrint("Buffer is not created yet [%dx%d]\n", *w, *h);
*w = handler->pd.default_width;
*h = handler->pd.default_height;
} else {
case _LB_TYPE_BUFFER:
case _LB_TYPE_SCRIPT:
if (!fb_is_created(handler->lb.data.fb)) {
- DbgPrint("Buffer is not created yet - reset size\n");
w = 0;
h = 0;
}
if (!cb)
cb = default_group_changed_cb;
- handler->group_changed_cb = cb;
- handler->group_cbdata = data;
-
ret = master_rpc_async_request(handler, packet, 0, set_group_ret_cb, NULL);
- if (ret < 0) {
- handler->group_changed_cb = NULL;
- handler->group_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->group_changed_cb = cb;
+ handler->group_cbdata = data;
}
return ret;
if (!cb)
cb = default_pinup_cb;
- handler->pinup_cb = cb;
- handler->pinup_cbdata = data;
-
ret = master_rpc_async_request(handler, packet, 0, pinup_done_cb, NULL);
- if (ret < 0) {
- handler->pinup_cb = NULL;
- handler->pinup_cbdata = NULL;
+ if (ret == LB_STATUS_SUCCESS) {
+ handler->pinup_cb = cb;
+ handler->pinup_cbdata = data;
}
return ret;
}
}
- DbgPrint("Change the visibility %d <> %d, %s\n", handler->visible, state, handler->id);
-
if (handler->visible == state)
return LB_STATUS_ERROR_ALREADY;
return handler;
if (handler->created_cb) {
- DbgPrint("Clear created event callback\n");
handler->created_cb(handler, LB_STATUS_ERROR_FAULT, handler->created_cbdata);
handler->created_cb = NULL;
handler->created_cbdata = NULL;
}
if (handler->deleted_cb) {
- DbgPrint("Clear deleted event callback\n");
handler->deleted_cb(handler, LB_STATUS_ERROR_FAULT, handler->deleted_cbdata);
handler->deleted_cb = NULL;
handler->deleted_cbdata = NULL;
}
if (handler->pinup_cb) {
- DbgPrint("Clear pinup event callback\n");
handler->pinup_cb(handler, LB_STATUS_ERROR_FAULT, handler->pinup_cbdata);
handler->pinup_cb = NULL;
handler->pinup_cbdata = NULL;
}
if (handler->group_changed_cb) {
- DbgPrint("Clear group changed event callback\n");
handler->group_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->group_cbdata);
handler->group_changed_cb = NULL;
handler->group_cbdata = NULL;
}
if (handler->period_changed_cb) {
- DbgPrint("Clear period changed event callback\n");
handler->period_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->period_cbdata);
handler->period_changed_cb = NULL;
handler->period_cbdata = NULL;
}
if (handler->size_changed_cb) {
- DbgPrint("Clear size changed event callback\n");
handler->size_changed_cb(handler, LB_STATUS_ERROR_FAULT, handler->size_cbdata);
handler->size_changed_cb = NULL;
handler->size_cbdata = NULL;
}
if (handler->pd_created_cb) {
- DbgPrint("Clear pd created event callback\n");
handler->pd_created_cb(handler, LB_STATUS_ERROR_FAULT, handler->pd_created_cbdata);
handler->pd_created_cb = NULL;
handler->pd_created_cbdata = NULL;
}
if (handler->pd_destroyed_cb) {
- DbgPrint("Clear pd destroyed event callback\n");
handler->pd_destroyed_cb(handler, LB_STATUS_ERROR_FAULT, handler->pd_destroyed_cbdata);
handler->pd_destroyed_cb = NULL;
handler->pd_destroyed_cbdata = NULL;
}
if (handler->update_mode_cb) {
- DbgPrint("Clear update mode callback\n");
handler->update_mode_cb(handler, LB_STATUS_ERROR_FAULT, handler->update_mode_cbdata);
handler->update_mode_cb = NULL;
handler->update_mode_cbdata = NULL;
}
if (handler->access_event_cb) {
- DbgPrint("Clear access status callback\n");
handler->access_event_cb(handler, LB_STATUS_ERROR_FAULT, handler->access_event_cbdata);
handler->access_event_cb = NULL;
handler->access_event_cbdata = NULL;