Пример #1
0
static void
nautilus_search_engine_set_query (NautilusSearchProvider *provider,
                                  NautilusQuery          *query)
{
    NautilusSearchEngine *engine;
    NautilusSearchEnginePrivate *priv;

    engine = NAUTILUS_SEARCH_ENGINE (provider);
    priv = nautilus_search_engine_get_instance_private (engine);

    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->tracker), query);
    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->recent), query);
    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->model), query);
    nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (priv->simple), query);
}
Пример #2
0
static void
check_providers_status (NautilusSearchEngine *engine)
{
    NautilusSearchEnginePrivate *priv;
    gint num_finished;

    priv = nautilus_search_engine_get_instance_private (engine);
    num_finished = priv->providers_error + priv->providers_finished;

    if (num_finished < priv->providers_running)
    {
        return;
    }

    if (num_finished == priv->providers_error)
    {
        DEBUG ("Search engine error");
        nautilus_search_provider_error (NAUTILUS_SEARCH_PROVIDER (engine),
                                        _("Unable to complete the requested search"));
    }
    else
    {
        if (priv->restart)
        {
            DEBUG ("Search engine finished and restarting");
        }
        else
        {
            DEBUG ("Search engine finished");
        }
        nautilus_search_provider_finished (NAUTILUS_SEARCH_PROVIDER (engine),
                                           priv->restart ? NAUTILUS_SEARCH_PROVIDER_STATUS_RESTARTING :
                                           NAUTILUS_SEARCH_PROVIDER_STATUS_NORMAL);
    }

    priv->running = FALSE;
    g_object_notify (G_OBJECT (engine), "running");

    g_hash_table_remove_all (priv->uris);

    if (priv->restart)
    {
        nautilus_search_engine_start (NAUTILUS_SEARCH_PROVIDER (engine));
    }

    g_object_unref (engine);
}
Пример #3
0
static void
search_engine_start_real_simple (NautilusSearchEngine *engine)
{
    NautilusSearchEnginePrivate *priv;

    priv = nautilus_search_engine_get_instance_private (engine);
    priv->providers_running++;

    nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->simple));
}
Пример #4
0
static void
stop_search (NautilusSearchDirectory *search)
{
	if (!search->details->search_running) {
		return;
	}

	search->details->search_running = FALSE;
	nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (search->details->engine));

	reset_file_list (search);
}
Пример #5
0
static void
nautilus_search_engine_stop (NautilusSearchProvider *provider)
{
    NautilusSearchEngine *engine;
    NautilusSearchEnginePrivate *priv;

    engine = NAUTILUS_SEARCH_ENGINE (provider);
    priv = nautilus_search_engine_get_instance_private (engine);

    DEBUG ("Search engine stop");

    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->tracker));
    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->recent));
    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->model));
    nautilus_search_provider_stop (NAUTILUS_SEARCH_PROVIDER (priv->simple));

    priv->running = FALSE;
    priv->restart = FALSE;

    g_object_notify (G_OBJECT (provider), "running");
}
Пример #6
0
static void
search_engine_start_real_model (NautilusSearchEngine *engine)
{
    NautilusSearchEnginePrivate *priv;

    priv = nautilus_search_engine_get_instance_private (engine);
    if (nautilus_search_engine_model_get_model (priv->model))
    {
        priv->providers_running++;
        nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (priv->model));
    }
}
Пример #7
0
static void
start_search (NautilusSearchDirectory *search)
{
	NautilusSearchEngineModel *model_provider;
	NautilusSearchEngineSimple *simple_provider;
	gboolean recursive;

	if (!search->details->query) {
		return;
	}

	if (search->details->search_running) {
		return;
	}

	if (!search->details->monitor_list && !search->details->pending_callback_list) {
		return;
	}

	/* We need to start the search engine */
	search->details->search_running = TRUE;
	search->details->search_ready_and_valid = FALSE;

	set_hidden_files (search);
	nautilus_search_provider_set_query (NAUTILUS_SEARCH_PROVIDER (search->details->engine),
					    search->details->query);

	model_provider = nautilus_search_engine_get_model_provider (search->details->engine);
	nautilus_search_engine_model_set_model (model_provider, search->details->base_model);

	simple_provider = nautilus_search_engine_get_simple_provider (search->details->engine);
	recursive = nautilus_query_get_recursive (search->details->query);
	g_object_set (simple_provider, "recursive", recursive, NULL);

	reset_file_list (search);

	nautilus_search_provider_start (NAUTILUS_SEARCH_PROVIDER (search->details->engine));
}
Пример #8
0
static void
nautilus_search_engine_get_property (GObject    *object,
                                     guint       prop_id,
                                     GValue     *value,
                                     GParamSpec *pspec)
{
    NautilusSearchProvider *self = NAUTILUS_SEARCH_PROVIDER (object);

    switch (prop_id)
    {
        case PROP_RUNNING:
        {
            g_value_set_boolean (value, nautilus_search_engine_is_running (self));
        }
        break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}
Пример #9
0
static void
search_provider_hits_added (NautilusSearchProvider *provider,
                            GList                  *hits,
                            NautilusSearchEngine   *engine)
{
    NautilusSearchEnginePrivate *priv;
    GList *added = NULL;
    GList *l;

    priv = nautilus_search_engine_get_instance_private (engine);

    if (!priv->running || priv->restart)
    {
        DEBUG ("Ignoring hits-added, since engine is %s",
               !priv->running ? "not running" : "waiting to restart");
        return;
    }

    for (l = hits; l != NULL; l = l->next)
    {
        NautilusSearchHit *hit = l->data;
        int count;
        const char *uri;

        uri = nautilus_search_hit_get_uri (hit);
        count = GPOINTER_TO_INT (g_hash_table_lookup (priv->uris, uri));
        if (count == 0)
        {
            added = g_list_prepend (added, hit);
        }
        g_hash_table_replace (priv->uris, g_strdup (uri), GINT_TO_POINTER (++count));
    }
    if (added != NULL)
    {
        added = g_list_reverse (added);
        nautilus_search_provider_hits_added (NAUTILUS_SEARCH_PROVIDER (engine), added);
        g_list_free (added);
    }
}