enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

Rename edbus->eldbus

This commit is contained in:
Lucas De Marchi 2013-04-23 13:05:43 -03:00
parent 9634137319
commit cb495f13de
22 changed files with 474 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
legacy/elementary/ChangeLog
View File

@ -741,8 +741,8 @@
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

2
legacy/elementary/NEWS
View File

@ -18,7 +18,7 @@ Additions:
* 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.

40
legacy/elementary/configure.ac
View File

@ -482,33 +482,33 @@ if test "x$want_elementary_wayland" = "xyes" -a "x$have_elementary_wayland" = "x
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], [])
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_edbus2" != "xno"; then
PKG_CHECK_MODULES([ELEMENTARY_EDBUS2],
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"
@ -534,7 +534,7 @@ else
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)
@ -857,7 +857,7 @@ echo
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}"

4
legacy/elementary/doc/widgets/Makefile.am
View File

@ -15,7 +15,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_FB_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ -107,7 +107,7 @@ widget_preview_toolbar \
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

14
legacy/elementary/src/bin/Makefile.am
View File

@ -16,7 +16,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ -144,7 +144,7 @@ endif
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@ \
@ -159,7 +159,7 @@ config.c
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@ \
@ -175,7 +175,7 @@ elementary_codegen.c
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@ \
@ -205,7 +205,7 @@ if BUILD_QUICKLAUNCH
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@ \
@ -231,7 +231,7 @@ elementary_testql_LTLIBRARIES = elementary_testql.la
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@ \
@ -245,7 +245,7 @@ elementary_testql_la_LDFLAGS = -module -avoid-version -no-undefined
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@ \

2
legacy/elementary/src/bin/test_flipselector.c
View File

@ -92,7 +92,7 @@ test_flipselector(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *even
"Eet",
"Ecore",
"Efreet",
"Edbus"
"Eldbus"
};
win = elm_win_util_standard_add("flipselector", "Flip Selector");

2
legacy/elementary/src/edje_externals/Makefile.am
View File

@ -14,7 +14,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_FB_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_ETHUMB_CFLAGS@ \

2
legacy/elementary/src/examples/Makefile.am
View File

@ -14,7 +14,7 @@ AM_CPPFLAGS = \
-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@ \

2
legacy/elementary/src/examples/flipselector_example.c
View File

@ -155,7 +155,7 @@ elm_main(int argc, char **argv)
"Eet",
"Ecore",
"Efreet",
"Edbus"
"Eldbus"
};
win = elm_win_add(NULL, "flipselector", ELM_WIN_BASIC);

6
legacy/elementary/src/lib/Elementary.h.in
View File

@ -10,7 +10,7 @@
@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
@ -75,8 +75,8 @@
@ELEMENTARY_ECORE_CON_INC@
#include <Edje.h>
#ifdef ELM_EDBUS2
#include <EDBus.h>
#ifdef ELM_ELDBUS
#include <Eldbus.h>
#endif
#ifdef ELM_EFREET

4
legacy/elementary/src/lib/Makefile.am
View File

@ -19,7 +19,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \
@ -315,7 +315,7 @@ libelementary_la_LIBADD = \
@ELEMENTARY_SDL_LIBS@ \
@ELEMENTARY_WIN32_LIBS@ \
@ELEMENTARY_WINCE_LIBS@ \
@ELEMENTARY_EDBUS2_LIBS@ \
@ELEMENTARY_ELDBUS_LIBS@ \
@ELEMENTARY_EFREET_LIBS@ \
@ELEMENTARY_ELOCATION_LIBS@ \
@ELEMENTARY_ETHUMB_LIBS@ \

428
legacy/elementary/src/lib/elm_dbus_menu.c
View File

@ -4,7 +4,7 @@
#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"
@ -21,10 +21,10 @@ typedef struct _Callback_Data Callback_Data;
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;
@ -32,8 +32,8 @@ struct _Elm_DBus_Menu
#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
@ -56,7 +56,7 @@ struct _Callback_Data
{
void (*result_cb)(Eina_Bool, void *);
void *data;
EDBus_Pending *pending_register;
Eldbus_Pending *pending_register;
Ecore_X_Window xid;
};
@ -83,8 +83,8 @@ _menu_add_recursive(Elm_DBus_Menu *dbus_menu, Elm_Menu_Item *item)
}
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;
@ -93,8 +93,8 @@ _app_register_cb(void *data, const EDBus_Message *msg,
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;
@ -109,24 +109,24 @@ _app_menu_watch_cb(void *data, const char *bus EINA_UNUSED,
{
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);
}
}
@ -136,7 +136,7 @@ _layout_idler(void *data)
{
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;
@ -227,16 +227,16 @@ _property_exists(Elm_Menu_Item *item,
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)
{
@ -244,27 +244,27 @@ _property_append(Elm_Menu_Item *item,
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:
@ -272,19 +272,19 @@ _property_append(Elm_Menu_Item *item,
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)
{
@ -293,76 +293,76 @@ _property_dict_build(Elm_Menu_Item *item,
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)
{
@ -370,16 +370,16 @@ _root_layout_build(Elm_DBus_Menu *dbus_menu, Eina_List *property_list,
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 *
@ -397,16 +397,16 @@ _empty_properties_handle(Eina_List *property_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,
&timestamp);
i = id;
item = eina_hash_find(dbus_menu->elements, &i);
@ -474,9 +474,9 @@ error_menu:
// =============================================================================
// 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;
@ -484,19 +484,19 @@ _method_layout_get(const EDBus_Service_Interface *iface,
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);
@ -507,15 +507,15 @@ _method_layout_get(const EDBus_Service_Interface *iface,
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);
@ -526,14 +526,14 @@ _method_layout_get(const EDBus_Service_Interface *iface,
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;
@ -542,31 +542,31 @@ _method_group_properties_get(const EDBus_Service_Interface *iface,
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);
@ -578,25 +578,25 @@ _method_group_properties_get(const EDBus_Service_Interface *iface,
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;
@ -604,16 +604,16 @@ _method_property_get(const EDBus_Service_Interface *iface,
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;
}
@ -621,15 +621,15 @@ _method_property_get(const EDBus_Service_Interface *iface,
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;
@ -640,136 +640,136 @@ _method_property_get(const EDBus_Service_Interface *iface,
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"}),
@ -779,22 +779,22 @@ static const EDBus_Method _methods[] = {
},
{
"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
},
@ -805,12 +805,12 @@ static const EDBus_Method _methods[] = {
// =============================================================================
// 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}
};
@ -819,61 +819,61 @@ static const EDBus_Signal _signals[] = {
// 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 },
@ -881,7 +881,7 @@ static const EDBus_Property _properties[] = {
{ 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
};
// =============================================================================
@ -893,22 +893,22 @@ _elm_dbus_menu_register(Eo *obj)
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
@ -923,8 +923,8 @@ _elm_dbus_menu_unregister(Eo *obj)
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);
@ -963,7 +963,7 @@ _elm_dbus_menu_app_menu_register(Ecore_X_Window xid, Eo *obj,
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);
}
@ -971,7 +971,7 @@ _elm_dbus_menu_app_menu_register(Ecore_X_Window xid, Eo *obj,
void
_elm_dbus_menu_app_menu_unregister(Eo *obj)
{
EDBus_Message *msg;
Eldbus_Message *msg;
Callback_Data *cd;
ELM_MENU_CHECK(obj);
@ -988,13 +988,13 @@ _elm_dbus_menu_app_menu_unregister(Eo *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;

32
legacy/elementary/src/lib/elm_main.c
View File

@ -366,11 +366,11 @@ elm_need_e_dbus(void)
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;
@ -394,16 +394,16 @@ _elm_unneed_e_dbus(void)
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;
@ -411,12 +411,12 @@ elm_need_edbus(void)
}
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
}
@ -442,7 +442,7 @@ _elm_unneed_elocation(void)
#ifdef ELM_ELOCATION
if (!_elm_need_elocation) return;
_elm_need_elocation = EINA_FALSE;
edbus_shutdown();
eldbus_shutdown();
#endif
}
@ -662,7 +662,7 @@ elm_quicklaunch_shutdown(void)
_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();

14
legacy/elementary/src/lib/elm_need.h
View File

@ -48,7 +48,7 @@ EAPI Eina_Bool elm_need_sys_notify(void);
*
* @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
@ -56,19 +56,19 @@ EAPI Eina_Bool elm_need_sys_notify(void);
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
@ -81,7 +81,7 @@ EAPI Eina_Bool elm_need_edbus(void);
*
* @since 1.8.0
*
* @ingroup edbus
* @ingroup eldbus
*/
EAPI Eina_Bool elm_need_elocation(void);

150
legacy/elementary/src/lib/elm_sys_notify.c
View File

@ -8,12 +8,12 @@
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;
@ -24,49 +24,49 @@ typedef struct _Elm_Sys_Notify_Send_Data
} 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;
@ -82,24 +82,24 @@ _elm_sys_notify_capabilities_get(void)
{
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
@ -107,11 +107,11 @@ _close_notification_cb(void *data EINA_UNUSED,
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
@ -119,19 +119,19 @@ elm_sys_notify_close(unsigned int id)
#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;
@ -148,9 +148,9 @@ elm_sys_notify_send(unsigned int replaces_id, const char *icon,
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;
@ -172,16 +172,16 @@ elm_sys_notify_send(unsigned int replaces_id, const char *icon,
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, ""))
@ -190,12 +190,12 @@ elm_sys_notify_send(unsigned int replaces_id, const char *icon,
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;
@ -212,24 +212,24 @@ error:
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;
@ -256,22 +256,22 @@ _ev_action_invoked_free(void *data EINA_UNUSED,
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;
@ -294,13 +294,13 @@ _release(void)
{
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;
}
}
@ -309,26 +309,26 @@ static void
_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();
}
@ -349,10 +349,10 @@ _name_owner_changed_cb(void *data EINA_UNUSED,
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();
@ -360,13 +360,13 @@ elm_need_sys_notify(void)
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;
@ -379,14 +379,14 @@ elm_need_sys_notify(void)
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
}

190
legacy/elementary/src/lib/elm_systray.c
View File

@ -35,15 +35,15 @@ static Elm_Systray_Private_Data _item = {
.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",
@ -65,31 +65,31 @@ static const char *_Elm_Systray_Status_Str[] = {
// =============================================================================
// 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
@ -111,9 +111,9 @@ typedef enum _Elm_Systray_Service_Signals
} 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
},
@ -121,16 +121,16 @@ static const EDBus_Signal signals[] = {
"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 }
};
@ -139,139 +139,139 @@ static const EDBus_Signal signals[] = {
// 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 },
@ -288,7 +288,7 @@ static const EDBus_Property properties[] = {
{ 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
@ -304,8 +304,8 @@ _menu_died(void *data EINA_UNUSED,
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
}
@ -317,8 +317,8 @@ _category_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
}
@ -338,8 +338,8 @@ _status_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
@ -359,8 +359,8 @@ _att_icon_name_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
}
@ -379,8 +379,8 @@ _icon_name_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
}
@ -400,8 +400,8 @@ _icon_theme_path_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
@ -421,8 +421,8 @@ _id_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
}
@ -440,8 +440,8 @@ _title_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
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
}
@ -476,8 +476,8 @@ _menu_set(Eo *obj EINA_UNUSED, void *priv EINA_UNUSED, va_list *args)
_item.menu_obj = menu_obj;
#ifdef ELM_EDBUS2
edbus_service_property_changed(_iface, "Menu");
#ifdef ELM_ELDBUS
eldbus_service_property_changed(_iface, "Menu");
#endif
}
@ -492,7 +492,7 @@ static void
_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);
@ -506,20 +506,20 @@ err:
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;
@ -528,7 +528,7 @@ elm_need_systray(void)
err:
if (_conn)
{
edbus_connection_unref(_conn);
eldbus_connection_unref(_conn);
_conn = NULL;
}
@ -540,14 +540,14 @@ err:
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();

42
legacy/elementary/src/lib/elm_systray_watcher.c
View File

@ -3,37 +3,37 @@
#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))
{
@ -48,19 +48,19 @@ _elm_systray_watcher_status_notifier_item_register(const char *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;
}
}
@ -70,8 +70,8 @@ _update(void)
{
_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);
}
@ -92,14 +92,14 @@ _name_owner_changed_cb(void *data EINA_UNUSED,
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);
@ -113,14 +113,14 @@ _elm_systray_watcher_init(void)
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
}

2
legacy/elementary/src/modules/access_output/Makefile.am
View File

@ -15,7 +15,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \

2
legacy/elementary/src/modules/datetime_input_ctxpopup/Makefile.am
View File

@ -16,7 +16,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \

2
legacy/elementary/src/modules/prefs/Makefile.am
View File

@ -32,7 +32,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_ETHUMB_CFLAGS@ \

2
legacy/elementary/src/modules/test_entry/Makefile.am
View File

@ -15,7 +15,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \

2
legacy/elementary/src/modules/test_map/Makefile.am
View File

@ -15,7 +15,7 @@ AM_CPPFLAGS = \
@ELEMENTARY_SDL_CFLAGS@ \
@ELEMENTARY_WIN32_CFLAGS@ \
@ELEMENTARY_WINCE_CFLAGS@ \
@ELEMENTARY_EDBUS2_CFLAGS@ \
@ELEMENTARY_ELDBUS_CFLAGS@ \
@ELEMENTARY_EFREET_CFLAGS@ \
@ELEMENTARY_ELOCATION_CFLAGS@ \
@ELEMENTARY_EWEATHER_CFLAGS@ \