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; }