mirror of
https://gitlab.gnome.org/GNOME/glade.git
synced 2025-11-09 00:13:50 -05:00
464 lines
14 KiB
C
464 lines
14 KiB
C
/*
|
|
* Copyright (C) 2008 Tristan Van Berkom.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU 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:
|
|
* Tristan Van Berkom <tvb@gnome.org>
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <gladeui/glade.h>
|
|
#include <glib/gi18n-lib.h>
|
|
|
|
#include "glade-editor-table.h"
|
|
|
|
static void glade_editor_table_init (GladeEditorTable * self);
|
|
static void glade_editor_table_class_init (GladeEditorTableClass * klass);
|
|
static void glade_editor_table_dispose (GObject * object);
|
|
static void glade_editor_table_editable_init (GladeEditableIface * iface);
|
|
static void glade_editor_table_realize (GtkWidget * widget);
|
|
static void glade_editor_table_grab_focus (GtkWidget * widget);
|
|
|
|
struct _GladeEditorTablePrivate
|
|
{
|
|
GladeWidgetAdaptor *adaptor; /* The GladeWidgetAdaptor this
|
|
* table was created for.
|
|
*/
|
|
|
|
GladeWidget *loaded_widget; /* A pointer to the currently loaded GladeWidget
|
|
*/
|
|
|
|
GtkWidget *name_label; /* A pointer to the "Name:" label (for show/hide) */
|
|
GtkWidget *name_entry; /* A pointer to the gtk_entry that holds
|
|
* the name of the widget. This is the
|
|
* first item _pack'ed to the table_widget.
|
|
* We have a pointer here because it is an
|
|
* entry which will not be created from a
|
|
* GladeProperty but rather from code.
|
|
*/
|
|
|
|
GList *properties; /* A list of GladeEditorPropery items.
|
|
* For each row in the gtk_table, there is a
|
|
* corrsponding GladeEditorProperty struct.
|
|
*/
|
|
|
|
GladeEditorPageType type; /* Is this table to be used in the common tab, ?
|
|
* the general tab, a packing tab or the query popup ?
|
|
*/
|
|
|
|
gint rows;
|
|
};
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GladeEditorTable, glade_editor_table, GTK_TYPE_GRID,
|
|
G_IMPLEMENT_INTERFACE (GLADE_TYPE_EDITABLE,
|
|
glade_editor_table_editable_init));
|
|
|
|
|
|
#define BLOCK_NAME_ENTRY_CB(table) \
|
|
do { if (table->priv->name_entry) \
|
|
g_signal_handlers_block_by_func (G_OBJECT (table->priv->name_entry), \
|
|
G_CALLBACK (widget_name_edited), table); \
|
|
} while (0);
|
|
|
|
#define UNBLOCK_NAME_ENTRY_CB(table) \
|
|
do { if (table->priv->name_entry) \
|
|
g_signal_handlers_unblock_by_func (G_OBJECT (table->priv->name_entry), \
|
|
G_CALLBACK (widget_name_edited), table); \
|
|
} while (0);
|
|
|
|
|
|
static void
|
|
glade_editor_table_class_init (GladeEditorTableClass * klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
object_class->dispose = glade_editor_table_dispose;
|
|
widget_class->realize = glade_editor_table_realize;
|
|
widget_class->grab_focus = glade_editor_table_grab_focus;
|
|
|
|
g_type_class_add_private (klass, sizeof (GladeEditorTablePrivate));
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_init (GladeEditorTable * self)
|
|
{
|
|
self->priv =
|
|
G_TYPE_INSTANCE_GET_PRIVATE ((self),
|
|
GLADE_TYPE_EDITOR_TABLE,
|
|
GladeEditorTablePrivate);
|
|
|
|
gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
|
|
GTK_ORIENTATION_VERTICAL);
|
|
gtk_grid_set_row_spacing (GTK_GRID (self), 4);
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_dispose (GObject * object)
|
|
{
|
|
GladeEditorTable *table = GLADE_EDITOR_TABLE (object);
|
|
|
|
table->priv->properties = (g_list_free (table->priv->properties), NULL);
|
|
|
|
/* the entry is finalized anyway, just avoid setting
|
|
* text in it from _load();
|
|
*/
|
|
table->priv->name_entry = NULL;
|
|
|
|
glade_editable_load (GLADE_EDITABLE (table), NULL);
|
|
|
|
G_OBJECT_CLASS (glade_editor_table_parent_class)->dispose (object);
|
|
}
|
|
|
|
|
|
static void
|
|
glade_editor_table_realize (GtkWidget * widget)
|
|
{
|
|
GladeEditorTable *table = GLADE_EDITOR_TABLE (widget);
|
|
GList *list;
|
|
GladeEditorProperty *property;
|
|
|
|
GTK_WIDGET_CLASS (glade_editor_table_parent_class)->realize (widget);
|
|
|
|
/* Sync up properties, even if widget is NULL */
|
|
for (list = table->priv->properties; list; list = list->next)
|
|
{
|
|
property = list->data;
|
|
glade_editor_property_load_by_widget (property, table->priv->loaded_widget);
|
|
}
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_grab_focus (GtkWidget * widget)
|
|
{
|
|
GladeEditorTable *editor_table = GLADE_EDITOR_TABLE (widget);
|
|
|
|
if (editor_table->priv->name_entry &&
|
|
gtk_widget_get_mapped (editor_table->priv->name_entry))
|
|
gtk_widget_grab_focus (editor_table->priv->name_entry);
|
|
else if (editor_table->priv->properties)
|
|
gtk_widget_grab_focus (GTK_WIDGET (editor_table->priv->properties->data));
|
|
else
|
|
GTK_WIDGET_CLASS (glade_editor_table_parent_class)->grab_focus (widget);
|
|
}
|
|
|
|
static void
|
|
widget_name_edited (GtkWidget * editable, GladeEditorTable * table)
|
|
{
|
|
GladeWidget *widget;
|
|
gchar *new_name;
|
|
|
|
g_return_if_fail (GTK_IS_EDITABLE (editable));
|
|
g_return_if_fail (GLADE_IS_EDITOR_TABLE (table));
|
|
|
|
if (table->priv->loaded_widget == NULL)
|
|
{
|
|
g_warning ("Name entry edited with no loaded widget in editor %p!\n",
|
|
table);
|
|
return;
|
|
}
|
|
|
|
widget = table->priv->loaded_widget;
|
|
new_name = gtk_editable_get_chars (GTK_EDITABLE (editable), 0, -1);
|
|
|
|
if (glade_project_available_widget_name (glade_widget_get_project (widget),
|
|
widget, new_name))
|
|
glade_command_set_name (widget, new_name);
|
|
g_free (new_name);
|
|
}
|
|
|
|
static void
|
|
widget_name_changed (GladeWidget * widget,
|
|
GParamSpec * pspec, GladeEditorTable * table)
|
|
{
|
|
if (!gtk_widget_get_mapped (GTK_WIDGET (table)))
|
|
return;
|
|
|
|
if (table->priv->name_entry)
|
|
{
|
|
BLOCK_NAME_ENTRY_CB (table);
|
|
gtk_entry_set_text (GTK_ENTRY (table->priv->name_entry),
|
|
glade_widget_get_name (table->priv->loaded_widget));
|
|
UNBLOCK_NAME_ENTRY_CB (table);
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
widget_finalized (GladeEditorTable * table, GladeWidget * where_widget_was)
|
|
{
|
|
table->priv->loaded_widget = NULL;
|
|
|
|
glade_editable_load (GLADE_EDITABLE (table), NULL);
|
|
}
|
|
|
|
|
|
static void
|
|
glade_editor_table_load (GladeEditable * editable, GladeWidget * widget)
|
|
{
|
|
GladeEditorTable *table = GLADE_EDITOR_TABLE (editable);
|
|
GladeEditorProperty *property;
|
|
GList *list;
|
|
|
|
/* abort mission */
|
|
if (table->priv->loaded_widget == widget)
|
|
return;
|
|
|
|
if (table->priv->loaded_widget)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (G_OBJECT (table->priv->loaded_widget),
|
|
G_CALLBACK (widget_name_changed),
|
|
table);
|
|
|
|
/* The widget could die unexpectedly... */
|
|
g_object_weak_unref (G_OBJECT (table->priv->loaded_widget),
|
|
(GWeakNotify) widget_finalized, table);
|
|
}
|
|
|
|
table->priv->loaded_widget = widget;
|
|
|
|
BLOCK_NAME_ENTRY_CB (table);
|
|
|
|
if (table->priv->loaded_widget)
|
|
{
|
|
g_signal_connect (G_OBJECT (table->priv->loaded_widget), "notify::name",
|
|
G_CALLBACK (widget_name_changed), table);
|
|
|
|
/* The widget could die unexpectedly... */
|
|
g_object_weak_ref (G_OBJECT (table->priv->loaded_widget),
|
|
(GWeakNotify) widget_finalized, table);
|
|
|
|
if (table->priv->name_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (table->priv->name_entry),
|
|
glade_widget_get_name (widget));
|
|
|
|
}
|
|
else if (table->priv->name_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (table->priv->name_entry), "");
|
|
|
|
UNBLOCK_NAME_ENTRY_CB (table);
|
|
|
|
/* Sync up properties, even if widget is NULL */
|
|
for (list = table->priv->properties; list; list = list->next)
|
|
{
|
|
property = list->data;
|
|
glade_editor_property_load_by_widget (property, widget);
|
|
}
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_set_show_name (GladeEditable * editable, gboolean show_name)
|
|
{
|
|
GladeEditorTable *table = GLADE_EDITOR_TABLE (editable);
|
|
|
|
if (table->priv->name_label)
|
|
{
|
|
if (show_name)
|
|
{
|
|
gtk_widget_show (table->priv->name_label);
|
|
gtk_widget_show (table->priv->name_entry);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (table->priv->name_label);
|
|
gtk_widget_hide (table->priv->name_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_editable_init (GladeEditableIface * iface)
|
|
{
|
|
iface->load = glade_editor_table_load;
|
|
iface->set_show_name = glade_editor_table_set_show_name;
|
|
}
|
|
|
|
static void
|
|
glade_editor_table_attach (GladeEditorTable * table,
|
|
GtkWidget * child, gint pos, gint row)
|
|
{
|
|
gtk_grid_attach (GTK_GRID (table), child, pos, row, 1, 1);
|
|
|
|
if (pos)
|
|
gtk_widget_set_hexpand (child, TRUE);
|
|
}
|
|
|
|
static gint
|
|
property_class_comp (gconstpointer a, gconstpointer b)
|
|
{
|
|
GladePropertyClass *ca = (GladePropertyClass *)a, *cb = (GladePropertyClass *)b;
|
|
GParamSpec *pa, *pb;
|
|
|
|
pa = glade_property_class_get_pspec (ca);
|
|
pb = glade_property_class_get_pspec (cb);
|
|
|
|
if (pa->owner_type == pb->owner_type)
|
|
{
|
|
gdouble result = glade_property_class_weight (ca) - glade_property_class_weight (cb);
|
|
/* Avoid cast to int */
|
|
if (result < 0.0)
|
|
return -1;
|
|
else if (result > 0.0)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
if (g_type_is_a (pa->owner_type, pb->owner_type))
|
|
return (glade_property_class_common (ca) || glade_property_class_get_is_packing (ca)) ? 1 : -1;
|
|
else
|
|
return (glade_property_class_common (ca) || glade_property_class_get_is_packing (ca)) ? -1 : 1;
|
|
}
|
|
}
|
|
|
|
static GList *
|
|
get_sorted_properties (GladeWidgetAdaptor * adaptor, GladeEditorPageType type)
|
|
{
|
|
const GList *l, *properties;
|
|
GList *list = NULL;
|
|
|
|
properties =
|
|
(type == GLADE_PAGE_PACKING) ?
|
|
glade_widget_adaptor_get_packing_props (adaptor) :
|
|
glade_widget_adaptor_get_properties (adaptor);
|
|
|
|
for (l = properties; l; l = g_list_next (l))
|
|
{
|
|
GladePropertyClass *klass = l->data;
|
|
|
|
/* Collect properties in our domain, query dialogs are allowed editor
|
|
* invisible properties, allow adaptors to filter out properties from
|
|
* the GladeEditorTable using the "custom-layout" attribute.
|
|
*/
|
|
if (!glade_property_class_custom_layout (klass) && GLADE_PROPERTY_CLASS_IS_TYPE (klass, type)
|
|
&& (glade_property_class_is_visible (klass) || type == GLADE_PAGE_QUERY))
|
|
{
|
|
list = g_list_prepend (list, klass);
|
|
}
|
|
|
|
}
|
|
return g_list_sort (list, property_class_comp);
|
|
}
|
|
|
|
static GladeEditorProperty *
|
|
append_item (GladeEditorTable * table,
|
|
GladePropertyClass * klass, gboolean from_query_dialog)
|
|
{
|
|
GladeEditorProperty *property;
|
|
|
|
if (!(property = glade_widget_adaptor_create_eprop
|
|
(glade_property_class_get_adaptor (klass), klass, from_query_dialog == FALSE)))
|
|
{
|
|
g_critical ("Unable to create editor for property '%s' of class '%s'",
|
|
glade_property_class_id (klass),
|
|
glade_widget_adaptor_get_name (glade_property_class_get_adaptor (klass)));
|
|
return NULL;
|
|
}
|
|
|
|
gtk_widget_show (GTK_WIDGET (property));
|
|
gtk_widget_show_all (glade_editor_property_get_item_label (property));
|
|
|
|
glade_editor_table_attach (table, glade_editor_property_get_item_label (property), 0, table->priv->rows);
|
|
glade_editor_table_attach (table, GTK_WIDGET (property), 1, table->priv->rows);
|
|
|
|
table->priv->rows++;
|
|
|
|
return property;
|
|
}
|
|
|
|
|
|
static void
|
|
append_items (GladeEditorTable * table,
|
|
GladeWidgetAdaptor * adaptor, GladeEditorPageType type)
|
|
{
|
|
GladeEditorProperty *property;
|
|
GladePropertyClass *property_class;
|
|
GList *list, *sorted_list;
|
|
|
|
sorted_list = get_sorted_properties (adaptor, type);
|
|
for (list = sorted_list; list != NULL; list = list->next)
|
|
{
|
|
property_class = (GladePropertyClass *) list->data;
|
|
|
|
property = append_item (table, property_class, type == GLADE_PAGE_QUERY);
|
|
table->priv->properties = g_list_prepend (table->priv->properties, property);
|
|
}
|
|
g_list_free (sorted_list);
|
|
|
|
table->priv->properties = g_list_reverse (table->priv->properties);
|
|
}
|
|
|
|
static void
|
|
append_name_field (GladeEditorTable * table)
|
|
{
|
|
gchar *text = _("The Object's name");
|
|
|
|
/* Name */
|
|
table->priv->name_label = gtk_label_new (_("Name:"));
|
|
gtk_misc_set_alignment (GTK_MISC (table->priv->name_label), 0.0, 0.5);
|
|
gtk_widget_show (table->priv->name_label);
|
|
gtk_widget_set_no_show_all (table->priv->name_label, TRUE);
|
|
|
|
table->priv->name_entry = gtk_entry_new ();
|
|
gtk_widget_show (table->priv->name_entry);
|
|
gtk_widget_set_no_show_all (table->priv->name_entry, TRUE);
|
|
|
|
gtk_widget_set_tooltip_text (table->priv->name_label, text);
|
|
gtk_widget_set_tooltip_text (table->priv->name_entry, text);
|
|
|
|
g_signal_connect (G_OBJECT (table->priv->name_entry), "activate",
|
|
G_CALLBACK (widget_name_edited), table);
|
|
g_signal_connect (G_OBJECT (table->priv->name_entry), "changed",
|
|
G_CALLBACK (widget_name_edited), table);
|
|
|
|
glade_editor_table_attach (table, table->priv->name_label, 0, table->priv->rows);
|
|
glade_editor_table_attach (table, table->priv->name_entry, 1, table->priv->rows);
|
|
|
|
table->priv->rows++;
|
|
}
|
|
|
|
/**
|
|
* glade_editor_table_new:
|
|
* @adaptor: A #GladeWidgetAdaptor
|
|
* @type: The #GladeEditorPageType
|
|
*
|
|
* Creates a new #GladeEditorTable.
|
|
*
|
|
* Returns: a new #GladeEditorTable
|
|
*
|
|
*/
|
|
GtkWidget *
|
|
glade_editor_table_new (GladeWidgetAdaptor * adaptor, GladeEditorPageType type)
|
|
{
|
|
GladeEditorTable *table;
|
|
|
|
g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL);
|
|
|
|
table = g_object_new (GLADE_TYPE_EDITOR_TABLE, NULL);
|
|
table->priv->adaptor = adaptor;
|
|
table->priv->type = type;
|
|
|
|
if (type == GLADE_PAGE_GENERAL)
|
|
append_name_field (table);
|
|
|
|
append_items (table, adaptor, type);
|
|
|
|
gtk_widget_show (GTK_WIDGET (table));
|
|
|
|
return GTK_WIDGET (table);
|
|
}
|