static TrackerDecoratorInfo *
tracker_decorator_info_new (TrackerDecorator *decorator,
TrackerSparqlCursor *cursor)
{
TrackerSparqlBuilder *sparql;
TrackerDecoratorInfo *info;
GCancellable *cancellable;
info = g_slice_new0 (TrackerDecoratorInfo);
info->urn = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL));
info->id = tracker_sparql_cursor_get_integer (cursor, 1);
info->url = g_strdup (tracker_sparql_cursor_get_string (cursor, 2, NULL));
info->mimetype = g_strdup (tracker_sparql_cursor_get_string (cursor, 3, NULL));
info->ref_count = 1;
cancellable = g_cancellable_new ();
info->task = g_task_new (decorator, cancellable,
decorator_task_done, info);
g_object_unref (cancellable);
sparql = tracker_sparql_builder_new_update ();
g_task_set_task_data (info->task, sparql,
(GDestroyNotify) g_object_unref);
return info;
}
static void find_channel_and_update (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
gchar **values;
GtkTreeModel *model;
GtkTreeIter iter;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
g_warning ("Unable to update channel: %s", error->message);
g_error_free (error);
return;
}
model = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
if (retrive_row_by_id (model, tracker_sparql_cursor_get_string (cursor, 0, NULL), &iter) == TRUE) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
}
static void fill_model_with_channels (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
int i;
GtkWidget *dialog;
GtkListStore *list;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to fetch data about current feeds:\n%s", error->message);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "Is Tracker running?");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
return;
}
list = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gtk_list_store_insert_with_values (list, NULL, G_MAXINT,
PREDICATE_SUBJECT, tracker_sparql_cursor_get_string (cursor, 0, NULL),
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
static void
pass_channels (ReaderEngine *engine,
TrackerSparqlCursor *cursor)
{
const gchar *subject;
const gchar *title;
const gchar *url;
gint64 unread;
GtkTreeModel *model;
GtkTreeIter *iter;
GtkTreeIter iter2;
GtkTreeStore *items_model;
GdkPixbuf *icon;
ReaderEnginePrivate *priv;
if (cursor != NULL) {
priv = reader_engine_get_instance_private (engine);
model = GTK_TREE_MODEL (priv->data);
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
title = tracker_sparql_cursor_get_string (cursor, 1, NULL);
unread = tracker_sparql_cursor_get_integer (cursor, 2);
url = tracker_sparql_cursor_get_string (cursor, 4, NULL);
if (find_in_model (model, GD_MAIN_COLUMN_ID, subject, &iter)) {
gtk_list_store_set (GTK_LIST_STORE (model), iter,
GD_MAIN_COLUMN_PRIMARY_TEXT, title,
EXTRA_COLUMN_UNREADS, unread, -1);
gtk_tree_iter_free (iter);
}
else {
items_model = gtk_tree_store_new (ITEM_COLUMN_LAST,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING);
g_signal_connect (items_model, "row-changed", G_CALLBACK (model_item_changed), engine);
icon = get_icon_for_channel (tracker_sparql_cursor_get_string (cursor, 3, NULL));
gtk_list_store_append (GTK_LIST_STORE (model), &iter2);
gtk_list_store_set (GTK_LIST_STORE (model), &iter2,
GD_MAIN_COLUMN_ID, subject,
GD_MAIN_COLUMN_PRIMARY_TEXT, title,
GD_MAIN_COLUMN_ICON, icon,
EXTRA_COLUMN_UNREADS, unread,
EXTRA_COLUMN_URL, url,
EXTRA_COLUMN_FEEDS_MODEL, items_model, -1);
}
collect_items (engine, subject, NULL);
}
g_object_unref (cursor);
}
}
static gchar *
get_class_from_prefix (TrackerSparqlConnection *connection,
const gchar *prefix)
{
GError *error = NULL;
TrackerSparqlCursor *cursor;
const gchar *query;
gchar *found = NULL;
query = "SELECT ?prefix ?ns "
"WHERE {"
" ?ns a tracker:Namespace ;"
" tracker:prefix ?prefix "
"}";
/* We have namespace prefix, get full name */
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get namespace prefixes"),
error->message);
g_error_free (error);
return NULL;
}
if (!cursor) {
g_printerr ("%s\n",
_("No namespace prefixes were found"));
return NULL;
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL) && !found) {
const gchar *class_prefix, *class_name;
class_prefix = tracker_sparql_cursor_get_string (cursor, 0, NULL);
class_name = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (strcmp (class_prefix, prefix) == 0) {
found = g_strdup (class_name);
}
}
g_object_unref (cursor);
return found;
}
static void
handle_channel_deletes (ReaderEngine *engine,
gint sub)
{
gchar *query;
const gchar *subject;
GtkTreeIter *iter;
TrackerSparqlCursor *cursor;
ReaderEnginePrivate *priv;
priv = reader_engine_get_instance_private (engine);
query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub);
cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL);
tracker_sparql_cursor_next (cursor, NULL, NULL);
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
if (find_in_model (GTK_TREE_MODEL (priv->data), GD_MAIN_COLUMN_ID, subject, &iter)) {
remove_channel_data (GTK_TREE_MODEL (priv->data), iter);
gtk_list_store_remove (priv->data, iter);
gtk_tree_iter_free (iter);
}
g_free (query);
g_object_unref (cursor);
}
static void
photos_fetch_collections_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosFetchCollectionsJob *self = PHOTOS_FETCH_COLLECTIONS_JOB (user_data);
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
gboolean valid;
gchar *urn;
error = NULL;
valid = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_warning ("Unable to fetch collections: %s", error->message);
g_error_free (error);
goto end;
}
if (!valid)
goto end;
urn = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL));
self->collections = g_list_prepend (self->collections, urn);
tracker_sparql_cursor_next_async (cursor,
NULL,
photos_fetch_collections_job_cursor_next,
self);
return;
end:
self->collections = g_list_reverse (self->collections);
photos_fetch_collections_job_emit_callback (self);
tracker_sparql_cursor_close (cursor);
g_object_unref (self);
}
GIcon *
photos_utils_get_icon_from_cursor (TrackerSparqlCursor *cursor)
{
GIcon *icon = NULL;
gboolean is_remote = FALSE;
const gchar *identifier;
const gchar *mime_type;
const gchar *rdf_type;
identifier = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_IDENTIFIER, NULL);
if (identifier != NULL)
{
if (g_str_has_prefix (identifier, "facebook:") || g_str_has_prefix (identifier, "flickr:"))
is_remote = TRUE;
}
if (!is_remote)
{
const gchar *uri;
uri = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URI, NULL);
if (uri != NULL)
icon = photos_utils_get_thumbnail_icon (uri);
}
if (icon != NULL)
goto out;
mime_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MIME_TYPE, NULL);
if (mime_type != NULL)
icon = g_content_type_get_icon (mime_type);
if (icon != NULL)
goto out;
rdf_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL);
if (mime_type != NULL)
icon = photos_utils_icon_from_rdf_type (rdf_type);
if (icon != NULL)
goto out;
icon = g_themed_icon_new ("image-x-generic");
out:
return icon;
}
static void
photos_camera_cache_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
PhotosCameraCache *self;
PhotosCameraCachePrivate *priv;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
const gchar *manufacturer;
const gchar *model;
gchar *camera;
gpointer key;
self = PHOTOS_CAMERA_CACHE (g_task_get_source_object (task));
priv = self->priv;
error = NULL;
tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
manufacturer = tracker_sparql_cursor_get_string (cursor, 0, NULL);
model = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (manufacturer == NULL && model == NULL)
camera = NULL;
else if (manufacturer == NULL || g_str_has_prefix (model, manufacturer))
camera = g_strdup (model);
else if (model == NULL)
camera = g_strdup (manufacturer);
else
camera = g_strconcat (manufacturer, " ", model, NULL);
key = g_task_get_task_data (task);
g_hash_table_insert (priv->cache, key, camera);
g_task_return_pointer (task, g_strdup (camera), g_free);
out:
tracker_sparql_cursor_close (cursor);
g_object_unref (task);
}
static void
pass_items (ReaderEngine *engine,
TrackerSparqlCursor *cursor)
{
gboolean blocked;
const gchar *channel_id;
const gchar *item_id;
GtkTreeIter iter;
GtkTreeModel *model;
GDateTime *date;
if (cursor != NULL) {
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
channel_id = tracker_sparql_cursor_get_string (cursor, 0, NULL);
model = reader_engine_get_items_model (engine, channel_id);
if (model == NULL)
continue;
item_id = tracker_sparql_cursor_get_string (cursor, 1, NULL);
date = item_cursor_to_time (cursor);
if (dispose_item_in_model (model, item_id, date, &iter) == FALSE) {
g_signal_handlers_block_by_func (model, G_CALLBACK (model_item_changed), engine);
blocked = TRUE;
}
else {
blocked = FALSE;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
ITEM_COLUMN_ID, item_id,
ITEM_COLUMN_TITLE, tracker_sparql_cursor_get_string (cursor, 2, NULL),
ITEM_COLUMN_URL, tracker_sparql_cursor_get_string (cursor, 3, NULL),
ITEM_COLUMN_TIME, date,
ITEM_COLUMN_CONTENTS, tracker_sparql_cursor_get_string (cursor, 5, NULL),
ITEM_COLUMN_READ, tracker_sparql_cursor_get_boolean (cursor, 4) ? READ_FONT_WEIGHT : UNREAD_FONT_WEIGHT, -1);
if (blocked == TRUE)
g_signal_handlers_unblock_by_func (model, G_CALLBACK (model_item_changed), engine);
}
g_object_unref (cursor);
}
}
static void
set_title (TrackerSparqlCursor *cursor,
gint column,
GrlMedia *media,
GrlKeyID key)
{
const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL);
grl_data_set_boolean (GRL_DATA (media), GRL_METADATA_KEY_TITLE_FROM_FILENAME, FALSE);
grl_media_set_title (media, str);
}
static GDateTime*
item_cursor_to_time (TrackerSparqlCursor *cursor)
{
const gchar *date;
GTimeVal val;
date = tracker_sparql_cursor_get_string (cursor, 6, NULL);
g_time_val_from_iso8601 (date, &val);
return g_date_time_new_from_timeval_local (&val);
}
static void
cursor_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
TrackerSparqlCursor *cursor;
GError *error = NULL;
MyData *md = user_data;
gboolean more_results;
cursor = TRACKER_SPARQL_CURSOR (object);
more_results = tracker_sparql_cursor_next_finish (cursor,
res,
&error);
if (!error) {
static gint i = 0;
if (more_results) {
if (i++ < 5) {
if (i == 1) {
g_print ("Printing first 5 results:\n");
}
g_print (" %s\n", tracker_sparql_cursor_get_string (cursor, 0, NULL));
if (i == 5) {
g_print (" ...\n");
g_print (" Printing nothing for remaining results\n");
}
}
tracker_sparql_cursor_next_async (cursor,
md->cancellable,
cursor_cb,
md);
} else {
g_print ("\n");
g_print ("Async cursor next took: %.6f (for all %d results)\n",
g_timer_elapsed (md->timer, NULL), i);
g_object_unref (cursor);
g_main_loop_quit (md->loop);
}
} else {
g_critical ("Could not run cursor next: %s", error->message);
if (cursor) {
g_object_unref (cursor);
}
g_error_free (error);
g_main_loop_quit (md->loop);
}
}
static void
cursor_callback (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GtkSearchEngineTracker *tracker;
GError *error = NULL;
TrackerSparqlCursor *cursor;
GList *hits;
gboolean success;
gdk_threads_enter ();
tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
cursor = TRACKER_SPARQL_CURSOR (object);
success = tracker_sparql_cursor_next_finish (cursor, result, &error);
if (error)
{
_gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
g_error_free (error);
if (cursor)
g_object_unref (cursor);
gdk_threads_leave ();
return;
}
if (!success)
{
_gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
if (cursor)
g_object_unref (cursor);
gdk_threads_leave ();
return;
}
/* We iterate result by result, not n at a time. */
hits = g_list_append (NULL, (gchar*) tracker_sparql_cursor_get_string (cursor, 0, NULL));
_gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits);
g_list_free (hits);
/* Get next */
cursor_next (tracker, cursor);
gdk_threads_leave ();
}
static void
set_favourite (TrackerSparqlCursor *cursor,
gint column,
GrlMedia *media,
GrlKeyID key)
{
const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL);
gboolean is_favourite = FALSE;
if (str != NULL && g_str_has_suffix (str, "predefined-tag-favorite"))
is_favourite = TRUE;
grl_data_set_boolean (GRL_DATA (media), key, is_favourite);
}
QString QTrackerDirectSyncResult::stringValue(int i) const
{
if (!cursor || pos() == QSparql::BeforeFirstRow || pos() == QSparql::AfterLastRow)
return QString();
// get the no. of columns only once; it won't change between rows
if (n_columns < 0)
n_columns = tracker_sparql_cursor_get_n_columns(cursor);
if (i < 0 || i >= n_columns)
return QString();
return QString::fromUtf8(tracker_sparql_cursor_get_string(cursor, i, 0));
}
static inline void
insert_string_value (TrackerSparqlCursor *const cursor,
GVariantDict *const dict,
gchar const *const key,
gint const column)
{
GVariant *const value = g_variant_new_printf (
"%s",
tracker_sparql_cursor_get_string (cursor, column, NULL)
);
g_variant_dict_insert_value (dict, key, value);
}
static void
photos_fetch_metas_job_executed (TrackerSparqlCursor *cursor, gpointer user_data)
{
PhotosFetchMetasJob *self = PHOTOS_FETCH_METAS_JOB (user_data);
GIcon *icon = NULL;
PhotosFetchMeta *meta;
gboolean is_collection;
const gchar *id;
const gchar *rdf_type;
const gchar *title;
id = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL);
title = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_TITLE, NULL);
rdf_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL);
is_collection = (strstr (rdf_type, "nfo#DataContainer") != NULL);
if (!is_collection)
icon = photos_utils_get_icon_from_cursor (cursor);
if (title == NULL || title[0] == '\0')
title = _("Untitled Photo");
meta = photos_fetch_meta_new (icon, id, title);
if (is_collection)
photos_fetch_metas_job_create_collection_pixbuf (self, meta);
else
{
self->metas = g_list_prepend (self->metas, meta);
photos_fetch_metas_job_collector (self);
}
g_clear_object (&icon);
g_object_unref (self);
}
static void
set_date (TrackerSparqlCursor *cursor,
gint column,
GrlMedia *media,
GrlKeyID key)
{
const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL);
if (key == GRL_METADATA_KEY_CREATION_DATE
|| key == GRL_METADATA_KEY_MODIFICATION_DATE) {
GDateTime *date = grl_date_time_from_iso8601 (str);
if (date) {
grl_data_set_boxed (GRL_DATA (media), key, date);
g_date_time_unref (date);
}
}
}
static void
set_orientation (TrackerSparqlCursor *cursor,
gint column,
GrlMedia *media,
GrlKeyID key)
{
const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL);
if (g_str_has_suffix (str, "nfo#orientation-top"))
grl_data_set_int (GRL_DATA (media), key, 0);
else if (g_str_has_suffix (str, "nfo#orientation-right"))
grl_data_set_int (GRL_DATA (media), key, 90);
else if (g_str_has_suffix (str, "nfo#orientation-bottom"))
grl_data_set_int (GRL_DATA (media), key, 180);
else if (g_str_has_suffix (str, "nfo#orientation-left"))
grl_data_set_int (GRL_DATA (media), key, 270);
}
static void
item_warn (TrackerSparqlConnection *conn,
gint id,
const gchar *sparql,
const GError *error)
{
TrackerSparqlCursor *cursor;
const gchar *elem;
gchar *query;
query = g_strdup_printf ("SELECT COALESCE (nie:url (?u), ?u) {"
" ?u a rdfs:Resource. "
" FILTER (tracker:id (?u) = %d)"
"}", id);
cursor = tracker_sparql_connection_query (conn, query, NULL, NULL);
g_free (query);
g_debug ("--8<------------------------------");
g_debug ("The information relevant for a bug report is between "
"the dotted lines");
if (cursor &&
tracker_sparql_cursor_next (cursor, NULL, NULL)) {
elem = tracker_sparql_cursor_get_string (cursor, 0, NULL);
g_warning ("Could not insert metadata for item \"%s\": %s",
elem, error->message);
} else {
g_warning ("Could not insert metadata for item with ID %d: %s",
id, error->message);
}
g_warning ("If the error above is recurrent for the same item/ID, "
"consider running \"%s\" in the terminal with the "
"TRACKER_VERBOSITY=3 environment variable, and filing a "
"bug with the additional information", g_get_prgname ());
g_debug ("Sparql was:\n%s", sparql);
g_debug ("NOTE: The information above may contain data you "
"consider sensitive. Feel free to edit it out, but please "
"keep it as unmodified as you possibly can.");
g_debug ("------------------------------>8--");
g_clear_object (&cursor);
}
static void
photos_fetch_ids_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosFetchIdsJob *self;
GCancellable *cancellable;
g_autoptr (GTask) task = G_TASK (user_data);
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
gboolean success;
self = PHOTOS_FETCH_IDS_JOB (g_task_get_source_object (task));
cancellable = g_task_get_cancellable (task);
error = NULL;
/* Note that tracker_sparql_cursor_next_finish can return FALSE even
* without an error.
*/
success = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto end;
}
if (success)
{
const gchar *id;
id = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL);
g_ptr_array_add (self->ids, g_strdup (id));
tracker_sparql_cursor_next_async (cursor,
cancellable,
photos_fetch_ids_job_cursor_next,
g_object_ref (task));
return;
}
g_ptr_array_add (self->ids, NULL);
g_task_return_pointer (task, self->ids->pdata, NULL);
end:
return;
}
static void
handle_channel_inserts (ReaderEngine *engine,
gint sub)
{
gchar *query;
const gchar *subject;
TrackerSparqlCursor *cursor;
ReaderEnginePrivate *priv;
priv = reader_engine_get_instance_private (engine);
query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub);
cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL);
tracker_sparql_cursor_next (cursor, NULL, NULL);
subject = tracker_sparql_cursor_get_string (cursor, 0, NULL);
collect_channels (engine, subject);
g_free (query);
g_object_unref (cursor);
}
static void
photos_application_activate_query_executed (TrackerSparqlCursor *cursor, gpointer user_data)
{
PhotosApplication *self = PHOTOS_APPLICATION (user_data);
PhotosApplicationPrivate *priv = self->priv;
GObject *item;
const gchar *identifier;
if (cursor == NULL)
goto out;
photos_item_manager_add_item (PHOTOS_ITEM_MANAGER (priv->item_mngr), cursor);
identifier = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL);
item = photos_base_manager_get_object_by_id (priv->item_mngr, identifier);
photos_application_activate_item (self, item);
out:
g_object_unref (self);
}
static int
status_stat (void)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return EXIT_FAILURE;
}
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
g_object_unref (connection);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get Tracker statistics"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
/* We use search terms on ALL ontologies not just common ones */
if (terms && g_strv_length (terms) > 0) {
show_all = TRUE;
}
if (!cursor) {
g_print ("%s\n", _("No statistics available"));
} else {
GString *output;
output = g_string_new ("");
if (!show_all) {
get_common_rdf_types ();
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *rdf_type;
const gchar *rdf_type_count;
rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL);
rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) {
continue;
}
if (terms) {
gint i, n_terms;
gboolean show_rdf_type = FALSE;
n_terms = g_strv_length (terms);
for (i = 0;
i < n_terms && !show_rdf_type;
i++) {
show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE);
}
if (!show_rdf_type) {
continue;
}
}
g_string_append_printf (output,
" %s = %s\n",
rdf_type,
rdf_type_count);
}
if (output->len > 0) {
/* To translators: This is to say there are no
* statistics found. We use a "Statistics:
* None" with multiple print statements */
g_string_prepend (output, "\n");
g_string_prepend (output, _("Statistics:"));
} else {
g_string_append_printf (output,
" %s\n", _("None"));
}
g_print ("%s\n", output->str);
g_string_free (output, TRUE);
if (common_rdf_types) {
g_hash_table_unref (common_rdf_types);
}
g_object_unref (cursor);
}
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GOptionContext *context;
GError *error = NULL;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Translators: this messagge will apper immediately after the */
/* usage string - Usage: COMMAND [OPTION]... <THIS_MESSAGE> */
context = g_option_context_new (_(" - Show statistics for all Nepomuk defined ontology classes"));
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
if (print_version) {
g_print ("\n" ABOUT "\n" LICENSE "\n");
g_option_context_free (context);
return EXIT_SUCCESS;
}
/* We use search terms on ALL ontologies not just common ones */
if (terms && g_strv_length (terms) > 0) {
show_all = TRUE;
}
g_option_context_free (context);
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return EXIT_FAILURE;
}
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
if (error) {
g_printerr ("%s, %s\n",
_("Could not get Tracker statistics"),
error->message);
g_error_free (error);
return EXIT_FAILURE;
}
if (!cursor) {
g_print ("%s\n", _("No statistics available"));
} else {
GString *output;
output = g_string_new ("");
if (!show_all) {
get_common_rdf_types ();
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *rdf_type;
const gchar *rdf_type_count;
rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL);
rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) {
continue;
}
if (terms) {
gint i, n_terms;
gboolean show_rdf_type = FALSE;
n_terms = g_strv_length (terms);
for (i = 0;
i < n_terms && !show_rdf_type;
i++) {
show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE);
}
if (!show_rdf_type) {
continue;
}
}
g_string_append_printf (output,
" %s = %s\n",
rdf_type,
rdf_type_count);
}
if (output->len > 0) {
/* To translators: This is to say there are no
* statistics found. We use a "Statistics:
* None" with multiple print statements */
g_string_prepend (output, "\n");
g_string_prepend (output, _("Statistics:"));
} else {
g_string_append_printf (output,
" %s\n", _("None"));
}
g_print ("%s\n", output->str);
g_string_free (output, TRUE);
if (common_rdf_types) {
g_hash_table_unref (common_rdf_types);
}
g_object_unref (cursor);
}
g_object_unref (connection);
return EXIT_SUCCESS;
}
static int
collect_debug (void)
{
/* What to collect?
* This is based on information usually requested from maintainers to users.
*
* 1. Package details, e.g. version.
* 2. Disk size, space left, type (SSD/etc)
* 3. Size of dataset (tracker-stats), size of databases
* 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract)
* All txt files in ~/.cache/
* 5. Statistics about data (tracker-stats)
*/
GDir *d;
gchar *data_dir;
gchar *str;
data_dir = g_build_filename (g_get_user_cache_dir (), "tracker", NULL);
/* 1. Package details, e.g. version. */
g_print ("[Package Details]\n");
g_print ("%s: " PACKAGE_VERSION "\n", _("Version"));
g_print ("\n\n");
/* 2. Disk size, space left, type (SSD/etc) */
guint64 remaining_bytes;
gdouble remaining;
g_print ("[%s]\n", _("Disk Information"));
remaining_bytes = tracker_file_system_get_remaining_space (data_dir);
str = g_format_size (remaining_bytes);
remaining = tracker_file_system_get_remaining_space_percentage (data_dir);
g_print ("%s: %s (%3.2lf%%)\n",
_("Remaining space on database partition"),
str,
remaining);
g_free (str);
g_print ("\n\n");
/* 3. Size of dataset (tracker-stats), size of databases */
g_print ("[%s]\n", _("Data Set"));
for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) {
const gchar *f;
gchar *path;
goffset size;
f = g_dir_read_name (d);
if (!f) {
break;
}
if (g_str_has_suffix (f, ".txt")) {
continue;
}
path = g_build_filename (data_dir, f, NULL);
size = tracker_file_get_size (path);
str = g_format_size (size);
g_print ("%s\n%s\n\n", path, str);
g_free (str);
g_free (path);
}
g_dir_close (d);
g_print ("\n");
/* 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract)
* All txt files in ~/.cache/
*/
GSList *all, *l;
g_print ("[%s]\n", _("Configuration"));
all = tracker_gsettings_get_all (NULL);
if (all) {
for (l = all; l; l = l->next) {
ComponentGSettings *c = l->data;
gchar **keys, **p;
if (!c) {
continue;
}
keys = g_settings_list_keys (c->settings);
for (p = keys; p && *p; p++) {
GVariant *v;
gchar *printed;
v = g_settings_get_value (c->settings, *p);
printed = g_variant_print (v, FALSE);
g_print ("%s.%s: %s\n", c->name, *p, printed);
g_free (printed);
g_variant_unref (v);
}
}
tracker_gsettings_free (all);
} else {
g_print ("** %s **\n", _("No configuration was found"));
}
g_print ("\n\n");
g_print ("[%s]\n", _("States"));
for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) {
const gchar *f;
gchar *path;
gchar *content = NULL;
f = g_dir_read_name (d);
if (!f) {
break;
}
if (!g_str_has_suffix (f, ".txt")) {
continue;
}
path = g_build_filename (data_dir, f, NULL);
if (g_file_get_contents (path, &content, NULL, NULL)) {
/* Special case last-index.txt which is time() dump to file */
if (g_str_has_suffix (path, "last-crawl.txt")) {
guint64 then, now;
now = (guint64) time (NULL);
then = g_ascii_strtoull (content, NULL, 10);
str = tracker_seconds_to_string (now - then, FALSE);
g_print ("%s\n%s (%s)\n\n", path, content, str);
} else {
g_print ("%s\n%s\n\n", path, content);
}
g_free (content);
}
g_free (path);
}
g_dir_close (d);
g_print ("\n");
/* 5. Statistics about data (tracker-stats) */
TrackerSparqlConnection *connection;
GError *error = NULL;
g_print ("[%s]\n", _("Data Statistics"));
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_print ("** %s, %s **\n",
_("No connection available"),
error ? error->message : _("No error given"));
g_clear_error (&error);
} else {
TrackerSparqlCursor *cursor;
cursor = tracker_sparql_connection_statistics (connection, NULL, &error);
if (error) {
g_print ("** %s, %s **\n",
_("Could not get statistics"),
error ? error->message : _("No error given"));
g_error_free (error);
} else {
if (!cursor) {
g_print ("** %s **\n",
_("No statistics were available"));
} else {
gint count = 0;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
g_print ("%s: %s\n",
tracker_sparql_cursor_get_string (cursor, 0, NULL),
tracker_sparql_cursor_get_string (cursor, 1, NULL));
count++;
}
if (count == 0) {
g_print ("%s\n",
_("Database is currently empty"));
}
g_object_unref (cursor);
}
}
}
g_object_unref (connection);
g_print ("\n\n");
g_print ("\n");
g_free (data_dir);
return EXIT_SUCCESS;
}
static void
photos_base_item_populate_from_cursor (PhotosBaseItem *self, TrackerSparqlCursor *cursor)
{
PhotosBaseItemPrivate *priv = self->priv;
GTimeVal timeval;
const gchar *date_created;
const gchar *equipment;
const gchar *flash;
const gchar *mtime;
const gchar *title;
const gchar *uri;
uri = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URI, NULL);
priv->uri = g_strdup ((uri == NULL) ? "" : uri);
priv->id = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL));
priv->identifier = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_IDENTIFIER, NULL));
priv->author = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_AUTHOR, NULL));
priv->resource_urn = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RESOURCE_URN, NULL));
priv->favorite = tracker_sparql_cursor_get_boolean (cursor, PHOTOS_QUERY_COLUMNS_RESOURCE_FAVORITE);
mtime = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MTIME, NULL);
if (mtime != NULL)
{
g_time_val_from_iso8601 (mtime, &timeval);
priv->mtime = (gint64) timeval.tv_sec;
}
else
priv->mtime = g_get_real_time () / 1000000;
priv->mime_type = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MIME_TYPE, NULL));
priv->rdf_type = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL));
photos_base_item_update_info_from_type (self);
date_created = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_DATE_CREATED, NULL);
if (date_created != NULL)
{
g_time_val_from_iso8601 (date_created, &timeval);
priv->date_created = (gint64) timeval.tv_sec;
}
else
priv->date_created = -1;
if (g_strcmp0 (priv->id, PHOTOS_COLLECTION_SCREENSHOT) == 0)
title = _("Screenshots");
else
title = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_TITLE, NULL);
if (title == NULL)
title = "";
priv->name = g_strdup (title);
priv->filename = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_FILENAME, NULL));
priv->width = tracker_sparql_cursor_get_integer (cursor, PHOTOS_QUERY_COLUMNS_WIDTH);
priv->height = tracker_sparql_cursor_get_integer (cursor, PHOTOS_QUERY_COLUMNS_HEIGHT);
equipment = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_EQUIPMENT, NULL);
priv->equipment = g_quark_from_string (equipment);
priv->exposure_time = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_EXPOSURE_TIME);
priv->fnumber = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_FNUMBER);
priv->focal_length = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_FOCAL_LENGTH);
priv->iso_speed = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_ISO_SPEED);
flash = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_FLASH, NULL);
priv->flash = g_quark_from_string (flash);
priv->name_fallback = PHOTOS_BASE_ITEM_GET_CLASS (self)->create_name_fallback (self);
photos_base_item_refresh_icon (self);
}
static void
on_query_finished (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
TrackerSparqlCursor *cursor = NULL;
GDir *dir = NULL;
GHashTable *table = NULL;
const gchar *name;
gchar *dirname = NULL;
GList *to_remove = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object),
res,
&error);
if (error) {
goto on_error;
}
dirname = g_build_filename (g_get_user_cache_dir (),
"media-art",
NULL);
if (!g_file_test (dirname, G_FILE_TEST_EXISTS)) {
/* Ignore this and just quit the function */
goto on_error;
}
dir = g_dir_open (dirname, 0, &error);
if (error) {
goto on_error;
}
table = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) NULL);
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gchar *target = NULL, *album_path = NULL;
const gchar *album, *artist;
album = tracker_sparql_cursor_get_string (cursor, 0, NULL);
artist = tracker_sparql_cursor_get_value_type (cursor, 1) != TRACKER_SPARQL_VALUE_TYPE_UNBOUND ? tracker_sparql_cursor_get_string (cursor, 1, NULL) : NULL;
/* The get_path API does stripping itself */
media_art_get_path (artist,
album,
"album", NULL,
&target, NULL);
g_hash_table_replace (table, target, target);
/* Also add the file to which the symlinks are made */
media_art_get_path (NULL,
album,
"album", NULL,
&album_path, NULL);
g_hash_table_replace (table, album_path, album_path);
}
/* Perhaps we should have an internal list of media art files that we made,
* instead of going over all the media art (which could also have been made
* by other softwares) */
for (name = g_dir_read_name (dir); name != NULL; name = g_dir_read_name (dir)) {
gpointer value;
gchar *full;
full = g_build_filename (dirname, name, NULL);
value = g_hash_table_lookup (table, full);
if (!value) {
g_message ("Removing media-art file %s: no album exists that has "
"any songs for this media-art cache", name);
to_remove = g_list_prepend (to_remove, (gpointer) full);
} else {
g_free (full);
}
}
g_list_foreach (to_remove, (GFunc) g_unlink, NULL);
g_list_foreach (to_remove, (GFunc) g_free, NULL);
g_list_free (to_remove);
on_error:
g_free (dirname);
if (table) {
g_hash_table_unref (table);
}
if (cursor) {
g_object_unref (cursor);
}
if (dir) {
g_dir_close (dir);
}
if (error) {
g_critical ("Error running cleanup of media-art: %s",
error->message ? error->message : "No error given");
g_error_free (error);
}
}
GHashTable *
tracker_sparql_get_prefixes (void)
{
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
GHashTable *retval;
const gchar *query;
connection = tracker_sparql_connection_get (NULL, &error);
if (!connection) {
g_printerr ("%s: %s\n",
_("Could not establish a connection to Tracker"),
error ? error->message : _("No error given"));
g_clear_error (&error);
return NULL;
}
retval = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_free);
/* FIXME: Would like to get this in the same SPARQL that we
* use to get the info, but doesn't seem possible at the
* moment with the limited string manipulation features we
* support in SPARQL.
*/
query = "SELECT ?ns ?prefix "
"WHERE {"
" ?ns a tracker:Namespace ;"
" tracker:prefix ?prefix "
"}";
cursor = tracker_sparql_connection_query (connection, query, NULL, &error);
g_object_unref (connection);
if (error) {
g_printerr ("%s, %s\n",
_("Unable to retrieve namespace prefixes"),
error->message);
g_error_free (error);
return retval;
}
if (!cursor) {
g_printerr ("%s\n", _("No namespace prefixes were returned"));
return retval;
}
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
const gchar *key, *value;
key = tracker_sparql_cursor_get_string (cursor, 0, NULL);
value = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (!key || !value) {
continue;
}
g_hash_table_insert (retval,
g_strndup (key, strlen (key) - 1),
g_strdup (value));
}
if (cursor) {
g_object_unref (cursor);
}
return retval;
}
