void entitylist_treeviewcolumn_celldatafunc(GtkTreeViewColumn* column, GtkCellRenderer* renderer, GtkTreeModel* model, GtkTreeIter* iter, gpointer data)
{
scene::Node* node;
gtk_tree_model_get_pointer(model, iter, 0, &node);
scene::Instance* instance;
gtk_tree_model_get_pointer(model, iter, 1, &instance);
if(node != 0)
{
gtk_cell_renderer_set_fixed_size(renderer, -1, -1);
char* name = const_cast<char*>(node_get_name(*node));
g_object_set(G_OBJECT(renderer), "text", name, "visible", TRUE, 0);
//globalOutputStream() << "rendering cell " << makeQuoted(name) << "\n";
GtkStyle* style = gtk_widget_get_style(GTK_WIDGET(getEntityList().m_tree_view));
if(instance->childSelected())
{
g_object_set(G_OBJECT(renderer), "cell-background-gdk", &style->base[GTK_STATE_ACTIVE], 0);
}
else
{
g_object_set(G_OBJECT(renderer), "cell-background-gdk", &style->base[GTK_STATE_NORMAL], 0);
}
}
else
{
gtk_cell_renderer_set_fixed_size(renderer, -1, 0);
g_object_set(G_OBJECT(renderer), "text", "", "visible", FALSE, 0);
}
}
/*
* @brief creates all GTK+ widgets that compose the player & sets up callbacks
* */
static void create_ui(CustomData *data) {
GtkWidget *main_window; /* uppermost container window */
GtkWidget *video_window; /* video is shown here */
GtkWidget *main_box; /* holds hbox & controls */
GtkWidget *main_hbox; /* hold video window & streaminfo widget */
GtkWidget *controls; /* hold buttons & slider */
GtkWidget *play_button, *pause_button, *stop_button;
GtkCellRenderer *renderer;
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(main_window), "delete-event", G_CALLBACK(delete_event_cb), data);
video_window = gtk_drawing_area_new();
gtk_widget_set_double_buffered(video_window, FALSE);
g_signal_connect(G_OBJECT(video_window), "realize", G_CALLBACK(realise_cb), data);
g_signal_connect (video_window, "expose_event", G_CALLBACK (expose_cb), data);
play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data);
pause_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data);
stop_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_hscale_new_with_range(0, 100, 1);
gtk_scale_set_draw_value(GTK_SCALE(data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
data->streams_list = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Name", renderer, "text", COL_STREAM_NAME, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size(renderer, 15, -1);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list),
-1, "Stream Details", renderer, "text", COL_STREAM_DETAILS, NULL);
g_signal_connect(data->streams_list, "row-activated", G_CALLBACK(stream_select_cb), data);
//gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE);
controls = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2);
main_box = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_box), video_window, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_box), data->streams_list, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), main_box);
gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480);
gtk_widget_show_all (main_window);
}
static VALUE
rg_set_fixed_size(VALUE self, VALUE width, VALUE height)
{
gtk_cell_renderer_set_fixed_size(_SELF(self), NUM2INT(width),
NUM2INT(height));
return self;
}
/**
* gwy_coords_view_create_column_index:
* @view: A coords view.
* @title: (allow-none):
* Column title. Passing %NULL means a column title will be
* constructed automatically, containing something like "n". If you
* want an empty title pass the empty string.
*
* Creates a standard column with item index for a coords view.
*
* Returns: (transfer full):
* Newly created tree view column.
**/
GtkTreeViewColumn*
gwy_coords_view_create_column_index(GwyCoordsView *view,
const gchar *title)
{
g_return_val_if_fail(GWY_IS_COORDS_VIEW(view), NULL);
CoordsView *priv = view->priv;
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_fixed_size(renderer, -1, priv->height);
g_object_set(renderer, "foreground-set", TRUE, NULL);
GtkTreeViewColumn *column = gtk_tree_view_column_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_index,
NULL, NULL);
GtkWidget *header = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(header), GTK_JUSTIFY_CENTER);
gtk_widget_show(header);
gtk_tree_view_column_set_widget(column, header);
ColumnInfo *column_info = g_slice_new(ColumnInfo);
column_info->column = column;
column_info->i = G_MAXUINT;
column_info->is_index = TRUE;
column_info->title = g_strdup(title ? title : "n");
priv->column_info = g_slist_prepend(priv->column_info, column_info);
g_object_weak_ref(G_OBJECT(column), column_gone, view);
update_column_title(view, column_info);
return column;
}
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;
}
static void fill_combo_box (GtkIconTheme *theme, GtkComboBox *combo_box, GList *app_list)
{
GList *entry;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
if (theme == NULL) {
theme = gtk_icon_theme_get_default ();
}
gtk_combo_box_set_row_separator_func (combo_box, is_separator,
GINT_TO_POINTER (g_list_length (app_list)), NULL);
model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING));
gtk_combo_box_set_model (combo_box, model);
renderer = gtk_cell_renderer_pixbuf_new ();
/* not all cells have a pixbuf, this prevents the combo box to shrink */
gtk_cell_renderer_set_fixed_size (renderer, -1, 22);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"pixbuf", PIXBUF_COL,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"text", TEXT_COL,
NULL);
for (entry = app_list; entry != NULL; entry = g_list_next (entry)) {
MateDAItem *item;
item = (MateDAItem *) entry->data;
pixbuf = gtk_icon_theme_load_icon (theme, item->icon_name, 22, 0, NULL);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, pixbuf,
TEXT_COL, item->name,
-1);
item->icon_path = gtk_tree_model_get_string_from_iter (model, &iter);
if (pixbuf)
g_object_unref (pixbuf);
}
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, -1);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, NULL,
TEXT_COL, _("Custom"),
-1);
}
gboolean update_snapshot()
{
GtkTreeModel *model;
GtkTreeIter iter;
GdkPixbuf *icon;
gboolean have_iter;
gint pixWidth = 200, pixHeight = 30;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
gtk_tree_model_get(model, &iter, COL_SNAPSHOT, &icon, -1);
if (icon != NULL) {
g_object_unref(icon);
}
// build panel's snapshot
GdkPixbuf *pixbuf = NULL;
gchar *name, *snap, *cmd;
snap = g_build_filename(g_get_user_config_dir(), "tint2", "snap.jpg", NULL);
g_remove(snap);
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &name, -1);
cmd = g_strdup_printf("tint2 -c \'%s\' -s \'%s\'", name, snap);
if (system(cmd) == 0) {
// load
pixbuf = gdk_pixbuf_new_from_file(snap, NULL);
if (pixbuf == NULL) {
printf("snapshot NULL : %s\n", cmd);
}
}
g_free(snap);
g_free(cmd);
g_free(name);
gint w, h;
w = gdk_pixbuf_get_width(pixbuf);
h = gdk_pixbuf_get_height(pixbuf);
pixWidth = w > pixWidth ? w : pixWidth;
pixHeight = h > pixHeight ? h : pixHeight;
gtk_list_store_set(g_store, &iter, COL_SNAPSHOT, pixbuf, -1);
have_iter = gtk_tree_model_iter_next(model, &iter);
}
gtk_cell_renderer_set_fixed_size(g_renderer, pixWidth + 30, pixHeight + 30);
return FALSE;
}
static void
fm_list_view_zoom_level_changed (FMDirectoryView *view)
{
/* set the new "size" for the icon renderer */
g_object_set (G_OBJECT (view->icon_renderer), "size", marlin_zoom_level_to_icon_size (view->zoom_level), "zoom-level", view->zoom_level, NULL);
gint xpad, ypad;
gtk_cell_renderer_get_padding (view->icon_renderer, &xpad, &ypad);
gtk_cell_renderer_set_fixed_size (view->icon_renderer,
marlin_zoom_level_to_icon_size (view->zoom_level) + 2 * xpad,
marlin_zoom_level_to_icon_size (view->zoom_level) + 2 * ypad);
gtk_tree_view_columns_autosize (FM_LIST_VIEW (view)->tree);
}
void TextureOverviewDialog::populateWindow ()
{
GtkWidget* dialogVBox = gtk_vbox_new(FALSE, 6);
// Set up the info table
GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), TRUE);
// Connect up selection changed callback
_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
g_signal_connect(G_OBJECT(_selection), "changed", G_CALLBACK(onSelectionChanged), this);
GtkCellRenderer* rend;
GtkTreeViewColumn* col;
rend = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(rend, 128, -1);
col = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_column_set_title(col, _("Image"));
gtk_tree_view_column_pack_start(col, rend, false);
gtk_tree_view_column_add_attribute(col, rend, "pixbuf", TEXTUREOVERVIEW_IMAGE);
rend = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Name"), rend, "text", TEXTUREOVERVIEW_NAME, NULL);
g_object_set(G_OBJECT(rend), "weight", 400, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
rend = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Count"), rend, "text", TEXTUREOVERVIEW_COUNT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
GtkWidget *scroll = gtkutil::ScrolledFrame(view);
gtk_box_pack_start(GTK_BOX(dialogVBox), GTK_WIDGET(scroll), TRUE, TRUE, 0);
GtkWidget* hbox = gtk_hbox_new(FALSE, 6);
GtkWidget* closeButton = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_widget_set_size_request(closeButton, -1, -1);
g_signal_connect(G_OBJECT(closeButton), "clicked", G_CALLBACK(onClose), this);
gtk_box_pack_end(GTK_BOX(hbox), closeButton, FALSE, FALSE, 0);
GtkWidget* findAndReplaceButton = gtk_button_new_from_stock(GTK_STOCK_FIND_AND_REPLACE);
gtk_widget_set_size_request(findAndReplaceButton, -1, -1);
g_signal_connect(G_OBJECT(findAndReplaceButton), "clicked", G_CALLBACK(onFindAndReplace), this);
gtk_box_pack_end(GTK_BOX(hbox), findAndReplaceButton, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(dialogVBox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(getWindow()), dialogVBox);
TextureCounter counter(_store);
Scene_ForEachBrush_ForEachFace(GlobalSceneGraph(), counter);
}
static void
thunar_text_renderer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ThunarTextRenderer *text_renderer = THUNAR_TEXT_RENDERER (object);
const gchar *sval;
switch (prop_id)
{
case PROP_FOLLOW_PRELIT:
text_renderer->follow_prelit = g_value_get_boolean (value);
break;
case PROP_FOLLOW_STATE:
text_renderer->follow_state = g_value_get_boolean (value);
break;
case PROP_TEXT:
/* release the previous text (if not static) */
if (!text_renderer->text_static)
g_free (text_renderer->text);
sval = g_value_get_string (value);
text_renderer->text_static = (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS);
text_renderer->text = (sval == NULL) ? "" : (gchar *)sval;
if (!text_renderer->text_static)
text_renderer->text = g_strdup (text_renderer->text);
break;
case PROP_WRAP_MODE:
text_renderer->wrap_mode = g_value_get_enum (value);
break;
case PROP_WRAP_WIDTH:
/* be sure to reset fixed height if wrapping is requested */
text_renderer->wrap_width = g_value_get_int (value);
if (G_LIKELY (text_renderer->wrap_width >= 0))
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (text_renderer), -1, -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GtkWidget *create_view()
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
g_store = gtk_list_store_new(NB_COL, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
g_object_unref(g_store); // destroy store automatically with view
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE);
gtk_tree_view_column_set_visible(col, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
g_width_list = 200;
g_height_list = 30;
g_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(g_renderer, "xalign", 0.0, NULL);
gtk_cell_renderer_set_fixed_size(g_renderer, g_width_list, g_height_list);
// specific to gtk-2.18 or higher
//gtk_cell_renderer_set_padding(g_renderer, 5, 5);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, g_renderer, TRUE);
gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
GtkTreeSortable *sortable;
sortable = GTK_TREE_SORTABLE(g_store);
gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL);
return view;
}
static void
fill_combo_box(GtkIconTheme* theme, GtkComboBox* combo_box, GList* app_list, gchar* mime)
{
guint index = 0;
GList* entry;
GtkTreeModel* model;
GtkCellRenderer* renderer;
GtkTreeIter iter;
GdkPixbuf* pixbuf;
GAppInfo* default_app;
default_app = NULL;
if (g_strcmp0(mime, "terminal") == 0)
{
GSettings *terminal_settings = g_settings_new (TERMINAL_SCHEMA);
gchar *default_terminal = g_settings_get_string (terminal_settings, TERMINAL_KEY);
for (entry = app_list; entry != NULL; entry = g_list_next(entry))
{
GAppInfo* item = (GAppInfo*) entry->data;
if (g_strcmp0 (g_app_info_get_executable (item), default_terminal) == 0)
{
default_app = item;
}
}
g_free (default_terminal);
g_object_unref (terminal_settings);
}
else if (g_strcmp0(mime, "visual") == 0)
{
GSettings *visual_settings = g_settings_new (VISUAL_SCHEMA);
gchar *default_visual = g_settings_get_string (visual_settings, VISUAL_KEY);
for (entry = app_list; entry != NULL; entry = g_list_next(entry))
{
GAppInfo* item = (GAppInfo*) entry->data;
if (g_strcmp0 (g_app_info_get_executable (item), default_visual) == 0)
{
default_app = item;
}
}
g_free (default_visual);
g_object_unref (visual_settings);
}
else if (g_strcmp0(mime, "mobility") == 0)
{
GSettings *mobility_settings = g_settings_new (MOBILITY_SCHEMA);
gchar *default_mobility = g_settings_get_string (mobility_settings, MOBILITY_KEY);
for (entry = app_list; entry != NULL; entry = g_list_next(entry))
{
GAppInfo* item = (GAppInfo*) entry->data;
if (g_strcmp0 (g_app_info_get_executable (item), default_mobility) == 0)
{
default_app = item;
}
}
g_free (default_mobility);
g_object_unref (mobility_settings);
}
else
{
default_app = g_app_info_get_default_for_type (mime, FALSE);
}
if (theme == NULL)
{
theme = gtk_icon_theme_get_default();
}
model = GTK_TREE_MODEL(gtk_list_store_new(4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING));
gtk_combo_box_set_model(combo_box, model);
renderer = gtk_cell_renderer_pixbuf_new();
/* Not all cells have a pixbuf, this prevents the combo box to shrink */
gtk_cell_renderer_set_fixed_size(renderer, -1, 22);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer,
"pixbuf", PIXBUF_COL,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer,
"text", TEXT_COL,
NULL);
for (entry = app_list; entry != NULL; entry = g_list_next(entry))
{
GAppInfo* item = (GAppInfo*) entry->data;
/* Icon */
GIcon* icon = g_app_info_get_icon(item);
gchar* icon_name = g_icon_to_string(icon);
if (icon_name == NULL)
{
/* Default icon */
icon_name = g_strdup("binary");
}
pixbuf = gtk_icon_theme_load_icon(theme, icon_name, 22, 0, NULL);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PIXBUF_COL, pixbuf,
TEXT_COL, g_app_info_get_display_name(item),
ID_COL, g_app_info_get_id(item),
ICONAME_COL, icon_name,
-1);
if (pixbuf)
{
g_object_unref(pixbuf);
}
/* Set the index for the default app */
if (default_app != NULL && g_app_info_equal(item, default_app))
{
gtk_combo_box_set_active(combo_box, index);
}
g_free(icon_name);
index++;
}
}
static GtkWidget *create_tree(void)
{
GtkWidget *tree;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
tree = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tree),
GTK_TREE_VIEW_GRID_LINES_NONE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_spacing(column, 6);
gtk_tree_view_column_set_min_width(column, 250);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer,
"icon-name", CONNMAN_COLUMN_ICON);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
service_to_text, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_fixed_size(renderer, 100, -1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
strength_to_value, NULL, NULL);
model = connman_client_get_model(client);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
g_object_unref(model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree),
CONNMAN_COLUMN_NAME);
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), tree);
g_signal_connect(G_OBJECT(tree), "button-press-event",
G_CALLBACK(button_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "popup-menu",
G_CALLBACK(popup_callback), NULL);
g_signal_connect(G_OBJECT(tree), "drag-drop",
G_CALLBACK(drag_drop), NULL);
g_signal_connect(G_OBJECT(tree), "drag-data-get",
G_CALLBACK(drag_data_get), selection);
g_signal_connect(G_OBJECT(tree), "drag-data-received",
G_CALLBACK(drag_data_received), model);
return tree;
}
void
gui_create_tasks(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table;
GtkWidget *label;
GtkWidget *top_scrolledwindow;
GtkWidget *hseparator;
GtkWidget *close_button;
GtkCellRenderer *renderer;
GtkWidget *top_viewport;
GtkWidget *bottom_viewport;
GtkTextBuffer *text_buffer;
GError *error = NULL;
GtkActionGroup *action_group = NULL;
gchar tmpbuf[BUFFER_SIZE];
const gchar *ui_info =
" <toolbar name=\"toolbar\">\n"
" <toolitem name=\"add\" action=\"add\" />\n"
" <toolitem name=\"delete\" action=\"delete\" />\n"
" <separator name=\"sep1\" />\n"
" <toolitem name=\"edit\" action=\"edit\" />\n"
" </toolbar>\n";
GtkActionEntry entries[] = {
{ "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL },
{ "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL },
{ "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL },
};
guint n_entries = G_N_ELEMENTS (entries);
appGUI->tsk->filter_index = 0;
label = gtk_label_new(NULL);
gtk_label_set_angle (GTK_LABEL(label), -90.0);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks"));
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
vbox1 = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
gtk_notebook_append_page(GTK_NOTEBOOK(appGUI->notebook), vbox1, label);
appGUI->tsk->vbox = GTK_BOX(vbox1);
/*-------------------------------------------------------------------------------------*/
action_group = gtk_action_group_new ("_actions");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_set_sensitive(action_group, TRUE);
appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0);
g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI);
if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) {
g_message ("building toolbar failed: %s", error->message);
g_error_free (error);
}
gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget);
gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips);
/*-------------------------------------------------------------------------------------*/
/* assign callbacks */
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked",
G_CALLBACK(tasks_add_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked",
G_CALLBACK(tasks_edit_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked",
G_CALLBACK(tasks_remove_item_cb), appGUI);
/*-------------------------------------------------------------------------------------*/
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Category filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
appGUI->tsk->cf_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->cf_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(appGUI->tsk->cf_combobox, "changed",
G_CALLBACK(category_filter_cb), appGUI);
g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus",
G_CALLBACK(category_combo_box_focus_cb), NULL);
appGUI->tsk->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->tsk->n_items_label);
gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
/*-------------------------------------------------------------------------------------*/
appGUI->tsk->tasks_paned = gtk_vpaned_new();
gtk_widget_show (appGUI->tsk->tasks_paned);
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0);
top_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (top_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE);
gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE);
top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (top_scrolledwindow);
gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter),
(GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb,
appGUI, NULL);
appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter));
appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint);
gtk_widget_show (appGUI->tsk->tasks_list);
GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT);
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED]));
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event",
G_CALLBACK(list_dbclick_cb), appGUI);
appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed",
G_CALLBACK(tasks_item_selected), appGUI);
/* create columns */
renderer = gtk_cell_renderer_toggle_new();
appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"),
renderer,
"active", COLUMN_DONE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]);
g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"),
renderer,
"text", COLUMN_DUE_DATE,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_DUE_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_START_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"),
renderer,
"text", COLUMN_PRIORITY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"),
renderer,
"text", COLUMN_CATEGORY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size(renderer, 0, -1);
appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"),
renderer,
"text", COLUMN_SUMMARY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"),
renderer,
"text", COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]);
/* configure list options */
gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE);
/* configure sorting */
gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0,
(GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order);
/*----------------------------------------------------------------------------*/
bottom_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (bottom_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE);
gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0);
gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2);
appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0);
gtk_widget_show(appGUI->tsk->panel_hbox);
sprintf(tmpbuf, "%s:", _("Task details"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0);
if (config.default_stock_icons) {
close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE);
} else {
close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL);
gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (panel_close_desc_cb), appGUI);
appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (appGUI->tsk->panel_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_widget_show (appGUI->tsk->tasks_desc_textview);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gtk_text_buffer_create_tag (text_buffer, "italic",
"style", PANGO_STYLE_ITALIC, NULL);
appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font",
"font", (gchar *) config.task_info_font, NULL);
}
static void
marlin_text_renderer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MarlinTextRenderer *text_renderer = MARLIN_TEXT_RENDERER (object);
const gchar *sval;
switch (prop_id)
{
case PROP_FOLLOW_PRELIT:
text_renderer->follow_prelit = g_value_get_boolean (value);
break;
case PROP_FOLLOW_STATE:
text_renderer->follow_state = g_value_get_boolean (value);
break;
case PROP_TEXT:
/* release the previous text (if not static) */
if (!text_renderer->text_static)
g_free (text_renderer->text);
sval = g_value_get_string (value);
text_renderer->text_static = (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS);
text_renderer->text = (sval == NULL) ? "" : (gchar *)sval;
if (!text_renderer->text_static)
text_renderer->text = g_strdup (text_renderer->text);
break;
case PROP_BACKGROUND:
g_free (text_renderer->background);
sval = g_value_get_string (value);
text_renderer->background = g_strdup (sval);
break;
case PROP_ZOOM_LEVEL:
text_renderer->zoom_level = g_value_get_enum (value);
if (text_renderer->layout != NULL) {
if (text_renderer->zoom_level < MARLIN_ZOOM_LEVEL_NORMAL)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small ());
else
pango_layout_set_attributes (text_renderer->layout, NULL);
}
break;
case PROP_WRAP_MODE:
text_renderer->wrap_mode = g_value_get_enum (value);
break;
case PROP_WRAP_WIDTH:
/* be sure to reset fixed height if wrapping is requested */
text_renderer->wrap_width = g_value_get_int (value);
if (G_LIKELY (text_renderer->wrap_width >= 0))
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (text_renderer), -1, -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GtkWidget*
gwy_app_recent_file_list_construct(Controls *controls)
{
static const struct {
const gchar *title;
const guint id;
}
columns[] = {
{ "Preview", FILELIST_THUMB },
{ "File Path", FILELIST_FILENAME },
};
GtkWidget *list;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
g_return_val_if_fail(controls->store, NULL);
list = gtk_tree_view_new_with_model(controls->filter);
controls->list = list;
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), FALSE);
/* thumbnail name column */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(renderer, THUMB_SIZE, THUMB_SIZE);
column = gtk_tree_view_column_new_with_attributes(_(columns[0].title),
renderer, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
cell_renderer_thumb,
GUINT_TO_POINTER(columns[0].id),
NULL); /* destroy notify */
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_fixed_size(renderer, -1, THUMB_SIZE);
column = gtk_tree_view_column_new_with_attributes(_(columns[1].title),
renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
cell_renderer_desc,
GUINT_TO_POINTER(columns[1].id),
NULL); /* destroy notify */
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
/* selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect_swapped
(selection, "changed",
G_CALLBACK(gwy_app_recent_file_list_update_sensitivity), controls);
g_signal_connect_swapped
(controls->store, "row-deleted",
G_CALLBACK(gwy_app_recent_file_list_update_sensitivity), controls);
g_signal_connect_swapped
(controls->store, "row-inserted",
G_CALLBACK(gwy_app_recent_file_list_update_sensitivity), controls);
g_signal_connect(controls->list, "row-activated",
G_CALLBACK(gwy_app_recent_file_list_row_activated),
controls);
return list;
}
void rc_gui_treeview_init()
{
rc_ui = rc_gui_get_data();
gint count = 0;
rc_ui->list2_tree_model = NULL;
rc_ui->list1_tree_model = NULL;
rc_ui->list1_tree_view = gtk_tree_view_new();
rc_ui->list2_tree_view = gtk_tree_view_new();
gtk_widget_set_name(rc_ui->list1_tree_view, "RCListView1");
gtk_widget_set_name(rc_ui->list2_tree_view, "RCListView2");
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(rc_ui->list1_tree_view));
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(rc_ui->list2_tree_view));
for(count=0;count<5;count++)
rc_ui->renderer_text[count] = gtk_cell_renderer_text_new();
for(count=0;count<2;count++)
rc_ui->renderer_pixbuf[count] = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(rc_ui->renderer_text[0], 80, -1);
gtk_cell_renderer_set_fixed_size(rc_ui->renderer_text[1], 120, -1);
gtk_cell_renderer_set_fixed_size(rc_ui->renderer_text[4], 55, -1);
g_object_set(G_OBJECT(rc_ui->renderer_text[0]), "ellipsize",
PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
g_object_set(G_OBJECT(rc_ui->renderer_text[1]), "ellipsize",
PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
g_object_set(G_OBJECT(rc_ui->renderer_text[2]), "ellipsize",
PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
g_object_set(G_OBJECT(rc_ui->renderer_text[3]),"ellipsize",
PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
g_object_set(G_OBJECT(rc_ui->renderer_text[4]), "xalign", 1.0, "width-chars", 5,
NULL);
gtk_cell_renderer_set_fixed_size(rc_ui->renderer_pixbuf[0], 16, -1);
gtk_cell_renderer_set_fixed_size(rc_ui->renderer_pixbuf[1], 16, -1);
list1_column = gtk_tree_view_column_new();
list2_index_column = gtk_tree_view_column_new_with_attributes(
"#", rc_ui->renderer_pixbuf[1], "stock-id", PLIST2_STATE, NULL);
list2_title_column = gtk_tree_view_column_new_with_attributes(
_("Title"), rc_ui->renderer_text[2], "text", PLIST2_TITLE, NULL);
list2_time_column = gtk_tree_view_column_new_with_attributes(
_("Length"), rc_ui->renderer_text[4], "text", PLIST2_LENGTH, NULL);
gtk_tree_view_column_set_title(list1_column, "Playlist");
gtk_tree_view_column_pack_start(list1_column, rc_ui->renderer_pixbuf[0],
FALSE);
gtk_tree_view_column_pack_start(list1_column, rc_ui->renderer_text[0],
TRUE);
gtk_tree_view_column_add_attribute(list1_column,
rc_ui->renderer_pixbuf[0], "stock-id", PLIST1_STATE);
gtk_tree_view_column_add_attribute(list1_column,
rc_ui->renderer_text[0], "text", PLIST1_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(rc_ui->list1_tree_view),
list1_column);
gtk_tree_view_column_set_expand(list1_column, TRUE);
gtk_tree_view_column_set_expand(list2_title_column, TRUE);
gtk_tree_view_column_set_sizing(list2_time_column,
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(list2_index_column ,30);
gtk_tree_view_column_set_min_width(list2_index_column, 30);
gtk_tree_view_column_set_max_width(list2_index_column, 30);
gtk_tree_view_column_set_fixed_width(list2_time_column, 55);
gtk_tree_view_column_set_alignment(list2_time_column, 1.0);
gtk_tree_view_append_column(GTK_TREE_VIEW(rc_ui->list2_tree_view),
list2_index_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(rc_ui->list2_tree_view),
list2_title_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(rc_ui->list2_tree_view),
list2_time_column);
rc_ui->list1_selection = gtk_tree_view_get_selection(
GTK_TREE_VIEW(rc_ui->list1_tree_view));
rc_ui->list2_selection = gtk_tree_view_get_selection(
GTK_TREE_VIEW(rc_ui->list2_tree_view));
gtk_tree_selection_set_mode(rc_ui->list1_selection,
GTK_SELECTION_BROWSE);
gtk_tree_selection_set_mode(rc_ui->list2_selection,
GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(
rc_ui->list1_tree_view), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(
rc_ui->list2_tree_view), FALSE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(rc_ui->list2_tree_view),
FALSE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(rc_ui->list1_tree_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(rc_ui->list2_tree_view),
TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(rc_ui->list1_tree_view),
TRUE);
rc_gui_list1_tree_view_set_drag();
rc_gui_list2_tree_view_set_drag();
g_signal_connect(G_OBJECT(rc_ui->renderer_text[0]), "edited",
G_CALLBACK(rc_gui_list1_edited), NULL);
g_signal_connect(G_OBJECT(rc_ui->list1_tree_view), "cursor-changed",
G_CALLBACK(rc_gui_list1_row_selected), NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view), "row-activated",
G_CALLBACK(rc_gui_list2_row_activated), NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view),
"button-press-event", G_CALLBACK(rc_gui_list2_popup_menu), NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view),
"button-release-event",
G_CALLBACK(rc_gui_list2_button_release_event), NULL);
g_signal_connect(G_OBJECT(rc_ui->list1_tree_view),
"button-release-event", G_CALLBACK(rc_gui_list1_popup_menu), NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view),
"drag_data_received", G_CALLBACK(rc_gui_list2_dnd_data_received),
NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view), "drag-data-get",
G_CALLBACK(rc_gui_list2_dnd_data_get), NULL);
g_signal_connect(G_OBJECT(rc_ui->list2_tree_view), "drag-motion",
G_CALLBACK(rc_gui_list2_dnd_motion), NULL);
g_signal_connect(G_OBJECT(rc_ui->list1_tree_view),
"drag-data-received", G_CALLBACK(rc_gui_list1_dnd_data_received),
NULL);
g_signal_connect(G_OBJECT(rc_ui->list1_tree_view), "drag-data-get",
G_CALLBACK(rc_gui_list1_dnd_data_get), NULL);
}
static void
fill_combo_box(GtkIconTheme* theme, GtkComboBox* combo_box, GList* app_list, gchar* mime)
{
guint index = 0;
GList* entry;
GtkTreeModel* model;
GtkCellRenderer* renderer;
GtkTreeIter iter;
GdkPixbuf* pixbuf;
GAppInfo* default_app;
default_app = g_app_info_get_default_for_type(mime, FALSE);
if (theme == NULL)
{
theme = gtk_icon_theme_get_default();
}
model = GTK_TREE_MODEL(gtk_list_store_new(4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING));
gtk_combo_box_set_model(combo_box, model);
renderer = gtk_cell_renderer_pixbuf_new();
/* not all cells have a pixbuf, this prevents the combo box to shrink */
gtk_cell_renderer_set_fixed_size(renderer, -1, 22);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer,
"pixbuf", PIXBUF_COL,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer,
"text", TEXT_COL,
NULL);
for (entry = app_list; entry != NULL; entry = g_list_next(entry))
{
GAppInfo* item = (GAppInfo*) entry->data;
// icon
GIcon* icon = g_app_info_get_icon(item);
gchar* icon_name = g_icon_to_string(icon);
if (icon_name == NULL)
{
icon_name = g_strdup("binary"); // default icon
}
pixbuf = gtk_icon_theme_load_icon(theme, icon_name, 22, 0, NULL);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PIXBUF_COL, pixbuf,
TEXT_COL, g_app_info_get_display_name(item),
ID_COL, g_app_info_get_id(item),
ICONAME_COL, icon_name,
-1);
if (pixbuf)
{
g_object_unref(pixbuf);
}
/* set the index */
if (default_app != NULL && g_app_info_equal(item, default_app))
{
gtk_combo_box_set_active(combo_box, index);
}
g_free(icon_name);
index++;
}
}
static void
thunar_text_renderer_set_widget (ThunarTextRenderer *text_renderer,
GtkWidget *widget)
{
PangoFontMetrics *metrics;
PangoContext *context;
gint focus_padding;
gint focus_line_width;
if (G_LIKELY (widget == text_renderer->widget))
return;
/* disconnect from the previously set widget */
if (G_UNLIKELY (text_renderer->widget != NULL))
{
g_signal_handlers_disconnect_by_func (G_OBJECT (text_renderer->widget), thunar_text_renderer_invalidate, text_renderer);
g_object_unref (G_OBJECT (text_renderer->layout));
g_object_unref (G_OBJECT (text_renderer->widget));
}
/* activate the new widget */
text_renderer->widget = widget;
/* connect to the new widget */
if (G_LIKELY (widget != NULL))
{
/* take a reference on the widget */
g_object_ref (G_OBJECT (widget));
/* we need to recalculate the metrics when a new style (and thereby a new font) is set */
g_signal_connect_swapped (G_OBJECT (text_renderer->widget), "destroy", G_CALLBACK (thunar_text_renderer_invalidate), text_renderer);
g_signal_connect_swapped (G_OBJECT (text_renderer->widget), "style-set", G_CALLBACK (thunar_text_renderer_invalidate), text_renderer);
/* allocate a new pango layout for this widget */
context = gtk_widget_get_pango_context (widget);
text_renderer->layout = pango_layout_new (context);
/* disable automatic text direction, but use the direction specified by Gtk+ */
pango_layout_set_auto_dir (text_renderer->layout, FALSE);
/* we don't want to interpret line separators in file names */
pango_layout_set_single_paragraph_mode (text_renderer->layout, TRUE);
/* calculate the average character dimensions */
metrics = pango_context_get_metrics (context, widget->style->font_desc, pango_context_get_language (context));
text_renderer->char_width = PANGO_PIXELS (pango_font_metrics_get_approximate_char_width (metrics));
text_renderer->char_height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics));
pango_font_metrics_unref (metrics);
/* tell the cell renderer about the fixed height if we're not wrapping text */
if (G_LIKELY (text_renderer->wrap_width < 0))
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (text_renderer), -1, text_renderer->char_height);
/* determine the focus-padding and focus-line-width style properties from the widget */
gtk_widget_style_get (widget, "focus-padding", &focus_padding, "focus-line-width", &focus_line_width, NULL);
text_renderer->focus_width = focus_padding + focus_line_width;
}
else
{
text_renderer->layout = NULL;
text_renderer->char_width = 0;
text_renderer->char_height = 0;
}
}
static void
bt_settings_page_interaction_controller_init_ui (const
BtSettingsPageInteractionController * self, GtkWidget * pages)
{
GtkWidget *label, *widget, *scrolled_window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *tree_col;
GtkTreeSelection *tree_sel;
BtIcRegistry *ic_registry;
gchar *str;
gtk_widget_set_name (GTK_WIDGET (self), "interaction controller settings");
// create the widget already so that we can set the initial text
self->priv->message = GTK_LABEL (gtk_label_new (NULL));
g_object_set (GTK_WIDGET (self->priv->message), "hexpand", TRUE, NULL);
// add setting widgets
label = gtk_label_new (NULL);
str = g_strdup_printf ("<big><b>%s</b></big>", _("Interaction Controller"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
g_object_set (label, "xalign", 0.0, NULL);
gtk_grid_attach (GTK_GRID (self), label, 0, 0, 3, 1);
gtk_grid_attach (GTK_GRID (self), gtk_label_new (" "), 0, 1, 1, 3);
label = gtk_label_new (_("Device"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (self), label, 1, 1, 1, 1);
widget = gtk_combo_box_new ();
self->priv->device_menu = GTK_COMBO_BOX (widget);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_fixed_size (renderer, 1, -1);
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT
(renderer), 1);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->device_menu),
renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->device_menu),
renderer, "text", DEVICE_MENU_LABEL, NULL);
// get list of devices from libbtic and listen to changes
g_object_get (self->priv->app, "ic-registry", &ic_registry, NULL);
g_signal_connect_object (ic_registry, "notify::devices",
G_CALLBACK (on_ic_registry_devices_changed), (gpointer) self, 0);
g_object_unref (ic_registry);
g_object_set (widget, "hexpand", TRUE, "margin-left", LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (self), widget, 2, 1, 1, 1);
g_signal_connect (widget, "changed",
G_CALLBACK (on_device_menu_changed), (gpointer) self);
// add list of controllers (updated when selecting a device)
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_ETCHED_IN);
self->priv->controller_list = GTK_TREE_VIEW (gtk_tree_view_new ());
g_object_set (self->priv->controller_list,
"enable-search", FALSE, "rules-hint", TRUE, NULL);
// have this first as the last column gets the remaining space (always :/)
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (self->priv->controller_list, -1,
_("In use"), renderer, "active", CONTROLLER_LIST_USED, NULL);
self->priv->id_renderer = renderer = gtk_cell_renderer_text_new ();
//gtk_cell_renderer_set_fixed_size (renderer, 1, -1);
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT
(renderer), 1);
g_signal_connect (renderer, "edited", G_CALLBACK (on_control_name_edited),
(gpointer) self);
if ((tree_col =
gtk_tree_view_column_new_with_attributes (_("Controller"), renderer,
"text", CONTROLLER_LIST_LABEL, NULL))
) {
g_object_set (tree_col, "expand", TRUE, NULL);
gtk_tree_view_insert_column (self->priv->controller_list, tree_col, -1);
} else
GST_WARNING ("can't create treeview column");
tree_sel = gtk_tree_view_get_selection (self->priv->controller_list);
gtk_tree_selection_set_mode (tree_sel, GTK_SELECTION_BROWSE);
g_signal_connect (tree_sel, "changed", G_CALLBACK (on_control_selected),
(gpointer) self);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (self->priv->controller_list));
g_object_set (GTK_WIDGET (scrolled_window), "hexpand", TRUE, "vexpand", TRUE,
"margin-left", LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (scrolled_window), 1, 2, 2, 1);
// add a message pane
#if ! defined(USE_GUDEV) && ! defined(USE_ALSA)
gtk_label_set_text (self->priv->message,
_("This package has been built without GUdev and Alsa support and thus "
"supports no interaction controllers."));
#endif
gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (self->priv->message), 0, 3, 3,
1);
// listen to page changes
g_signal_connect ((gpointer) pages, "notify::page",
G_CALLBACK (on_page_switched), (gpointer) self);
// initial refresh
on_ic_registry_devices_changed (ic_registry, NULL, (gpointer) self);
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
static void
gvc_combo_box_init (GvcComboBox *combo_box)
{
GtkWidget *frame;
GtkWidget *box;
GtkWidget *sbox;
GtkWidget *ebox;
GtkCellRenderer *renderer;
combo_box->priv = GVC_COMBO_BOX_GET_PRIVATE (combo_box);
combo_box->priv->model = GTK_TREE_MODEL (gtk_list_store_new (NUM_COLS,
G_TYPE_STRING,
G_TYPE_STRING));
combo_box->priv->label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (combo_box->priv->label),
0.0,
0.5);
/* frame */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (combo_box), frame);
combo_box->priv->drop_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combo_box->priv->combobox = gtk_combo_box_new_with_model (combo_box->priv->model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box->priv->combobox),
renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->combobox),
renderer,
"text", COL_HUMAN_NAME);
/* Make sure that the combo box isn't too wide when human names are overly long,
* but that we can still read the full length of it */
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size (renderer, 5, -1);
g_object_set (G_OBJECT (combo_box->priv->combobox), "popup-fixed-width", FALSE, NULL);
combo_box->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), combo_box->priv->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), combo_box->priv->combobox, TRUE, TRUE, 0);
combo_box->priv->button = gtk_button_new_with_label ("APPLICATION BUG");
gtk_button_set_use_underline (GTK_BUTTON (combo_box->priv->button), TRUE);
gtk_widget_set_no_show_all (combo_box->priv->button, TRUE);
gtk_box_pack_start (GTK_BOX (box), combo_box->priv->button, FALSE, FALSE, 0);
combo_box->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);
if (combo_box->priv->size_group != NULL) {
gtk_size_group_add_widget (combo_box->priv->size_group, sbox);
if (combo_box->priv->symmetric) {
gtk_size_group_add_widget (combo_box->priv->size_group, ebox);
}
}
gtk_container_add (GTK_CONTAINER (frame), combo_box->priv->drop_box);
gtk_widget_show_all (frame);
gtk_label_set_mnemonic_widget (GTK_LABEL (combo_box->priv->label),
combo_box->priv->combobox);
g_signal_connect (G_OBJECT (combo_box->priv->combobox), "changed",
G_CALLBACK (on_combo_box_changed), combo_box);
g_signal_connect (G_OBJECT (combo_box->priv->button), "clicked",
G_CALLBACK (on_combo_box_button_clicked), combo_box);
}
GtkWidget * ISFSetupWin::create_factory_list_view (void)
{
GtkCellRenderer* renderer = NULL;
GtkTreeViewColumn* column = NULL;
GtkWidget *tv = gtk_tree_view_new ();
g_object_set (tv, "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_NONE, NULL);
column = gtk_tree_view_column_new ();
//toggle renderer
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "activatable", TRUE, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, FALSE);
gtk_cell_renderer_set_fixed_size (renderer, _screen_width/8, (gint)(40*_height_rate));
g_object_set (renderer, "xalign", 0.5, NULL);
g_object_set (renderer, "radio", 0, NULL);
g_object_set (renderer, "indicator-size", (gint)(26*(_width_rate < _height_rate ? _width_rate : _height_rate)), NULL);
gtk_tree_view_column_set_attributes (column, renderer, "active", FACTORY_LIST_ENABLE, NULL);
g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (on_factory_enable_box_clicked), (gpointer) NULL);
// text renderer
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "text", FACTORY_LIST_NAME, NULL);
gtk_cell_renderer_set_fixed_size (renderer, (gint)(_screen_width*5/8), (gint)(40*_height_rate));
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set (renderer, "xalign", 0.0, NULL);
#if HAVE_GCONF
gtk_cell_renderer_set_cell_flag (tv, renderer, GTK_CELL_RENDERER_MAINCELL);
#endif
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
// pixbuf render
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
#if HAVE_GCONF
renderer->cell_type = GTK_CELL_RENDERER_ICONCELL;
#endif
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FACTORY_LIST_HELP_PIX, NULL);
gtk_cell_renderer_set_fixed_size (renderer, _screen_width/11, _screen_width/10);
g_object_set (renderer, "xalign", 0.5, NULL);
g_object_set (renderer, "yalign", 0.5, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
// pixbuf render
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
#if HAVE_GCONF
renderer->cell_type = GTK_CELL_RENDERER_ICONCELL;
#endif
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FACTORY_LIST_OPTION_PIX, NULL);
gtk_cell_renderer_set_fixed_size (renderer, _screen_width/11, _screen_width/10);
g_object_set (renderer, "yalign", 0.5, NULL);
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
#if HAVE_GCONF
gtk_tree_view_set_special_row_selection_indicator (GTK_TREE_VIEW (tv), TRUE);
#endif
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), false);
g_signal_connect (GTK_TREE_VIEW (tv), "button_press_event", G_CALLBACK (button_press_cb), this);
gtk_widget_show_all (tv);
return tv;
}
gboolean update_snapshot()
{
GtkTreeModel *model;
GtkTreeIter iter;
GdkPixbuf *icon;
gboolean have_iter, found = FALSE;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
gtk_tree_model_get(model, &iter, COL_SNAPSHOT, &icon, -1);
if (icon != NULL) {
g_object_unref(icon);
have_iter = gtk_tree_model_iter_next(model, &iter);
}
else {
found = TRUE;
break;
}
}
if (found) {
// build panel's snapshot
GdkPixbuf *pixbuf;
gchar *name, *snap, *cmd;
gint pixWidth, pixHeight;
gboolean changeSize = FALSE;
snap = g_build_filename (g_get_user_config_dir(), "tint2", "snap.jpg", NULL);
g_remove(snap);
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &name, -1);
cmd = g_strdup_printf("tint2 -c \'%s\' -s \'%s\'", name, snap);
system(cmd);
// load
pixbuf = gdk_pixbuf_new_from_file(snap, NULL);
if (pixbuf == NULL) {
printf("snapshot NULL : %s\n", cmd);
found = FALSE;
}
g_free(snap);
g_free(cmd);
g_free(name);
pixWidth = gdk_pixbuf_get_width(pixbuf);
pixHeight = gdk_pixbuf_get_height(pixbuf);
if (g_width_list != pixWidth) {
g_width_list = pixWidth;
changeSize = TRUE;
}
if (g_height_list != (pixHeight+30)) {
g_height_list = pixHeight+30;
changeSize = TRUE;
}
if (changeSize)
gtk_cell_renderer_set_fixed_size(g_renderer, g_width_list, g_height_list);
gtk_list_store_set(g_store, &iter, COL_SNAPSHOT, pixbuf, -1);
}
return found;
}
