Commit d38ad3ce authored by Tristan Van Berkom's avatar Tristan Van Berkom

- Added GladeEditable interface used as pages by GladeEditor - Added


	* gladeui/Makefile.am, gladeui/glade-editable.[ch], gladeui/glade-editor-table.[ch]:
	- Added GladeEditable interface used as pages by GladeEditor
	- Added GladeEditorTable widget to implmenemt the editable as the traditional table
	  with sorted properties

	* gladeui/glade-editor.[ch]: Removed lots of code, now uses GladeEditables returned
	  by thier adaptors.

	* gladeui/glade-editor-property.c: Removed obsolete doc-search signal.

	* gladeui/glade-widget-adaptor.[ch]: Added GladeCreateEditableFunc to allow backends
	  to define layouts of pages in the editor.


svn path=/trunk/; revision=1990
parent d8cb7c32
2008-10-23 Tristan Van Berkom <tvb@gnome.org>
* gladeui/Makefile.am, gladeui/glade-editable.[ch], gladeui/glade-editor-table.[ch]:
- Added GladeEditable interface used as pages by GladeEditor
- Added GladeEditorTable widget to implmenemt the editable as the traditional table
with sorted properties
* gladeui/glade-editor.[ch]: Removed lots of code, now uses GladeEditables returned
by thier adaptors.
* gladeui/glade-editor-property.c: Removed obsolete doc-search signal.
* gladeui/glade-widget-adaptor.[ch]: Added GladeCreateEditableFunc to allow backends
to define layouts of pages in the editor.
2008-10-22 Juan Pablo Ugarte <juanpablougarte@gmail.com>
* plugins/gtk+/glade-gtk.c: fixed bug in glade_gtk_assistant_verify_property()
......
......@@ -64,7 +64,9 @@ libgladeui_1_la_SOURCES = \
glade-accumulators.h \
glade-widget-action.c \
glade-name-context.c \
glade-displayable-values.c
glade-displayable-values.c \
glade-editable.c \
glade-editor-table.c
libgladeui_1_la_CPPFLAGS = \
$(common_defines) \
......@@ -115,7 +117,9 @@ libgladeuiinclude_HEADERS = \
glade-catalog.h \
glade-widget-action.h \
glade-name-context.h \
glade-displayable-values.h
glade-displayable-values.h \
glade-editable.h \
glade-editor-table.h
if PLATFORM_WIN32
......
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* glade-name-context.c
*
* Copyright (C) 2008 Tristan Van Berkom.
*
* Authors:
* Tristan Van Berkom <tvb@gnome.org>
*
* 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.
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <glib/gi18n-lib.h>
#include <string.h>
#include <stdlib.h>
#include "glade-widget.h"
#include "glade-editable.h"
static void
glade_editable_class_init (gpointer g_iface)
{
/* */
}
GType
glade_editable_get_type (void)
{
static GType editable_type = 0;
if (!editable_type)
editable_type =
g_type_register_static_simple (G_TYPE_INTERFACE, "GladeEditable",
sizeof (GladeEditableIface),
(GClassInitFunc) glade_editable_class_init,
0, NULL, (GTypeFlags)0);
return editable_type;
}
/**
* glade_editable_load:
* @editable: A #GladeEditable
* @widget: the #GladeWidget to load
*
*/
void
glade_editable_load (GladeEditable *editable,
GladeWidget *widget)
{
GladeEditableIface *iface;
g_return_if_fail (GLADE_IS_EDITABLE (editable));
g_return_if_fail (widget == NULL || GLADE_IS_WIDGET (widget));
iface = GLADE_EDITABLE_GET_IFACE (editable);
if (iface->load)
iface->load (editable, widget);
else
g_critical ("No GladeEditable::load() support on type %s",
G_OBJECT_TYPE_NAME (editable));
}
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
#ifndef __GLADE_EDITABLE_H__
#define __GLADE_EDITABLE_H__
#include <glib.h>
#include <glib-object.h>
G_BEGIN_DECLS
#define GLADE_TYPE_EDITABLE (glade_editable_get_type ())
#define GLADE_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GLADE_TYPE_EDITABLE, GladeEditable))
#define GLADE_EDITABLE_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), GLADE_TYPE_EDITABLE, GladeEditableIface))
#define GLADE_IS_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GLADE_TYPE_EDITABLE))
#define GLADE_EDITABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GLADE_TYPE_EDITABLE, GladeEditableIface))
typedef struct _GladeEditable GladeEditable; /* Dummy typedef */
typedef struct _GladeEditableIface GladeEditableIface;
typedef enum
{
GLADE_PAGE_GENERAL,
GLADE_PAGE_COMMON,
GLADE_PAGE_PACKING,
GLADE_PAGE_ATK,
GLADE_PAGE_QUERY
} GladeEditorPageType;
struct _GladeEditableIface
{
GTypeInterface g_iface;
/* virtual table */
void (* load) (GladeEditable *editable,
GladeWidget *widget);
};
GType glade_editable_get_type (void) G_GNUC_CONST;
void glade_editable_load (GladeEditable *editable,
GladeWidget *widget);
G_END_DECLS
#endif /* __GLADE_EDITABLE_H__ */
......@@ -57,16 +57,9 @@ enum {
PROP_USE_COMMAND
};
enum {
GTK_DOC_SEARCH,
LAST_SIGNAL
};
static GtkTableClass *table_class;
static GladeEditorPropertyClass *editor_property_class;
static guint glade_editor_property_signals[LAST_SIGNAL] = { 0 };
#define GLADE_PROPERTY_TABLE_ROW_SPACING 2
#define FLAGS_COLUMN_SETTING 0
#define FLAGS_COLUMN_SYMBOL 1
......@@ -570,26 +563,6 @@ glade_editor_property_class_init (GladeEditorPropertyClass *eprop_class)
eprop_class->load = glade_editor_property_load_common;
eprop_class->create_input = NULL;
/**
* GladeEditorProperty::gtk-doc-search:
* @gladeeditor: the #GladeEditorProperty which received the signal.
* @arg1: the (#gchar *) book to search or %NULL
* @arg2: the (#gchar *) page to search or %NULL
* @arg3: the (#gchar *) search string or %NULL
*
* Emitted when the editor property requests that a doc-search be performed.
*/
glade_editor_property_signals[GTK_DOC_SEARCH] =
g_signal_new ("gtk-doc-search",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GladeEditorPropertyClass,
gtk_doc_search),
NULL, NULL,
glade_marshal_VOID__STRING_STRING_STRING,
G_TYPE_NONE, 3,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
/* Properties */
g_object_class_install_property
(object_class, PROP_PROPERTY_CLASS,
......
......@@ -123,11 +123,6 @@ struct _GladeEditorPropertyClass {
GtkWidget *(* create_input) (GladeEditorProperty *);
void (* gtk_doc_search)(GladeEditorProperty *,
const gchar *,
const gchar *,
const gchar *);
};
......
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* 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_finalize (GObject *object);
static void glade_editor_table_editable_init (GladeEditableIface *iface);
static void glade_editor_table_grab_focus (GtkWidget *widget);
static void append_packing_items (GladeEditorTable *table,
GladeWidget *widget);
G_DEFINE_TYPE_WITH_CODE (GladeEditorTable, glade_editor_table, GTK_TYPE_TABLE,
G_IMPLEMENT_INTERFACE (GLADE_TYPE_EDITABLE,
glade_editor_table_editable_init));
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->finalize = glade_editor_table_finalize;
widget_class->grab_focus = glade_editor_table_grab_focus;
}
static void
glade_editor_table_init (GladeEditorTable *self)
{
}
static void
glade_editor_table_finalize (GObject *object)
{
GladeEditorTable *table = GLADE_EDITOR_TABLE (object);
table->properties =
(g_list_free (table->properties), NULL);
glade_editable_load (GLADE_EDITABLE (table), NULL);
G_OBJECT_CLASS (glade_editor_table_parent_class)->finalize (object);
}
static void
glade_editor_table_grab_focus (GtkWidget *widget)
{
GladeEditorTable *editor_table = GLADE_EDITOR_TABLE (widget);
if (editor_table->name_entry)
gtk_widget_grab_focus (editor_table->name_entry);
else if (editor_table->properties)
gtk_widget_grab_focus (GTK_WIDGET (editor_table->properties->data));
else
GTK_WIDGET_CLASS (glade_editor_table_parent_class)->grab_focus (widget);
}
static void
widget_name_changed (GladeWidget *widget,
GParamSpec *pspec,
GladeEditorTable *table)
{
table->loading = TRUE;
if (table->name_entry)
gtk_entry_set_text (GTK_ENTRY (table->name_entry), table->loaded_widget->name);
table->loading = FALSE;
}
static void
widget_finalized (GladeEditorTable *table,
GladeWidget *where_widget_was)
{
table->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->loaded_widget && !widget) ||
(table->loaded_widget && widget && table->loaded_widget == widget))
return;
table->loading = TRUE;
if (table->loaded_widget && table->name_entry)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (table->loaded_widget),
G_CALLBACK (widget_name_changed), table);
/* The widget could die unexpectedly... */
g_object_weak_unref (G_OBJECT (table->loaded_widget),
(GWeakNotify)widget_finalized,
table);
}
table->loaded_widget = widget;
if (table->loaded_widget && table->name_entry)
{
g_signal_connect (G_OBJECT (table->loaded_widget), "notify::name",
G_CALLBACK (widget_name_changed), table);
/* The widget could die unexpectedly... */
g_object_weak_ref (G_OBJECT (table->loaded_widget),
(GWeakNotify)widget_finalized,
table);
gtk_entry_set_text (GTK_ENTRY (table->name_entry), widget->name);
}
else if (table->name_entry)
gtk_entry_set_text (GTK_ENTRY (table->name_entry), "");
/* If this is a packing page, we need to generate the properties here... */
if (table->loaded_widget && table->type == GLADE_PAGE_PACKING)
append_packing_items (table, table->loaded_widget);
/* Sync up properties, even if widget is NULL */
for (list = table->properties; list; list = list->next)
{
property = list->data;
glade_editor_property_load_by_widget (property, widget);
}
table->loading = FALSE;
}
static void
glade_editor_table_editable_init (GladeEditableIface *iface)
{
iface->load = glade_editor_table_load;
}
static void
glade_editor_table_attach (GladeEditorTable *table,
GtkWidget *child,
gint pos, gint row)
{
gtk_table_attach (GTK_TABLE (table), child,
pos, pos+1, row, row +1,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL,
3, 1);
}
static gint
property_class_comp (gconstpointer a, gconstpointer b)
{
const GladePropertyClass *ca = a, *cb = b;
if (ca->pspec->owner_type == cb->pspec->owner_type)
{
gdouble result = ca->weight - cb->weight;
/* 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 (ca->pspec->owner_type, cb->pspec->owner_type))
return (ca->common || ca->packing) ? 1 : -1;
else
return (ca->common || ca->packing) ? -1 : 1;
}
}
static GList *
get_sorted_properties (GladeWidgetAdaptor *adaptor,
GladeEditorPageType type)
{
GList *l, *list = NULL;
for (l = adaptor->properties; l && l->data; l = g_list_next (l))
{
GladePropertyClass *klass = l->data;
/* Collect properties in our domain, query dialogs are allowed editor invisible properties */
if (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_WIDGET_ADAPTOR (klass->handle),
klass, from_query_dialog == FALSE)))
{
g_critical ("Unable to create editor for property '%s' of class '%s'",
klass->id, GLADE_WIDGET_ADAPTOR (klass->handle)->name);
return NULL;
}
gtk_widget_show (GTK_WIDGET (property));
gtk_widget_show_all (property->item_label);
glade_editor_table_attach (table, property->item_label, 0, table->rows);
glade_editor_table_attach (table, GTK_WIDGET (property), 1, table->rows);
table->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->properties = g_list_prepend (table->properties, property);
}
g_list_free (sorted_list);
table->properties = g_list_reverse (table->properties);
}
static void
append_packing_items (GladeEditorTable *table,
GladeWidget *widget)
{
GladeEditorProperty *eprop;
GladeProperty *property;
GList *list;
for (list = widget->packing_properties; list != NULL; list = list->next)
{
property = list->data;
eprop = append_item (table, property->klass, FALSE);
table->properties = g_list_prepend (table->properties, eprop);
}
table->properties = g_list_reverse (table->properties);
}
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->loading) return;
widget = table->loaded_widget;
new_name = gtk_editable_get_chars (GTK_EDITABLE (editable), 0, -1);
if (glade_project_available_widget_name (widget->project, widget, new_name))
glade_command_set_name (widget, new_name);
g_free (new_name);
}
static void
append_name_field (GladeEditorTable *table)
{
GtkWidget *label;
gchar *text = _("The Object's name");
/* Name */
label = gtk_label_new (_("Name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
table->name_entry = gtk_entry_new ();
gtk_widget_show (table->name_entry);
gtk_widget_set_tooltip_text (label, text);
gtk_widget_set_tooltip_text (table->name_entry, text);
g_signal_connect (G_OBJECT (table->name_entry), "activate",
G_CALLBACK (widget_name_edited), table);
g_signal_connect (G_OBJECT (table->name_entry), "changed",
G_CALLBACK (widget_name_edited), table);
glade_editor_table_attach (table, label, 0, table->rows);
glade_editor_table_attach (table, table->name_entry, 1, table->rows);
table->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->adaptor = adaptor;
table->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);
}
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* 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>
*/
#ifndef _GLADE_EDITOR_BUTTON_H_
#define _GLADE_EDITOR_BUTTON_H_
#include <gtk/gtk.h>
#include <gladeui/glade-editable.h>
G_BEGIN_DECLS
#define GLADE_TYPE_EDITOR_TABLE (glade_editor_table_get_type ())
#define GLADE_EDITOR_TABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GLADE_TYPE_EDITOR_TABLE, GladeEditorTable))
#define GLADE_EDITOR_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GLADE_TYPE_EDITOR_TABLE, GladeEditorTableClass))
#define GLADE_IS_EDITOR_TABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GLADE_TYPE_EDITOR_TABLE))
#define GLADE_IS_EDITOR_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GLADE_TYPE_EDITOR_TABLE))
#define GLADE_EDITOR_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GLADE_TYPE_EDITOR_TABLE, GladeEditorEditorClass))
typedef struct _GladeEditorTable GladeEditorTable;
typedef struct _GladeEditorTableClass GladeEditorTableClass;
struct _GladeEditorTable
{
GtkTable parent;
GladeWidgetAdaptor *adaptor; /* The GladeWidgetAdaptor this
* table was created for.
*/
GladeWidget *loaded_widget; /* A pointer to the currently loaded GladeWidget
*/
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 ?
*/
gboolean loading; /* Avoid recursion while loading values into widgets
*/
gint rows;
};
struct _GladeEditorTableClass
{
GtkTableClass parent;
};
GType glade_editor_table_get_type (void);
GtkWidget *glade_editor_table_new (GladeWidgetAdaptor *adaptor,
GladeEditorPageType type);
G_END_DECLS
#endif /* _GLADE_EDITOR_TABLE_H_ */
This diff is collapsed.
......@@ -3,6 +3,7 @@
#define __GLADE_EDITOR_H__
#include <gladeui/glade-signal-editor.h>
#include <gladeui/glade-editable.h>
G_BEGIN_DECLS
......@@ -14,21 +15,8 @@ G_BEGIN_DECLS
#define GLADE_IS_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GLADE_TYPE_EDITOR))
#define GLADE_EDITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GLADE_TYPE_EDITOR, GladeEditorClass))
#define GLADE_EDITOR_TABLE(t) ((GladeEditorTable *)t)
#define GLADE_IS_EDITOR_TABLE(t) (t != NULL)
typedef struct _GladeEditor GladeEditor;
typedef struct _GladeEditorClass GladeEditorClass;
typedef struct _GladeEditorTable GladeEditorTable;
typedef enum _GladeEditorTableType
{
TABLE_TYPE_GENERAL,
TABLE_TYPE_COMMON,
TABLE_TYPE_PACKING,
TABLE_TYPE_ATK,
TABLE_TYPE_QUERY
} GladeEditorTableType;
/* The GladeEditor is a window that is used to display and modify widget
* properties. The glade editor contains the details of the selected
......@@ -78,20 +66,15 @@ struct _GladeEditor
GladeSignalEditor *signal_editor; /* The signal editor packed into vbox_signals
*/
GList *widget_tables; /* A list of GladeEditorTable. We have a table
* (gtktable) for each GladeWidgetClass, if
* we don't have one yet, we create it when
* we are asked to load a widget of a particular
* GladeWidgetClass
*/
GladeEditorTable *packing_etable; /* Packing pages are dynamicly created each
* selection, this pointer is only to free
* the last packing page.
*/
GList *packing_eprops; /* Current list of packing GladeEditorProperties
*/
GList *editables; /* A list of GladeEditables. We have a widget
* for each GladeWidgetAdaptor and we only load
* them on demand
*/
GtkWidget *packing_page; /* Packing pages are dynamicly created each
* selection, this pointer is only to free
* the last packing page.
*/
gboolean loading; /* Use when loading a GladeWidget into the editor
* we set this flag so that we can ignore the
......@@ -100,15 +83,12 @@ struct _GladeEditor
* was loaded.
*/