2012-12-03 Gustavo Sverzut Barbieri (k-s)
- * Add elm_need_edbus(), deprecate elm_need_e_dbus(), integrating
- edbus (v2).
+ * Add elm_need_eldbus(), deprecate elm_need_e_dbus(), integrating
+ eldbus.
2012-12-04 Cedric Bail
* Add elm_genlist_nth_item_get
* Add elm_gengrid_nth_item_get
* Add elm_config_selection_unfocused_clear_get and elm_config_selection_unfocused_clear_set
- * Add elm_need_edbus() and EDBus.h support with ELM_EDBUS2 macro to integrate edbus (v2). Deprecated elm_need_e_dbus() (e_dbus, v1).
+ * Add elm_need_eldbus() and Eldbus.h support with ELM_ELDBUS macro to integrate eldbus. Deprecated elm_need_e_dbus() (e_dbus, v1).
* Add window profile set/get API in elm_win
* Add elm_sys_notify.[ch]
* Add elm_need_elocation() and Elocation.h support with ELM_ELOCATION macro to integrate elocation.
AC_MSG_ERROR([ecore-wayland support requested, but not found by pkg-config.])
fi
-ELM_EDBUS2_DEF="#undef"
-have_elementary_edbus2="no"
-want_elementary_edbus2="auto"
-AC_ARG_ENABLE([edbus2],
- [AC_HELP_STRING([--disable-edbus2], [disable edbus2 support. @<:@default=detect@:>@])],
- [want_elementary_edbus2=$enableval], [])
-
-if test "x$want_elementary_edbus2" != "xno"; then
- PKG_CHECK_MODULES([ELEMENTARY_EDBUS2],
+ELM_ELDBUS_DEF="#undef"
+have_elementary_eldbus="no"
+want_elementary_eldbus="auto"
+AC_ARG_ENABLE([eldbus],
+ [AC_HELP_STRING([--disable-eldbus], [disable eldbus support. @<:@default=detect@:>@])],
+ [want_elementary_eldbus=$enableval], [])
+
+if test "x$want_elementary_eldbus" != "xno"; then
+ PKG_CHECK_MODULES([ELEMENTARY_ELDBUS],
[
- edbus2 >= 1.6.99
+ eldbus >= 1.6.99
],
[
- AC_DEFINE(HAVE_ELEMENTARY_EDBUS2, 1, [EDbus2 support for Elementary])
- have_elementary_edbus2="yes"
- ELM_EDBUS2_DEF="#define"
- requirement_elm="edbus2 >= 1.6.99 ${requirement_elm}"
+ AC_DEFINE(HAVE_ELEMENTARY_ELDBUS, 1, [Eldbus support for Elementary])
+ have_elementary_eldbus="yes"
+ ELM_ELDBUS_DEF="#define"
+ requirement_elm="eldbus >= 1.6.99 ${requirement_elm}"
],
- [have_elementary_edbus2="no"]
+ [have_elementary_eldbus="no"]
)
else
- have_elementary_edbus2="no"
+ have_elementary_eldbus="no"
fi
-if test "x$want_elementary_edbus2" = "xyes" -a "x$have_elementary_edbus2" = "xno"; then
- AC_MSG_ERROR([EDBus (v2) support requested, but no edbus2 found by pkg-config.])
+if test "x$want_elementary_eldbus" = "xyes" -a "x$have_elementary_eldbus" = "xno"; then
+ AC_MSG_ERROR([Eldbus (v2) support requested, but no eldbus found by pkg-config.])
fi
-AC_SUBST(ELM_EDBUS2_DEF)
+AC_SUBST(ELM_ELDBUS_DEF)
ELM_ELOCATION_DEF="#undef"
have_elementary_elocation="no"
have_elementary_elocation="no"
fi
if test "x$want_elementary_elocation" = "xyes" -a "x$have_elementary_elocation" = "xno"; then
- AC_MSG_ERROR([EDBus (v2) support requested, but no elocation found by pkg-config.])
+ AC_MSG_ERROR([Eldbus (v2) support requested, but no elocation found by pkg-config.])
fi
AC_SUBST(ELM_ELOCATION_DEF)
echo " Features:"
echo " Ecore_IMF..............: ${have_ecore_imf}"
echo " Ecore_Con..............: ${have_ecore_con}"
-echo " EDBus..................: v2=${have_elementary_edbus2}"
+echo " Eldbus..................: v2=${have_elementary_eldbus}"
echo " EFreet.................: ${have_elementary_efreet}"
echo " EWeather...............: ${have_elementary_eweather}"
echo " EMap...................: ${have_elementary_emap}"
@ELEMENTARY_FB_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
widget_preview_web \
widget_preview_win
-LDADD = $(top_builddir)/src/lib/libelementary.la @ELEMENTARY_EWEATHER_LIBS@ @ELEMENTARY_EDBUS2_LIBS@ @ELEMENTARY_EFREET_LIBS@ @ELEMENTARY_EMAP_LIBS@ @ELEMENTARY_LIBS@ @EIO_LIBS@ @my_libs@
+LDADD = $(top_builddir)/src/lib/libelementary.la @ELEMENTARY_EWEATHER_LIBS@ @ELEMENTARY_ELDBUS_LIBS@ @ELEMENTARY_EFREET_LIBS@ @ELEMENTARY_EMAP_LIBS@ @ELEMENTARY_LIBS@ @EIO_LIBS@ @my_libs@
endif
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
elementary_test_LDADD = $(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
elementary_config_LDADD = $(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
elementary_codegen_LDADD = \
$(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
elementary_quicklaunch_SOURCES = quicklaunch.c
elementary_quicklaunch_LDADD = $(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
elementary_testql_la_SOURCES = $(elementary_test_SOURCES)
elementary_testql_la_LIBADD = $(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
elementary_testql_SOURCES = $(elementary_test_SOURCES)
elementary_testql_LDADD = $(top_builddir)/src/lib/libelementary.la \
@ELEMENTARY_EWEATHER_LIBS@ \
- @ELEMENTARY_EDBUS2_LIBS@ \
+ @ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_EMAP_LIBS@ \
"Eet",
"Ecore",
"Efreet",
- "Edbus"
+ "Eldbus"
};
win = elm_win_util_standard_add("flipselector", "Flip Selector");
@ELEMENTARY_FB_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_ETHUMB_CFLAGS@ \
-DPACKAGE_DATA_DIR="\"$(pkgdatadir)\"" \
-DPACKAGE_BIN_DIR=\"$(bindir)\" \
-DPACKAGE_LIB_DIR=\"$(libdir)\" \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
"Eet",
"Ecore",
"Efreet",
- "Edbus"
+ "Eldbus"
};
win = elm_win_add(NULL, "flipselector", ELM_WIN_BASIC);
@ELM_UNIX_DEF@ ELM_UNIX
@ELM_WIN32_DEF@ ELM_WIN32
@ELM_WINCE_DEF@ ELM_WINCE
-@ELM_EDBUS2_DEF@ ELM_EDBUS2
+@ELM_ELDBUS_DEF@ ELM_ELDBUS
@ELM_EFREET_DEF@ ELM_EFREET
@ELM_ELOCATION_DEF@ ELM_ELOCATION
@ELM_ETHUMB_DEF@ ELM_ETHUMB
@ELEMENTARY_ECORE_CON_INC@
#include <Edje.h>
-#ifdef ELM_EDBUS2
-#include <EDBus.h>
+#ifdef ELM_ELDBUS
+#include <Eldbus.h>
#endif
#ifdef ELM_EFREET
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ELEMENTARY_SDL_LIBS@ \
@ELEMENTARY_WIN32_LIBS@ \
@ELEMENTARY_WINCE_LIBS@ \
-@ELEMENTARY_EDBUS2_LIBS@ \
+@ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_ETHUMB_LIBS@ \
#include "elm_widget_menu.h"
#include "elm_widget_icon.h"
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
#define DBUS_PATH "/com/canonical/dbusmenu"
#define DBUS_INTERFACE "com.canonical.dbusmenu"
struct _Elm_DBus_Menu
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
Eo *menu;
- EDBus_Connection *bus;
- EDBus_Service_Interface *iface;
+ Eldbus_Connection *bus;
+ Eldbus_Service_Interface *iface;
unsigned timestamp;
Eina_Hash *elements;
Ecore_Idler *signal_idler;
#endif
};
-#ifdef ELM_EDBUS2
-static const EDBus_Service_Interface_Desc _interface;
+#ifdef ELM_ELDBUS
+static const Eldbus_Service_Interface_Desc _interface;
static unsigned last_object_path;
typedef enum _Elm_DBus_Property
{
void (*result_cb)(Eina_Bool, void *);
void *data;
- EDBus_Pending *pending_register;
+ Eldbus_Pending *pending_register;
Ecore_X_Window xid;
};
}
static void
-_app_register_cb(void *data, const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+_app_register_cb(void *data, const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
Elm_DBus_Menu *menu = data;
Callback_Data *cd = menu->app_menu_data;
cd->pending_register = NULL;
- result = !edbus_message_error_get(msg, &error_name, NULL);
- if (!result && !strcmp(error_name, EDBUS_ERROR_PENDING_CANCELED))
+ result = !eldbus_message_error_get(msg, &error_name, NULL);
+ if (!result && !strcmp(error_name, ELDBUS_ERROR_PENDING_CANCELED))
{
DBG("Register canceled");
return;
{
Elm_DBus_Menu *menu = data;
Callback_Data *cd = menu->app_menu_data;
- EDBus_Message *msg;
+ Eldbus_Message *msg;
const char *obj_path;
if (!strcmp(new_id, ""))
{
- if (cd->pending_register) edbus_pending_cancel(cd->pending_register);
+ if (cd->pending_register) eldbus_pending_cancel(cd->pending_register);
if (cd->result_cb) cd->result_cb(EINA_FALSE, cd->data);
}
else
{
- msg = edbus_message_method_call_new(REGISTRAR_NAME, REGISTRAR_PATH,
+ msg = eldbus_message_method_call_new(REGISTRAR_NAME, REGISTRAR_PATH,
REGISTRAR_INTERFACE,
"RegisterWindow");
- obj_path = edbus_service_object_path_get(menu->iface);
- edbus_message_arguments_append(msg, "uo", (unsigned)cd->xid,
+ obj_path = eldbus_service_object_path_get(menu->iface);
+ eldbus_message_arguments_append(msg, "uo", (unsigned)cd->xid,
obj_path);
- cd->pending_register = edbus_connection_send(menu->bus, msg,
+ cd->pending_register = eldbus_connection_send(menu->bus, msg,
_app_register_cb, data, -1);
}
}
{
Elm_DBus_Menu *dbus_menu = data;
- edbus_service_signal_emit(dbus_menu->iface, ELM_DBUS_SIGNAL_LAYOUT_UPDATED,
+ eldbus_service_signal_emit(dbus_menu->iface, ELM_DBUS_SIGNAL_LAYOUT_UPDATED,
dbus_menu->timestamp, 0);
dbus_menu->signal_idler = NULL;
static void
_property_append(Elm_Menu_Item *item,
Elm_DBus_Property property,
- EDBus_Message_Iter *iter)
+ Eldbus_Message_Iter *iter)
{
- EDBus_Message_Iter *variant = NULL;
+ Eldbus_Message_Iter *variant = NULL;
Elm_Object_Item *item_obj = (Elm_Object_Item *)item;
const char *t;
switch (property)
{
case ELM_DBUS_PROPERTY_LABEL:
- variant = edbus_message_iter_container_new(iter, 'v', "s");
+ variant = eldbus_message_iter_container_new(iter, 'v', "s");
t = elm_object_item_part_text_get(item_obj, NULL);
if (!t)
{
if (!t) t = "";
}
- edbus_message_iter_basic_append(variant, 's', t);
+ eldbus_message_iter_basic_append(variant, 's', t);
break;
case ELM_DBUS_PROPERTY_CHILDREN_DISPLAY:
- variant = edbus_message_iter_container_new(iter, 'v', "s");
- edbus_message_iter_basic_append(variant, 's', "submenu");
+ variant = eldbus_message_iter_container_new(iter, 'v', "s");
+ eldbus_message_iter_basic_append(variant, 's', "submenu");
break;
case ELM_DBUS_PROPERTY_ENABLED:
- variant = edbus_message_iter_container_new(iter, 'v', "b");
- edbus_message_iter_basic_append(variant, 'b', EINA_FALSE);
+ variant = eldbus_message_iter_container_new(iter, 'v', "b");
+ eldbus_message_iter_basic_append(variant, 'b', EINA_FALSE);
break;
case ELM_DBUS_PROPERTY_TYPE:
- variant = edbus_message_iter_container_new(iter, 'v', "s");
- edbus_message_iter_basic_append(variant, 's', "separator");
+ variant = eldbus_message_iter_container_new(iter, 'v', "s");
+ eldbus_message_iter_basic_append(variant, 's', "separator");
break;
case ELM_DBUS_PROPERTY_ICON_NAME:
- variant = edbus_message_iter_container_new(iter, 'v', "s");
- edbus_message_iter_basic_append(variant, 's', item->icon_str);
+ variant = eldbus_message_iter_container_new(iter, 'v', "s");
+ eldbus_message_iter_basic_append(variant, 's', item->icon_str);
break;
case ELM_DBUS_PROPERTY_UNKNOWN:
return;
}
- edbus_message_iter_container_close(iter, variant);
+ eldbus_message_iter_container_close(iter, variant);
}
static void
_property_dict_build(Elm_Menu_Item *item,
- Eina_List *property_list, EDBus_Message_Iter *iter)
+ Eina_List *property_list, Eldbus_Message_Iter *iter)
{
char *propstr;
Elm_DBus_Property property;
- EDBus_Message_Iter *array, *pair;
+ Eldbus_Message_Iter *array, *pair;
Eina_List *l;
- array = edbus_message_iter_container_new(iter, 'a', "{sv}");
+ array = eldbus_message_iter_container_new(iter, 'a', "{sv}");
EINA_LIST_FOREACH (property_list, l, propstr)
{
if (property == ELM_DBUS_PROPERTY_UNKNOWN) continue;
if (!_property_exists(item, property)) continue;
- pair = edbus_message_iter_container_new(array, 'e', NULL);
- edbus_message_iter_basic_append(pair, 's', propstr);
+ pair = eldbus_message_iter_container_new(array, 'e', NULL);
+ eldbus_message_iter_basic_append(pair, 's', propstr);
_property_append(item, property, pair);
- edbus_message_iter_container_close(array, pair);
+ eldbus_message_iter_container_close(array, pair);
}
- edbus_message_iter_container_close(iter, array);
+ eldbus_message_iter_container_close(iter, array);
}
static void
_layout_build_recursive(Elm_Menu_Item *item,
Eina_List *property_list, unsigned recursion_depth,
- EDBus_Message_Iter *iter)
+ Eldbus_Message_Iter *iter)
{
Eina_List *l;
Elm_Menu_Item *subitem;
- EDBus_Message_Iter *layout, *array, *variant;
+ Eldbus_Message_Iter *layout, *array, *variant;
- layout = edbus_message_iter_container_new(iter, 'r', NULL);
- edbus_message_iter_basic_append(layout, 'i', item->dbus_idx);
+ layout = eldbus_message_iter_container_new(iter, 'r', NULL);
+ eldbus_message_iter_basic_append(layout, 'i', item->dbus_idx);
_property_dict_build(item, property_list, layout);
- array = edbus_message_iter_container_new(layout, 'a', "v");
+ array = eldbus_message_iter_container_new(layout, 'a', "v");
if (recursion_depth > 0)
{
EINA_LIST_FOREACH (item->submenu.items, l, subitem)
{
- variant = edbus_message_iter_container_new(array, 'v',
+ variant = eldbus_message_iter_container_new(array, 'v',
"(ia{sv}av)");
_layout_build_recursive(subitem, property_list,
recursion_depth - 1, variant);
- edbus_message_iter_container_close(array, variant);
+ eldbus_message_iter_container_close(array, variant);
}
}
- edbus_message_iter_container_close(layout, array);
- edbus_message_iter_container_close(iter, layout);
+ eldbus_message_iter_container_close(layout, array);
+ eldbus_message_iter_container_close(iter, layout);
}
static void
_root_layout_build(Elm_DBus_Menu *dbus_menu, Eina_List *property_list,
- unsigned recursion_depth, EDBus_Message_Iter *iter)
+ unsigned recursion_depth, Eldbus_Message_Iter *iter)
{
char *property;
- EDBus_Message_Iter *layout, *array, *pair, *variant;
+ Eldbus_Message_Iter *layout, *array, *pair, *variant;
const Eina_List *ret = NULL;
Eina_List *items;
Eina_List *l;
Elm_Menu_Item *item;
- layout = edbus_message_iter_container_new(iter, 'r', NULL);
- edbus_message_iter_basic_append(layout, 'i', 0);
- array = edbus_message_iter_container_new(layout, 'a', "{sv}");
+ layout = eldbus_message_iter_container_new(iter, 'r', NULL);
+ eldbus_message_iter_basic_append(layout, 'i', 0);
+ array = eldbus_message_iter_container_new(layout, 'a', "{sv}");
EINA_LIST_FOREACH (property_list, l, property)
{
if (!strcmp(property, "children-display"))
{
- pair = edbus_message_iter_container_new(array, 'e', NULL);
- edbus_message_iter_basic_append(pair, 's', property);
- variant = edbus_message_iter_container_new(pair, 'v', "s");
- edbus_message_iter_basic_append(variant, 's', "submenu");
- edbus_message_iter_container_close(pair, variant);
- edbus_message_iter_container_close(array, pair);
+ pair = eldbus_message_iter_container_new(array, 'e', NULL);
+ eldbus_message_iter_basic_append(pair, 's', property);
+ variant = eldbus_message_iter_container_new(pair, 'v', "s");
+ eldbus_message_iter_basic_append(variant, 's', "submenu");
+ eldbus_message_iter_container_close(pair, variant);
+ eldbus_message_iter_container_close(array, pair);
break;
}
}
- edbus_message_iter_container_close(layout, array);
- array = edbus_message_iter_container_new(layout, 'a', "v");
+ eldbus_message_iter_container_close(layout, array);
+ array = eldbus_message_iter_container_new(layout, 'a', "v");
if (recursion_depth > 0)
{
items = (Eina_List *)ret;
EINA_LIST_FOREACH (items, l, item)
{
- variant = edbus_message_iter_container_new(array, 'v',
+ variant = eldbus_message_iter_container_new(array, 'v',
"(ia{sv}av)");
_layout_build_recursive(item, property_list,
recursion_depth - 1, variant);
- edbus_message_iter_container_close(array, variant);
+ eldbus_message_iter_container_close(array, variant);
}
}
- edbus_message_iter_container_close(layout, array);
- edbus_message_iter_container_close(iter, layout);
+ eldbus_message_iter_container_close(layout, array);
+ eldbus_message_iter_container_close(iter, layout);
}
static Eina_List *
}
static Eina_Bool
-_event_handle(Elm_DBus_Menu *dbus_menu, EDBus_Message_Iter *iter, int *error_id)
+_event_handle(Elm_DBus_Menu *dbus_menu, Eldbus_Message_Iter *iter, int *error_id)
{
Elm_Menu_Item *item;
const char *event;
int id;
int32_t i;
- EDBus_Message_Iter *data;
+ Eldbus_Message_Iter *data;
unsigned *timestamp;
- edbus_message_iter_arguments_get(iter, "isvu", &id, &event, &data,
+ eldbus_message_iter_arguments_get(iter, "isvu", &id, &event, &data,
×tamp);
i = id;
item = eina_hash_find(dbus_menu->elements, &i);
// =============================================================================
// Methods
// =============================================================================
-static EDBus_Message *
-_method_layout_get(const EDBus_Service_Interface *iface,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_layout_get(const Eldbus_Service_Interface *iface,
+ const Eldbus_Message *msg)
{
int parent_id;
int32_t id;
unsigned recursion_depth;
char *property;
Eina_List *property_list = NULL;
- EDBus_Message *reply;
- EDBus_Message_Iter *iter, *array;
+ Eldbus_Message *reply;
+ Eldbus_Message_Iter *iter, *array;
Elm_DBus_Menu *dbus_menu;
Elm_Menu_Item *item = NULL;
- dbus_menu = edbus_service_object_data_get(iface, DBUS_DATA_KEY);
+ dbus_menu = eldbus_service_object_data_get(iface, DBUS_DATA_KEY);
- if (!edbus_message_arguments_get(msg, "iias", &parent_id, &r, &array))
+ if (!eldbus_message_arguments_get(msg, "iias", &parent_id, &r, &array))
ERR("Invalid arguments in D-Bus message");
recursion_depth = r;
- while (edbus_message_iter_get_and_next(array, 's', &property))
+ while (eldbus_message_iter_get_and_next(array, 's', &property))
property_list = eina_list_append(property_list, property);
property_list = _empty_properties_handle(property_list);
item = eina_hash_find(dbus_menu->elements, &id);
if (!item)
{
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Invalid parent");
return reply;
}
}
- reply = edbus_message_method_return_new(msg);
- iter = edbus_message_iter_get(reply);
- edbus_message_iter_basic_append(iter, 'u', dbus_menu->timestamp);
+ reply = eldbus_message_method_return_new(msg);
+ iter = eldbus_message_iter_get(reply);
+ eldbus_message_iter_basic_append(iter, 'u', dbus_menu->timestamp);
if (parent_id)
_layout_build_recursive(item, property_list, recursion_depth, iter);
return reply;
}
-static EDBus_Message *
-_method_group_properties_get(const EDBus_Service_Interface *iface,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_group_properties_get(const Eldbus_Service_Interface *iface,
+ const Eldbus_Message *msg)
{
Eina_Iterator *hash_iter;
- EDBus_Message *reply;
- EDBus_Message_Iter *ids, *property_names;
- EDBus_Message_Iter *iter, *array, *tuple;
+ Eldbus_Message *reply;
+ Eldbus_Message_Iter *ids, *property_names;
+ Eldbus_Message_Iter *iter, *array, *tuple;
Eina_List *property_list = NULL;
Elm_DBus_Menu *dbus_menu;
Elm_Menu_Item *item;
int32_t i;
void *data;
- dbus_menu = edbus_service_object_data_get(iface, DBUS_DATA_KEY);
+ dbus_menu = eldbus_service_object_data_get(iface, DBUS_DATA_KEY);
- if (!edbus_message_arguments_get(msg, "aias", &ids, &property_names))
+ if (!eldbus_message_arguments_get(msg, "aias", &ids, &property_names))
ERR("Invalid arguments in D-Bus message");
- while (edbus_message_iter_get_and_next(property_names, 's', &property))
+ while (eldbus_message_iter_get_and_next(property_names, 's', &property))
property_list = eina_list_append(property_list, property);
property_list = _empty_properties_handle(property_list);
- reply = edbus_message_method_return_new(msg);
- iter = edbus_message_iter_get(reply);
- array = edbus_message_iter_container_new(iter, 'a', "(ia{sv})");
+ reply = eldbus_message_method_return_new(msg);
+ iter = eldbus_message_iter_get(reply);
+ array = eldbus_message_iter_container_new(iter, 'a', "(ia{sv})");
- if (!edbus_message_iter_get_and_next(ids, 'i', &id))
+ if (!eldbus_message_iter_get_and_next(ids, 'i', &id))
{
hash_iter = eina_hash_iterator_data_new(dbus_menu->elements);
while (eina_iterator_next(hash_iter, &data))
{
item = data;
- tuple = edbus_message_iter_container_new(array, 'r', NULL);
- edbus_message_iter_basic_append(tuple, 'i', item->dbus_idx);
+ tuple = eldbus_message_iter_container_new(array, 'r', NULL);
+ eldbus_message_iter_basic_append(tuple, 'i', item->dbus_idx);
_property_dict_build(item, property_list, tuple);
- edbus_message_iter_container_close(array, tuple);
+ eldbus_message_iter_container_close(array, tuple);
}
eina_iterator_free(hash_iter);
item = eina_hash_find(dbus_menu->elements, &i);
if (!item) continue;
- tuple = edbus_message_iter_container_new(array, 'r', NULL);
- edbus_message_iter_basic_append(tuple, 'i', item->dbus_idx);
+ tuple = eldbus_message_iter_container_new(array, 'r', NULL);
+ eldbus_message_iter_basic_append(tuple, 'i', item->dbus_idx);
_property_dict_build(item, property_list, tuple);
- edbus_message_iter_container_close(array, tuple);
+ eldbus_message_iter_container_close(array, tuple);
}
- while (edbus_message_iter_get_and_next(ids, 'i', &id));
+ while (eldbus_message_iter_get_and_next(ids, 'i', &id));
- edbus_message_iter_container_close(iter, array);
+ eldbus_message_iter_container_close(iter, array);
eina_list_free(property_list);
return reply;
}
-static EDBus_Message *
-_method_property_get(const EDBus_Service_Interface *iface,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_property_get(const Eldbus_Service_Interface *iface,
+ const Eldbus_Message *msg)
{
- EDBus_Message *reply;
- EDBus_Message_Iter *iter, *variant;
+ Eldbus_Message *reply;
+ Eldbus_Message_Iter *iter, *variant;
Elm_DBus_Property property;
Elm_DBus_Menu *dbus_menu;
Elm_Menu_Item *item;
int32_t i;
char *name;
- dbus_menu = edbus_service_object_data_get(iface, DBUS_DATA_KEY);
+ dbus_menu = eldbus_service_object_data_get(iface, DBUS_DATA_KEY);
- if (!edbus_message_arguments_get(msg, "is", &id, &name))
+ if (!eldbus_message_arguments_get(msg, "is", &id, &name))
ERR("Invalid arguments in D-Bus message");
property = _str_to_property(name);
if (property == ELM_DBUS_PROPERTY_UNKNOWN)
{
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Property not found");
return reply;
}
if (!id)
{
if (property != ELM_DBUS_PROPERTY_CHILDREN_DISPLAY)
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Property not found");
else
{
- reply = edbus_message_method_return_new(msg);
- iter = edbus_message_iter_get(reply);
- variant = edbus_message_iter_container_new(iter, 'v', "s");
- edbus_message_iter_basic_append(variant, 's', "submenu");
- edbus_message_iter_container_close(iter, variant);
+ reply = eldbus_message_method_return_new(msg);
+ iter = eldbus_message_iter_get(reply);
+ variant = eldbus_message_iter_container_new(iter, 'v', "s");
+ eldbus_message_iter_basic_append(variant, 's', "submenu");
+ eldbus_message_iter_container_close(iter, variant);
}
return reply;
if (!item)
{
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Invalid menu identifier");
return reply;
}
if (!_property_exists(item, property))
{
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Property not found");
return reply;
}
- reply = edbus_message_method_return_new(msg);
- iter = edbus_message_iter_get(reply);
+ reply = eldbus_message_method_return_new(msg);
+ iter = eldbus_message_iter_get(reply);
_property_append(item, property, iter);
return reply;
}
-static EDBus_Message *
-_method_event(const EDBus_Service_Interface *iface,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_event(const Eldbus_Service_Interface *iface,
+ const Eldbus_Message *msg)
{
Elm_DBus_Menu *dbus_menu;
- EDBus_Message *reply;
+ Eldbus_Message *reply;
- reply = edbus_message_method_return_new(msg);
- dbus_menu = edbus_service_object_data_get(iface, DBUS_DATA_KEY);
+ reply = eldbus_message_method_return_new(msg);
+ dbus_menu = eldbus_service_object_data_get(iface, DBUS_DATA_KEY);
- if (!_event_handle(dbus_menu, edbus_message_iter_get(msg), NULL))
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ if (!_event_handle(dbus_menu, eldbus_message_iter_get(msg), NULL))
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Invalid menu");
else
- reply = edbus_message_method_return_new(msg);
+ reply = eldbus_message_method_return_new(msg);
return reply;
}
-static EDBus_Message *
-_method_event_group(const EDBus_Service_Interface *iface,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_event_group(const Eldbus_Service_Interface *iface,
+ const Eldbus_Message *msg)
{
- EDBus_Message *reply;
- EDBus_Message_Iter *iter, *array, *tuple, *errors;
+ Eldbus_Message *reply;
+ Eldbus_Message_Iter *iter, *array, *tuple, *errors;
int id;
Elm_DBus_Menu *dbus_menu;
Eina_Bool return_error = EINA_TRUE;
- dbus_menu = edbus_service_object_data_get(iface, DBUS_DATA_KEY);
+ dbus_menu = eldbus_service_object_data_get(iface, DBUS_DATA_KEY);
- if (!edbus_message_arguments_get(msg, "a(isvu)", &array))
+ if (!eldbus_message_arguments_get(msg, "a(isvu)", &array))
ERR("Invalid arguments in D-Bus message");
- reply = edbus_message_method_return_new(msg);
- iter = edbus_message_iter_get(reply);
- errors = edbus_message_iter_container_new(iter, 'a', "i");
+ reply = eldbus_message_method_return_new(msg);
+ iter = eldbus_message_iter_get(reply);
+ errors = eldbus_message_iter_container_new(iter, 'a', "i");
- while (edbus_message_iter_get_and_next(array, 'r', &tuple))
+ while (eldbus_message_iter_get_and_next(array, 'r', &tuple))
{
if (_event_handle(dbus_menu, tuple, &id))
return_error = EINA_FALSE;
else
- edbus_message_iter_basic_append(errors, 'i', id);
+ eldbus_message_iter_basic_append(errors, 'i', id);
}
if (return_error)
{
- edbus_message_unref(reply);
- reply = edbus_message_error_new(msg, DBUS_INTERFACE ".Error",
+ eldbus_message_unref(reply);
+ reply = eldbus_message_error_new(msg, DBUS_INTERFACE ".Error",
"Invalid menu identifiers");
}
else
- edbus_message_iter_container_close(iter, errors);
+ eldbus_message_iter_container_close(iter, errors);
return reply;
}
-static EDBus_Message *
-_method_about_to_show(const EDBus_Service_Interface *iface EINA_UNUSED,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_about_to_show(const Eldbus_Service_Interface *iface EINA_UNUSED,
+ const Eldbus_Message *msg)
{
- EDBus_Message *reply = edbus_message_method_return_new(msg);
- edbus_message_arguments_append(reply, "b", EINA_TRUE);
+ Eldbus_Message *reply = eldbus_message_method_return_new(msg);
+ eldbus_message_arguments_append(reply, "b", EINA_TRUE);
return reply;
}
-static EDBus_Message *
-_method_about_to_show_group(const EDBus_Service_Interface *iface EINA_UNUSED,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_method_about_to_show_group(const Eldbus_Service_Interface *iface EINA_UNUSED,
+ const Eldbus_Message *msg)
{
- EDBus_Message *reply = edbus_message_method_return_new(msg);
- EDBus_Message_Iter *iter, *array;
+ Eldbus_Message *reply = eldbus_message_method_return_new(msg);
+ Eldbus_Message_Iter *iter, *array;
- iter = edbus_message_iter_get(reply);
- array = edbus_message_iter_container_new(iter, 'a', "i");
- edbus_message_iter_container_close(iter, array);
- array = edbus_message_iter_container_new(iter, 'a', "i");
- edbus_message_iter_container_close(iter, array);
+ iter = eldbus_message_iter_get(reply);
+ array = eldbus_message_iter_container_new(iter, 'a', "i");
+ eldbus_message_iter_container_close(iter, array);
+ array = eldbus_message_iter_container_new(iter, 'a', "i");
+ eldbus_message_iter_container_close(iter, array);
return reply;
}
-static const EDBus_Method _methods[] = {
+static const Eldbus_Method _methods[] = {
{
"GetLayout",
- EDBUS_ARGS({"i", "parentId"},
+ ELDBUS_ARGS({"i", "parentId"},
{"i", "recursionDepth"},
{"as", "propertyNames"}),
- EDBUS_ARGS({"u", "revision"}, {"(ia{sv}av)", "layout"}),
+ ELDBUS_ARGS({"u", "revision"}, {"(ia{sv}av)", "layout"}),
_method_layout_get,
0
},
{
"GetGroupProperties",
- EDBUS_ARGS({"ai", "ids"}, {"as", "propertyNames"}),
- EDBUS_ARGS({"a(ia{sv})", "properties"}),
+ ELDBUS_ARGS({"ai", "ids"}, {"as", "propertyNames"}),
+ ELDBUS_ARGS({"a(ia{sv})", "properties"}),
_method_group_properties_get,
0
},
{
"GetProperty",
- EDBUS_ARGS({"i", "id"}, {"s", "name"}),
- EDBUS_ARGS({"v", "value"}),
+ ELDBUS_ARGS({"i", "id"}, {"s", "name"}),
+ ELDBUS_ARGS({"v", "value"}),
_method_property_get,
0
},
{
"Event",
- EDBUS_ARGS({"i", "id"},
+ ELDBUS_ARGS({"i", "id"},
{"s", "eventId"},
{"v", "data"},
{"u", "timestamp"}),
},
{
"EventGroup",
- EDBUS_ARGS({"a(isvu)", "events"}),
- EDBUS_ARGS({"ai", "idErrors"}),
+ ELDBUS_ARGS({"a(isvu)", "events"}),
+ ELDBUS_ARGS({"ai", "idErrors"}),
_method_event_group,
0
},
{
"AboutToShow",
- EDBUS_ARGS({"i", "id"}),
- EDBUS_ARGS({"b", "needUpdate"}),
+ ELDBUS_ARGS({"i", "id"}),
+ ELDBUS_ARGS({"b", "needUpdate"}),
_method_about_to_show,
0
},
{
"AboutToShowGroup",
- EDBUS_ARGS({"ai", "ids"}),
- EDBUS_ARGS({"ai", "updatesNeeded"}, {"ai", "idErrors"}),
+ ELDBUS_ARGS({"ai", "ids"}),
+ ELDBUS_ARGS({"ai", "updatesNeeded"}, {"ai", "idErrors"}),
_method_about_to_show_group,
0
},
// =============================================================================
// Signals
// =============================================================================
-static const EDBus_Signal _signals[] = {
+static const Eldbus_Signal _signals[] = {
[ELM_DBUS_SIGNAL_LAYOUT_UPDATED] = {
- "LayoutUpdated", EDBUS_ARGS({"u", "revision"}, {"i", "parent"}), 0
+ "LayoutUpdated", ELDBUS_ARGS({"u", "revision"}, {"i", "parent"}), 0
},
[ELM_DBUS_SIGNAL_ITEM_ACTIVATION_REQUESTED] = {
- "ItemActivationRequested", EDBUS_ARGS({"i", "id"}, {"u", "timestamp"}), 0
+ "ItemActivationRequested", ELDBUS_ARGS({"i", "id"}, {"u", "timestamp"}), 0
},
{NULL, NULL, 0}
};
// Properties
// =============================================================================
static Eina_Bool
-_prop_version_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_version_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- edbus_message_iter_basic_append(iter, 'u', DBUS_MENU_VERSION);
+ eldbus_message_iter_basic_append(iter, 'u', DBUS_MENU_VERSION);
return EINA_TRUE;
}
static Eina_Bool
-_prop_text_direction_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_text_direction_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
if (_elm_config->is_mirrored)
- edbus_message_iter_basic_append(iter, 's', "rtl");
+ eldbus_message_iter_basic_append(iter, 's', "rtl");
else
- edbus_message_iter_basic_append(iter, 's', "ltr");
+ eldbus_message_iter_basic_append(iter, 's', "ltr");
return EINA_TRUE;
}
static Eina_Bool
-_prop_status_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_status_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
static const char *normal = "normal";
- edbus_message_iter_basic_append(iter, 's', normal);
+ eldbus_message_iter_basic_append(iter, 's', normal);
return EINA_TRUE;
}
static Eina_Bool
-_prop_icon_theme_path_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_icon_theme_path_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- EDBus_Message_Iter *actions;
- edbus_message_iter_arguments_append(iter, "as", &actions);
- edbus_message_iter_arguments_append(actions, "s", ICON_DIR);
- edbus_message_iter_container_close(iter, actions);
+ Eldbus_Message_Iter *actions;
+ eldbus_message_iter_arguments_append(iter, "as", &actions);
+ eldbus_message_iter_arguments_append(actions, "s", ICON_DIR);
+ eldbus_message_iter_container_close(iter, actions);
return EINA_TRUE;
}
-static const EDBus_Property _properties[] = {
+static const Eldbus_Property _properties[] = {
{ "Version", "u", _prop_version_get, NULL, 0 },
{ "TextDirection", "s", _prop_text_direction_get, NULL, 0 },
{ "Status", "s", _prop_status_get, NULL, 0 },
{ NULL, NULL, NULL, NULL, 0 },
};
-static const EDBus_Service_Interface_Desc _interface = {
+static const Eldbus_Service_Interface_Desc _interface = {
DBUS_INTERFACE, _methods, _signals, _properties, NULL, NULL
};
// =============================================================================
ELM_MENU_CHECK(obj) NULL;
ELM_MENU_DATA_GET(obj, sd);
- elm_need_edbus();
+ elm_need_eldbus();
if (sd->dbus_menu)
goto end;
sd->dbus_menu = _elm_dbus_menu_add(obj);
- sd->dbus_menu->bus = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
+ sd->dbus_menu->bus = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
snprintf(buf, sizeof(buf), "%s/%u", DBUS_PATH, ++last_object_path);
- sd->dbus_menu->iface = edbus_service_interface_register(sd->dbus_menu->bus,
+ sd->dbus_menu->iface = eldbus_service_interface_register(sd->dbus_menu->bus,
buf,
&_interface);
- edbus_service_object_data_set(sd->dbus_menu->iface, DBUS_DATA_KEY,
+ eldbus_service_object_data_set(sd->dbus_menu->iface, DBUS_DATA_KEY,
sd->dbus_menu);
end:
- return edbus_service_object_path_get(sd->dbus_menu->iface);
+ return eldbus_service_object_path_get(sd->dbus_menu->iface);
}
void
if (sd->dbus_menu->app_menu_data)
_elm_dbus_menu_app_menu_unregister(obj);
- edbus_service_interface_unregister(sd->dbus_menu->iface);
- edbus_connection_unref(sd->dbus_menu->bus);
+ eldbus_service_interface_unregister(sd->dbus_menu->iface);
+ eldbus_connection_unref(sd->dbus_menu->bus);
if (sd->dbus_menu->signal_idler)
ecore_idler_del(sd->dbus_menu->signal_idler);
cd->data = data;
cd->pending_register = NULL;
cd->xid = xid;
- edbus_name_owner_changed_callback_add(sd->dbus_menu->bus, REGISTRAR_NAME,
+ eldbus_name_owner_changed_callback_add(sd->dbus_menu->bus, REGISTRAR_NAME,
_app_menu_watch_cb, sd->dbus_menu,
EINA_TRUE);
}
void
_elm_dbus_menu_app_menu_unregister(Eo *obj)
{
- EDBus_Message *msg;
+ Eldbus_Message *msg;
Callback_Data *cd;
ELM_MENU_CHECK(obj);
if (!cd) return;
if (cd->pending_register)
- edbus_pending_cancel(cd->pending_register);
+ eldbus_pending_cancel(cd->pending_register);
- msg = edbus_message_method_call_new(REGISTRAR_NAME, REGISTRAR_PATH,
+ msg = eldbus_message_method_call_new(REGISTRAR_NAME, REGISTRAR_PATH,
REGISTRAR_INTERFACE, "UnregisterWindow");
- edbus_message_arguments_append(msg, "u", (unsigned)cd->xid);
- edbus_connection_send(sd->dbus_menu->bus, msg, NULL, NULL, -1);
- edbus_name_owner_changed_callback_del(sd->dbus_menu->bus, REGISTRAR_NAME,
+ eldbus_message_arguments_append(msg, "u", (unsigned)cd->xid);
+ eldbus_connection_send(sd->dbus_menu->bus, msg, NULL, NULL, -1);
+ eldbus_name_owner_changed_callback_del(sd->dbus_menu->bus, REGISTRAR_NAME,
_app_menu_watch_cb, sd->dbus_menu);
free(cd);
sd->dbus_menu->app_menu_data = NULL;
int (*init_func)(void) = NULL;
if (_elm_need_e_dbus) return EINA_TRUE;
- /* We use RTLD_NOLOAD when available, so we are sure to use the 'libedbus' that was linked to the binary */
+ /* We use RTLD_NOLOAD when available, so we are sure to use the 'libeldbus' that was linked to the binary */
#ifndef RTLD_NOLOAD
# define RTLD_NOLOAD RTLD_GLOBAL
#endif
- if (!e_dbus_handle) e_dbus_handle = dlopen("libedbus.so", RTLD_LAZY | RTLD_NOLOAD);
+ if (!e_dbus_handle) e_dbus_handle = dlopen("libeldbus.so", RTLD_LAZY | RTLD_NOLOAD);
if (!e_dbus_handle) return EINA_FALSE;
init_func = dlsym(e_dbus_handle, "e_dbus_init");
if (!init_func) return EINA_FALSE;
e_dbus_handle = NULL;
}
-#ifdef ELM_EDBUS2
-static Eina_Bool _elm_need_edbus = EINA_FALSE;
+#ifdef ELM_ELDBUS
+static Eina_Bool _elm_need_eldbus = EINA_FALSE;
#endif
EAPI Eina_Bool
-elm_need_edbus(void)
+elm_need_eldbus(void)
{
-#ifdef ELM_EDBUS2
- if (_elm_need_edbus) return EINA_TRUE;
- _elm_need_edbus = EINA_TRUE;
- edbus_init();
+#ifdef ELM_ELDBUS
+ if (_elm_need_eldbus) return EINA_TRUE;
+ _elm_need_eldbus = EINA_TRUE;
+ eldbus_init();
return EINA_TRUE;
#else
return EINA_FALSE;
}
static void
-_elm_unneed_edbus(void)
+_elm_unneed_eldbus(void)
{
-#ifdef ELM_EDBUS2
- if (!_elm_need_edbus) return;
- _elm_need_edbus = EINA_FALSE;
- edbus_shutdown();
+#ifdef ELM_ELDBUS
+ if (!_elm_need_eldbus) return;
+ _elm_need_eldbus = EINA_FALSE;
+ eldbus_shutdown();
#endif
}
#ifdef ELM_ELOCATION
if (!_elm_need_elocation) return;
_elm_need_elocation = EINA_FALSE;
- edbus_shutdown();
+ eldbus_shutdown();
#endif
}
_elm_unneed_sys_notify();
_elm_unneed_efreet();
_elm_unneed_e_dbus();
- _elm_unneed_edbus();
+ _elm_unneed_eldbus();
_elm_unneed_elocation();
_elm_unneed_ethumb();
_elm_unneed_web();
*
* @return EINA_TRUE if support exists and initialization succeeded.
*
- * @deprecated use elm_need_edbus() for EDBus (v2) support. Old API is
+ * @deprecated use elm_need_eldbus() for Eldbus (v2) support. Old API is
* deprecated.
*
* @ingroup E_dbus
EAPI Eina_Bool elm_need_e_dbus(void) EINA_DEPRECATED;
/**
- * Request that your elementary application needs edbus
+ * Request that your elementary application needs eldbus
*
- * This initializes the edbus (aka v2) library when called and if
+ * This initializes the eldbus (aka v2) library when called and if
* support exists it returns EINA_TRUE, otherwise returns
- * EINA_FALSE. This must be called before any edbus calls.
+ * EINA_FALSE. This must be called before any eldbus calls.
*
* @return EINA_TRUE if support exists and initialization succeeded.
*
* @since 1.8.0
*
- * @ingroup edbus
+ * @ingroup eldbus
*/
-EAPI Eina_Bool elm_need_edbus(void);
+EAPI Eina_Bool elm_need_eldbus(void);
/**
* Request that your elementary application needs elocation
*
* @since 1.8.0
*
- * @ingroup edbus
+ * @ingroup eldbus
*/
EAPI Eina_Bool elm_need_elocation(void);
EAPI int ELM_EVENT_SYS_NOTIFY_NOTIFICATION_CLOSED = 0;
EAPI int ELM_EVENT_SYS_NOTIFY_ACTION_INVOKED = 0;
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
static Eina_Bool _elm_need_sys_notify = EINA_FALSE;
-static EDBus_Connection *_elm_sysnotif_conn = NULL;
-static EDBus_Object *_elm_sysnotif_obj = NULL;
-static EDBus_Proxy *_elm_sysnotif_proxy = NULL;
+static Eldbus_Connection *_elm_sysnotif_conn = NULL;
+static Eldbus_Object *_elm_sysnotif_obj = NULL;
+static Eldbus_Proxy *_elm_sysnotif_proxy = NULL;
static Eina_Bool _has_markup = EINA_FALSE;
} Elm_Sys_Notify_Send_Data;
static void
-_elm_sys_notify_marshal_dict_byte(EDBus_Message_Iter *array,
+_elm_sys_notify_marshal_dict_byte(Eldbus_Message_Iter *array,
const char *key,
const char value)
{
- EDBus_Message_Iter *var, *entry;
+ Eldbus_Message_Iter *var, *entry;
- edbus_message_iter_arguments_append(array, "{sv}", &entry);
- edbus_message_iter_basic_append(entry, 's', key);
+ eldbus_message_iter_arguments_append(array, "{sv}", &entry);
+ eldbus_message_iter_basic_append(entry, 's', key);
- var = edbus_message_iter_container_new(entry, 'v', "y");
- edbus_message_iter_basic_append(var, 'y', value);
- edbus_message_iter_container_close(entry, var);
- edbus_message_iter_container_close(array, entry);
+ var = eldbus_message_iter_container_new(entry, 'v', "y");
+ eldbus_message_iter_basic_append(var, 'y', value);
+ eldbus_message_iter_container_close(entry, var);
+ eldbus_message_iter_container_close(array, entry);
}
static void
-_elm_sys_notify_marshal_dict_string(EDBus_Message_Iter *array,
+_elm_sys_notify_marshal_dict_string(Eldbus_Message_Iter *array,
const char *key,
const char *value)
{
- EDBus_Message_Iter *var, *entry;
+ Eldbus_Message_Iter *var, *entry;
- edbus_message_iter_arguments_append(array, "{sv}", &entry);
- edbus_message_iter_basic_append(entry, 's', key);
+ eldbus_message_iter_arguments_append(array, "{sv}", &entry);
+ eldbus_message_iter_basic_append(entry, 's', key);
- var = edbus_message_iter_container_new(entry, 'v', "s");
- edbus_message_iter_basic_append(var, 's', value);
- edbus_message_iter_container_close(entry, var);
- edbus_message_iter_container_close(array, entry);
+ var = eldbus_message_iter_container_new(entry, 'v', "s");
+ eldbus_message_iter_basic_append(var, 's', value);
+ eldbus_message_iter_container_close(entry, var);
+ eldbus_message_iter_container_close(array, entry);
}
static void
_get_capabilities_cb(void *data EINA_UNUSED,
- const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+ const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
char *val;
- EDBus_Message_Iter *arr;
+ Eldbus_Message_Iter *arr;
- if (edbus_message_error_get(msg, NULL, NULL) ||
- !edbus_message_arguments_get(msg, "as", &arr)) goto end;
+ if (eldbus_message_error_get(msg, NULL, NULL) ||
+ !eldbus_message_arguments_get(msg, "as", &arr)) goto end;
- while(edbus_message_iter_get_and_next(arr, 's', &val))
+ while(eldbus_message_iter_get_and_next(arr, 's', &val))
if (!strcmp(val, "body-markup"))
{
_has_markup = EINA_TRUE;
{
EINA_SAFETY_ON_NULL_RETURN(_elm_sysnotif_proxy);
- if (!edbus_proxy_call(_elm_sysnotif_proxy, "GetCapabilities",
+ if (!eldbus_proxy_call(_elm_sysnotif_proxy, "GetCapabilities",
_get_capabilities_cb, NULL, -1, ""))
ERR("Error sending message: "INTERFACE".GetCapabilities.");
}
static void
_close_notification_cb(void *data EINA_UNUSED,
- const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+ const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
const char *errname, *errmsg;
- if (edbus_message_error_get(msg, &errname, &errmsg))
+ if (eldbus_message_error_get(msg, &errname, &errmsg))
{
if (errmsg && errmsg[0] == '\0')
INF("Notification no longer exists.");
else
- ERR("Edbus Error: %s %s", errname, errmsg);
+ ERR("Eldbus Error: %s %s", errname, errmsg);
}
}
#endif
EAPI void
elm_sys_notify_close(unsigned int id)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
EINA_SAFETY_ON_FALSE_RETURN(_elm_need_sys_notify);
EINA_SAFETY_ON_NULL_RETURN(_elm_sysnotif_proxy);
- if (!edbus_proxy_call(_elm_sysnotif_proxy, "CloseNotification",
+ if (!eldbus_proxy_call(_elm_sysnotif_proxy, "CloseNotification",
_close_notification_cb, NULL, -1, "u", id))
ERR("Error sending message: "INTERFACE".CloseNotification.");
#else
#endif
}
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
static void
_notify_cb(void *data,
- const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+ const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
const char *errname, *errmsg;
Elm_Sys_Notify_Send_Data *d = data;
unsigned int id = 0;
- if (edbus_message_error_get(msg, &errname, &errmsg))
+ if (eldbus_message_error_get(msg, &errname, &errmsg))
ERR("Error: %s %s", errname, errmsg);
- else if (!edbus_message_arguments_get(msg, "u", &id))
+ else if (!eldbus_message_arguments_get(msg, "u", &id))
{
ERR("Error getting return values of "INTERFACE".Notify.");
id = 0;
Elm_Sys_Notify_Urgency urgency, int timeout,
Elm_Sys_Notify_Send_Cb cb, const void *cb_data)
{
-#ifdef ELM_EDBUS2
- EDBus_Message *msg;
- EDBus_Message_Iter *iter, *actions, *hints;
+#ifdef ELM_ELDBUS
+ Eldbus_Message *msg;
+ Eldbus_Message_Iter *iter, *actions, *hints;
Elm_Sys_Notify_Send_Data *data;
char *body_free = NULL;
char *desk_free = NULL;
else if (!_has_markup)
body = body_free = elm_entry_markup_to_utf8(body);
- msg = edbus_proxy_method_call_new(_elm_sysnotif_proxy, "Notify");
+ msg = eldbus_proxy_method_call_new(_elm_sysnotif_proxy, "Notify");
- iter = edbus_message_iter_get(msg);
- edbus_message_iter_arguments_append(iter, "susssas", appname, replaces_id,
+ iter = eldbus_message_iter_get(msg);
+ eldbus_message_iter_arguments_append(iter, "susssas", appname, replaces_id,
icon, summary, body, &actions);
/* actions */
- edbus_message_iter_container_close(iter, actions);
+ eldbus_message_iter_container_close(iter, actions);
/* hints */
- edbus_message_iter_arguments_append(iter, "a{sv}", &hints);
+ eldbus_message_iter_arguments_append(iter, "a{sv}", &hints);
_elm_sys_notify_marshal_dict_byte(hints, "urgency", (char) urgency);
if (strcmp(deskentry, ""))
deskentry = desk_free = ecore_file_strip_ext(deskentry);
_elm_sys_notify_marshal_dict_string(hints, "desktop_entry", deskentry);
}
- edbus_message_iter_container_close(iter, hints);
+ eldbus_message_iter_container_close(iter, hints);
/* timeout */
- edbus_message_iter_arguments_append(iter, "i", timeout);
+ eldbus_message_iter_arguments_append(iter, "i", timeout);
- edbus_proxy_send(_elm_sysnotif_proxy, msg, _notify_cb, data, -1);
+ eldbus_proxy_send(_elm_sysnotif_proxy, msg, _notify_cb, data, -1);
free(desk_free);
free(body_free);
return;
if (cb) cb((void *)cb_data, 0);
}
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
static void
_on_notification_closed(void *data EINA_UNUSED,
- const EDBus_Message *msg)
+ const Eldbus_Message *msg)
{
const char *errname;
const char *errmsg;
Elm_Sys_Notify_Notification_Closed *d;
- if (edbus_message_error_get(msg, &errname, &errmsg))
+ if (eldbus_message_error_get(msg, &errname, &errmsg))
{
- ERR("Edbus Error: %s %s", errname, errmsg);
+ ERR("Eldbus Error: %s %s", errname, errmsg);
return;
}
d = malloc(sizeof(*d));
- if (!edbus_message_arguments_get(msg, "uu", &(d->id), &(d->reason)))
+ if (!eldbus_message_arguments_get(msg, "uu", &(d->id), &(d->reason)))
{
ERR("Error processing signal: "INTERFACE".NotificationClosed.");
goto cleanup;
static void
_on_action_invoked(void *data EINA_UNUSED,
- const EDBus_Message *msg)
+ const Eldbus_Message *msg)
{
const char *errname;
const char *aux;
Elm_Sys_Notify_Action_Invoked *d;
- if (edbus_message_error_get(msg, &errname, &aux))
+ if (eldbus_message_error_get(msg, &errname, &aux))
{
- ERR("Edbus Error: %s %s", errname, aux);
+ ERR("Eldbus Error: %s %s", errname, aux);
return;
}
d = malloc(sizeof(*d));
- if (!edbus_message_arguments_get(msg, "us", &(d->id), &aux))
+ if (!eldbus_message_arguments_get(msg, "us", &(d->id), &aux))
{
ERR("Error processing signal: "INTERFACE".ActionInvoked.");
goto cleanup;
{
if (_elm_sysnotif_proxy)
{
- edbus_proxy_unref(_elm_sysnotif_proxy);
+ eldbus_proxy_unref(_elm_sysnotif_proxy);
_elm_sysnotif_proxy = NULL;
}
if (_elm_sysnotif_obj)
{
- edbus_object_unref(_elm_sysnotif_obj);
+ eldbus_object_unref(_elm_sysnotif_obj);
_elm_sysnotif_obj = NULL;
}
}
_update(void)
{
_release();
- _elm_sysnotif_obj = edbus_object_get(_elm_sysnotif_conn, BUS, OBJ);
- _elm_sysnotif_proxy = edbus_proxy_get(_elm_sysnotif_obj, INTERFACE);
+ _elm_sysnotif_obj = eldbus_object_get(_elm_sysnotif_conn, BUS, OBJ);
+ _elm_sysnotif_proxy = eldbus_proxy_get(_elm_sysnotif_obj, INTERFACE);
_elm_sys_notify_capabilities_get();
- edbus_proxy_signal_handler_add(_elm_sysnotif_proxy, "NotificationClosed",
+ eldbus_proxy_signal_handler_add(_elm_sysnotif_proxy, "NotificationClosed",
_on_notification_closed, NULL);
- edbus_proxy_signal_handler_add(_elm_sysnotif_proxy, "ActionInvoked",
+ eldbus_proxy_signal_handler_add(_elm_sysnotif_proxy, "ActionInvoked",
_on_action_invoked, NULL);
}
static void
_name_owner_get_cb(void *data EINA_UNUSED,
- const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+ const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
const char *errname, *errmsg;
- if (edbus_message_error_get(msg, &errname, &errmsg))
- ERR("Edbus Error: %s %s", errname, errmsg);
+ if (eldbus_message_error_get(msg, &errname, &errmsg))
+ ERR("Eldbus Error: %s %s", errname, errmsg);
else
_update();
}
EAPI Eina_Bool
elm_need_sys_notify(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (_elm_need_sys_notify) return EINA_TRUE;
- if (!elm_need_edbus()) return EINA_FALSE;
+ if (!elm_need_eldbus()) return EINA_FALSE;
if (!ELM_EVENT_SYS_NOTIFY_NOTIFICATION_CLOSED)
ELM_EVENT_SYS_NOTIFY_NOTIFICATION_CLOSED = ecore_event_type_new();
if (!ELM_EVENT_SYS_NOTIFY_ACTION_INVOKED)
ELM_EVENT_SYS_NOTIFY_ACTION_INVOKED = ecore_event_type_new();
- _elm_sysnotif_conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
+ _elm_sysnotif_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
- edbus_name_owner_changed_callback_add(_elm_sysnotif_conn, BUS,
+ eldbus_name_owner_changed_callback_add(_elm_sysnotif_conn, BUS,
_name_owner_changed_cb, NULL,
EINA_FALSE);
- edbus_name_owner_get(_elm_sysnotif_conn, BUS, _name_owner_get_cb, NULL);
+ eldbus_name_owner_get(_elm_sysnotif_conn, BUS, _name_owner_get_cb, NULL);
_elm_need_sys_notify = EINA_TRUE;
void
_elm_unneed_sys_notify(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (!_elm_need_sys_notify) return;
_elm_need_sys_notify = EINA_FALSE;
_release();
- edbus_connection_unref(_elm_sysnotif_conn);
+ eldbus_connection_unref(_elm_sysnotif_conn);
_elm_sysnotif_conn = NULL;
#endif
}
.menu_obj = NULL
};
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
#define OBJ_PATH "/org/ayatana/NotificationItem/StatusNotifierItem"
#define INTERFACE "org.kde.StatusNotifierItem"
static Eina_Bool _elm_need_systray = EINA_FALSE;
-static EDBus_Connection *_conn = NULL;
-static EDBus_Service_Interface *_iface = NULL;
+static Eldbus_Connection *_conn = NULL;
+static Eldbus_Service_Interface *_iface = NULL;
static const char *_Elm_Systray_Cat_Str[] = {
[ELM_SYSTRAY_CATEGORY_APP_STATUS] = "ApplicationStatus",
// =============================================================================
// Methods
// =============================================================================
-static EDBus_Message *
-_empty_method(const EDBus_Service_Interface *iface EINA_UNUSED,
- const EDBus_Message *msg)
+static Eldbus_Message *
+_empty_method(const Eldbus_Service_Interface *iface EINA_UNUSED,
+ const Eldbus_Message *msg)
{
- return edbus_message_method_return_new(msg);
+ return eldbus_message_method_return_new(msg);
}
-static const EDBus_Method methods[] = {
+static const Eldbus_Method methods[] = {
{
"Scroll",
- EDBUS_ARGS({"i", "delta"}, {"s", "orientation"}),
+ ELDBUS_ARGS({"i", "delta"}, {"s", "orientation"}),
NULL,
_empty_method,
0
},
{
"SecondaryActivate",
- EDBUS_ARGS({"i", "x"}, {"i", "y"}),
+ ELDBUS_ARGS({"i", "x"}, {"i", "y"}),
NULL,
_empty_method,
0
},
{
"XAyatanaSecondaryActivate",
- EDBUS_ARGS({"u", "timestamp"}),
+ ELDBUS_ARGS({"u", "timestamp"}),
NULL,
_empty_method,
0
} Elm_Systray_Service_Signals;
#define _elm_systray_signal_emit(sig, ...) \
- edbus_service_signal_emit(_iface, sig, __VA_ARGS__)
+ eldbus_service_signal_emit(_iface, sig, __VA_ARGS__)
-static const EDBus_Signal signals[] = {
+static const Eldbus_Signal signals[] = {
[ELM_SYSTRAY_SIGNAL_NEWATTENTIONICON] = {
"NewAttentionIcon", NULL, 0
},
"NewIcon", NULL, 0
},
[ELM_SYSTRAY_SIGNAL_NEWICONTHEMEPATH] = {
- "NewIconThemePath", EDBUS_ARGS({"s", "icon_theme_path"}), 0
+ "NewIconThemePath", ELDBUS_ARGS({"s", "icon_theme_path"}), 0
},
[ELM_SYSTRAY_SIGNAL_NEWSTATUS] = {
- "NewStatus", EDBUS_ARGS({"s", "status"}), 0
+ "NewStatus", ELDBUS_ARGS({"s", "status"}), 0
},
[ELM_SYSTRAY_SIGNAL_NEWTITLE] = {
"NewTitle", NULL, 0
},
[ELM_SYSTRAY_SIGNAL_XAYATANANEWLABEL] = {
- "XAyatanaNewLabel", EDBUS_ARGS({"s", "label"}, {"s", "guide"}), 0
+ "XAyatanaNewLabel", ELDBUS_ARGS({"s", "label"}, {"s", "guide"}), 0
},
{ NULL, NULL, 0 }
};
// Properties
// =============================================================================
static Eina_Bool
-_prop_str_empty_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_str_empty_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- edbus_message_iter_basic_append(iter, 's', "");
+ eldbus_message_iter_basic_append(iter, 's', "");
return EINA_TRUE;
}
static Eina_Bool
-_prop_attention_icon_name_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_attention_icon_name_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.att_icon_name ? _item.att_icon_name : "";
- edbus_message_iter_basic_append(iter, 's', s);
+ eldbus_message_iter_basic_append(iter, 's', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_category_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_category_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- edbus_message_iter_basic_append(iter, 's', _Elm_Systray_Cat_Str[_item.cat]);
+ eldbus_message_iter_basic_append(iter, 's', _Elm_Systray_Cat_Str[_item.cat]);
return EINA_TRUE;
}
static Eina_Bool
-_prop_icon_name_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_icon_name_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.icon_name ? _item.icon_name : "";
- edbus_message_iter_basic_append(iter, 's', s);
+ eldbus_message_iter_basic_append(iter, 's', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_icon_theme_path_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_icon_theme_path_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.icon_theme_path ? _item.icon_theme_path : "";
- edbus_message_iter_basic_append(iter, 's', s);
+ eldbus_message_iter_basic_append(iter, 's', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_id_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_id_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.id ? _item.id : "";
- edbus_message_iter_basic_append(iter, 's', s);
+ eldbus_message_iter_basic_append(iter, 's', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_menu_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_menu_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.menu ? _item.menu : "/";
- edbus_message_iter_basic_append(iter, 'o', s);
+ eldbus_message_iter_basic_append(iter, 'o', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_status_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_status_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- edbus_message_iter_basic_append(iter, 's',
+ eldbus_message_iter_basic_append(iter, 's',
_Elm_Systray_Status_Str[_item.status]);
return EINA_TRUE;
}
static Eina_Bool
-_prop_title_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_title_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
const char *s = _item.title ? _item.title : "";
- edbus_message_iter_basic_append(iter, 's', s);
+ eldbus_message_iter_basic_append(iter, 's', s);
return EINA_TRUE;
}
static Eina_Bool
-_prop_xayatana_orderindex_get(const EDBus_Service_Interface *iface EINA_UNUSED,
+_prop_xayatana_orderindex_get(const Eldbus_Service_Interface *iface EINA_UNUSED,
const char *propname EINA_UNUSED,
- EDBus_Message_Iter *iter,
- const EDBus_Message *request_msg EINA_UNUSED,
- EDBus_Message **error EINA_UNUSED)
+ Eldbus_Message_Iter *iter,
+ const Eldbus_Message *request_msg EINA_UNUSED,
+ Eldbus_Message **error EINA_UNUSED)
{
- edbus_message_iter_basic_append(iter, 'u', 0);
+ eldbus_message_iter_basic_append(iter, 'u', 0);
return EINA_TRUE;
}
-static const EDBus_Property properties[] = {
+static const Eldbus_Property properties[] = {
{ "AttentionAcessibleDesc", "s", _prop_str_empty_get, NULL, 0 },
{ "AttentionIconName", "s", _prop_attention_icon_name_get, NULL, 0 },
{ "Category", "s", _prop_category_get, NULL, 0 },
{ NULL, NULL, NULL, NULL, 0 }
};
-static const EDBus_Service_Interface_Desc _iface_desc = {
+static const Eldbus_Service_Interface_Desc _iface_desc = {
INTERFACE, methods, signals, properties, NULL, NULL
};
#endif
eina_stringshare_replace(&(_item.menu), NULL);
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Menu");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Menu");
#endif
}
if (_item.cat == cat) return;
_item.cat = cat;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Category");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Category");
#endif
}
if (_item.status == st) return;
_item.status = st;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Status");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Status");
_elm_systray_signal_emit(ELM_SYSTRAY_SIGNAL_NEWSTATUS,
_Elm_Systray_Status_Str[_item.status]);
#endif
if (!eina_stringshare_replace(&(_item.att_icon_name), att_icon_name)) return;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "AttentionIconName");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "AttentionIconName");
_elm_systray_signal_emit(ELM_SYSTRAY_SIGNAL_NEWATTENTIONICON, NULL);
#endif
}
if (!eina_stringshare_replace(&(_item.icon_name), icon_name)) return;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "IconName");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "IconName");
_elm_systray_signal_emit(ELM_SYSTRAY_SIGNAL_NEWICON, NULL);
#endif
}
if (!eina_stringshare_replace(&(_item.icon_theme_path), icon_theme_path))
return;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "IconThemePath");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "IconThemePath");
_elm_systray_signal_emit(ELM_SYSTRAY_SIGNAL_NEWICONTHEMEPATH,
_item.icon_theme_path);
#endif
if (!eina_stringshare_replace(&(_item.id), id)) return;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Id");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Id");
#endif
}
if (!eina_stringshare_replace(&(_item.title), title)) return;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Title");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Title");
_elm_systray_signal_emit(ELM_SYSTRAY_SIGNAL_NEWTITLE, NULL);
#endif
}
_item.menu_obj = menu_obj;
-#ifdef ELM_EDBUS2
- edbus_service_property_changed(_iface, "Menu");
+#ifdef ELM_ELDBUS
+ eldbus_service_property_changed(_iface, "Menu");
#endif
}
_register(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
{
Eina_Bool *ret = va_arg(*args, Eina_Bool *);
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (!_elm_need_systray) goto err;
*ret = _elm_systray_watcher_status_notifier_item_register(OBJ_PATH);
EAPI Eina_Bool
elm_need_systray(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (_elm_need_systray) return EINA_TRUE;
- if (!elm_need_edbus()) return EINA_FALSE;
+ if (!elm_need_eldbus()) return EINA_FALSE;
if (!ELM_EVENT_SYSTRAY_READY)
ELM_EVENT_SYSTRAY_READY = ecore_event_type_new();
if (!_elm_systray_watcher_init()) return EINA_FALSE;
- _conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
+ _conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
if (!_conn) goto err;
- _iface = edbus_service_interface_register(_conn, OBJ_PATH, &_iface_desc);
+ _iface = eldbus_service_interface_register(_conn, OBJ_PATH, &_iface_desc);
if (!_iface) goto err;
_elm_need_systray = EINA_TRUE;
err:
if (_conn)
{
- edbus_connection_unref(_conn);
+ eldbus_connection_unref(_conn);
_conn = NULL;
}
void
_elm_unneed_systray(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (!_elm_need_systray) return;
_elm_need_systray = EINA_FALSE;
- edbus_service_interface_unregister(_iface);
+ eldbus_service_interface_unregister(_iface);
- edbus_connection_unref(_conn);
+ eldbus_connection_unref(_conn);
_elm_systray_watcher_shutdown();
#include "elm_systray_watcher.h"
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
#define OBJ "/StatusNotifierWatcher"
#define BUS "org.kde.StatusNotifierWatcher"
#define INTERFACE "org.kde.StatusNotifierWatcher"
static Eina_Bool _elm_systray_watcher = EINA_FALSE;
-static EDBus_Connection *_watcher_conn = NULL;
-static EDBus_Object *_watcher_obj = NULL;
-static EDBus_Proxy *_watcher_proxy = NULL;
+static Eldbus_Connection *_watcher_conn = NULL;
+static Eldbus_Object *_watcher_obj = NULL;
+static Eldbus_Proxy *_watcher_proxy = NULL;
static void
_status_notifier_item_register_cb(void *data EINA_UNUSED,
- const EDBus_Message *msg,
- EDBus_Pending *pending EINA_UNUSED)
+ const Eldbus_Message *msg,
+ Eldbus_Pending *pending EINA_UNUSED)
{
const char *errname, *errmsg;
- if (edbus_message_error_get(msg, &errname, &errmsg))
- ERR("Edbus Error: %s %s", errname, errmsg);
+ if (eldbus_message_error_get(msg, &errname, &errmsg))
+ ERR("Eldbus Error: %s %s", errname, errmsg);
}
#endif
Eina_Bool
_elm_systray_watcher_status_notifier_item_register(const char *obj)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(_watcher_proxy, EINA_FALSE);
- if (!edbus_proxy_call(_watcher_proxy, "RegisterStatusNotifierItem",
+ if (!eldbus_proxy_call(_watcher_proxy, "RegisterStatusNotifierItem",
_status_notifier_item_register_cb,
NULL, -1, "s", obj))
{
#endif
}
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
static void
_release(void)
{
if (_watcher_proxy)
{
- edbus_proxy_unref(_watcher_proxy);
+ eldbus_proxy_unref(_watcher_proxy);
_watcher_proxy = NULL;
}
if (_watcher_obj)
{
- edbus_object_unref(_watcher_obj);
+ eldbus_object_unref(_watcher_obj);
_watcher_obj = NULL;
}
}
{
_release();
- _watcher_obj = edbus_object_get(_watcher_conn, BUS, OBJ);
- _watcher_proxy = edbus_proxy_get(_watcher_obj, INTERFACE);
+ _watcher_obj = eldbus_object_get(_watcher_conn, BUS, OBJ);
+ _watcher_proxy = eldbus_proxy_get(_watcher_obj, INTERFACE);
ecore_event_add(ELM_EVENT_SYSTRAY_READY, NULL, NULL, NULL);
}
Eina_Bool
_elm_systray_watcher_init(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (_elm_systray_watcher) return EINA_TRUE;
- if (!elm_need_edbus()) return EINA_FALSE;
+ if (!elm_need_eldbus()) return EINA_FALSE;
- _watcher_conn = edbus_connection_get(EDBUS_CONNECTION_TYPE_SESSION);
+ _watcher_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
- edbus_name_owner_changed_callback_add(_watcher_conn, BUS,
+ eldbus_name_owner_changed_callback_add(_watcher_conn, BUS,
_name_owner_changed_cb, NULL,
EINA_TRUE);
void
_elm_systray_watcher_shutdown(void)
{
-#ifdef ELM_EDBUS2
+#ifdef ELM_ELDBUS
if (!_elm_systray_watcher) return;
_elm_systray_watcher = EINA_FALSE;
_release();
- edbus_connection_unref(_watcher_conn);
+ eldbus_connection_unref(_watcher_conn);
_watcher_conn = NULL;
#endif
}
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_ETHUMB_CFLAGS@ \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
-@ELEMENTARY_EDBUS2_CFLAGS@ \
+@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
projects / platform / upstream / elementary.git / commitdiff