static void
global_vars_view_value_data_func (GtkTreeViewColumn *col,
GtkCellRenderer *cell,
GtkTreeModel *global_vars_model,
GtkTreeIter *iter,
gpointer user_data)
{
gchar *name = NULL, *value = NULL;
SnippetsDB *snippets_db = NULL;
/* Assertions */
g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (cell));
g_return_if_fail (ANJUTA_IS_SNIPPETS_DB (user_data));
snippets_db = ANJUTA_SNIPPETS_DB (user_data);
/* Get the name */
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_NAME, &name,
-1);
value = snippets_db_get_global_variable (snippets_db, name);
g_object_set (cell, "text", value, NULL);
g_free (name);
}
static gboolean
get_text_foreach (GtkCellRenderer *renderer,
gchar **text)
{
if (GTK_IS_CELL_RENDERER_TEXT (renderer))
{
g_object_get (renderer, "text", text, NULL);
return TRUE;
}
return FALSE;
}
static void
gtvo_set_column_editor(GncTreeViewOwner *view,
GtkTreeViewColumn *column,
GncTreeViewOwnerColumnTextEdited edited_cb)
{
GList *renderers_orig, *renderers;
GtkCellRenderer *renderer;
// look for the first text-renderer; on the 0th column of the owner tree,
// there are two renderers: pixbuf and text. So find the text one.
for (renderers_orig = renderers = gtk_tree_view_column_get_cell_renderers(column);
renderers && !GTK_IS_CELL_RENDERER_TEXT(renderers->data);
renderers = renderers->next);
renderer = GTK_CELL_RENDERER(renderers->data);
g_list_free(renderers_orig);
g_return_if_fail(renderer != NULL);
gtvo_setup_column_renderer_edited_cb(GNC_TREE_VIEW_OWNER(view), column, renderer, edited_cb);
}
static void
global_vars_view_name_data_func (GtkTreeViewColumn *col,
GtkCellRenderer *cell,
GtkTreeModel *global_vars_model,
GtkTreeIter *iter,
gpointer user_data)
{
gchar *name = NULL;
gboolean is_internal = FALSE;
/* Assertions */
g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (cell));
/* Get the name */
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_NAME, &name,
-1);
/* Check if it's internal */
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_IS_INTERNAL, &is_internal,
-1);
if (is_internal)
{
gchar *temp = NULL;
temp = g_strconcat ("<b>", name, "</b> <i>(Internal)</i>", NULL);
g_free (name);
name = temp;
g_object_set (cell, "sensitive", FALSE, NULL);
g_object_set (cell, "editable", FALSE, NULL);
}
else
{
gchar *temp = NULL;
temp = g_strconcat ("<b>", name, "</b>", NULL);
g_free (name);
name = temp;
g_object_set (cell, "sensitive", TRUE, NULL);
g_object_set (cell, "editable", TRUE, NULL);
}
g_object_set (cell, "markup", name, NULL);
g_free (name);
}
GtkTreeView *view_connect(const char *name, ScpTreeStore **store, GtkTreeSelection **selection,
const TreeCell *cell_info, const char *window, GObject **display_cell)
{
guint i;
GtkScrolledWindow *scrolled = GTK_SCROLLED_WINDOW(get_widget(window));
GtkAdjustment *hadjustment = gtk_scrolled_window_get_hadjustment(scrolled);
GtkTreeView *tree = view_create(name, store, selection);
for (i = 0; cell_info->name; cell_info++, i++)
{
GtkCellRenderer *cell = GTK_CELL_RENDERER(get_object(cell_info->name));
const char *signame;
const char *property;
if (GTK_IS_CELL_RENDERER_TEXT(cell))
{
signame = "edited";
property = "editable";
g_signal_connect(cell, "editing-started", G_CALLBACK(on_editing_started),
hadjustment);
if (display_cell && i == 0)
{
g_signal_connect(cell, "editing-started",
G_CALLBACK(on_display_editing_started), *store);
*display_cell = G_OBJECT(cell);
}
}
else
{
g_assert(GTK_IS_CELL_RENDERER_TOGGLE(cell));
signame = "toggled";
property = "activatable";
}
g_signal_connect(cell, signame, cell_info->callback, GINT_TO_POINTER(i));
g_object_set(cell, property, TRUE, NULL);
}
return tree;
}
static gchar *
get_text_from_label_widget (GtkWidget *label)
{
if (GTK_IS_LABEL (label))
return g_strdup (gtk_label_get_text (GTK_LABEL (label)));
else if (GTK_IS_CELL_VIEW (label))
{
GList *cells, *l;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
GtkCellArea *area;
gchar *text;
model = gtk_cell_view_get_model (GTK_CELL_VIEW (label));
path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (label));
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (label));
gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (label));
text = NULL;
for (l = cells; l; l = l->next)
{
GtkCellRenderer *cell = l->data;
if (GTK_IS_CELL_RENDERER_TEXT (cell))
{
g_object_get (cell, "text", &text, NULL);
break;
}
}
g_list_free (cells);
return text;
}
return NULL;
}
void
cc_shell_item_view_update_cells (CcShellItemView *view)
{
GList *cells, *l;
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (view));
for (l = cells ; l != NULL; l = l->next)
{
GtkCellRenderer *cell = l->data;
if (GTK_IS_CELL_RENDERER_TEXT (cell)) {
g_object_set (G_OBJECT (cell),
"wrap-mode", PANGO_WRAP_WORD,
NULL);
/* We only have one text cell */
break;
}
}
g_list_free (cells);
}
void
render_name (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GValue *val;
GnomeVFSFileInfo *info;
gint valid;
puts("entering render_name");
// g_object_set (G_OBJECT(cell), "text", "bu", NULL);
// return;
gtk_tree_model_get (tree_model, iter,
COLUMN_ONE, &info,
COLUMN_TWO, &valid,
-1);
puts("value get");
// if (valid) goto done;
puts(info->name);
//puts("checking type");
// g_return_if_fail (G_VALUE_HOLDS_POINTER(val));
//puts("extracting data");
// info = g_value_get_pointer (val);
/* FIXME: handle possible errors */
g_return_if_fail (info != NULL);
// g_value_unset (val);
g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (cell));
g_object_set (G_OBJECT(cell), "text", info->name, NULL);
gtk_list_store_set(GTK_LIST_STORE(tree_model), iter, COLUMN_TWO, 1, -1);
done:
puts("leaving render_name");
}
static void
cell_data_func (GtkTreeViewColumn *column,
GtkCellRenderer *renderer,
GtkTreeModel *model,
GtkTreeIter *iter,
GladeEditorProperty *eprop)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
gboolean dummy;
GdkRGBA color;
gtk_tree_model_get (model, iter, COLUMN_DUMMY, &dummy, -1);
if (GTK_IS_CELL_RENDERER_TEXT (renderer))
{
GtkStyleContext* context = gtk_widget_get_style_context (eprop_string_list->view);
if (dummy)
{
gtk_style_context_save (context);
gtk_style_context_set_state (context, gtk_style_context_get_state (context) | GTK_STATE_FLAG_INSENSITIVE);
gtk_style_context_get_color (context, gtk_style_context_get_state (context), &color);
gtk_style_context_restore (context);
g_object_set (renderer,
"style", PANGO_STYLE_ITALIC,
"foreground-rgba", &color,
NULL);
}
else
{
gtk_style_context_get_color (context, gtk_style_context_get_state (context), &color);
g_object_set (renderer,
"style", PANGO_STYLE_NORMAL,
"foreground-rgba", &color,
NULL);
}
}
else if (GLADE_IS_CELL_RENDERER_ICON (renderer))
g_object_set (renderer, "visible", !dummy && eprop_string_list->translatable, NULL);
}
static void
global_vars_view_text_data_func (GtkTreeViewColumn *col,
GtkCellRenderer *cell,
GtkTreeModel *global_vars_model,
GtkTreeIter *iter,
gpointer user_data)
{
gchar *name = NULL, *text = NULL;
SnippetsDB *snippets_db = NULL;
gboolean is_internal = FALSE;
/* Assertions */
g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (cell));
g_return_if_fail (ANJUTA_IS_SNIPPETS_DB (user_data));
snippets_db = ANJUTA_SNIPPETS_DB (user_data);
/* Get the name */
gtk_tree_model_get (global_vars_model, iter,
GLOBAL_VARS_MODEL_COL_NAME, &name,
GLOBAL_VARS_MODEL_COL_IS_INTERNAL, &is_internal,
-1);
if (is_internal)
{
g_object_set (cell, "editable", FALSE, NULL);
}
else
{
g_object_set (cell, "editable", TRUE, NULL);
}
text = snippets_db_get_global_variable_text (snippets_db, name);
g_object_set (cell, "text", text, NULL);
g_free (name);
g_free (text);
}
/**
* na_gtk_utils_set_editable:
* @widget: the #GtkWdiget.
* @editable: whether the @widget is editable or not.
*
* Try to set a visual indication of whether the @widget is editable or not.
*
* Having a GtkWidget should be enough, but we also deal with a GtkTreeViewColumn.
* So the most-bottom common ancestor is just GObject (since GtkObject having been
* deprecated in Gtk+-3.0)
*
* Note that using 'sensitivity' property is just a work-around because the
* two things have distinct semantics:
* - editable: whether we are allowed to modify the value (is not read-only)
* - sensitive: whether the value is relevant (has a sense in this context)
*/
void
na_gtk_utils_set_editable( GObject *widget, gboolean editable )
{
GList *renderers, *irender;
/* GtkComboBoxEntry is deprecated from Gtk+3
* see. http://git.gnome.org/browse/gtk+/commit/?id=9612c648176378bf237ad0e1a8c6c995b0ca7c61
* while 'has_entry' property exists since 2.24
*/
#if GTK_CHECK_VERSION( 2,24,0 )
if( GTK_IS_COMBO_BOX( widget ) && gtk_combo_box_get_has_entry( GTK_COMBO_BOX( widget ))){
#else
if( GTK_IS_COMBO_BOX_ENTRY( widget )){
#endif
/* idem as GtkEntry */
gtk_editable_set_editable( GTK_EDITABLE( gtk_bin_get_child( GTK_BIN( widget ))), editable );
g_object_set( G_OBJECT( gtk_bin_get_child( GTK_BIN( widget ))), "can-focus", editable, NULL );
/* disable the listbox button itself */
gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF );
} else if( GTK_IS_COMBO_BOX( widget )){
/* disable the listbox button itself */
gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF );
} else if( GTK_IS_ENTRY( widget )){
gtk_editable_set_editable( GTK_EDITABLE( widget ), editable );
/* removing the frame leads to a disturbing modification of the
* height of the control */
/*g_object_set( G_OBJECT( widget ), "has-frame", editable, NULL );*/
/* this prevents the caret to be displayed when we click in the entry */
g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );
} else if( GTK_IS_TEXT_VIEW( widget )){
g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );
gtk_text_view_set_editable( GTK_TEXT_VIEW( widget ), editable );
} else if( GTK_IS_TOGGLE_BUTTON( widget )){
/* transforms to a quasi standard GtkButton */
/*g_object_set( G_OBJECT( widget ), "draw-indicator", editable, NULL );*/
/* this at least prevent the keyboard focus to go to the button
* (which is better than nothing) */
g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );
} else if( GTK_IS_TREE_VIEW_COLUMN( widget )){
renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( GTK_TREE_VIEW_COLUMN( widget )));
for( irender = renderers ; irender ; irender = irender->next ){
if( GTK_IS_CELL_RENDERER_TEXT( irender->data )){
g_object_set( G_OBJECT( irender->data ), "editable", editable, "editable-set", TRUE, NULL );
}
}
g_list_free( renderers );
} else if( GTK_IS_BUTTON( widget )){
gtk_widget_set_sensitive( GTK_WIDGET( widget ), editable );
}
}
/**
* na_gtk_utils_radio_set_initial_state:
* @button: the #GtkRadioButton button which is initially active.
* @handler: the corresponding "toggled" handler.
* @user_data: the user data associated to the handler.
* @editable: whether this radio button group is editable.
* @sensitive: whether this radio button group is sensitive.
*
* This function should be called for the button which is initially active
* inside of a radio button group when the radio group may happen to not be
* editable.
* This function should be called only once for the radio button group.
*
* It does the following operations:
* - set the button as active
* - set other buttons of the radio button group as icactive
* - set all buttons of radio button group as @editable
*
* The initially active @button, along with its @handler, are recorded
* as properties of the radio button group (actually as properties of each
* radio button of the group), so that they can later be used to reset the
* initial state.
*/
void
na_gtk_utils_radio_set_initial_state( GtkRadioButton *button,
GCallback handler, void *user_data, gboolean editable, gboolean sensitive )
{
GSList *group, *ig;
GtkRadioButton *other;
group = gtk_radio_button_get_group( button );
for( ig = group ; ig ; ig = ig->next ){
other = GTK_RADIO_BUTTON( ig->data );
g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_BUTTON, button );
g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_HANDLER, handler );
g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_USER_DATA, user_data );
g_object_set_data( G_OBJECT( other ), NA_TOGGLE_DATA_EDITABLE, GUINT_TO_POINTER( editable ));
na_gtk_utils_set_editable( G_OBJECT( other ), editable );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( other ), FALSE );
gtk_widget_set_sensitive( GTK_WIDGET( other ), sensitive );
}
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( button ), TRUE );
}
static void
egg_property_cell_renderer_set_renderer (EggPropertyCellRenderer *renderer,
const gchar *prop_name)
{
EggPropertyCellRendererPrivate *priv;
GParamSpec *pspec;
gchar *text = NULL;
gdouble number;
priv = EGG_PROPERTY_CELL_RENDERER_GET_PRIVATE (renderer);
pspec = get_pspec_from_object (priv->object, prop_name);
/*
* Set this renderers mode, so that any actions can be forwarded to our
* child renderers.
*/
switch (pspec->value_type) {
/* toggle renderers */
case G_TYPE_BOOLEAN:
priv->renderer = priv->toggle_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
break;
/* spin renderers */
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
priv->renderer = priv->spin_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
g_object_set (priv->renderer, "digits", 5, NULL);
break;
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_INT64:
case G_TYPE_UINT64:
priv->renderer = priv->spin_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
g_object_set (priv->renderer, "digits", 0, NULL);
break;
/* text renderers */
case G_TYPE_POINTER:
case G_TYPE_STRING:
priv->renderer = priv->text_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
break;
/* combo renderers */
default:
if (G_TYPE_IS_ENUM (pspec->value_type)) {
priv->renderer = priv->combo_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
}
break;
}
/*
* Set the content from the objects property.
*/
switch (pspec->value_type) {
case G_TYPE_BOOLEAN:
{
gboolean val;
g_object_get (priv->object, prop_name, &val, NULL);
g_object_set (priv->renderer,
"active", val,
"activatable", pspec->flags & G_PARAM_WRITABLE ? TRUE : FALSE,
NULL);
break;
}
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_INT64:
case G_TYPE_UINT64:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
get_string_double_repr (priv->object, prop_name, &text, &number);
break;
case G_TYPE_STRING:
g_object_get (priv->object, prop_name, &text, NULL);
break;
case G_TYPE_POINTER:
{
gpointer val;
g_object_get (priv->object, prop_name, &val, NULL);
text = g_strdup_printf ("0x%x", GPOINTER_TO_INT (val));
}
break;
default:
if (G_TYPE_IS_ENUM (pspec->value_type)) {
GParamSpecEnum *pspec_enum;
GEnumClass *enum_class;
GtkTreeModel *combo_model;
GtkTreeIter iter;
gint value;
g_object_get (priv->object, prop_name, &value, NULL);
pspec_enum = G_PARAM_SPEC_ENUM (pspec);
enum_class = pspec_enum->enum_class;
combo_model = g_hash_table_lookup (priv->combo_models, prop_name);
if (combo_model == NULL) {
combo_model = GTK_TREE_MODEL (gtk_list_store_new (N_COMBO_COLUMNS, G_TYPE_STRING, G_TYPE_INT));
g_hash_table_insert (priv->combo_models, g_strdup (prop_name), combo_model);
for (guint i = 0; i < enum_class->n_values; i++) {
gtk_list_store_append (GTK_LIST_STORE (combo_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (combo_model), &iter,
COMBO_COLUMN_VALUE_NAME, enum_class->values[i].value_name,
COMBO_COLUMN_VALUE, enum_class->values[i].value,
-1);
}
}
for (guint i = 0; i < enum_class->n_values; i++) {
if (enum_class->values[i].value == value)
text = g_strdup (enum_class->values[i].value_name);
}
g_object_set (priv->renderer,
"model", combo_model,
"text-column", 0,
NULL);
}
break;
}
if (pspec->flags & G_PARAM_WRITABLE) {
if (GTK_IS_CELL_RENDERER_TOGGLE (priv->renderer))
g_object_set (priv->renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
else
g_object_set (priv->renderer, "foreground", "#000000", NULL);
if (GTK_IS_CELL_RENDERER_TEXT (priv->renderer)) {
g_object_set (priv->renderer,
"editable", TRUE,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
NULL);
}
if (GTK_IS_CELL_RENDERER_SPIN (priv->renderer)) {
GtkObject *adjustment = NULL;
#define gtk_typed_adjustment_new(type, pspec, val, step_inc, page_inc) \
gtk_adjustment_new (val, ((type *) pspec)->minimum, ((type *) pspec)->maximum, step_inc, page_inc, 0)
switch (pspec->value_type) {
case G_TYPE_INT:
adjustment = gtk_typed_adjustment_new (GParamSpecInt, pspec, number, 1, 10);
break;
case G_TYPE_UINT:
adjustment = gtk_typed_adjustment_new (GParamSpecUInt, pspec, number, 1, 10);
break;
case G_TYPE_LONG:
adjustment = gtk_typed_adjustment_new (GParamSpecLong, pspec, number, 1, 10);
break;
case G_TYPE_ULONG:
adjustment = gtk_typed_adjustment_new (GParamSpecULong, pspec, number, 1, 10);
break;
case G_TYPE_INT64:
adjustment = gtk_typed_adjustment_new (GParamSpecInt64, pspec, number, 1, 10);
break;
case G_TYPE_UINT64:
adjustment = gtk_typed_adjustment_new (GParamSpecUInt64, pspec, number, 1, 10);
break;
case G_TYPE_FLOAT:
adjustment = gtk_typed_adjustment_new (GParamSpecFloat, pspec, number, 0.05, 10);
break;
case G_TYPE_DOUBLE:
adjustment = gtk_typed_adjustment_new (GParamSpecDouble, pspec, number, 0.05, 10);
break;
}
clear_adjustment (G_OBJECT (priv->renderer));
g_object_set (priv->renderer, "adjustment", adjustment, NULL);
}
}
else {
g_object_set (priv->renderer, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
if (!GTK_IS_CELL_RENDERER_TOGGLE (priv->renderer))
g_object_set (priv->renderer, "foreground", "#aaaaaa", NULL);
}
if (text != NULL) {
g_object_set (priv->renderer, "text", text, NULL);
g_free (text);
}
}
