static void
setup_data (AppData *data)
{
int i;
GtkCellRenderer *cell;
char clabel[] = "0";
GType types[17];
types[0] = G_TYPE_UINT;
for (i = 1; i < 17; i++)
types[i] = G_TYPE_UCHAR;
data->ls_data = gtk_list_store_newv (17, types);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_data, -1, "Address",
cell, display_hex_4,
GINT_TO_POINTER (0), NULL);
for (i = 1; i < 17; i++)
{
clabel[0] = i <= 10 ? 47 + i : 54 + i;
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_data, -1, clabel,
cell, display_hex_1,
GINT_TO_POINTER (i), NULL);
}
gtk_tree_view_set_model (data->tw_data, GTK_TREE_MODEL (data->ls_data));
g_object_unref (data->ls_data);
}
/****************************************************************
Populate view with buildable item information
*****************************************************************/
static void populate_view(GtkTreeView *view, struct city **ppcity,
GtkTreeViewColumn **pcol)
{
static const char *titles[] =
{ N_("Type"), N_("Name"), N_("Info"), N_("Cost"), N_("Turns") };
static bool titles_done;
guint i;
GtkCellRenderer *rend;
GtkTreeViewColumn *col;
intl_slist(ARRAY_SIZE(titles), titles, &titles_done);
/* Case i == 0 taken out of the loop to workaround gcc-4.2.1 bug
* http://gcc.gnu.org/PR33381
* Some values would 'stick' from i == 0 round. */
i = 0;
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_data_func(view,
i, titles[i], rend, cell_render_func, ppcity, NULL);
col = gtk_tree_view_get_column(view, i);
if (gui_gtk3_show_task_icons) {
if (max_unit_width == -1 || max_unit_height == -1) {
update_max_unit_size();
}
} else {
g_object_set(col, "visible", FALSE, NULL);
}
if (gui_gtk3_show_task_icons) {
g_object_set(rend, "height", max_unit_height, NULL);
}
for (i = 1; i < ARRAY_SIZE(titles); i++) {
gint pos = i-1;
rend = gtk_cell_renderer_text_new();
g_object_set_data(G_OBJECT(rend), "column", GINT_TO_POINTER(pos));
gtk_tree_view_insert_column_with_data_func(view,
i, titles[i], rend, cell_render_func, ppcity, NULL);
col = gtk_tree_view_get_column(view, i);
if (pos >= 2) {
g_object_set(G_OBJECT(rend), "xalign", 1.0, NULL);
gtk_tree_view_column_set_alignment(col, 1.0);
}
if (pos == 3) {
*pcol = col;
}
if (gui_gtk3_show_task_icons) {
g_object_set(rend, "height", max_unit_height, NULL);
}
}
}
static GtkListStore *
create_items_list (GtkWidget **tree_view_p)
{
GtkWidget *tree_view;
GtkListStore *list_store;
GtkCellRenderer *cell;
list_store = gtk_list_store_new (2, GTK_TYPE_TOOL_ITEM, G_TYPE_STRING);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Tool Item",
gtk_cell_renderer_text_new (),
"text", 1, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (visibile_toggled),
list_store);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
-1, "Visible",
cell,
set_visible_func, NULL, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (expand_toggled),
list_store);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
-1, "Expand",
cell,
set_expand_func, NULL, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (homogeneous_toggled),
list_store);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
-1, "Homogeneous",
cell,
set_homogeneous_func, NULL,NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (important_toggled),
list_store);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
-1, "Important",
cell,
set_important_func, NULL,NULL);
g_object_unref (list_store);
*tree_view_p = tree_view;
return list_store;
}
void
trace_view_load(GtkWidget *view, struct tracecmd_input *handle,
GtkWidget *spin)
{
GtkCellRenderer *renderer;
GtkCellRenderer *fix_renderer;
GtkTreeModel *model;
long c;
/*
* The handle should have loaded the file by now.
* Try to turn off function trace indent and turn on show parent
* if possible.
*/
trace_util_add_option("ftrace:parent", "1");
trace_util_add_option("ftrace:indent", "0");
/* Also, show the function name in the tail for function graph */
trace_util_add_option("fgraph:tailprint", "1");
/* --- CPU column --- */
renderer = gtk_cell_renderer_text_new();
fix_renderer = gtk_cell_renderer_text_new();
g_object_set(fix_renderer,
"family", "Monospace",
"family-set", TRUE,
NULL);
/*
* Set fixed height mode now which will cause all the columns below to
* be created with their sizing property to be set to
* GTK_TREE_VIEW_COLUMN_FIXED.
*/
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(view), TRUE);
for (c = 0; c < NUM_COLS; c++)
{
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view),
-1,
col_labels[c],
(c == COL_LAT || c == COL_INFO) ? fix_renderer : renderer,
trace_view_data_func,
(gpointer)c,
NULL);
}
g_signal_connect_swapped (G_OBJECT (spin), "value-changed",
G_CALLBACK (spin_changed),
(gpointer) view);
if (handle) {
model = create_trace_view_model(handle);
trace_view_store_set_spin_button(TRACE_VIEW_STORE(model), spin);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model); /* destroy model automatically with view */
}
}
void
users_table_create (GstTool *tool)
{
GtkWidget *table;
GtkCellRenderer *renderer;
table = gst_dialog_get_widget (tool->main_dialog, "users_table");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (table), FALSE);
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (table),
-1, "",
renderer,
"active", COL_ACTIVE,
NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (user_toggled_cb), tool);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (table),
-1, "",
renderer,
users_table_text_cell_data_func,
g_object_ref (tool),
(GDestroyNotify) g_object_unref);
}
static void
setup_mcode (AppData *data)
{
GtkCellRenderer *cell;
data->ls_mcode = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_UINT);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_mcode, -1, "Address",
cell, display_hex_4,
GINT_TO_POINTER (0), NULL);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_mcode, -1, "Instruction",
cell, display_hex_4,
GINT_TO_POINTER (1), NULL);
gtk_tree_view_set_model (data->tw_mcode, GTK_TREE_MODEL (data->ls_mcode));
g_object_unref (data->ls_mcode);
}
static void
setup_regs (AppData *data)
{
GtkCellRenderer *cell;
data->ls_regs = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_UINT);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_attributes (data->tw_regs, -1, "Reg",
cell, "text", 0, NULL);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "family", "monospace", NULL);
gtk_tree_view_insert_column_with_data_func (data->tw_regs, -1, "Value",
cell, display_hex_4,
GINT_TO_POINTER (1), NULL);
gtk_tree_view_set_model (data->tw_regs, GTK_TREE_MODEL (data->ls_regs));
g_object_unref (data->ls_regs);
}
static void _lib_modulelist_populate_callback(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
if(!self || !(self->data)) return;
GtkListStore *store;
GtkTreeIter iter;
GtkWidget *view = GTK_WIDGET(((dt_lib_modulelist_t *)self->data)->tree);
GtkCellRenderer *pix_renderer, *fav_renderer, *text_renderer;
GdkRGBA color;
GtkStyleContext *context = gtk_widget_get_style_context(view);
gboolean color_found = gtk_style_context_lookup_color (context, "selected_bg_color", &color);
if(!color_found)
{
color.red = 1.0;
color.green = 0.0;
color.blue = 0.0;
color.alpha = 1.0;
}
store = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_MODULE, _lib_modulelist_gui_sort, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_MODULE, GTK_SORT_ASCENDING);
pix_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(pix_renderer, "cell-background-rgba", &color, NULL);
fav_renderer = gtk_cell_renderer_pixbuf_new();
cairo_surface_t *fav_cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ICON_SIZE, ICON_SIZE);
cairo_t *fav_cr = cairo_create(fav_cst);
cairo_set_source_rgb(fav_cr, 0.7, 0.7, 0.7);
dtgtk_cairo_paint_modulegroup_favorites(fav_cr, 0, 0, ICON_SIZE, ICON_SIZE, 0);
guchar *data = cairo_image_surface_get_data(fav_cst);
dt_draw_cairo_to_gdk_pixbuf(data, ICON_SIZE, ICON_SIZE);
((dt_lib_modulelist_t *)self->data)->fav_pixbuf
= gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE, 8, ICON_SIZE, ICON_SIZE,
cairo_image_surface_get_stride(fav_cst), NULL, NULL);
g_object_set(fav_renderer, "cell-background-rgba", &color, NULL);
g_object_set(fav_renderer, "width", gdk_pixbuf_get_width(((dt_lib_modulelist_t *)self->data)->fav_pixbuf),
NULL);
text_renderer = gtk_cell_renderer_text_new();
g_object_set(text_renderer, "cell-background-rgba", &color, NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), FALSE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 0, "favorite", fav_renderer,
favorite_renderer_function, NULL, NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 1);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 1, "image", pix_renderer,
image_renderer_function, NULL, NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 2);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 2, "name", text_renderer,
text_renderer_function, NULL, NULL);
/* go thru list of iop modules and add them to the list */
GList *modules = g_list_last(darktable.develop->iop);
char datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
while(modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
if(!dt_iop_is_hidden(module) && !(module->flags() & IOP_FLAGS_DEPRECATED) && module->multi_priority == 0)
{
GdkPixbuf *pixbuf;
char filename[PATH_MAX] = { 0 };
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.svg", datadir, module->op);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.png", datadir, module->op);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.svg", datadir);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.png", datadir);
pixbuf = load_image(filename);
if(pixbuf) goto end;
// wow, we could neither load the SVG nor the PNG files. something is f****d up.
pixbuf = gdk_pixbuf_new_from_data(fallback_pixel, GDK_COLORSPACE_RGB, TRUE, 8, 1, 1, 4, NULL, NULL);
end:
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, COL_IMAGE, pixbuf, COL_MODULE, module, -1);
g_object_unref(pixbuf);
}
modules = g_list_previous(modules);
}
}
void
gftpui_ask_transfer (gftp_transfer * tdata)
{
GtkWidget * dialog, * tempwid, * scroll, * hbox;
gftp_file * tempfle;
GList * templist;
GtkTreeIter iter;
dialog = gtk_dialog_new_with_buttons (_("Transfer Files"), GTK_WINDOW(window), 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), 10);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), 5);
tempwid = gtk_label_new (_("The following file(s) exist on both the local and remote computer\nPlease select what you would like to do"));
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), tempwid, FALSE,
FALSE, 0);
gtk_widget_show (tempwid);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_window_set_default_size(GTK_WINDOW (dialog), 450, 350);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkListStore * l = gtk_list_store_new (1, G_TYPE_POINTER);
tdata->clist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(l));
GtkCellRenderer * cell = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tdata->clist), -1, _("Filename"), cell, data_col_0, tdata, NULL);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tdata->clist), -1, tdata->fromreq->hostname, cell, data_col_1, NULL, NULL);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tdata->clist), -1, tdata->toreq->hostname, cell, data_col_2, NULL, NULL);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tdata->clist), -1, _("Action"), cell, data_col_3, NULL, NULL);
gtk_container_add (GTK_CONTAINER (scroll), tdata->clist);
GtkTreeSelection * select = gtk_tree_view_get_selection (GTK_TREE_VIEW(tdata->clist));
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
GtkTreeViewColumn * c;
c = gtk_tree_view_get_column(GTK_TREE_VIEW(tdata->clist), 0);
gtk_tree_view_column_set_fixed_width(c, 100);
c = gtk_tree_view_get_column(GTK_TREE_VIEW(tdata->clist), 1);
gtk_tree_view_column_set_fixed_width(c, 85);
c = gtk_tree_view_get_column(GTK_TREE_VIEW(tdata->clist), 2);
gtk_tree_view_column_set_fixed_width(c, 85);
c = gtk_tree_view_get_column(GTK_TREE_VIEW(tdata->clist), 3);
gtk_tree_view_column_set_fixed_width(c, 85);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), scroll, TRUE, TRUE, 0);
gtk_widget_show (tdata->clist);
gtk_widget_show (scroll);
for (templist = tdata->files; templist != NULL;
templist = templist->next)
{
tempfle = templist->data;
if (tempfle->startsize == 0 || S_ISDIR (tempfle->st_mode))
{
tempfle->shown = 0;
continue;
}
tempfle->shown = 1;
gftp_get_transfer_action (tdata->fromreq, tempfle);
gtk_list_store_append (l, &iter);
gtk_list_store_set (l, &iter, 0, tempfle, -1);
}
gtk_tree_selection_select_all (select);
hbox = gtk_hbox_new (TRUE, 20);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
tempwid = gtk_button_new_with_label (_("Overwrite"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tempwid), "clicked",
G_CALLBACK (gftpui_gtk_overwrite), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Resume"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tempwid), "clicked",
G_CALLBACK (gftpui_gtk_resume), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Skip File"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tempwid), "clicked",
G_CALLBACK (gftpui_gtk_skip), (gpointer) tdata);
gtk_widget_show (tempwid);
hbox = gtk_hbox_new (TRUE, 20);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (dialog))), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
tempwid = gtk_button_new_with_label (_("Select All"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tempwid), "clicked",
G_CALLBACK (gftpui_gtk_trans_selectall), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Deselect All"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tempwid), "clicked",
G_CALLBACK (gftpui_gtk_trans_unselectall), (gpointer) tdata);
gtk_widget_show (tempwid);
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gint response = gtk_dialog_run (GTK_DIALOG(dialog));
g_static_mutex_lock (&tdata->structmutex);
if (response == GTK_RESPONSE_OK)
{
for (templist = tdata->files; templist != NULL; templist = templist->next)
{
tempfle = templist->data;
if (tempfle->transfer_action != GFTP_TRANS_ACTION_SKIP)
break;
}
tdata->ready = 1;
if (templist == NULL)
{
tdata->show = 0;
tdata->done = 1;
}
else
tdata->show = 1;
}
else
{
tdata->show = 0;
tdata->done = tdata->ready = 1;
}
g_static_mutex_unlock (&tdata->structmutex);
gtk_widget_destroy (dialog);
}
void gglk_do_glk_objects(GtkMenuItem *unused_menuitem,
gpointer unused_data)
{
GtkTreeView *tree;
GtkTreeStore *store;
GtkTreeSelection *select;
if(win_glk_objects) {
gtk_window_present(GTK_WINDOW(win_glk_objects));
return;
}
win_glk_objects = create_win_glk_objects();
g_signal_connect(win_glk_objects, "destroy",
G_CALLBACK(gtk_widget_destroyed),
&win_glk_objects);
{
GtkSizeGroup *group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
int i;
const char *p;
static const char group_widget_names[] =
"char" "\0" "line" "\0"
"mouse" "\0" "hyper" "\0"
"arrange" "\0" "redraw" "\0";
for(p = group_widget_names; *p; p += strlen(p) + 1) {
char name[30];
sprintf(name, "request_%s", p);
gtk_size_group_add_widget(group,
lookup_widget(win_glk_objects, name));
}
for(i = 1; i <= 15; i++) {
char labelname[30];
sprintf(labelname, "glabel%d", i);
gtk_size_group_add_widget(group,
lookup_widget(win_glk_objects,
labelname));
}
g_object_unref(group);
}
tree = GTK_TREE_VIEW(lookup_widget(win_glk_objects, "treeview1"));
store = gtk_tree_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_POINTER, G_TYPE_POINTER);
gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes(tree, -1, "ID",
gtk_cell_renderer_text_new(),
"text", 0,
NULL);
gtk_tree_view_insert_column_with_attributes(tree, -1, "Type",
gtk_cell_renderer_text_new(),
"text", 1,
NULL);
gtk_tree_view_insert_column_with_data_func(tree, -1, "Key",
gtk_cell_renderer_text_new(),
gglk_key_render,
GINT_TO_POINTER(2), NULL);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(select, "changed",
G_CALLBACK(gglk_objects_tree_selection_changed),
win_glk_objects);
gglk_object_tree_update();
gtk_widget_show(win_glk_objects);
}
static GtkWidget *create_right(void)
{
GtkWidget *mainbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
mainbox = gtk_vbox_new(FALSE, 24);
gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
label = create_label("Networks");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(vbox), scrolled);
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_container_add(GTK_CONTAINER(scrolled), tree);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0,
NULL, gtk_cell_renderer_pixbuf_new(),
status_to_icon, NULL, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0);
gtk_tree_view_column_set_min_width(column, 24);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer,
"text", CONNMAN_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
tree_networks = tree;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), NULL);
return mainbox;
}
static void _lib_modulelist_populate_callback(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
if(!self || !(self->data)) return;
GtkListStore *store;
GtkTreeIter iter;
GtkWidget *view=GTK_WIDGET(((dt_lib_modulelist_t*)self->data)->tree);
GtkCellRenderer *pix_renderer,*fav_renderer,*text_renderer;
GtkStyle *style=gtk_widget_get_style(view);
store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_object_unref (store);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_MODULE, _lib_modulelist_gui_sort, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_MODULE, GTK_SORT_ASCENDING);
pix_renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set(pix_renderer,"cell-background-gdk",&style->bg[GTK_STATE_ACTIVE],NULL);
fav_renderer = gtk_cell_renderer_pixbuf_new ();
cairo_surface_t *fav_cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ICON_SIZE, ICON_SIZE);
cairo_t *fav_cr = cairo_create(fav_cst);
cairo_set_source_rgb(fav_cr, 0.7,0.7,0.7);
dtgtk_cairo_paint_modulegroup_favorites(fav_cr, 0, 0, ICON_SIZE, ICON_SIZE, 0);
guchar* data = cairo_image_surface_get_data(fav_cst);
dt_draw_cairo_to_gdk_pixbuf(data, ICON_SIZE, ICON_SIZE);
((dt_lib_modulelist_t*)self->data)->fav_pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE, 8, ICON_SIZE,
ICON_SIZE, cairo_image_surface_get_stride(fav_cst), NULL, NULL);
g_object_set(fav_renderer,"cell-background-gdk",&style->bg[GTK_STATE_ACTIVE],NULL);
g_object_set(fav_renderer,"width",gdk_pixbuf_get_width(((dt_lib_modulelist_t*)self->data)->fav_pixbuf),NULL);
text_renderer = gtk_cell_renderer_text_new ();
g_object_set(text_renderer,"cell-background-gdk",&style->bg[GTK_STATE_ACTIVE],NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view),FALSE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view),FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view),FALSE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (view),
0,
"favorite",
fav_renderer,
favorite_renderer_function,
NULL,NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 1);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (view),
1,
"image",
pix_renderer,
image_renderer_function,
NULL,NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 2);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (view),
2,
"name",
text_renderer,
text_renderer_function,
NULL,NULL);
/* go thru list of iop modules and add them to the list */
GList *modules = g_list_last(darktable.develop->iop);
while(modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
if(!dt_iop_is_hidden(module) && !(module->flags() & IOP_FLAGS_DEPRECATED) && module->multi_priority==0)
{
char filename[DT_MAX_PATH_LEN], datadir[DT_MAX_PATH_LEN];
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
snprintf(filename, DT_MAX_PATH_LEN, "%s/pixmaps/plugins/darkroom/%s.png", datadir, module->op);
if(!g_file_test(filename, G_FILE_TEST_IS_REGULAR))
snprintf(filename, DT_MAX_PATH_LEN, "%s/pixmaps/plugins/darkroom/template.png", datadir);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(filename,NULL);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_IMAGE, pixbuf,
COL_MODULE,module,
-1);
g_object_unref (pixbuf);
}
modules = g_list_previous(modules);
}
}
static GtkWidget *
create_treeview (BluetoothChooser *self)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GtkWidget *scrolled, *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Create the scrolled window */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
/* Create the tree view */
tree = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree), TRUE);
g_object_set (tree, "show-expanders", FALSE, NULL);
g_signal_connect (G_OBJECT (tree), "row-activated",
G_CALLBACK (row_activated_cb), self);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Device"));
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN(column), TRUE);
/* The type icon */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_set_spacing (column, 4);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", BLUETOOTH_COLUMN_ICON, NULL);
/* The device name */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
alias_to_label, NULL, NULL);
/* The connected icon */
priv->connected_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, priv->connected_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->connected_cell,
connected_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
/* The bonded icon */
priv->bonded_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, priv->bonded_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->bonded_cell,
bonded_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW(tree), -1,
_("Type"), gtk_cell_renderer_text_new(),
type_to_text, NULL, NULL);
priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode (priv->selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT(priv->selection), "changed",
G_CALLBACK(select_browse_device_callback), self);
/* Set the model, and filter */
priv->model = bluetooth_client_get_device_model (priv->client);
if (priv->model) {
priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
filter_func, self, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW(tree), priv->filter);
g_signal_connect (priv->filter, "row-changed",
G_CALLBACK (device_model_row_changed), self);
g_object_unref (priv->filter);
} else {
gtk_widget_set_sensitive (GTK_WIDGET (tree), FALSE);
set_search_label (self, FALSE);
}
gtk_container_add (GTK_CONTAINER(scrolled), tree);
priv->treeview = tree;
return scrolled;
}
GtkWidget *
do_stock_browser (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkWidget *align;
GtkTreeModel *model;
GtkCellRenderer *cell_renderer;
StockItemDisplay *display;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Stock Icons and Items");
gtk_window_set_default_size (GTK_WINDOW (window), -1, 500);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_add (GTK_CONTAINER (window), hbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0);
model = create_model ();
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Macro");
cell_renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
FALSE);
gtk_tree_view_column_set_attributes (column, cell_renderer,
"stock_id", 1, NULL);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
macro_set_func_text, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview),
column);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
-1,
"Label",
cell_renderer,
label_set_func,
NULL,
NULL);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
-1,
"Accel",
cell_renderer,
accel_set_func,
NULL,
NULL);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
-1,
"ID",
cell_renderer,
id_set_func,
NULL,
NULL);
align = gtk_alignment_new (0.5, 0.0, 0.0, 0.0);
gtk_box_pack_end (GTK_BOX (hbox), align, FALSE, FALSE, 0);
frame = gtk_frame_new ("Selected Item");
gtk_container_add (GTK_CONTAINER (align), frame);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
display = g_new (StockItemDisplay, 1);
g_object_set_data_full (G_OBJECT (treeview),
"stock-display",
display,
g_free); /* free display with treeview */
display->type_label = gtk_label_new (NULL);
display->macro_label = gtk_label_new (NULL);
display->id_label = gtk_label_new (NULL);
display->label_accel_label = gtk_label_new (NULL);
display->icon_image = gtk_image_new_from_pixbuf (NULL); /* empty image */
gtk_box_pack_start (GTK_BOX (vbox), display->type_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), display->icon_image,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), display->label_accel_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), display->macro_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), display->id_label,
FALSE, FALSE, 0);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection,
"changed",
G_CALLBACK (selection_changed),
NULL);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static VALUE
rg_insert_column(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
rb_scan_args(argc, argv, "22", /* NORMAL ATTRIBUTES DATA_FUNC */
&args[0], /* column position position */
&args[1], /* position title title */
&args[2], /* renderer renderer */
&args[3]); /* attributes */
if (argc == 2) {
G_CHILD_ADD(self, args[0]);
return INT2NUM(gtk_tree_view_insert_column(_SELF(self),
TREEVIEW_COL(args[0]),
NUM2INT(args[1])));
} else if (argc == 3) {
int ret;
VALUE func = rb_block_proc();
G_RELATIVE(self, func);
ret = gtk_tree_view_insert_column_with_data_func(_SELF(self),
NUM2INT(args[0]),
RVAL2CSTR(args[1]),
RVAL2CELLRENDERER(args[2]),
(GtkTreeCellDataFunc)cell_data_func,
(gpointer)func,
NULL);
return INT2NUM(ret);
} else if (argc == 4) {
int i;
int col;
int ret;
const gchar *name;
VALUE ary;
GtkCellRenderer* renderer = RVAL2CELLRENDERER(args[2]);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
Check_Type(args[3], T_HASH);
/* TODO: Should this really be done before we know that everything
* below worked without error? */
G_CHILD_ADD(self, args[2]);
G_CHILD_ADD(self, args[3]);
gtk_tree_view_column_set_title(column, RVAL2CSTR(args[1]));
gtk_tree_view_column_pack_start(column, renderer, TRUE);
ret = gtk_tree_view_insert_column(_SELF(self), column, NUM2INT(args[0]));
ary = rb_funcall(args[3], rb_intern("to_a"), 0);
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE val = RARRAY_PTR(RARRAY_PTR(ary)[i])[0];
if (SYMBOL_P(val)) {
name = rb_id2name(SYM2ID(val));
} else {
name = RVAL2CSTR(val);
}
col = NUM2INT(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]);
gtk_tree_view_column_add_attribute(column,
renderer,
name, col);
}
return INT2NUM(ret);
} else {
rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
}
return Qnil;
}
