gboolean
set_fingerprint_label (GtkWidget *label1,
GtkWidget *label2)
{
GDBusProxy *device;
GVariant *result;
GVariantIter *fingers;
GError *error = NULL;
if (manager == NULL) {
create_manager ();
if (manager == NULL) {
return FALSE;
}
}
device = get_first_device ();
if (device == NULL)
return FALSE;
result = g_dbus_proxy_call_sync (device, "ListEnrolledFingers", g_variant_new ("(s)", ""), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (!result) {
if (!g_dbus_error_is_remote_error (error) ||
strcmp (g_dbus_error_get_remote_error(error), "net.reactivated.Fprint.Error.NoEnrolledPrints") != 0) {
g_object_unref (device);
return FALSE;
}
}
if (result && g_variant_is_of_type (result, G_VARIANT_TYPE ("(as)")))
g_variant_get (result, "(as)", &fingers);
else
fingers = NULL;
if (fingers == NULL || g_variant_iter_n_children (fingers) == 0) {
is_disable = FALSE;
gtk_label_set_text (GTK_LABEL (label1), _("Disabled"));
gtk_label_set_text (GTK_LABEL (label2), _("Disabled"));
} else {
is_disable = TRUE;
gtk_label_set_text (GTK_LABEL (label1), _("Enabled"));
gtk_label_set_text (GTK_LABEL (label2), _("Enabled"));
}
if (result != NULL)
g_variant_unref (result);
if (fingers != NULL)
g_variant_iter_free (fingers);
g_object_unref (device);
return TRUE;
}
static void
dispatcher_results_process (guint request_id, DispatcherAction action, GVariantIter *results)
{
const char *script, *err;
guint32 result;
const Monitor *monitor = _get_monitor_by_action (action);
g_return_if_fail (results != NULL);
if (g_variant_iter_n_children (results) == 0) {
_LOGD ("(%u) succeeded but no scripts invoked", request_id);
return;
}
while (g_variant_iter_next (results, "(&su&s)", &script, &result, &err)) {
const char *script_validation_msg = "";
if (!*script) {
script_validation_msg = " (path is NULL)";
script = "(unknown)";
} else if (!strncmp (script, monitor->dir, monitor->dir_len) /* check: prefixed by script directory */
&& script[monitor->dir_len] == '/' && script[monitor->dir_len+1] /* check: with additional "/?" */
&& !strchr (&script[monitor->dir_len+1], '/')) { /* check: and no further '/' */
/* we expect the script to lie inside monitor->dir. If it does,
* strip the directory name. Otherwise show the full path and a warning. */
script += monitor->dir_len + 1;
} else
script_validation_msg = " (unexpected path)";
if (result == DISPATCH_RESULT_SUCCESS) {
_LOGD ("(%u) %s succeeded%s",
request_id,
script, script_validation_msg);
} else {
_LOGW ("(%u) %s failed (%s): %s%s",
request_id,
script,
dispatch_result_to_string (result),
err,
script_validation_msg);
}
}
}
CCSSettingValueList
readListValue (GVariant *gsettingsValue, CCSSetting *setting, CCSObjectAllocationInterface *ai)
{
CCSSettingType listType = ccsSettingGetInfo (setting)->forList.listType;
gboolean hasVariantType;
unsigned int nItems;
CCSSettingValueList list = NULL;
GVariantIter iter;
hasVariantType = compizconfigTypeHasVariantType (listType);
if (!hasVariantType)
return NULL;
g_variant_iter_init (&iter, gsettingsValue);
nItems = g_variant_iter_n_children (&iter);
switch (listType)
{
case TypeBool:
list = readBoolListValue (&iter, nItems, setting, ai);
break;
case TypeInt:
list = readIntListValue (&iter, nItems, setting, ai);
break;
case TypeFloat:
list = readFloatListValue (&iter, nItems, setting, ai);
break;
case TypeString:
case TypeMatch:
list = readStringListValue (&iter, nItems, setting, ai);
break;
case TypeColor:
list = readColorListValue (&iter, nItems, setting, ai);
break;
default:
break;
}
return list;
}
static void
ol_lyric_source_download_complete_cb (OlLyricSource *source,
GVariant *parameters)
{
OlLyricSourceTask *task;
int taskid;
int status;
GVariantIter *iter;
gchar *content = NULL;
gsize len = 0;
g_variant_get (parameters, "(iiay)", &taskid, &status, &iter);
task = ol_lyric_source_get_download_task (source, taskid);
if (task == NULL)
{
ol_errorf ("Download task %d not exist\n", taskid);
}
else if (status < 0 || status > OL_LYRIC_SOURCE_STATUS_FALIURE)
{
ol_errorf ("Invalid download status %d\n", status);
}
else
{
len = g_variant_iter_n_children (iter);
content = g_new (gchar, len + 1);
gsize i = 0;
while (g_variant_iter_loop (iter, "y", &content[i]))
i++;
content[len] = '\0';
g_signal_emit (G_OBJECT (task),
_download_signals[DOWNLOAD_SIGNAL_COMPLETE],
0,
status,
content,
(guint) len);
g_free (content);
}
g_variant_iter_free (iter);
ol_lyric_source_remove_download_task (source, taskid);
}
Bool
appendToPluginsWithSetKeysList (const gchar *plugin,
GVariant *writtenPlugins,
char ***newWrittenPlugins,
gsize *newWrittenPluginsSize)
{
gsize writtenPluginsLen = 0;
Bool found = FALSE;
char *plug;
GVariantIter iter;
g_variant_iter_init (&iter, writtenPlugins);
*newWrittenPluginsSize = g_variant_iter_n_children (&iter);
while (g_variant_iter_loop (&iter, "s", &plug))
{
if (!found)
found = (g_strcmp0 (plug, plugin) == 0);
}
if (!found)
++(*newWrittenPluginsSize);
*newWrittenPlugins = g_variant_dup_strv (writtenPlugins, &writtenPluginsLen);
if (*newWrittenPluginsSize > writtenPluginsLen)
{
*newWrittenPlugins = g_realloc (*newWrittenPlugins, (*newWrittenPluginsSize + 1) * sizeof (gchar *));
/* Next item becomes plugin */
(*newWrittenPlugins)[writtenPluginsLen] = g_strdup (plugin);
/* Last item becomes NULL */
(*newWrittenPlugins)[*newWrittenPluginsSize] = NULL;
}
return !found;
}
static const gchar *
document_read_contents (YelpDocument *document,
const gchar *page_id)
{
gchar *real, *str, **colors;
g_mutex_lock (&document->priv->mutex);
if (page_id != NULL && g_str_has_prefix (page_id, "search=")) {
gchar *tmp, *tmp2, *txt;
GVariant *value;
GVariantIter *iter;
gchar *url, *title, *desc, *icon; /* do not free */
gchar *index_title;
GString *ret = g_string_new ("<html><head><style type='text/css'>");
colors = yelp_settings_get_colors (yelp_settings_get_default ());
g_string_append_printf (ret,
"html { height: 100%%; } "
"body { margin: 0; padding: 0;"
" background-color: %s; color: %s;"
" direction: %s; } "
"div.header { margin-bottom: 1em; } "
"div.trails { "
" margin: 0; padding: 0.2em 12px 0 12px;"
" background-color: %s;"
" border-bottom: solid 1px %s; } "
"div.trail { text-indent: -1em;"
" margin: 0 1em 0.2em 1em; padding: 0; color: %s; } "
"div.body { margin: 0 12px 0 12px; padding: 0 0 12px 0; max-width: 60em; } "
"div, p { margin: 1em 0 0 0; padding: 0; } "
"div:first-child, p:first-child { margin-top: 0; } "
"h1 { margin: 0; padding: 0; color: %s; font-size: 1.44em; } "
"a { color: %s; text-decoration: none; } "
"a.linkdiv { display: block; } "
"div.linkdiv { margin: 0; padding: 0.5em; }"
"a:hover div.linkdiv {"
" outline: solid 1px %s;"
" background: -webkit-gradient(linear, left top, left 80, from(%s), to(%s)); } "
"div.title { margin-bottom: 0.2em; font-weight: bold; } "
"div.desc { margin: 0; color: %s; } "
"</style></head><body><div class='header'>",
colors[YELP_SETTINGS_COLOR_BASE],
colors[YELP_SETTINGS_COLOR_TEXT],
(gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "rtl" : "ltr"),
colors[YELP_SETTINGS_COLOR_GRAY_BASE],
colors[YELP_SETTINGS_COLOR_GRAY_BORDER],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT],
colors[YELP_SETTINGS_COLOR_LINK],
colors[YELP_SETTINGS_COLOR_BLUE_BASE],
colors[YELP_SETTINGS_COLOR_BLUE_BASE],
colors[YELP_SETTINGS_COLOR_BASE],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT]
);
index_title = yelp_storage_get_root_title (yelp_storage_get_default (),
document->priv->doc_uri);
if (index_title != NULL) {
tmp = g_markup_printf_escaped ("<div class='trails'><div class='trail'>"
"<a href='xref:'>%s</a> %s "
"</div></div>",
index_title,
(gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "«" : "»")
);
g_string_append (ret, tmp);
g_free (tmp);
}
g_string_append (ret, "</div><div class='body'>");
g_strfreev (colors);
str = hash_lookup (document->priv->contents, real);
if (str) {
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
txt = g_uri_unescape_string (page_id + 7, NULL);
tmp2 = g_strdup_printf (_("Search results for “%s”"), txt);
tmp = g_markup_printf_escaped ("<h1>%s</h1>", tmp2);
g_string_append (ret, tmp);
g_free (tmp2);
g_free (tmp);
value = yelp_storage_search (yelp_storage_get_default (),
document->priv->doc_uri,
txt);
iter = g_variant_iter_new (value);
if (g_variant_iter_n_children (iter) == 0) {
if (index_title != NULL) {
gchar *t = g_strdup_printf (_("No matching help pages found in “%s”."), index_title);
tmp = g_markup_printf_escaped ("<p>%s</p>", t);
g_free (t);
}
else {
tmp = g_markup_printf_escaped ("<p>%s</p>",
_("No matching help pages found."));
}
g_string_append (ret, tmp);
g_free (tmp);
}
else {
while (g_variant_iter_loop (iter, "(&s&s&s&s)", &url, &title, &desc, &icon)) {
tmp = g_markup_printf_escaped ("<div><a class='linkdiv' href='%s'><div class='linkdiv'>"
"<div class='title'>%s</div>"
"<div class='desc'>%s</div>"
"</div></a></div>",
url, title, desc);
g_string_append (ret, tmp);
g_free (tmp);
}
}
g_variant_iter_free (iter);
g_variant_unref (value);
if (index_title != NULL)
g_free (index_title);
g_free (txt);
g_string_append (ret, "</div></body></html>");
hash_replace (document->priv->contents, page_id, g_string_free (ret, FALSE));
str = hash_lookup (document->priv->contents, page_id);
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
real = hash_lookup (document->priv->page_ids, page_id);
str = hash_lookup (document->priv->contents, real);
if (str)
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
gboolean
flatpak_builtin_document_info (int argc, char **argv,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GDBusConnection) session_bus = NULL;
const char *file;
XdpDbusDocuments *documents;
g_autofree char *mountpoint = NULL;
g_autofree char *basename = NULL;
g_autofree char *doc_id = NULL;
g_autofree char *doc_path = NULL;
g_autofree char *origin = NULL;
const char *app_id;
const char **perms;
g_autoptr(GVariant) apps = NULL;
g_autoptr(GVariantIter) iter = NULL;
context = g_option_context_new (_("FILE - Get information about an exported file"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
if (!flatpak_option_context_parse (context, options, &argc, &argv,
FLATPAK_BUILTIN_FLAG_NO_DIR,
NULL, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, _("FILE must be specified"), error);
file = argv[1];
basename = g_path_get_basename (file);
session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, error);
if (session_bus == NULL)
return FALSE;
documents = xdp_dbus_documents_proxy_new_sync (session_bus, 0,
"org.freedesktop.portal.Documents",
"/org/freedesktop/portal/documents",
NULL, error);
if (documents == NULL)
return FALSE;
if (!xdp_dbus_documents_call_get_mount_point_sync (documents, &mountpoint,
NULL, error))
return FALSE;
if (!xdp_dbus_documents_call_lookup_sync (documents, file, &doc_id, NULL, error))
return FALSE;
if (strcmp (doc_id, "") == 0)
{
g_print (_("Not exported\n"));
return TRUE;
}
doc_path = g_build_filename (mountpoint, doc_id, basename, NULL);
if (!xdp_dbus_documents_call_info_sync (documents, doc_id, &origin, &apps,
NULL, error))
return FALSE;
iter = g_variant_iter_new (apps);
g_print ("id: %s\n", doc_id);
g_print ("path: %s\n", doc_path);
g_print ("origin: %s\n", origin);
if (g_variant_iter_n_children (iter) > 0)
g_print ("permissions:\n");
while (g_variant_iter_next (iter, "{&s^a&s}", &app_id, &perms))
{
int i;
g_print ("\t%s\t", app_id);
for (i = 0; perms[i]; i++)
{
if (i > 0)
g_print (", ");
g_print ("%s", perms[i]);
}
g_print ("\n");
}
return TRUE;
}
int CtSgwUCIReadSection(const char *pkg_name, const char *section_type, const char *section_name, CtSgwUCIOpt_t **opts, uint32_t *optsize)
{
char *vendor = NULL;
int version = 0, ret = 0, n = 0;
int i = 0, cnt = 0;
char name[128] = {0}, path[128] = {0}, intf[128] = {0};
GVariant *value = NULL;
GVariant *vv = NULL;
GVariantIter *iter;
CtSgwUCIOpt_t *opt = NULL;
gchar *key = NULL, *val = NULL;
if (!pkg_name || (!section_name && !section_type))
return -1;
_CtSgwGetAppVendorVersion(pkg_name, &vendor, &version);
g_assert_nonnull(vendor);
sprintf(name, "com.%s.%s%d", vendor, pkg_name, version);
if (section_name) {
sprintf(path, "/com/%s/%s%d/Config/%s/%s", vendor, pkg_name, version, section_name, section_name);
sprintf(intf, "%s.Config.%s", name, section_name);
ret = CtSgwDBusGetAllProperty(name, path, intf, &value);
if (value) {
g_variant_get(value, "(a{sv})", &iter);
n = g_variant_iter_n_children(iter);
*optsize = n;
opt = (CtSgwUCIOpt_t *)malloc(sizeof(CtSgwUCIOpt_t) * n);
*opts = opt;
while (g_variant_iter_loop(iter,"{sv}", &key, &vv))
{
g_strlcpy(opt->name, key, MAX_UCI_OPT_NAME_LEN);
g_variant_get(vv, "&s", &val);
if (val)
g_strlcpy(opt->value, val, MAX_UCI_OPT_VAL_LEN);
opt++;
}
g_variant_iter_free(iter);
g_variant_unref(value);
}
}
else if (section_type) {
sprintf(path, "/com/%s/%s%d/Config/%s", vendor, pkg_name, version, section_type);
sprintf(intf, "%s.Config.%s", name, section_type);
cnt = _CtSgwGetNumOfNodes(name, path);
sprintf(path, "/com/%s/%s%d/Config/%s/1", vendor, pkg_name, version, section_type);
ret = CtSgwDBusGetAllProperty(name, path, intf, &value);
if (value) {
g_variant_get(value, "(a{sv})", &iter);
n = g_variant_iter_n_children(iter);
//each section have same number of properties
*optsize = n * cnt;
opt = (CtSgwUCIOpt_t *)malloc(sizeof(CtSgwUCIOpt_t) * n * cnt);
*opts = opt;
//fill properties of 1st section
while (g_variant_iter_loop(iter,"{sv}", &key, &vv))
{
g_variant_get(vv, "&s", &val);
g_strlcpy(opt->name, key, MAX_UCI_OPT_NAME_LEN);
if (val)
g_strlcpy(opt->value, val, MAX_UCI_OPT_VAL_LEN);
opt++;
}
g_variant_iter_free (iter);
g_variant_unref(value);
//fill other sections
for (i = 1; i < cnt; i++) {
sprintf(path, "/com/%s/%s%d/Config/%s/%d", vendor, pkg_name, version, section_type, i + 1);
ret = CtSgwDBusGetAllProperty(name, path, intf, &value);
g_assert_nonnull(value);
g_variant_get(value, "(a{sv})", &iter);
while (g_variant_iter_loop(iter,"{sv}", &key, &vv))
{
g_variant_get(vv, "&s", &val);
g_strlcpy(opt->name, key, MAX_UCI_OPT_NAME_LEN);
if (val)
g_strlcpy(opt->value, val, MAX_UCI_OPT_VAL_LEN);
opt++;
}
g_variant_iter_free (iter);
g_variant_unref(value);
}
}
}
return ret;
#if APPMGR_UCI_SUPPORT
GDBusConnection *connection;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *result;
GVariantIter *iter;
CtSgwUCIOpt_t *opt = NULL;
gchar *key, *value;
gint n = 0;
if (!pkg_name || (!section_name && !section_type))
return -1;
connection = g_bus_get_sync (DBUS_TYPE, NULL, &error);
g_assert_no_error(error);
proxy = g_dbus_proxy_new_sync(connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL, /* GDBusInterfaceInfo */
"com.ctc.appframework1", /* name */
"/com/ctc/appframework1", /* object path */
"com.ctc.appframework1.UCI", /* interface */
NULL, /* GCancellable */
&error);
g_assert_no_error(error);
if (section_name)
result = g_dbus_proxy_call_sync(proxy,
"ReadSectionByName",
g_variant_new("(ss)", pkg_name, section_name),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
else
result = g_dbus_proxy_call_sync(proxy,
"ReadSectionByType",
g_variant_new("(ss)", pkg_name, section_type),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
g_assert(result != NULL);
g_variant_get(result, "(a{ss})", &iter);
n = g_variant_iter_n_children(iter);
*optsize = n;
opt = (CtSgwUCIOpt_t *)malloc(sizeof(CtSgwUCIOpt_t) * n);
*opts = opt;
while (g_variant_iter_loop(iter,"{ss}", &key, &value))
{
g_strlcpy(opt->name, key, MAX_UCI_OPT_NAME_LEN);
g_strlcpy(opt->value, value, MAX_UCI_OPT_VAL_LEN);
opt++;
}
g_variant_unref(result);
g_object_unref(proxy);
g_object_unref (connection);
#endif
return 0;
}
static int _icd_state_list_from_gvariant(GVariant *var,
struct icd_state_list_s *value_list, int depth)
{
int ret;
GVariantIter iter;
const GVariantType *type;
union icd_state_value_u *value;
type = g_variant_get_type(var);
g_variant_iter_init(&iter, var);
value_list->dimensions[depth] = g_variant_iter_n_children(&iter);
DBG("[%d]list dim : %d", depth, value_list->dimensions[depth]);
if (g_variant_type_equal(G_VARIANT_TYPE("ab"), type)) {
bool b;
value_list->type = OCREP_PROP_BOOL;
while (g_variant_iter_loop(&iter, "b", &b)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->b = b;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("ai"), type)) {
int i;
value_list->type = OCREP_PROP_INT;
while (g_variant_iter_loop(&iter, "i", &i)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->i = i;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("ad"), type)) {
double d;
value_list->type = OCREP_PROP_DOUBLE;
while (g_variant_iter_loop(&iter, "d", &d)) {
value = calloc(1, sizeof(union icd_state_value_u));
if (NULL == value) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
value->d = d;
value_list->list = g_list_append(value_list->list, value);
}
} else if (g_variant_type_equal(G_VARIANT_TYPE("as"), type)) {
char *s;
value_list->type = OCREP_PROP_STRING;
while (g_variant_iter_next(&iter, "s", &s))
value_list->list = g_list_append(value_list->list, s);
} else if (g_variant_type_equal(G_VARIANT_TYPE("av"), type)) {
GVariant *value;
if (g_variant_iter_loop(&iter, "v", &value)) {
if (g_variant_is_of_type(value, G_VARIANT_TYPE("a{sv}"))) {
OCRepPayload *repr;
GVariantIter state_iter;
value_list->type = OCREP_PROP_OBJECT;
do {
repr = OCRepPayloadCreate();
g_variant_iter_init(&state_iter, value);
ret = _icd_state_value_from_gvariant(repr, &state_iter);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_value_from_gvariant() Fail(%d)", ret);
OCRepPayloadDestroy(repr);
return ret;
}
value_list->list = g_list_append(value_list->list, repr);
} while (g_variant_iter_loop(&iter, "v", &value));
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE("ay"))) {
OCByteString *byte_str;
value_list->type = OCREP_PROP_BYTE_STRING;
do {
byte_str = calloc(1, sizeof(OCByteString));
if (NULL == byte_str) {
ERR("calloc() Fail(%d)", errno);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
byte_str->len = g_variant_get_size(value);
byte_str->bytes = calloc(byte_str->len, sizeof(uint8_t));
if (NULL == byte_str->bytes) {
ERR("calloc() Fail(%d)", errno);
free(byte_str);
return IOTCON_ERROR_OUT_OF_MEMORY;
}
memcpy(byte_str->bytes, g_variant_get_data(value), byte_str->len);
value_list->list = g_list_append(value_list->list, byte_str);
} while (g_variant_iter_loop(&iter, "v", &value));
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_ARRAY)) {
do {
ret = _icd_state_list_from_gvariant(value, value_list, depth + 1);
if (IOTCON_ERROR_NONE != ret) {
ERR("_icd_state_list_from_gvariant() Fail(%d)", ret);
return ret;
}
} while (g_variant_iter_loop(&iter, "v", &value));
}
}
}
return IOTCON_ERROR_NONE;
}
static void
tracker_dbus_signal_cb (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
gchar *class_name;
gint graph = 0, subject = 0, predicate = 0, object = 0;
GVariantIter *iter1, *iter2;
tracker_evt_update_t *evt = tracker_evt_update_new ();
g_variant_get (parameters, "(&sa(iiii)a(iiii))", &class_name, &iter1, &iter2);
GRL_DEBUG ("Tracker update event for class=%s ins=%lu del=%lu evt=%p",
class_name,
(unsigned long) g_variant_iter_n_children (iter1),
(unsigned long) g_variant_iter_n_children (iter2),
evt);
/* Process deleted items */
while (g_variant_iter_loop (iter1, "(iiii)", &graph,
&subject, &predicate, &object)) {
gpointer psubject = GSIZE_TO_POINTER (subject);
GrlTrackerSource *source =
grl_tracker_source_cache_get_source (grl_tracker_item_cache, subject);
/* GRL_DEBUG ("\tdelete=> subject=%i", subject); */
if (source) {
g_hash_table_insert (evt->deleted_items, psubject,
g_object_ref (source));
} else {
g_hash_table_insert (evt->orphan_items, psubject,
GSIZE_TO_POINTER (GRL_CONTENT_REMOVED));
}
}
while (g_variant_iter_loop (iter2, "(iiii)", &graph,
&subject, &predicate, &object)) {
gpointer psubject = GSIZE_TO_POINTER (subject);
GrlTrackerSource *source =
grl_tracker_source_cache_get_source (grl_tracker_item_cache, subject);
/* GRL_DEBUG ("\tinsert=> subject=%i", subject); */
if (source) {
/* Removed & inserted items are probably just renamed items... */
if (g_hash_table_lookup (evt->deleted_items, psubject)) {
g_hash_table_remove (evt->deleted_items, psubject);
g_hash_table_insert (evt->updated_items, psubject,
g_object_ref (source));
} else if (!g_hash_table_lookup (evt->updated_items, psubject)) {
g_hash_table_insert (evt->inserted_items, psubject,
g_object_ref (source));
}
} else {
gpointer state;
if (g_hash_table_lookup_extended (evt->orphan_items, psubject,
NULL, &state) &&
(GPOINTER_TO_INT (state) == GRL_CONTENT_REMOVED)) {
g_hash_table_insert (evt->orphan_items, psubject,
GSIZE_TO_POINTER (GRL_CONTENT_CHANGED));
} else {
g_hash_table_insert (evt->orphan_items, psubject,
GSIZE_TO_POINTER (GRL_CONTENT_ADDED));
}
}
}
g_variant_iter_free (iter1);
g_variant_iter_free (iter2);
GRL_DEBUG ("\tinserted=%i deleted=%i updated=%i orphan=%i",
g_hash_table_size (evt->inserted_items),
g_hash_table_size (evt->deleted_items),
g_hash_table_size (evt->updated_items),
g_hash_table_size (evt->orphan_items));
if (grl_tracker_per_device_source) {
tracker_evt_preupdate_sources (evt);
} else {
tracker_evt_update_items (evt);
tracker_evt_update_orphans (evt);
}
}