/*
* glade-adaptor-chooser-widget.c
*
* Copyright (C) 2014-2017 Juan Pablo Ugarte
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Authors:
* Juan Pablo Ugarte <juanpablougarte@gmail.com>
*/
#include "glade-app.h"
#include "gladeui-enum-types.h"
#include "glade-adaptor-chooser-widget.h"
#include "glade-dnd.h"
#include <string.h>
enum
{
COLUMN_ADAPTOR = 0,
COLUMN_GROUP,
COLUMN_NORMALIZED_NAME,
COLUMN_NORMALIZED_NAME_LEN,
N_COLUMN
};
struct _GladeAdaptorChooserWidgetPrivate
{
GtkTreeView *treeview;
GtkListStore *store;
GtkTreeModelFilter *treemodelfilter;
GtkSearchEntry *searchentry;
GtkEntryCompletion *entrycompletion;
GtkScrolledWindow *scrolledwindow;
/* Needed for gtk_tree_view_column_set_cell_data_func() */
GtkTreeViewColumn *column_icon;
GtkCellRenderer *icon_cell;
GtkTreeViewColumn *column_adaptor;
GtkCellRenderer *adaptor_cell;
/* Properties */
_GladeAdaptorChooserWidgetFlags flags;
GladeProject *project;
gboolean show_group_title;
gchar *search_text;
};
enum
{
PROP_0,
PROP_SHOW_FLAGS,
PROP_PROJECT,
PROP_SHOW_GROUP_TITLE
};
enum
{
ADAPTOR_SELECTED,
LAST_SIGNAL
};
static guint adaptor_chooser_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_PRIVATE (_GladeAdaptorChooserWidget, _glade_adaptor_chooser_widget, GTK_TYPE_BOX);
#define GET_PRIVATE(d) ((_GladeAdaptorChooserWidgetPrivate *) _glade_adaptor_chooser_widget_get_instance_private((_GladeAdaptorChooserWidget*)d))
static void
_glade_adaptor_chooser_widget_init (_GladeAdaptorChooserWidget *chooser)
{
gtk_widget_init_template (GTK_WIDGET (chooser));
}
static void
_glade_adaptor_chooser_widget_finalize (GObject *object)
{
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (object);
g_clear_pointer (&priv->search_text, g_free);
g_clear_object (&priv->project);
G_OBJECT_CLASS (_glade_adaptor_chooser_widget_parent_class)->finalize (object);
}
static void
_glade_adaptor_chooser_widget_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
_GladeAdaptorChooserWidgetPrivate *priv;
g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (object));
priv = GET_PRIVATE (object);
switch (prop_id)
{
case PROP_SHOW_FLAGS:
priv->flags = g_value_get_flags (value);
break;
case PROP_PROJECT:
_glade_adaptor_chooser_widget_set_project (GLADE_ADAPTOR_CHOOSER_WIDGET (object),
g_value_get_object (value));
break;
case PROP_SHOW_GROUP_TITLE:
priv->show_group_title = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
_glade_adaptor_chooser_widget_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
_GladeAdaptorChooserWidgetPrivate *priv;
g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (object));
priv = GET_PRIVATE (object);
switch (prop_id)
{
case PROP_SHOW_FLAGS:
g_value_set_flags (value, priv->flags);
break;
case PROP_PROJECT:
g_value_set_object (value, priv->project);
break;
case PROP_SHOW_GROUP_TITLE:
g_value_set_boolean (value, priv->show_group_title);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static inline gchar *
normalize_name (const gchar *name)
{
gchar *normalized_name = g_utf8_normalize (name, -1, G_NORMALIZE_DEFAULT);
gchar *casefold_name = g_utf8_casefold (normalized_name, -1);
g_free (normalized_name);
return casefold_name;
}
static inline void
store_append_adaptor (GtkListStore *store, GladeWidgetAdaptor *adaptor)
{
gchar *normalized_name = normalize_name (glade_widget_adaptor_get_name (adaptor));
gtk_list_store_insert_with_values (store, NULL, -1,
COLUMN_ADAPTOR, adaptor,
COLUMN_NORMALIZED_NAME, normalized_name,
COLUMN_NORMALIZED_NAME_LEN, strlen (normalized_name),
-1);
g_free (normalized_name);
}
static void
on_treeview_row_activated (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
_GladeAdaptorChooserWidget *chooser)
{
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
GtkTreeIter iter;
if (gtk_tree_model_get_iter (model, &iter, path))
{
GladeWidgetAdaptor *adaptor;
gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
if (!adaptor)
return;
/* Emit selected signal */
g_signal_emit (chooser, adaptor_chooser_signals[ADAPTOR_SELECTED], 0, adaptor);
g_object_unref (adaptor);
}
}
static void
on_searchentry_search_changed (GtkEntry *entry,
_GladeAdaptorChooserWidget *chooser)
{
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
const gchar *text = gtk_entry_get_text (entry);
g_clear_pointer (&priv->search_text, g_free);
if (g_utf8_strlen (text, -1))
priv->search_text = normalize_name (text);
gtk_tree_model_filter_refilter (priv->treemodelfilter);
}
static void
on_searchentry_activate (GtkEntry *entry, _GladeAdaptorChooserWidget *chooser)
{
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
const gchar *text = gtk_entry_get_text (entry);
GladeWidgetAdaptor *adaptor;
/* try to find an adaptor by name */
if (!(adaptor = glade_widget_adaptor_get_by_name (text)))
{
GtkTreeModel *model = GTK_TREE_MODEL (priv->treemodelfilter);
gchar *normalized_name = normalize_name (text);
GtkTreeIter iter;
gboolean valid;
gint count = 0;
valid = gtk_tree_model_get_iter_first (model, &iter);
/* we could not find it check if we can find it by normalized name */
while (valid)
{
gchar *name;
gtk_tree_model_get (model, &iter, COLUMN_NORMALIZED_NAME, &name, -1);
if (g_strcmp0 (name, normalized_name) == 0)
{
gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
g_free (name);
break;
}
valid = gtk_tree_model_iter_next (model, &iter);
g_free (name);
count++;
}
/* if not, and there is only one row, then we select that one */
if (!adaptor && count == 1 && gtk_tree_model_get_iter_first (model, &iter))
gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
g_free (normalized_name);
}
if (adaptor)
g_signal_emit (chooser, adaptor_chooser_signals[ADAPTOR_SELECTED], 0, adaptor);
}
static gboolean
chooser_match_func (_GladeAdaptorChooserWidget *chooser,
GtkTreeModel *model,
const gchar *key,
GtkTreeIter *iter)
{
gboolean visible;
gint name_len;
gchar *name;
if (!key || *key == '\0')
return TRUE;
gtk_tree_model_get (model, iter,
COLUMN_NORMALIZED_NAME, &name,
COLUMN_NORMALIZED_NAME_LEN, &name_len,
-1);
if (!name)
return FALSE;
visible = (g_strstr_len (name, name_len, key) != NULL);
g_free (name);
return visible;
}
static gboolean
treemodelfilter_visible_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
{
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (data);
GladeWidgetAdaptor *adaptor = NULL;
gboolean visible = TRUE;
gtk_tree_model_get (model, iter, COLUMN_ADAPTOR, &adaptor, -1);
if (!adaptor)
return priv->show_group_title && !priv->search_text;
/* Skip classes not available in project target version */
if (priv->project)
{
const gchar *catalog = NULL;
gint major, minor;
catalog = glade_widget_adaptor_get_catalog (adaptor);
glade_project_get_target_version (priv->project, catalog, &major, &minor);
visible = GWA_VERSION_CHECK (adaptor, major, minor);
}
if (visible && priv->flags)
{
GType type = glade_widget_adaptor_get_object_type (adaptor);
_GladeAdaptorChooserWidgetFlags flags = priv->flags;
/* Skip adaptors according to flags */
if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED && GWA_DEPRECATED (adaptor))
visible = FALSE;
else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL && GWA_IS_TOPLEVEL (adaptor))
visible = FALSE;
else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET && !g_type_is_a (type, GTK_TYPE_WIDGET))
visible = FALSE;
else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL && !GWA_IS_TOPLEVEL (adaptor))
visible = FALSE;
}
if (visible && priv->search_text)
visible = chooser_match_func (data, model, priv->search_text, iter);
g_clear_object (&adaptor);
return visible;
}
static gboolean
entrycompletion_match_func (GtkEntryCompletion *entry, const gchar *key, GtkTreeIter *iter, gpointer data)
{
return chooser_match_func (data, gtk_entry_completion_get_model (entry), key, iter);
}
static void
adaptor_icon_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GladeWidgetAdaptor *adaptor;
gtk_tree_model_get (tree_model, iter, COLUMN_ADAPTOR, &adaptor, -1);
if (adaptor)
g_object_set (cell, "sensitive", TRUE, "icon-name", glade_widget_adaptor_get_icon_name (adaptor), NULL);
else
g_object_set (cell, "sensitive", FALSE, "icon-name", "go-down-symbolic", NULL);
g_clear_object (&adaptor);
}
static void
adaptor_text_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GladeWidgetAdaptor *adaptor;
gchar *group;
gtk_tree_model_get (tree_model, iter,
COLUMN_ADAPTOR, &adaptor,
COLUMN_GROUP, &group,
-1);
if (adaptor)
g_object_set (cell,
"sensitive", TRUE,
"text", glade_widget_adaptor_get_name (adaptor),
"style", PANGO_STYLE_NORMAL,
NULL);
else
g_object_set (cell,
"sensitive", FALSE,
"text", group,
"style", PANGO_STYLE_ITALIC,
NULL);
g_clear_object (&adaptor);
g_free (group);
}
static void
glade_adaptor_chooser_widget_drag_begin (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
GladeWidgetAdaptor *adaptor;
gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
_glade_dnd_set_icon_widget (context,
glade_widget_adaptor_get_icon_name (adaptor),
glade_widget_adaptor_get_name (adaptor));
}
}
static void
glade_adaptor_chooser_widget_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time,
gpointer userdata)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
GladeWidgetAdaptor *adaptor;
gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
_glade_dnd_set_data (data, G_OBJECT (adaptor));
}
}
static void
_glade_adaptor_chooser_widget_constructed (GObject *object)
{
_GladeAdaptorChooserWidget *chooser = GLADE_ADAPTOR_CHOOSER_WIDGET (object);
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
/* Set cell data function: this save us from alocating name and icon name for each adaptor. */
gtk_tree_view_column_set_cell_data_func (priv->column_icon,
priv->icon_cell,
adaptor_icon_cell_data_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (priv->column_adaptor,
priv->adaptor_cell,
adaptor_text_cell_data_func,
NULL, NULL);
/* Set tree model filter function */
gtk_tree_model_filter_set_visible_func (priv->treemodelfilter,
treemodelfilter_visible_func,
chooser, NULL);
/* Set completion match function */
gtk_entry_completion_set_match_func (priv->entrycompletion,
entrycompletion_match_func,
chooser, NULL);
/* Enable Drag & Drop */
gtk_tree_view_enable_model_drag_source (priv->treeview, GDK_BUTTON1_MASK,
_glade_dnd_get_target (), 1, 0);
g_signal_connect_after (priv->treeview, "drag-begin",
G_CALLBACK (glade_adaptor_chooser_widget_drag_begin),
NULL);
g_signal_connect (priv->treeview, "drag-data-get",
G_CALLBACK (glade_adaptor_chooser_widget_drag_data_get),
NULL);
}
static void
_glade_adaptor_chooser_widget_map (GtkWidget *widget)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (toplevel)
{
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (widget);
gint height = gtk_widget_get_allocated_height (toplevel) - 100;
if (height > 512)
height = height * 0.75;
gtk_scrolled_window_set_max_content_height (priv->scrolledwindow, height);
}
GTK_WIDGET_CLASS (_glade_adaptor_chooser_widget_parent_class)->map (widget);
}
static GType
_glade_adaptor_chooser_widget_flags_get_type (void)
{
static GType etype = 0;
if (G_UNLIKELY(etype == 0)) {
static const GFlagsValue values[] = {
{ GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET, "GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET", "widget" },
{ GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL, "GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL", "toplevel" },
{ GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL, "GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL", "skip-toplevel" },
{ GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED, "GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED", "skip-deprecated" },
{ 0, NULL, NULL }
};
etype = g_flags_register_static (g_intern_static_string ("_GladeAdaptorChooserWidgetFlag"), values);
}
return etype;
}
static void
_glade_adaptor_chooser_widget_class_init (_GladeAdaptorChooserWidgetClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->finalize = _glade_adaptor_chooser_widget_finalize;
object_class->set_property = _glade_adaptor_chooser_widget_set_property;
object_class->get_property = _glade_adaptor_chooser_widget_get_property;
object_class->constructed = _glade_adaptor_chooser_widget_constructed;
widget_class->map = _glade_adaptor_chooser_widget_map;
g_object_class_install_property (object_class,
PROP_SHOW_FLAGS,
g_param_spec_flags ("show-flags",
"Show flags",
"Widget adaptors show flags",
_glade_adaptor_chooser_widget_flags_get_type (),
0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class,
PROP_SHOW_GROUP_TITLE,
g_param_spec_boolean ("show-group-title",
"Show group title",
"Whether to show the group title",
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class,
PROP_PROJECT,
g_param_spec_object ("project",
"Glade Project",
"If set, use project target version to skip unsupported classes",
GLADE_TYPE_PROJECT,
G_PARAM_READWRITE));
adaptor_chooser_signals[ADAPTOR_SELECTED] =
g_signal_new ("adaptor-selected", G_OBJECT_CLASS_TYPE (klass), 0, 0,
NULL, NULL, NULL,
G_TYPE_NONE, 1,
GLADE_TYPE_WIDGET_ADAPTOR);
gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/gladeui/glade-adaptor-chooser-widget.ui");
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, treeview);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, store);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, treemodelfilter);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, searchentry);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, entrycompletion);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, column_icon);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, icon_cell);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, column_adaptor);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, adaptor_cell);
gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, scrolledwindow);
gtk_widget_class_bind_template_callback (widget_class, on_treeview_row_activated);
gtk_widget_class_bind_template_callback (widget_class, on_searchentry_search_changed);
gtk_widget_class_bind_template_callback (widget_class, on_searchentry_activate);
}
GtkWidget *
_glade_adaptor_chooser_widget_new (_GladeAdaptorChooserWidgetFlags flags, GladeProject *project)
{
return GTK_WIDGET (g_object_new (GLADE_TYPE_ADAPTOR_CHOOSER_WIDGET,
"show-flags", flags,
"project", project,
NULL));
}
void
_glade_adaptor_chooser_widget_set_project (_GladeAdaptorChooserWidget *chooser,
GladeProject *project)
{
_GladeAdaptorChooserWidgetPrivate *priv;
g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));
priv = GET_PRIVATE (chooser);
g_clear_object (&priv->project);
if (project)
priv->project = g_object_ref (project);
gtk_tree_model_filter_refilter (priv->treemodelfilter);
}
void
_glade_adaptor_chooser_widget_populate (_GladeAdaptorChooserWidget *chooser)
{
GList *l;
for (l = glade_app_get_catalogs (); l; l = g_list_next (l))
_glade_adaptor_chooser_widget_add_catalog (chooser, l->data);
}
void
_glade_adaptor_chooser_widget_add_catalog (_GladeAdaptorChooserWidget *chooser,
GladeCatalog *catalog)
{
GList *groups;
g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));
for (groups = glade_catalog_get_widget_groups (catalog); groups;
groups = g_list_next (groups))
_glade_adaptor_chooser_widget_add_group (chooser, groups->data);
}
void
_glade_adaptor_chooser_widget_add_group (_GladeAdaptorChooserWidget *chooser,
GladeWidgetGroup *group)
{
_GladeAdaptorChooserWidgetPrivate *priv;
const GList *adaptors;
g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));
priv = GET_PRIVATE (chooser);
if (priv->show_group_title)
gtk_list_store_insert_with_values (priv->store, NULL, -1,
COLUMN_GROUP, glade_widget_group_get_title (group),
-1);
for (adaptors = glade_widget_group_get_adaptors (group); adaptors;
adaptors = g_list_next (adaptors))
store_append_adaptor (priv->store, adaptors->data);
}