static void
custom_cell_renderer_progress_init (CustomCellRendererProgress *cellrendererprogress)
{
GTK_CELL_RENDERER(cellrendererprogress)->mode = GTK_CELL_RENDERER_MODE_INERT;
GTK_CELL_RENDERER(cellrendererprogress)->xpad = 2;
GTK_CELL_RENDERER(cellrendererprogress)->ypad = 2;
}
/*! \brief Create a ComboBox with the gschem fill styles.
*
* \return GtkWidget
*/
GtkWidget*
x_fstylecb_new ()
{
GtkComboBox *combo;
GtkCellLayout *layout;
GtkCellRenderer *swatch_cell;
GtkCellRenderer *text_cell;
if (fstyle_list_store == NULL) {
fstyle_list_store = create_fstyle_list_store ();
}
combo = GTK_COMBO_BOX (gtk_combo_box_new_with_model (GTK_TREE_MODEL (fstyle_list_store)));
layout = GTK_CELL_LAYOUT (combo); /* For convenience */
/* Renders the fill swatch. Since this won't contain text, set a
* minimum width. */
swatch_cell = GTK_CELL_RENDERER (gschem_fill_swatch_cell_renderer_new ());
g_object_set (swatch_cell, "width", 25, NULL);
gtk_cell_layout_pack_start (layout, swatch_cell, FALSE);
gtk_cell_layout_add_attribute (layout, swatch_cell, "fill-type", COLUMN_INDEX);
/* Renders the name of the fill style */
text_cell = GTK_CELL_RENDERER (gtk_cell_renderer_text_new());
g_object_set (text_cell, "xpad", 5, NULL);
gtk_cell_layout_pack_start (layout, text_cell, TRUE);
gtk_cell_layout_add_attribute (layout, text_cell, "text", COLUMN_NAME);
return GTK_WIDGET (combo);
}
static void
book_tree_add_columns (DhBookTree *tree)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new ();
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_pixbuf_new ());
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", COL_OPEN_PIXBUF,
"pixbuf-expander-open", COL_OPEN_PIXBUF,
"pixbuf-expander-closed", COL_CLOSED_PIXBUF,
NULL);
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_TITLE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
}
static void
gqv_cell_renderer_icon_init(GQvCellRendererIcon *cellicon)
{
GTK_CELL_RENDERER(cellicon)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
GTK_CELL_RENDERER(cellicon)->xpad = 2;
GTK_CELL_RENDERER(cellicon)->ypad = 2;
}
static void
thunar_icon_renderer_init (ThunarIconRenderer *icon_renderer)
{
/* use 1px padding */
GTK_CELL_RENDERER (icon_renderer)->xpad = 1;
GTK_CELL_RENDERER (icon_renderer)->ypad = 1;
}
/***************************************************************************
*
* custom_cell_renderer_button_init: set some default properties of the
* parent (GtkCellRendererPixbuf).
*
***************************************************************************/
static void
custom_cell_renderer_button_init (CustomCellRendererButton *cellbutton)
{
GTK_CELL_RENDERER(cellbutton)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
GTK_CELL_RENDERER(cellbutton)->xpad = 2;
GTK_CELL_RENDERER(cellbutton)->ypad = 2;
}
static void
git_stash_pane_init (GitStashPane *self)
{
gchar *objects[] = {"stash_pane",
"stash_model",
NULL};
GError *error = NULL;
GtkTreeView *stash_view;
GtkTreeViewColumn *stash_number_column;
GtkCellRenderer *stash_number_renderer;
GtkTreeViewColumn *stash_message_column;
GtkCellRenderer *stash_message_renderer;
GtkCellRenderer *diff_renderer;
GtkTreeSelection *selection;
self->priv = g_new0 (GitStashPanePriv, 1);
self->priv->builder = gtk_builder_new ();
if (!gtk_builder_add_objects_from_file (self->priv->builder, BUILDER_FILE,
objects,
&error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
stash_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder,
"stash_view"));
stash_number_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"stash_number_column"));
stash_number_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"stash_number_renderer"));
stash_message_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"stash_message_column"));
stash_message_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"stash_message_renderer"));
diff_renderer = anjuta_cell_renderer_diff_new ();
selection = gtk_tree_view_get_selection (stash_view);
gtk_tree_view_column_set_cell_data_func (stash_number_column, stash_number_renderer,
stash_number_renderer_data_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (stash_message_column, stash_message_renderer,
stash_message_renderer_data_func,
NULL, NULL);
gtk_tree_view_column_pack_start (stash_message_column, diff_renderer, TRUE);
gtk_tree_view_column_add_attribute (stash_message_column, diff_renderer,
"diff", COL_DIFF);
/* Don't allow diffs to be selected */
gtk_tree_selection_set_select_function (selection, on_stash_view_row_selected,
NULL, NULL);
g_signal_connect (G_OBJECT (stash_view), "button-press-event",
G_CALLBACK (on_stash_view_button_press_event),
self);
}
static void
gtk_cell_renderer_text_init (GtkCellRendererText *celltext)
{
GTK_CELL_RENDERER (celltext)->xalign = 0.0;
GTK_CELL_RENDERER (celltext)->yalign = 0.5;
GTK_CELL_RENDERER (celltext)->xpad = 2;
GTK_CELL_RENDERER (celltext)->ypad = 2;
celltext->fixed_height_rows = -1;
celltext->font = pango_font_description_new ();
}
static void
freetuxtv_cellrenderer_channelslist_init (FreetuxTVCellRendererChannelsList *self)
{
#if GTK_API_VERSION == 3
gtk_cell_renderer_set_padding (GTK_CELL_RENDERER(self), 2, 2);
#else
GTK_CELL_RENDERER(self)->mode = GTK_CELL_RENDERER_MODE_INERT;
GTK_CELL_RENDERER(self)->xpad = 2;
GTK_CELL_RENDERER(self)->ypad = 2;
#endif
}
/**
* uploads_get_dialog:
*
* Returns the a #GtkWindow representing the Uploads window. If it
* has not already been created, it creates it. The Uploads window is
* set to be hidden instead of destroyed when closed, to avoid having
* to recreate it and re-parse the UI file, etc.
**/
static GtkWindow *
uploads_get_dialog (XviewerPostasaPlugin *plugin)
{
GtkBuilder *builder;
GError *error = NULL;
GtkButton *cancel_button;
GtkButton *cancel_all_button;
if (plugin->priv->uploads_window == NULL) {
builder = gtk_builder_new ();
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
gtk_builder_add_from_resource (builder, GTKBUILDER_UPLOAD_FILE,
&error);
if (error != NULL) {
g_warning ("Couldn't load Postasa uploads UI file:%d:%s", error->code, error->message);
g_error_free (error);
return NULL;
}
/* note: do not unref gtk_builder_get_object() returns */
plugin->priv->uploads_window = GTK_WINDOW (gtk_builder_get_object (builder, "uploads_window"));
plugin->priv->uploads_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "uploads_view"));
plugin->priv->uploads_store = GTK_LIST_STORE (gtk_builder_get_object (builder, "uploads_store"));
cancel_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_button"));
cancel_all_button = GTK_BUTTON (gtk_builder_get_object (builder, "cancel_all_button"));
/* TODO: can't set expand = TRUE when packing cells into columns via glade-3/GtkBuilder apparently?
bgo #602152 So for now, we take them, clear them out, and remap them. Ugh. Better solutions welcome. */
GtkTreeViewColumn *file_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "file_col"));
GtkCellRenderer *thumbnail_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "thumbnail_cell"));
GtkCellRenderer *filepath_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "filepath_cell"));
gtk_tree_view_column_clear (file_col);
gtk_tree_view_column_pack_start (file_col, thumbnail_cell, FALSE);
gtk_tree_view_column_pack_end (file_col, filepath_cell, TRUE);
gtk_tree_view_column_add_attribute (file_col, thumbnail_cell, "pixbuf", 0);
gtk_tree_view_column_add_attribute (file_col, filepath_cell, "text", 1);
GtkTreeViewColumn *progress_col = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, "progress_col"));
GtkCellRenderer *progress_cell = GTK_CELL_RENDERER (gtk_builder_get_object (builder, "progress_cell"));
gtk_tree_view_column_clear (progress_col);
gtk_tree_view_column_pack_end (progress_col, progress_cell, TRUE);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "pulse", 3);
gtk_tree_view_column_add_attribute (progress_col, progress_cell, "text", 5);
g_object_unref (builder);
g_signal_connect (G_OBJECT (cancel_button), "clicked", G_CALLBACK (uploads_cancel_cb), plugin);
g_signal_connect (G_OBJECT (cancel_all_button), "clicked", G_CALLBACK (uploads_cancel_all_cb), plugin);
g_signal_connect (G_OBJECT (plugin->priv->uploads_window), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), plugin);
}
return plugin->priv->uploads_window;
}
static void
empathy_cell_renderer_expander_init (EmpathyCellRendererExpander *expander)
{
EmpathyCellRendererExpanderPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (expander,
EMPATHY_TYPE_CELL_RENDERER_EXPANDER, EmpathyCellRendererExpanderPriv);
expander->priv = priv;
priv->expander_style = GTK_EXPANDER_COLLAPSED;
priv->expander_size = 12;
priv->activatable = TRUE;
priv->animation_node = NULL;
GTK_CELL_RENDERER (expander)->xpad = 2;
GTK_CELL_RENDERER (expander)->ypad = 2;
GTK_CELL_RENDERER (expander)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
}
static GtkTreeViewColumn *divelist_column(struct DiveList *dl, int index, const char *title,
data_func_t data_func, PangoAlignment align)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
double xalign = 0.0; /* left as default */
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_sort_column_id(col, index);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
if (data_func)
gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, NULL, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", index);
gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
switch (align) {
case PANGO_ALIGN_LEFT:
xalign = 0.0;
break;
case PANGO_ALIGN_CENTER:
xalign = 0.5;
break;
case PANGO_ALIGN_RIGHT:
xalign = 1.0;
break;
}
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(dl->tree_view), col);
return col;
}
static void
set_pixbuf (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
GdkPixbuf *pixbuf = NULL;
CongServiceDocumentFactory *factory;
gtk_tree_model_get (model, iter,
NEWDOCTYPELIST_FACTORY_COLUMN, &factory,
-1);
if (NULL==factory) {
return;
}
pixbuf = cong_document_factory_get_icon(factory);
g_object_set (GTK_CELL_RENDERER (cell), "pixbuf", pixbuf, NULL);
if (pixbuf) {
g_object_unref (pixbuf);
}
}
static void
gossip_cell_renderer_expander_init (GossipCellRendererExpander *expander)
{
GossipCellRendererExpanderPriv *priv;
priv = GET_PRIV (expander);
priv->expander_style = GTK_EXPANDER_COLLAPSED;
priv->expander_size = 12;
priv->activatable = TRUE;
priv->animation_node = NULL;
GTK_CELL_RENDERER (expander)->xpad = 2;
GTK_CELL_RENDERER (expander)->ypad = 2;
GTK_CELL_RENDERER (expander)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
}
static void
attachment_button_update_pixbufs (EAttachmentButton *button)
{
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
GdkPixbuf *pixbuf_expander_open;
GdkPixbuf *pixbuf_expander_closed;
GList *list;
/* Grab the first cell renderer. */
cell_layout = GTK_CELL_LAYOUT (button->priv->cell_view);
list = gtk_cell_layout_get_cells (cell_layout);
renderer = GTK_CELL_RENDERER (list->data);
g_list_free (list);
pixbuf_expander_open = gtk_widget_render_icon (
GTK_WIDGET (button), GTK_STOCK_GO_DOWN,
GTK_ICON_SIZE_BUTTON, NULL);
pixbuf_expander_closed = gtk_widget_render_icon (
GTK_WIDGET (button), GTK_STOCK_GO_FORWARD,
GTK_ICON_SIZE_BUTTON, NULL);
g_object_set (
renderer,
"pixbuf-expander-open", pixbuf_expander_open,
"pixbuf-expander-closed", pixbuf_expander_closed,
NULL);
g_object_unref (pixbuf_expander_open);
g_object_unref (pixbuf_expander_closed);
}
static void plugin_disable_set_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
{
gboolean disabled;
gtk_tree_model_get(tree_model, iter, DESKTOP_FILE_COLUMN_DISABLED, &disabled, -1);
if (disabled)
{
g_object_set(GTK_CELL_RENDERER(cell), "active", TRUE, NULL);
}
else
{
g_object_set(GTK_CELL_RENDERER(cell), "active", FALSE, NULL);
}
}
static void
get_size_full( TorrentCellRenderer * cell,
GtkWidget * widget,
gint * width,
gint * height )
{
int w, h;
int xpad, ypad;
GdkRectangle icon_area;
GdkRectangle name_area;
GdkRectangle stat_area;
GdkRectangle prog_area;
const char * name;
GdkPixbuf * icon;
struct TorrentCellRendererPrivate * p = cell->priv;
const tr_torrent * tor = p->tor;
const tr_stat * st = tr_torrentStatCached( (tr_torrent*)tor );
const tr_info * inf = tr_torrentInfo( tor );
GString * gstr_prog = p->gstr1;
GString * gstr_stat = p->gstr2;
icon = get_icon( tor, FULL_ICON_SIZE, widget );
name = tr_torrentName( tor );
g_string_truncate( gstr_stat, 0 );
getStatusString( gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps );
g_string_truncate( gstr_prog, 0 );
getProgressString( gstr_prog, tor, inf, st );
gtr_cell_renderer_get_padding( GTK_CELL_RENDERER( cell ), &xpad, &ypad );
/* get the idealized cell dimensions */
g_object_set( p->icon_renderer, "pixbuf", icon, NULL );
gtk_cell_renderer_get_size( p->icon_renderer, widget, NULL, NULL, NULL, &w, &h );
icon_area.width = w;
icon_area.height = h;
g_object_set( p->text_renderer, "text", name, "weight", PANGO_WEIGHT_BOLD, "scale", 1.0, "ellipsize", PANGO_ELLIPSIZE_NONE, NULL );
gtk_cell_renderer_get_size( p->text_renderer, widget, NULL, NULL, NULL, &w, &h );
name_area.width = w;
name_area.height = h;
g_object_set( p->text_renderer, "text", gstr_prog->str, "weight", PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL );
gtk_cell_renderer_get_size( p->text_renderer, widget, NULL, NULL, NULL, &w, &h );
prog_area.width = w;
prog_area.height = h;
g_object_set( p->text_renderer, "text", gstr_stat->str, NULL );
gtk_cell_renderer_get_size( p->text_renderer, widget, NULL, NULL, NULL, &w, &h );
stat_area.width = w;
stat_area.height = h;
/**
*** LAYOUT
**/
if( width != NULL )
*width = xpad * 2 + icon_area.width + GUI_PAD + MAX3( name_area.width, prog_area.width, stat_area.width );
if( height != NULL )
*height = ypad * 2 + name_area.height + prog_area.height + GUI_PAD_SMALL + p->bar_height + GUI_PAD_SMALL + stat_area.height;
/* cleanup */
g_object_unref( icon );
}
static void
attachment_button_update_pixbufs (EAttachmentButton *button)
{
GtkIconTheme *icon_theme;
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
GdkPixbuf *pixbuf_expander_open;
GdkPixbuf *pixbuf_expander_closed;
GList *list;
icon_theme = gtk_icon_theme_get_default ();
/* Grab the first cell renderer. */
cell_layout = GTK_CELL_LAYOUT (button->priv->cell_view);
list = gtk_cell_layout_get_cells (cell_layout);
renderer = GTK_CELL_RENDERER (list->data);
g_list_free (list);
pixbuf_expander_open = gtk_icon_theme_load_icon (
icon_theme, "go-down",
GTK_ICON_SIZE_BUTTON, 0, NULL);
pixbuf_expander_closed = gtk_icon_theme_load_icon (
icon_theme, "go-next",
GTK_ICON_SIZE_BUTTON, 0, NULL);
g_object_set (
renderer,
"pixbuf-expander-open", pixbuf_expander_open,
"pixbuf-expander-closed", pixbuf_expander_closed,
NULL);
g_object_unref (pixbuf_expander_open);
g_object_unref (pixbuf_expander_closed);
}
GtkCellRenderer *trg_cell_renderer_numgteqthan_new(gint64 minvalue)
{
return
GTK_CELL_RENDERER(g_object_new
(TRG_TYPE_CELL_RENDERER_NUMGTEQTHAN, "minvalue",
minvalue, NULL));
}
static void
marlin_text_renderer_editing_done (GtkCellEditable *editable,
MarlinTextRenderer *text_renderer)
{
const gchar *path;
const gchar *text;
gboolean canceled;
//renametest
//printf ("%s\n", G_STRFUNC);
/* disconnect our signals from the cell editable */
g_signal_handlers_disconnect_by_func (G_OBJECT (editable), marlin_text_renderer_focus_out_event, text_renderer);
g_signal_handlers_disconnect_by_func (G_OBJECT (editable), marlin_text_renderer_editing_done, text_renderer);
g_signal_handlers_disconnect_by_func (G_OBJECT (editable), marlin_text_renderer_populate_popup, text_renderer);
g_object_get (editable, "editing-canceled", &canceled, NULL);
/* let the GtkCellRenderer class do it's part of the job */
gtk_cell_renderer_stop_editing (GTK_CELL_RENDERER (text_renderer), canceled);
/* inform whoever is interested that we have new text (if not cancelled) */
if (G_LIKELY (!canceled))
{
//text = gtk_entry_get_text (GTK_ENTRY (editable));
text = eel_editable_label_get_text (EEL_EDITABLE_LABEL (editable));
path = g_object_get_data (G_OBJECT (editable), "marlin-text-renderer-path");
g_signal_emit (G_OBJECT (text_renderer), text_renderer_signals[EDITED], 0, path, text);
}
}
static void
gail_text_cell_get_character_extents (AtkText *text,
gint offset,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coords)
{
GailRendererCell *gail_renderer;
GtkCellRendererText *gtk_renderer;
GdkRectangle rendered_rect;
GtkWidget *widget;
AtkObject *parent;
PangoRectangle char_rect;
PangoLayout *layout;
gint x_offset, y_offset, index, cell_height, cell_width;
if (!GAIL_TEXT_CELL (text)->cell_text)
{
*x = *y = *height = *width = 0;
return;
}
if (offset < 0 || offset >= GAIL_TEXT_CELL (text)->cell_length)
{
*x = *y = *height = *width = 0;
return;
}
gail_renderer = GAIL_RENDERER_CELL (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
/*
* Thus would be inconsistent with the cache
*/
gail_return_if_fail (gtk_renderer->text);
parent = atk_object_get_parent (ATK_OBJECT (text));
if (GAIL_IS_CONTAINER_CELL (parent))
parent = atk_object_get_parent (parent);
widget = GTK_ACCESSIBLE (parent)->widget;
g_return_if_fail (GAIL_IS_CELL_PARENT (parent));
gail_cell_parent_get_cell_area (GAIL_CELL_PARENT (parent), GAIL_CELL (text),
&rendered_rect);
gtk_cell_renderer_get_size (GTK_CELL_RENDERER (gtk_renderer), widget,
&rendered_rect, &x_offset, &y_offset, &cell_width, &cell_height);
layout = create_pango_layout (gtk_renderer, widget);
index = g_utf8_offset_to_pointer (gtk_renderer->text,
offset) - gtk_renderer->text;
pango_layout_index_to_pos (layout, index, &char_rect);
gail_misc_get_extents_from_pango_rectangle (widget,
&char_rect,
x_offset + rendered_rect.x + gail_renderer->renderer->xpad,
y_offset + rendered_rect.y + gail_renderer->renderer->ypad,
x, y, width, height, coords);
g_object_unref (layout);
return;
}
GtkWidget *
gnc_main_window_summary_new (void)
{
GNCMainSummary * retval = g_new0(GNCMainSummary, 1);
GtkCellRenderer *textRenderer;
int i;
retval->datamodel = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
retval->hbox = gtk_hbox_new (FALSE, 5);
retval->totals_combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (retval->datamodel));
g_object_unref (retval->datamodel);
retval->component_id = gnc_register_gui_component (WINDOW_SUMMARYBAR_CM_CLASS,
summarybar_refresh_handler,
NULL, retval);
gnc_gui_component_watch_entity_type (retval->component_id,
GNC_ID_ACCOUNT,
QOF_EVENT_DESTROY
| GNC_EVENT_ITEM_CHANGED);
// Allows you to get when the popup menu is present
g_signal_connect (retval->totals_combo, "notify::popup-shown",G_CALLBACK (summary_combo_popped), retval);
retval->combo_popped = FALSE;
for (i = 0; i <= N_COLUMNS; i += 2)
{
textRenderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_cell_renderer_set_fixed_size (textRenderer, 50, -1);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(retval->totals_combo), textRenderer, TRUE);
g_object_set_data (G_OBJECT(textRenderer), "view_column", GINT_TO_POINTER (i));
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT(retval->totals_combo), textRenderer, cdf, retval, NULL);
}
gtk_container_set_border_width (GTK_CONTAINER (retval->hbox), 2);
gtk_box_pack_start (GTK_BOX(retval->hbox), retval->totals_combo, TRUE, TRUE, 5);
gtk_widget_show (retval->totals_combo);
gtk_widget_show (retval->hbox);
g_signal_connect_swapped (G_OBJECT (retval->hbox), "destroy",
G_CALLBACK (gnc_main_window_summary_destroy_cb),
retval);
gnc_main_window_summary_refresh(retval);
retval->cnxn_id = gnc_prefs_register_cb (GNC_PREFS_GROUP, NULL,
prefs_changed_cb, retval);
return retval->hbox;
}
GtkCellRenderer *custom_cell_renderer_flexi_new (gboolean is_raw)
{
CustomCellRendererFlexi *cellflexi = g_object_new(CUSTOM_TYPE_CELL_RENDERER_FLEXI, NULL);
cellflexi -> is_raw = is_raw;
return GTK_CELL_RENDERER(cellflexi);
}
static GtkCellRenderer*
remmina_cell_renderer_pixbuf_new(void)
{
GtkCellRenderer *renderer;
renderer = GTK_CELL_RENDERER(g_object_new(REMMINA_TYPE_CELL_RENDERER_PIXBUF, NULL));
return renderer;
}
static void
i7_search_window_init(I7SearchWindow *self)
{
I7_SEARCH_WINDOW_USE_PRIVATE(self, priv);
priv->document = NULL;
priv->text = NULL;
priv->ignore_case = FALSE;
priv->algorithm = I7_SEARCH_CONTAINS;
gtk_window_set_destroy_with_parent(GTK_WINDOW(self), TRUE);
gtk_window_set_icon_name(GTK_WINDOW(self), "inform7");
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(self), TRUE);
gtk_window_set_title(GTK_WINDOW(self), _("Search Results"));
gtk_window_set_type_hint(GTK_WINDOW(self), GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_container_set_border_width(GTK_CONTAINER(self), 12);
gtk_window_set_default_size(GTK_WINDOW(self), 400, 400);
/* Build the interface from the builder file */
GFile *file = i7_app_get_data_file_va(i7_app_get(), "ui", "searchwindow.ui", NULL);
GtkBuilder *builder = create_new_builder(file, self);
g_object_unref(file);
/* Build the rest of the interface */
gtk_container_add(GTK_CONTAINER(self), GTK_WIDGET(load_object(builder, "search_window")));
priv->results = GTK_LIST_STORE(load_object(builder, "results"));
gtk_tree_view_column_set_cell_data_func(GTK_TREE_VIEW_COLUMN(load_object(builder, "result_column")),
GTK_CELL_RENDERER(load_object(builder, "result_renderer")),
(GtkTreeCellDataFunc)result_data_func, self, NULL);
gtk_tree_view_column_set_cell_data_func(GTK_TREE_VIEW_COLUMN(load_object(builder, "document_column")),
GTK_CELL_RENDERER(load_object(builder, "document_renderer")),
(GtkTreeCellDataFunc)location_data_func, self, NULL);
gtk_tree_view_column_set_cell_data_func(GTK_TREE_VIEW_COLUMN(load_object(builder, "type_column")),
GTK_CELL_RENDERER(load_object(builder, "type_renderer")),
(GtkTreeCellDataFunc)type_data_func, NULL, NULL);
g_signal_connect(self, "delete-event", G_CALLBACK(on_search_window_delete_event), NULL);
/* Save public pointers to other widgets */
LOAD_WIDGET(search_text);
LOAD_WIDGET(results_view);
LOAD_WIDGET(spinner);
/* Builder object not needed anymore */
g_object_unref(builder);
}
static VALUE
rg_set_cursor_on_cell(VALUE self, VALUE path, VALUE focus_column, VALUE focus_cell, VALUE start_editing)
{
gtk_tree_view_set_cursor_on_cell(_SELF(self), RVAL2GTKTREEPATH(path),
NIL_P(focus_column) ? NULL : TREEVIEW_COL(focus_column),
NIL_P(focus_cell) ? NULL : GTK_CELL_RENDERER(RVAL2GOBJ(focus_cell)),
RVAL2CBOOL(start_editing));
return self;
}
GtkCellRenderer *
cg_cell_renderer_flags_new (void)
{
GObject *object;
object = g_object_new (CG_TYPE_CELL_RENDERER_FLAGS, NULL);
return GTK_CELL_RENDERER (object);
}
static void
gtk_cell_renderer_toggle_init (GtkCellRendererToggle *celltoggle)
{
GtkCellRendererTogglePrivate *priv;
priv = GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE (celltoggle);
celltoggle->activatable = TRUE;
celltoggle->active = FALSE;
celltoggle->radio = FALSE;
GTK_CELL_RENDERER (celltoggle)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
GTK_CELL_RENDERER (celltoggle)->xpad = 2;
GTK_CELL_RENDERER (celltoggle)->ypad = 2;
priv->indicator_size = TOGGLE_WIDTH;
priv->inconsistent = FALSE;
}
gboolean
_gtk_cell_layout_buildable_custom_tag_start (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *tagname,
GMarkupParser *parser,
gpointer *data)
{
AttributesSubParserData *attr_data;
CellPackingSubParserData *packing_data;
if (!child)
return FALSE;
if (strcmp (tagname, "attributes") == 0)
{
attr_data = g_slice_new0 (AttributesSubParserData);
attr_data->cell_layout = GTK_CELL_LAYOUT (buildable);
attr_data->renderer = GTK_CELL_RENDERER (child);
attr_data->builder = builder;
attr_data->attr_name = NULL;
attr_data->string = g_string_new ("");
*parser = attributes_parser;
*data = attr_data;
return TRUE;
}
else if (strcmp (tagname, "cell-packing") == 0)
{
packing_data = g_slice_new0 (CellPackingSubParserData);
packing_data->string = g_string_new ("");
packing_data->builder = builder;
packing_data->cell_layout = GTK_CELL_LAYOUT (buildable);
packing_data->renderer = GTK_CELL_RENDERER (child);
*parser = cell_packing_parser;
*data = packing_data;
return TRUE;
}
return FALSE;
}
void
xkb_layouts_prepare_selected_tree (GtkBuilder * dialog,
MateConfChangeSet * changeset)
{
GtkListStore *list_store =
gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN);
GtkWidget *tree_view = WID ("xkb_layouts_selected");
GtkTreeSelection *selection;
GtkTargetEntry self_drag_target =
{ "xkb_layouts_selected", GTK_TARGET_SAME_WIDGET, 0 };
GtkTreeViewColumn *desc_column;
text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
desc_column =
gtk_tree_view_column_new_with_attributes (_("Layout"),
text_renderer,
"text",
SEL_LAYOUT_TREE_COL_DESCRIPTION,
"sensitive",
SEL_LAYOUT_TREE_COL_ENABLED,
NULL);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
GTK_TREE_MODEL (list_store));
gtk_tree_view_column_set_sizing (desc_column,
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (desc_column, TRUE);
gtk_tree_view_column_set_expand (desc_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
desc_column);
g_signal_connect_swapped (G_OBJECT (selection), "changed",
G_CALLBACK
(xkb_layouts_enable_disable_buttons),
dialog);
max_selected_layouts = xkl_engine_get_max_num_groups (engine);
/* Setting up DnD */
gtk_drag_source_set (tree_view, GDK_BUTTON1_MASK,
&self_drag_target, 1, GDK_ACTION_MOVE);
gtk_drag_source_set_icon_name (tree_view, "input-keyboard");
gtk_drag_dest_set (tree_view, GTK_DEST_DEFAULT_ALL,
&self_drag_target, 1, GDK_ACTION_MOVE);
g_signal_connect (G_OBJECT (tree_view), "drag_data_get",
G_CALLBACK (xkb_layouts_dnd_data_get), dialog);
g_signal_connect (G_OBJECT (tree_view), "drag_data_received",
G_CALLBACK (xkb_layouts_dnd_data_received),
dialog);
}
