wl_signal_emit_mutable make the sigsegv crash at multi-threading situation.
So libds-tizen does not use wl_signal_emit_mutable till fixing it
Change-Id: I7bda8bafac54df4c45e0954ab8896d2d76197480
wl_list_insert(&tdm->outputs, &output->link);
- wl_signal_emit_mutable(&tdm->base.events.new_output, &output->base);
+ wl_signal_emit(&tdm->base.events.new_output, &output->base);
}
return true;
output_update_front_buffer(output);
- wl_signal_emit_mutable(&output->base.events.frame, &output->base);
+ wl_signal_emit(&output->base.events.frame, &output->base);
}
static void
if (len < 0 && errno != EAGAIN)
return -1;
- wl_signal_emit_mutable(&queue->events.acquirable, queue);
+ wl_signal_emit(&queue->events.acquirable, queue);
return 0;
}
void
ds_tdm_output_hwc_destroy(struct ds_tdm_output_hwc *hwc)
{
- wl_signal_emit_mutable(&hwc->events.destroy, hwc);
+ wl_signal_emit(&hwc->events.destroy, hwc);
free(hwc);
}
wl_list_for_each_safe(hwc_window, tmp, &hwc->hwc_windows, link)
hwc_window_update_front_buffer(hwc_window);
- wl_signal_emit_mutable(&hwc->events.commit_handler, hwc);
+ wl_signal_emit(&hwc->events.commit_handler, hwc);
}
bool
ds_inf("Global destroy: blender(%p)", blender);
- wl_signal_emit_mutable(&blender->events.destroy, blender);
+ wl_signal_emit(&blender->events.destroy, blender);
wl_list_remove(&blender->destroy.link);
wl_global_destroy(blender->global);
free(blender);
{
ds_inf("blend_destroy (blend:%p)", blend);
- wl_signal_emit_mutable(&blend->events.destroy, blend);
+ wl_signal_emit(&blend->events.destroy, blend);
if (blend->listener.surface_commit.notify)
wl_list_remove(&blend->listener.surface_commit.link);
blend->current.committed = blend->pending.committed;
blend->pending.committed = DS_TIZEN_BLEND_STATE_NONE;
- wl_signal_emit_mutable(&blend->events.commit, blend);
+ wl_signal_emit(&blend->events.commit, blend);
}
static void
wl_signal_init(&blend->events.destroy);
wl_signal_init(&blend->events.commit);
- wl_signal_emit_mutable(&client->blender->events.new_blend, blend);
+ wl_signal_emit(&client->blender->events.new_blend, blend);
}
static void
ds_inf("Global destroy: blur_manager(%p)", blur_manager);
- wl_signal_emit_mutable(&blur_manager->events.destroy, blur_manager);
+ wl_signal_emit(&blur_manager->events.destroy, blur_manager);
wl_list_remove(&blur_manager->destroy.link);
wl_global_destroy(blur_manager->global);
free(blur_manager);
{
ds_inf("blur_destroy (blur:%p)", blur);
- wl_signal_emit_mutable(&blur->events.destroy, blur);
+ wl_signal_emit(&blur->events.destroy, blur);
if (blur->listener.surface_commit.notify)
wl_list_remove(&blur->listener.surface_commit.link);
blur->current.committed = blur->pending.committed;
blur->pending.committed = DS_TIZEN_BLUR_STATE_NONE;
- wl_signal_emit_mutable(&blur->events.commit, blur);
+ wl_signal_emit(&blur->events.commit, blur);
}
static void
wl_signal_init(&blur->events.destroy);
wl_signal_init(&blur->events.commit);
- wl_signal_emit_mutable(&client->blur_manager->events.new_blur, blur);
+ wl_signal_emit(&client->blur_manager->events.new_blur, blur);
}
static void
ds_inf("Global destroy: clipboard(%p)", clipboard);
- wl_signal_emit_mutable(&clipboard->events.destroy, clipboard);
+ wl_signal_emit(&clipboard->events.destroy, clipboard);
wl_list_remove(&clipboard->destroy.link);
wl_global_destroy(clipboard->global);
free(clipboard);
return;
}
- wl_signal_emit_mutable(&client->clipboard->events.show, surface);
+ wl_signal_emit(&client->clipboard->events.show, surface);
}
static void
return;
}
- wl_signal_emit_mutable(&client->clipboard->events.hide, surface);
+ wl_signal_emit(&client->clipboard->events.hide, surface);
}
static void
client = wl_resource_get_user_data(resource);
client->data_only = set;
- wl_signal_emit_mutable(&client->clipboard->events.set_data_only, client);
+ wl_signal_emit(&client->clipboard->events.set_data_only, client);
}
static const struct tizen_clipboard_interface clipboard_impl =
ds_inf("Global destroy: display_policy(%p)", display_policy);
- wl_signal_emit_mutable(&display_policy->events.destroy, display_policy);
+ wl_signal_emit(&display_policy->events.destroy, display_policy);
wl_list_remove(&display_policy->destroy.link);
wl_global_destroy(display_policy->global);
free(display_policy);
info->brightness_value = brightness_value;
- wl_signal_emit_mutable(&client->display_policy->events.set_brightness, info);
+ wl_signal_emit(&client->display_policy->events.set_brightness, info);
}
static const struct tizen_display_policy_interface display_policy_impl =
ds_inf("_tizen_display_policy_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(info, tmp, &client->infos, link) {
- wl_signal_emit_mutable(&client->events.destroy, info);
+ wl_signal_emit(&client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
ds_inf("global destroy : tizen_dpms_manager(%p)", dpms);
- wl_signal_emit_mutable(&dpms->events.destroy, dpms);
+ wl_signal_emit(&dpms->events.destroy, dpms);
wl_list_remove(&dpms->destroy.link);
if (dpms->res)
wl_resource_set_user_data(dpms->res, NULL);
.mode = ds_mode,
};
- wl_signal_emit_mutable(&dpms->events.set_dpms, &event);
+ wl_signal_emit(&dpms->events.set_dpms, &event);
}
static void
dpms = wl_resource_get_user_data(resource);
output = wl_resource_get_user_data(wl_output);
- wl_signal_emit_mutable(&dpms->events.get_dpms, output);
+ wl_signal_emit(&dpms->events.get_dpms, output);
}
static const struct tizen_dpms_manager_interface dpms_impl =
ds_inf("Global destroy: embedded_compositor(%p)", embedded_compositor);
- wl_signal_emit_mutable(&embedded_compositor->events.destroy, embedded_compositor);
+ wl_signal_emit(&embedded_compositor->events.destroy, embedded_compositor);
wl_list_remove(&embedded_compositor->destroy.link);
wl_global_destroy(embedded_compositor->global);
free(embedded_compositor);
ds_inf("send_output_info - id:%d, type:%d, mode:%d, conn:%d, w:%d, h:%d, w_mm:%d, h_mm:%d",
output->id, output->type, output->mode, output->status,
output->width, output->height, output->physical_width, output->physical_height);
-
+
}
WL_EXPORT void
ds_inf("global destroy : eom(%p)", eom);
- wl_signal_emit_mutable(&eom->events.destroy, eom);
+ wl_signal_emit(&eom->events.destroy, eom);
wl_list_remove(&eom->destroy.link);
wl_global_destroy(eom->global);
.attribute = eom_attribute,
};
- wl_signal_emit_mutable(&eom->events.set_attribute, &event);
+ wl_signal_emit(&eom->events.set_attribute, &event);
}
static void
.surface = surface,
};
- wl_signal_emit_mutable(&eom->events.set_shell_window, &event);
+ wl_signal_emit(&eom->events.set_shell_window, &event);
}
static void
eom_client = wl_resource_get_user_data(resource);
- wl_signal_emit_mutable(&eom_client->eom->events.client_destroy, eom_client);
+ wl_signal_emit(&eom_client->eom->events.client_destroy, eom_client);
wl_list_remove(&eom_client->link);
free(eom_client);
}
ds_inf("Global destroy: resource(%p)", global_resource);
- wl_signal_emit_mutable(&global_resource->events.destroy, global_resource);
+ wl_signal_emit(&global_resource->events.destroy, global_resource);
wl_list_remove(&global_resource->destroy.link);
wl_global_destroy(global_resource->global);
free(global_resource);
ds_inf("_tizen_surface_handle_destroy (info:%p)", info);
- wl_signal_emit_mutable(&info->client->events.destroy, info);
+ wl_signal_emit(&info->client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
wl_resource_set_implementation(info->resource, &resource_impl, info,
_tizen_surface_handle_destroy);
- wl_signal_emit_mutable(&client->global_resource->events.get_resource_info, info);
+ wl_signal_emit(&client->global_resource->events.get_resource_info, info);
tizen_resource_send_resource_id(info->resource, info->universal_id);
}
ds_inf("_tizen_global_resource_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(info, tmp, &client->infos, link) {
- wl_signal_emit_mutable(&info->client->events.destroy, info);
+ wl_signal_emit(&info->client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
commit_feedback->listener.surface_destroy.notify = NULL;
}
- wl_signal_emit_mutable(&commit_feedback->events.destroy, commit_feedback);
+ wl_signal_emit(&commit_feedback->events.destroy, commit_feedback);
free(commit_feedback);
}
wl_signal_init(&commit_feedback->events.destroy);
- wl_signal_emit_mutable(&hwc_client->hwc->events.new_commit_feedback, commit_feedback);
+ wl_signal_emit(&hwc_client->hwc->events.new_commit_feedback, commit_feedback);
}
static void
ds_inf("Global destroy: hwc(%p)", hwc);
- wl_signal_emit_mutable(&hwc->events.destroy, hwc);
+ wl_signal_emit(&hwc->events.destroy, hwc);
wl_list_remove(&hwc->destroy.link);
wl_global_destroy(hwc->global);
free(hwc);
ds_inf("Global destroy: indicator(%p)", indicator);
- wl_signal_emit_mutable(&indicator->events.destroy, indicator);
+ wl_signal_emit(&indicator->events.destroy, indicator);
wl_list_remove(&indicator->destroy.link);
wl_global_destroy(indicator->global);
free(indicator);
surface, info->state, indicator_state);
info->state = indicator_state;
- wl_signal_emit_mutable(&client->indicator->events.change_state, surface);
+ wl_signal_emit(&client->indicator->events.change_state, surface);
}
}
surface, info->opacity_mode, opacity_mode);
info->opacity_mode = opacity_mode;
- wl_signal_emit_mutable(&client->indicator->events.change_opacity_mode, surface);
+ wl_signal_emit(&client->indicator->events.change_opacity_mode, surface);
}
}
surface, info->visible_type, visible_type);
info->visible_type = visible_type;
- wl_signal_emit_mutable(&client->indicator->events.change_visible_type, surface);
+ wl_signal_emit(&client->indicator->events.change_visible_type, surface);
}
}
tz_devicemgr_ungrab_keyboard(tz_devicemgr);
ds_seat_keyboard_grab_destroy(tz_devicemgr->grab);
- wl_signal_emit_mutable(&tz_devicemgr->events.destroy, tz_devicemgr);
+ wl_signal_emit(&tz_devicemgr->events.destroy, tz_devicemgr);
wl_list_remove(&tz_devicemgr->backend_destroy.link);
wl_list_remove(&tz_devicemgr->seat_destroy.link);
wl_list_remove(&tz_devicemgr->new_input.link);
ds_inf("Pointer warp. surface:%p, x:%.2f, y:%.2f", ds_event.surface,
ds_event.x, ds_event.y);
- wl_signal_emit_mutable(&tz_devicemgr->events.pointer_warp, &ds_event);
+ wl_signal_emit(&tz_devicemgr->events.pointer_warp, &ds_event);
ret = TIZEN_INPUT_DEVICE_MANAGER_ERROR_NONE;
finish:
tz_devicemgr->devices.kbd->ref++;
}
if (dev->created) {
- wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+ wl_signal_emit(&tz_devicemgr->backend->events.new_input,
dev->input_device);
}
}
tz_devicemgr->devices.ptr->ref++;
}
if (dev->created) {
- wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+ wl_signal_emit(&tz_devicemgr->backend->events.new_input,
dev->input_device);
}
}
tz_devicemgr->devices.touch->ref++;
}
if (dev->created) {
- wl_signal_emit_mutable(&tz_devicemgr->backend->events.new_input,
+ wl_signal_emit(&tz_devicemgr->backend->events.new_input,
dev->input_device);
}
}
ds_event.y = y;
ds_inf("Generate touch motion. touch:%p, id:%d (%d, %d)", touch, ds_event.id, x, y);
- wl_signal_emit_mutable(&touch->events.motion, &ds_event);
+ wl_signal_emit(&touch->events.motion, &ds_event);
return true;
}
ds_event.y = y;
ds_inf("Generate touch down. touch:%p, id:%d (%d, %d)", touch, ds_event.id, x, y);
- wl_signal_emit_mutable(&touch->events.down, &ds_event);
+ wl_signal_emit(&touch->events.down, &ds_event);
return true;
}
ds_event.id = finger;
ds_inf("Generate touch up. touch:%p, id:%d", touch, ds_event.id);
- wl_signal_emit_mutable(&touch->events.up, &ds_event);
+ wl_signal_emit(&touch->events.up, &ds_event);
return true;
}
ds_event.delta_y = y;
ds_inf("Generate mouse motion. pointer:%p, x:%f, y:%f", pointer, ds_event.delta_x, ds_event.delta_y);
- wl_signal_emit_mutable(&pointer->events.motion, &ds_event);
+ wl_signal_emit(&pointer->events.motion, &ds_event);
return true;
}
ds_event.state = DS_BUTTON_RELEASED;
ds_inf("Generate mouse button. pointer:%p, button:%d, state:%s", pointer, ds_event.button, state ? "PRESSED" : "RELEASED");
- wl_signal_emit_mutable(&pointer->events.button, &ds_event);
+ wl_signal_emit(&pointer->events.button, &ds_event);
return true;
}
ds_inf("Global destroy: input_method_mgr(%p)", input_method_mgr);
- wl_signal_emit_mutable(&input_method_mgr->events.destroy, input_method_mgr);
+ wl_signal_emit(&input_method_mgr->events.destroy, input_method_mgr);
wl_list_remove(&input_method_mgr->destroy.link);
wl_global_destroy(input_method_mgr->global);
ds_event.im_mgr = input_method_mgr;
ds_event.pid_parent = parent_pid;
ds_event.pid_child = child_pid;
- wl_signal_emit_mutable(&input_method_mgr->events.set_transient_for, &ds_event);
+ wl_signal_emit(&input_method_mgr->events.set_transient_for, &ds_event);
}
static const struct zwp_input_method_manager_v1_interface input_method_mgr_impl =
{
ds_inf("input_method_context(%p) destroy", context);
- wl_signal_emit_mutable(&context->events.destroy, context);
+ wl_signal_emit(&context->events.destroy, context);
free(context);
}
ds_event.serial = serial;
ds_event.text = text;
- wl_signal_emit_mutable(&context->events.commit_string, &ds_event);
+ wl_signal_emit(&context->events.commit_string, &ds_event);
}
static void
ds_event.text = text;
ds_event.commit = commit;
- wl_signal_emit_mutable(&context->events.preedit_string, &ds_event);
+ wl_signal_emit(&context->events.preedit_string, &ds_event);
}
static void
ds_event.length = length;
ds_event.style = style;
- wl_signal_emit_mutable(&context->events.preedit_styling, &ds_event);
+ wl_signal_emit(&context->events.preedit_styling, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.index = index;
- wl_signal_emit_mutable(&context->events.preedit_styling, &ds_event);
+ wl_signal_emit(&context->events.preedit_styling, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.index = index;
ds_event.length = length;
- wl_signal_emit_mutable(&context->events.delete_surrounding_text, &ds_event);
+ wl_signal_emit(&context->events.delete_surrounding_text, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.index = index;
ds_event.anchor = anchor;
- wl_signal_emit_mutable(&context->events.cursor_position, &ds_event);
+ wl_signal_emit(&context->events.cursor_position, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.map = map;
- wl_signal_emit_mutable(&context->events.modifiers_map, &ds_event);
+ wl_signal_emit(&context->events.modifiers_map, &ds_event);
}
static void
ds_event.sym = sym;
ds_event.state = state;
ds_event.modifiers = modifiers;
- wl_signal_emit_mutable(&context->events.keysym, &ds_event);
+ wl_signal_emit(&context->events.keysym, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.serial = serial;
ds_event.language = language;
- wl_signal_emit_mutable(&context->events.language, &ds_event);
+ wl_signal_emit(&context->events.language, &ds_event);
}
static void
ds_event.im_context = context;
ds_event.serial = serial;
ds_event.direction = direction;
- wl_signal_emit_mutable(&context->events.text_direction, &ds_event);
+ wl_signal_emit(&context->events.text_direction, &ds_event);
}
static const struct zwp_input_method_context_v1_interface context_impl = {
if (input_method->context)
context_destroy(input_method->context);
- wl_signal_emit_mutable(&input_method->events.destroy, input_method);
+ wl_signal_emit(&input_method->events.destroy, input_method);
wl_list_remove(&input_method->destroy.link);
wl_global_destroy(input_method->global);
ds_inf("Global destroy: ds_tizen_keyrouter(%p)", keyrouter);
- wl_signal_emit_mutable(&keyrouter->events.destroy, keyrouter);
+ wl_signal_emit(&keyrouter->events.destroy, keyrouter);
if (keyrouter->security_initialized)
tizen_security_finish();
ds_inf("Global destroy: appinfo_mgr(%p)", appinfo_mgr);
- wl_signal_emit_mutable(&appinfo_mgr->events.destroy, appinfo_mgr);
+ wl_signal_emit(&appinfo_mgr->events.destroy, appinfo_mgr);
wl_list_remove(&appinfo_mgr->destroy.link);
wl_list_for_each_safe(client, tmp_client, &appinfo_mgr->clients, link) {
info->pid = pid;
ds_inf("appinfo(%p) set pid(%u)", info, pid);
- wl_signal_emit_mutable(&appinfo_mgr->events.set_pid, info);
+ wl_signal_emit(&appinfo_mgr->events.set_pid, info);
return true;
}
info->appid = strdup(appid);
ds_inf("appinfo(%p) set appid(%u)", info, appid);
- wl_signal_emit_mutable(&appinfo_mgr->events.set_appid, info);
+ wl_signal_emit(&appinfo_mgr->events.set_appid, info);
return true;
}
if ((uint32_t)info->pid != pid)
appinfo_set_pid(info, pid);
- wl_signal_emit_mutable(&client->appinfo_mgr->events.metadata_ready, info);
+ wl_signal_emit(&client->appinfo_mgr->events.metadata_ready, info);
/* TODO: base output resolution */
}
struct ds_tizen_launch_splash *splash, *tmp;
wl_list_for_each_safe(splash, tmp, &client->splashs, link) {
- wl_signal_emit_mutable(&splash->events.destroy, splash);
+ wl_signal_emit(&splash->events.destroy, splash);
wl_list_remove(&splash->link);
free(splash);
}
ds_inf("Global destroy: effect(%p)", effect);
- wl_signal_emit_mutable(&effect->events.destroy, effect);
+ wl_signal_emit(&effect->events.destroy, effect);
wl_list_remove(&effect->destroy.link);
wl_list_for_each_safe(client, tmp_client, &effect->clients, link) {
ds_inf("Effect type_set. pid:%u type:%s", ds_event.pid, effect_type);
- wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+ wl_signal_emit(&effect->events.type_set, &ds_event);
}
}
splash = wl_resource_get_user_data(resource);
ds_event.pid = pid;
- wl_signal_emit_mutable(&splash->events.owner, &ds_event);
+ wl_signal_emit(&splash->events.owner, &ds_event);
}
static void
ds_inf("Effect type_set. pid:%u type:%s", ds_event.pid, effect_type);
- wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+ wl_signal_emit(&effect->events.type_set, &ds_event);
}
//Parse extra config
ds_inf("splash_client_handle_destroy (client:%p)", splash->client);
- wl_signal_emit_mutable(&splash->events.destroy, splash);
+ wl_signal_emit(&splash->events.destroy, splash);
wl_list_remove(&splash->link);
free(splash);
}
if (!splash) return;
effect = client->effect;
- wl_signal_emit_mutable(&effect->events.new_splash, splash);
+ wl_signal_emit(&effect->events.new_splash, splash);
}
static void
ds_inf("Effect type_set. pid:%u type:%s", pid, effect_type);
- wl_signal_emit_mutable(&effect->events.type_set, &ds_event);
+ wl_signal_emit(&effect->events.type_set, &ds_event);
}
static void
ds_inf("Effect type_unset. pid:%u", pid);
- wl_signal_emit_mutable(&effect->events.type_unset, &ds_event);
+ wl_signal_emit(&effect->events.type_unset, &ds_event);
}
static void
ds_inf("Global destroy: memory_flusher(%p)", memory_flusher);
- wl_signal_emit_mutable(&memory_flusher->events.destroy, memory_flusher);
+ wl_signal_emit(&memory_flusher->events.destroy, memory_flusher);
wl_list_remove(&memory_flusher->destroy.link);
wl_global_destroy(memory_flusher->global);
free(memory_flusher);
ds_inf("_tizen_memory_flusher_info_handle_destroy (info:%p)", info);
- wl_signal_emit_mutable(&info->client->events.destroy, info);
+ wl_signal_emit(&info->client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
wl_resource_set_implementation(info->resource, &flusher_impl, info,
_tizen_memory_flusher_info_handle_destroy);
- wl_signal_emit_mutable(&client->memory_flusher->events.get_flusher, info);
+ wl_signal_emit(&client->memory_flusher->events.get_flusher, info);
}
static void
ds_inf("_tizen_memory_flusher_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(info, tmp, &client->infos, link) {
- wl_signal_emit_mutable(&client->events.destroy, info);
+ wl_signal_emit(&client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
.policy = client->policy,
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&client->policy->events.new_surface, &event);
+ wl_signal_emit(&client->policy->events.new_surface, &event);
return policy_surface;
}
ds_inf("Global destroy: policy(%p)", policy);
- wl_signal_emit_mutable(&policy->events.destroy, policy);
+ wl_signal_emit(&policy->events.destroy, policy);
if (policy->use_security)
tizen_security_finish();
ds_inf("_tizen_policy_visibility_handle_destroy (visibility:%p)",
visibility);
- wl_signal_emit_mutable(&visibility->events.destroy, visibility);
+ wl_signal_emit(&visibility->events.destroy, visibility);
wl_list_remove(&visibility->link);
free(visibility);
}
.policy_surface = policy_surface,
.visibility = visibility,
};
- wl_signal_emit_mutable(&policy_surface->events.new_visibility, &event);
+ wl_signal_emit(&policy_surface->events.new_visibility, &event);
}
static void
.x = x,
.y = y,
};
- wl_signal_emit_mutable(&position->events.set, &event);
+ wl_signal_emit(&position->events.set, &event);
}
static const struct tizen_position_interface position_impl =
ds_inf("_tizen_policy_position_handle_destroy (position:%p)",
position);
- wl_signal_emit_mutable(&position->events.destroy, position);
+ wl_signal_emit(&position->events.destroy, position);
wl_list_remove(&position->link);
free(position);
}
.policy_surface = policy_surface,
.position = position,
};
- wl_signal_emit_mutable(&policy_surface->events.new_position, &event);
+ wl_signal_emit(&policy_surface->events.new_position, &event);
}
static void
struct ds_tizen_policy_surface_event_activate event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.activate, &event);
+ wl_signal_emit(&policy_surface->events.activate, &event);
}
static void
.universal_id = universal_id,
.below_universal_id = below_universal_id,
};
- wl_signal_emit_mutable(&client->policy->events.activate_below_by_univeral_id, &event);
+ wl_signal_emit(&client->policy->events.activate_below_by_univeral_id, &event);
}
static void
struct ds_tizen_policy_surface_event_raise event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.raise, &event);
+ wl_signal_emit(&policy_surface->events.raise, &event);
}
static void
struct ds_tizen_policy_surface_event_lower event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.lower, &event);
+ wl_signal_emit(&policy_surface->events.lower, &event);
}
static void
.policy = client->policy,
.universal_id = universal_id,
};
- wl_signal_emit_mutable(&client->policy->events.lower_by_universal_id, &event);
+ wl_signal_emit(&client->policy->events.lower_by_universal_id, &event);
}
static void
struct ds_tizen_policy_surface_event_set_focus_skip event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.set_focus_skip, &event);
+ wl_signal_emit(&policy_surface->events.set_focus_skip, &event);
}
static void
struct ds_tizen_policy_surface_event_unset_focus_skip event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.unset_focus_skip, &event);
+ wl_signal_emit(&policy_surface->events.unset_focus_skip, &event);
}
static void
.policy_surface = policy_surface,
.role = role,
};
- wl_signal_emit_mutable(&policy_surface->events.set_role, &event);
+ wl_signal_emit(&policy_surface->events.set_role, &event);
}
static void
.policy_surface = policy_surface,
.win_type = win_type,
};
- wl_signal_emit_mutable(&policy_surface->events.set_window_type, &event);
+ wl_signal_emit(&policy_surface->events.set_window_type, &event);
}
static void
struct ds_tizen_policy_surface_event_set_conformant event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.set_conformant, &event);
+ wl_signal_emit(&policy_surface->events.set_conformant, &event);
}
static void
struct ds_tizen_policy_surface_event_unset_conformant event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.unset_conformant, &event);
+ wl_signal_emit(&policy_surface->events.unset_conformant, &event);
}
static void
struct ds_tizen_policy_surface_event_get_conformant event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.get_conformant, &event);
+ wl_signal_emit(&policy_surface->events.get_conformant, &event);
}
static void
.policy_surface = policy_surface,
.level = noti_level,
};
- wl_signal_emit_mutable(&policy_surface->events.set_notification_level, &event);
+ wl_signal_emit(&policy_surface->events.set_notification_level, &event);
}
static void
.child_universal_id = child_id,
.parent_universal_id = parent_id,
};
- wl_signal_emit_mutable(&client->policy->events.set_transient_for, &event);
+ wl_signal_emit(&client->policy->events.set_transient_for, &event);
tizen_policy_send_transient_for_done(resource, child_id);
}
.policy = client->policy,
.child_universal_id = child_id,
};
- wl_signal_emit_mutable(&client->policy->events.unset_transient_for, &event);
+ wl_signal_emit(&client->policy->events.unset_transient_for, &event);
}
static void
.policy_surface = policy_surface,
.mode = screen_mode,
};
- wl_signal_emit_mutable(&policy_surface->events.set_window_screen_mode, &event);
+ wl_signal_emit(&policy_surface->events.set_window_screen_mode, &event);
}
static void
.policy = client->policy,
.subsurface = subsurface,
};
- wl_signal_emit_mutable(
+ wl_signal_emit(
&client->policy->events.place_subsurface_below_parent,
&event);
}
.policy = client->policy,
.subsurface = subsurface,
};
- wl_signal_emit_mutable(
+ wl_signal_emit(
&client->policy->events.set_subsurface_stand_alone,
&event);
}
.policy_surface = policy_surface,
.parent_universal_id = parent_id,
};
- wl_signal_emit_mutable(&policy_surface->events.get_subsurface, &event);
+ wl_signal_emit(&policy_surface->events.get_subsurface, &event);
}
static void
struct ds_tizen_policy_surface_event_iconify event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.iconify, &event);
+ wl_signal_emit(&policy_surface->events.iconify, &event);
}
static void
struct ds_tizen_policy_surface_event_uniconify event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.uniconify, &event);
+ wl_signal_emit(&policy_surface->events.uniconify, &event);
}
static void
.name = name,
.value = value,
};
- wl_signal_emit_mutable(&policy_surface->events.add_aux_hint, &event);
+ wl_signal_emit(&policy_surface->events.add_aux_hint, &event);
}
static void
.id = id,
.value = value,
};
- wl_signal_emit_mutable(&policy_surface->events.change_aux_hint, &event);
+ wl_signal_emit(&policy_surface->events.change_aux_hint, &event);
}
static void
.policy_surface = policy_surface,
.id = id,
};
- wl_signal_emit_mutable(&policy_surface->events.delete_aux_hint, &event);
+ wl_signal_emit(&policy_surface->events.delete_aux_hint, &event);
}
static void
struct ds_tizen_policy_surface_event_get_supported_aux_hints event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.get_supported_aux_hints, &event);
+ wl_signal_emit(&policy_surface->events.get_supported_aux_hints, &event);
}
static void
.policy = client->policy,
.pid = pid,
};
- wl_signal_emit_mutable(&client->policy->events.set_background_state, &event);
+ wl_signal_emit(&client->policy->events.set_background_state, &event);
}
}
}
.policy = client->policy,
.pid = pid,
};
- wl_signal_emit_mutable(&client->policy->events.unset_background_state, &event);
+ wl_signal_emit(&client->policy->events.unset_background_state, &event);
}
}
}
struct ds_tizen_policy_surface_event_set_floating_mode event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.set_floating_mode, &event);
+ wl_signal_emit(&policy_surface->events.set_floating_mode, &event);
}
static void
struct ds_tizen_policy_surface_event_unset_floating_mode event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.unset_floating_mode, &event);
+ wl_signal_emit(&policy_surface->events.unset_floating_mode, &event);
}
static void
.policy_surface = policy_surface,
.mode = stack_mode,
};
- wl_signal_emit_mutable(&policy_surface->events.set_stack_mode, &event);
+ wl_signal_emit(&policy_surface->events.set_stack_mode, &event);
}
static void
.universal_id = universal_id,
.above_universal_id = above_universal_id,
};
- wl_signal_emit_mutable(&client->policy->events.activate_above_by_universal_id, &event);
+ wl_signal_emit(&client->policy->events.activate_above_by_universal_id, &event);
}
static void
ds_inf("_tizen_policy_subsurface_watcher_handle_destroy (subsurface_watcher:%p)",
subsurface_watcher);
- wl_signal_emit_mutable(&subsurface_watcher->events.destroy, subsurface_watcher);
+ wl_signal_emit(&subsurface_watcher->events.destroy, subsurface_watcher);
free(subsurface_watcher);
}
.policy_surface = policy_surface,
.subsurface_watcher = subsurface_watcher,
};
- wl_signal_emit_mutable(&policy_surface->events.new_subsurface_watcher, &event);
+ wl_signal_emit(&policy_surface->events.new_subsurface_watcher, &event);
}
static void
.policy_surface = policy_surface,
.parent_surface = parent_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.set_parent, &event);
+ wl_signal_emit(&policy_surface->events.set_parent, &event);
}
static void
.policy_surface = policy_surface,
.serial = serial,
};
- wl_signal_emit_mutable(&policy_surface->events.ack_conformant_region, &event);
+ wl_signal_emit(&policy_surface->events.ack_conformant_region, &event);
}
static void
.policy_surface = policy_surface,
.video = has,
};
- wl_signal_emit_mutable(&policy_surface->events.set_video, &event);
+ wl_signal_emit(&policy_surface->events.set_video, &event);
}
static void
.pid = pid,
.appid = appid,
};
- wl_signal_emit_mutable(&client->policy->events.set_appid, &event);
+ wl_signal_emit(&client->policy->events.set_appid, &event);
}
static void
struct ds_tizen_policy_surface_event_show event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.show, &event);
+ wl_signal_emit(&policy_surface->events.show, &event);
}
static void
struct ds_tizen_policy_surface_event_hide event = {
.policy_surface = policy_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.hide, &event);
+ wl_signal_emit(&policy_surface->events.hide, &event);
}
static void
.universal_id = universal_id,
.parent_universal_id = parent_universal_id,
};
- wl_signal_emit_mutable(&client->policy->events.set_transient_for_below, &event);
+ wl_signal_emit(&client->policy->events.set_transient_for_below, &event);
}
static void
.policy_surface = policy_surface,
.parent_surface = parent_surface,
};
- wl_signal_emit_mutable(&policy_surface->events.set_parent_with_below, &event);
+ wl_signal_emit(&policy_surface->events.set_parent_with_below, &event);
}
static const struct tizen_policy_interface policy_impl =
ds_inf("_tizen_policy_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(policy_surface, tmp, &client->policy_surfaces, link) {
- wl_signal_emit_mutable(&policy_surface->events.destroy, policy_surface);
+ wl_signal_emit(&policy_surface->events.destroy, policy_surface);
wl_list_remove(&policy_surface->link);
free(policy_surface);
}
remote_provider->offscreen = offscreen;
- wl_signal_emit_mutable(&remote_provider->events.set_offscreen, remote_provider);
+ wl_signal_emit(&remote_provider->events.set_offscreen, remote_provider);
}
static void
remote_provider->input_event_filter = event_filter;
- wl_signal_emit_mutable(&remote_provider->events.set_input_event_filter, remote_provider);
+ wl_signal_emit(&remote_provider->events.set_input_event_filter, remote_provider);
}
static const struct tizen_remote_surface_provider_interface remote_surface_provider_impl =
wl_list_remove(&remote_provider->link);
- wl_signal_emit_mutable(&remote_provider->events.destroy, remote_provider);
+ wl_signal_emit(&remote_provider->events.destroy, remote_provider);
free(remote_provider);
}
wl_signal_init(&remote_provider->events.set_offscreen);
wl_signal_init(&remote_provider->events.set_input_event_filter);
- wl_signal_emit_mutable(&remote_client->remote_manager->events.new_provider, remote_provider);
+ wl_signal_emit(&remote_client->remote_manager->events.new_provider, remote_provider);
remote_provider->resource_id = global_resource_id++;
remote_surface->redirect = true;
- wl_signal_emit_mutable(&remote_surface->events.set_redirect, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_redirect, remote_surface);
}
static void
remote_surface->redirect = false;
- wl_signal_emit_mutable(&remote_surface->events.set_redirect, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_redirect, remote_surface);
}
static void
event.identifier = identifier;
event.time = time;
- wl_signal_emit_mutable(&remote_surface->events.transfer_mouse_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_mouse_event, &event);
}
static void
event.identifier = identifier;
event.time = time;
- wl_signal_emit_mutable(&remote_surface->events.transfer_mouse_wheel_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_mouse_wheel_event, &event);
}
static void
event.identifier = identifier;
event.time = time;
- wl_signal_emit_mutable(&remote_surface->events.transfer_touch_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_touch_event, &event);
}
static void
event.remote_surface = remote_surface;
- wl_signal_emit_mutable(&remote_surface->events.transfer_touch_cancel_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_touch_cancel_event, &event);
}
static void
event.identifier = identifier;
event.time = time;
- wl_signal_emit_mutable(&remote_surface->events.transfer_key_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_key_event, &event);
}
static void
event.remote_surface = remote_surface;
event.visibility = visibility_type;
- wl_signal_emit_mutable(&remote_surface->events.transfer_visibility_event, &event);
+ wl_signal_emit(&remote_surface->events.transfer_visibility_event, &event);
}
static void
ds_surface_add_destroy_listener(surface, &remote_surface->listener.owner_surface_destroy);
remote_surface->owner_surface = surface;
- wl_signal_emit_mutable(&remote_surface->events.set_owner, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_owner, remote_surface);
}
static void
remote_region->w = w;
remote_region->h = h;
- wl_signal_emit_mutable(&remote_region->events.set_geometry, remote_region);
+ wl_signal_emit(&remote_region->events.set_geometry, remote_region);
}
static const struct tizen_remote_surface_region_interface remote_surface_region_impl =
ds_inf("remote_region:%p destroy", remote_region);
- wl_signal_emit_mutable(&remote_region->events.destroy, remote_region);
+ wl_signal_emit(&remote_region->events.destroy, remote_region);
free(remote_region);
}
wl_signal_init(&remote_region->events.destroy);
wl_signal_init(&remote_region->events.set_geometry);
- wl_signal_emit_mutable(&remote_surface->events.new_region, remote_region);
+ wl_signal_emit(&remote_surface->events.new_region, remote_region);
}
static void
event.remote_surface = remote_surface;
event.buffer = buffer;
- wl_signal_emit_mutable(&remote_surface->events.buffer_release, &event);
+ wl_signal_emit(&remote_surface->events.buffer_release, &event);
}
static void
else
remote_surface->remote_render = false;
- wl_signal_emit_mutable(&remote_surface->events.set_remote_render, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_remote_render, remote_surface);
}
static void
remote_surface->changed_buffer_event_filter = filter;
- wl_signal_emit_mutable(&remote_surface->events.set_changed_buffer_event_filter, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_changed_buffer_event_filter, remote_surface);
}
static void
event.buffer_type = buff_type;
event.request_serial = req_serial;
- wl_signal_emit_mutable(&remote_surface->events.get_current_buffer, &event);
+ wl_signal_emit(&remote_surface->events.get_current_buffer, &event);
}
static const struct tizen_remote_surface_interface remote_surface_impl =
wl_list_remove(&remote_surface->link);
- wl_signal_emit_mutable(&remote_surface->events.destroy, remote_surface);
+ wl_signal_emit(&remote_surface->events.destroy, remote_surface);
free(remote_surface);
}
wl_list_insert(&remote_client->remote_manager->remote_surfaces, &remote_surface->link);
- wl_signal_emit_mutable(&remote_client->remote_manager->events.new_surface, remote_surface);
+ wl_signal_emit(&remote_client->remote_manager->events.new_surface, remote_surface);
}
static void
event.remote_surface = remote_surface;
event.surface = surface;
- wl_signal_emit_mutable(&remote_client->remote_manager->events.bind_surface, &event);
+ wl_signal_emit(&remote_client->remote_manager->events.bind_surface, &event);
}
static void
wl_list_insert(&remote_client->remote_manager->remote_surfaces, &remote_surface->link);
- wl_signal_emit_mutable(&remote_client->remote_manager->events.new_surface, remote_surface);
- wl_signal_emit_mutable(&remote_surface->events.set_owner, remote_surface);
+ wl_signal_emit(&remote_client->remote_manager->events.new_surface, remote_surface);
+ wl_signal_emit(&remote_surface->events.set_owner, remote_surface);
}
static const struct tizen_remote_surface_manager_interface remote_surface_manager_impl =
ds_inf("Global destroy: remote_surface_manager(%p)", remote_manager);
- wl_signal_emit_mutable(&remote_manager->events.destroy, remote_manager);
+ wl_signal_emit(&remote_manager->events.destroy, remote_manager);
wl_list_remove(&remote_manager->destroy.link);
wl_global_destroy(remote_manager->global);
free(remote_manager);
ds_inf("Global destroy: renderer(%p)", renderer);
- wl_signal_emit_mutable(&renderer->events.destroy, renderer);
+ wl_signal_emit(&renderer->events.destroy, renderer);
wl_list_remove(&renderer->destroy.link);
wl_global_destroy(renderer->global);
free(renderer);
ds_inf("_tizen_renderer_info_handle_destroy (info:%p)", info);
- wl_signal_emit_mutable(&info->client->events.destroy, info);
+ wl_signal_emit(&info->client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
wl_resource_set_implementation(info->resource, &renderer_surface_impl, info,
_tizen_renderer_info_handle_destroy);
- wl_signal_emit_mutable(&client->renderer->events.get_renderer_surface, info);
+ wl_signal_emit(&client->renderer->events.get_renderer_surface, info);
}
static void
ds_inf("_tizen_renderer_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(info, tmp, &client->infos, link) {
- wl_signal_emit_mutable(&client->events.destroy, info);
+ wl_signal_emit(&client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
ds_inf("screen_splitscreen:%p activate", splitscreen);
- wl_signal_emit_mutable(&splitscreen->events.activate, splitscreen);
+ wl_signal_emit(&splitscreen->events.activate, splitscreen);
}
static void
ds_inf("screen_splitscreen:%p deactivate", splitscreen);
- wl_signal_emit_mutable(&splitscreen->events.deactivate, splitscreen);
+ wl_signal_emit(&splitscreen->events.deactivate, splitscreen);
}
static const struct wtz_splitscreen_interface splitscreen_impl =
ds_inf("screen_splitscreen:%p destroy", splitscreen);
- wl_signal_emit_mutable(&splitscreen->events.destroy, splitscreen);
+ wl_signal_emit(&splitscreen->events.destroy, splitscreen);
screen = splitscreen->screen;
screen->splitscreen_enabled = false; // unset splitscreen resource on a screen
screen->splitscreen_enabled = true; // set splitscreen resource on a screen
- wl_signal_emit_mutable(&screen_client->screen->events.get_splitscreen, splitscreen);
+ wl_signal_emit(&screen_client->screen->events.get_splitscreen, splitscreen);
}
static void
ds_inf("Global destroy: screen(%p)", screen);
- wl_signal_emit_mutable(&screen->events.destroy, screen);
+ wl_signal_emit(&screen->events.destroy, screen);
wl_list_remove(&screen->destroy.link);
wl_global_destroy(screen->global);
free(screen);
splitscreen_region->appid = appid;
- wl_signal_emit_mutable(&splitscreen_region->events.assign_appid, (void *)appid);
+ wl_signal_emit(&splitscreen_region->events.assign_appid, (void *)appid);
}
static const struct wtz_splitscreen_region_interface splitscreen_region_impl =
ds_inf("screen_splitscreen_region:%p destroy", splitscreen_region);
- wl_signal_emit_mutable(&splitscreen_region->events.destroy,
+ wl_signal_emit(&splitscreen_region->events.destroy,
splitscreen_region);
free(splitscreen_region);
ds_inf("Global destroy: screen_rotation(%p)", screen_rotation);
- wl_signal_emit_mutable(&screen_rotation->events.destroy, screen_rotation);
+ wl_signal_emit(&screen_rotation->events.destroy, screen_rotation);
wl_list_remove(&screen_rotation->destroy.link);
wl_global_destroy(screen_rotation->global);
free(screen_rotation);
return;
}
- wl_signal_emit_mutable(&client->screen_rotation->events.get_ignore_output_transfrom, info);
+ wl_signal_emit(&client->screen_rotation->events.get_ignore_output_transfrom, info);
}
static const struct tizen_screen_rotation_interface screen_rotation_impl =
ds_inf("_tizen_screen_rotation_client_handle_destroy (client:%p)", client);
wl_list_for_each_safe(info, tmp, &client->infos, link) {
- wl_signal_emit_mutable(&client->events.destroy, info);
+ wl_signal_emit(&client->events.destroy, info);
wl_list_remove(&info->link);
free(info);
}
if (mirror->resource)
wl_resource_set_destructor(mirror->resource, NULL);
- wl_signal_emit_mutable(&mirror->events.destroy, NULL);
+ wl_signal_emit(&mirror->events.destroy, NULL);
//should be called buffer_dequeued from server(ds_tizen_screenmirror_send_dequeued)
free(mirror);
ds_err("screenmirror create fail : memory alloc failed");
return NULL;
}
-
+
mirror->resource = wl_resource_create(client->client, &tizen_screenmirror_interface,
version, id);
if (mirror->resource == NULL) {
else
ds_stretch = DS_TIZEN_SCREENMIRROR_STRETCH_FULLY;
- wl_signal_emit_mutable(&mirror->events.set_stretch, &ds_stretch);
+ wl_signal_emit(&mirror->events.set_stretch, &ds_stretch);
}
static void
return;
}
- wl_signal_emit_mutable(&mirror->events.queue, &buffer);
+ wl_signal_emit(&mirror->events.queue, &buffer);
}
static void
return;
}
- wl_signal_emit_mutable(&mirror->events.dequeue, &buffer);
+ wl_signal_emit(&mirror->events.dequeue, &buffer);
}
static void
struct ds_tizen_screenmirror *mirror;
mirror = wl_resource_get_user_data(resource);
- wl_signal_emit_mutable(&mirror->events.start, NULL);
+ wl_signal_emit(&mirror->events.start, NULL);
}
static void
struct ds_tizen_screenmirror *mirror;
mirror = wl_resource_get_user_data(resource);
- wl_signal_emit_mutable(&mirror->events.stop, NULL);
+ wl_signal_emit(&mirror->events.stop, NULL);
}
static void
struct ds_tizen_screenmirror *mirror;
mirror = wl_resource_get_user_data(resource);
- wl_signal_emit_mutable(&mirror->events.set_auto_rotation, &set);
+ wl_signal_emit(&mirror->events.set_auto_rotation, &set);
}
static const struct tizen_screenmirror_interface _screenmirror_interface = {
ds_inf("global destroy : tizen_screenshooter(%p)", shot);
- wl_signal_emit_mutable(&shot->events.destroy, shot);
+ wl_signal_emit(&shot->events.destroy, shot);
wl_list_remove(&shot->destroy.link);
wl_global_destroy(shot->global);
free(shot);
if (shot_client->mirror == NULL)
wl_client_post_no_memory(client);
else
- wl_signal_emit_mutable(&shot->events.get_screenmirror, shot_client->mirror);
+ wl_signal_emit(&shot->events.get_screenmirror, shot_client->mirror);
}
static void
.auto_rotation = shot->auto_rotation,
};
- wl_signal_emit_mutable(&shot->events.shoot, &event);
+ wl_signal_emit(&shot->events.shoot, &event);
}
static const struct tizen_screenshooter_interface _tizen_screenshooter_interface =
tbm = wl_container_of(listener, tbm, display_destroy);
- wl_signal_emit_mutable(&tbm->events.destroy, tbm);
+ wl_signal_emit(&tbm->events.destroy, tbm);
wayland_tbm_server_deinit(tbm->wl_tbm);
free(tbm);
if (seat_client)
ds_event.seat = ds_seat_client_get_seat(seat_client);
ds_event.surface = ds_surf;
- wl_signal_emit_mutable(&text_input->events.activate, &ds_event);
+ wl_signal_emit(&text_input->events.activate, &ds_event);
ds_tizen_text_input_send_enter(text_input, ds_surf);
}
seat_client = ds_seat_client_from_resource(seat);
if (seat_client)
ds_event.seat = ds_seat_client_get_seat(seat_client);
- wl_signal_emit_mutable(&text_input->events.deactivate, &ds_event);
+ wl_signal_emit(&text_input->events.deactivate, &ds_event);
ds_tizen_text_input_send_leave(text_input);
}
struct ds_tizen_text_input *text_input = wl_resource_get_user_data(resource);
ds_inf("text_input_handle_reset");
- wl_signal_emit_mutable(&text_input->events.reset, text_input);
+ wl_signal_emit(&text_input->events.reset, text_input);
}
static void
ds_event.purpose = purpose;
ds_event.text_input = text_input;
- wl_signal_emit_mutable(&text_input->events.set_content_type, &ds_event);
+ wl_signal_emit(&text_input->events.set_content_type, &ds_event);
}
static void
ds_event.language = language;
ds_event.text_input = text_input;
- wl_signal_emit_mutable(&text_input->events.set_preferred_language, &ds_event);
+ wl_signal_emit(&text_input->events.set_preferred_language, &ds_event);
}
static void
ds_event.serial = serial;
ds_event.text_input = text_input;
- wl_signal_emit_mutable(&text_input->events.commit_state, &ds_event);
+ wl_signal_emit(&text_input->events.commit_state, &ds_event);
}
static void
ds_event.index = index;
ds_event.text_input = text_input;
- wl_signal_emit_mutable(&text_input->events.invoke_action, &ds_event);
+ wl_signal_emit(&text_input->events.invoke_action, &ds_event);
}
static void
static void
text_input_destroy(struct ds_tizen_text_input *text_input)
{
- wl_signal_emit_mutable(&text_input->events.destroy, text_input);
+ wl_signal_emit(&text_input->events.destroy, text_input);
wl_list_remove(&text_input->link);
free(text_input);
ds_inf("Global destroy: text_input_mgr(%p)", text_input_mgr);
- wl_signal_emit_mutable(&text_input_mgr->events.destroy, text_input_mgr);
+ wl_signal_emit(&text_input_mgr->events.destroy, text_input_mgr);
wl_list_remove(&text_input_mgr->destroy.link);
wl_list_for_each_safe(text_input, tmp, &text_input_mgr->text_inputs, link) {
wl_signal_init(&text_input->events.destroy);
wl_list_insert(&text_input_mgr->text_inputs, &text_input->link);
- wl_signal_emit_mutable(&text_input_mgr->events.new_text_input, text_input);
+ wl_signal_emit(&text_input_mgr->events.new_text_input, text_input);
}
static const struct wl_text_input_manager_interface text_input_mgr_impl =
ds_inf("Destroy ds_tizen_video(%p)", video);
- wl_signal_emit_mutable(&video->events.destroy, video);
+ wl_signal_emit(&video->events.destroy, video);
wl_array_release(&video->formats);
wl_array_release(&video->properties);
prop->name, prop->value);
}
- wl_signal_emit_mutable(&video->events.new_object, object);
+ wl_signal_emit(&video->events.new_object, object);
}
static void
return;
video = wl_resource_get_user_data(resource);
- wl_signal_emit_mutable(&video->events.new_viewport, viewport);
+ wl_signal_emit(&video->events.new_viewport, viewport);
}
static void
.name = name,
.value = value,
};
- wl_signal_emit_mutable(&object->events.request_set_property, &event);
+ wl_signal_emit(&object->events.request_set_property, &event);
}
static void
if (!object)
return;
- wl_signal_emit_mutable(&object->events.request_follow_topmost_visibility, object);
+ wl_signal_emit(&object->events.request_follow_topmost_visibility, object);
}
static void
if (!object)
return;
- wl_signal_emit_mutable(&object->events.request_unfollow_topmost_visibility, object);
+ wl_signal_emit(&object->events.request_unfollow_topmost_visibility, object);
}
static void
if (!object)
return;
- wl_signal_emit_mutable(&object->events.request_attribute_allowed, object);
+ wl_signal_emit(&object->events.request_attribute_allowed, object);
}
static void
if (!object)
return;
- wl_signal_emit_mutable(&object->events.request_attribute_disallowed, object);
+ wl_signal_emit(&object->events.request_attribute_disallowed, object);
}
static const struct tizen_video_object_interface video_object_impl = {
{
ds_inf("Destroy ds_tizen_video_object(%p)", object);
- wl_signal_emit_mutable(&object->events.destroy, object);
+ wl_signal_emit(&object->events.destroy, object);
wl_resource_set_user_data(object->resource, NULL);
}
static void
-viewport_handle_set_destination(struct wl_client *client,
+viewport_handle_set_destination(struct wl_client *client,
struct wl_resource *resource,
int32_t x, int32_t y, uint32_t width, uint32_t height)
{
viewport = wl_resource_get_user_data(resource);
viewport->query_parent_size = true;
- wl_signal_emit_mutable(&viewport->events.query_parent_size, viewport);
+ wl_signal_emit(&viewport->events.query_parent_size, viewport);
}
static void
viewport->current = viewport->pending;
viewport->pending.committed = DS_TIZEN_VIEWPORT_STATE_NONE;
- wl_signal_emit_mutable(&viewport->events.commit, &viewport->current);
+ wl_signal_emit(&viewport->events.commit, &viewport->current);
}
static void
viewport_destroy(struct ds_tizen_viewport *viewport)
{
- wl_signal_emit_mutable(&viewport->events.destroy, viewport);
+ wl_signal_emit(&viewport->events.destroy, viewport);
ds_surface_viewport_release(viewport->surface_viewport);
projects / platform / core / uifw / libds-tizen.git / commitdiff