void setup_device_treeview (GtkBuilder *builder) { GtkTreeModel *model; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; char *headers[] = { _("Device"), NULL}; treeview = GTK_WIDGET (gtk_builder_get_object (builder, "device-treeview")); g_assert (treeview != NULL); popup = GTK_WIDGET (gtk_builder_get_object (builder, "device-popup")); g_assert (popup != NULL); subscribe_menuitem = GTK_WIDGET (gtk_builder_get_object ( builder, "subscribe-to-events")); g_assert (subscribe_menuitem != NULL); action_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "invoke-action")); g_assert (action_menuitem != NULL); separator = GTK_WIDGET (gtk_builder_get_object ( builder, "device-popup-separator")); g_assert (separator != NULL); model = create_device_treemodel (); g_assert (model != NULL); setup_treeview (treeview, model, headers, 1); g_object_unref (model); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", 0); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_assert (selection != NULL); g_signal_connect (selection, "changed", G_CALLBACK (on_something_selected), NULL); expanded = FALSE; }
GtkWidget* create_i2c_view() { int i = 0; int loc_i; int num_cols = I2C_NUM_COLS + mix_number_of_i2c_headers() - 1; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *view; view = gtk_tree_view_new(); // --- Column #X --- while(i < num_cols) { col = gtk_tree_view_column_new(); loc_i = i > I2C_B ? I2C_B : i; gtk_tree_view_column_set_spacing(col, 1); gtk_tree_view_column_set_title(col, header[loc_i].title); // pack tree view column into tree view gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "editable", header[loc_i].editable, NULL); g_object_set_data(G_OBJECT(renderer), "column_index", GUINT_TO_POINTER(i)); g_signal_connect(renderer, "edited", (GCallback) i2c_edited_callback, NULL); // pack cell renderer into tree view column gtk_tree_view_column_pack_start(col, renderer, TRUE); // connect 'text' property of the cell renderer to // model column that contains the first name gtk_tree_view_column_add_attribute(col, renderer, header[loc_i].type, i); i++; } i2c_model = (GtkTreeModel*) create_i2c_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(view), i2c_model); g_object_unref(i2c_model); // destroy model automatically with view gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), TRUE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE); return view; }
static void function_list_populate (GtkTreeView *tv) { GtkListStore *liststore; GtkTreeIter iter; gint i; const gint n_funcs = expr_get_function_cnt (); liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); for (i = 0 ; i < n_funcs ; ++i) { const struct operation *op = expr_get_function (i); gtk_list_store_append (liststore, &iter); gtk_list_store_set (liststore, &iter, COMPUTE_COL_NAME, expr_operation_get_name (op), COMPUTE_COL_USAGE, expr_operation_get_prototype (op), COMPUTE_COL_ARITY, expr_operation_get_arg_cnt (op), -1); } /* Set the cell rendering */ { GtkTreeViewColumn *col; GtkCellRenderer *renderer; col = gtk_tree_view_column_new (); gtk_tree_view_append_column (tv, col); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COMPUTE_COL_USAGE); } gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore)); }
static void bar_exif_add_column_check(GtkWidget *listview, const gchar *title, gint n) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, title); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "active", n); gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(bar_exif_row_toggled_cb), listview); }
/** * add_columns: * @treeview: the GtkTreeView to add the column to * * Adds a column to a GtkTreeView. */ static void add_columns (GtkTreeView * treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *img_att; GdkPixbuf *pix; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_(" Index "), renderer, "text", COL_INDEX, NULL); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_(" Title "), renderer, "text", COL_ID, NULL); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); pix = gdk_pixbuf_new_from_xpm_data (clip_xpm); img_att = gtk_image_new_from_pixbuf (pix); gtk_misc_set_alignment (GTK_MISC (img_att), (gfloat) 0.5, (gfloat) 0.0); g_object_unref (G_OBJECT (pix)); gtk_tree_view_column_set_widget (column, img_att); g_object_set (G_OBJECT (renderer), "xalign", (gfloat) 0.5, NULL); /*needed at least in GTK 2.0.6, anyways doing it seems stupid 2 me*/ gtk_widget_show (img_att); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", NUM_ATT); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); }
void treeview2_set_up_constants(GtkTreeView *treeview, gint type) { #ifdef DEBUG printf("treeview2_set_up_constants\n"); #endif GtkTreeViewColumn *col; GtkCellRenderer *renderer; gchar *titles[2] = {_("Name"), _("Value")}; gint i; gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview), GTK_SELECTION_SINGLE); gtk_tree_view_set_headers_visible(treeview, TRUE); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_search_column(treeview, 0); gtk_tree_view_set_search_equal_func(treeview, treeview_helper_search_equal_strings, NULL, NULL); for(i = 0; i < 2; i++) { col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, titles[i]); gtk_tree_view_append_column(treeview, col); renderer = treeview_helper_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", i); if(i == 1) { g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", (type == CONSTANTS_TYPE_APP) ? G_CALLBACK (treeview_helper_constants_app_editing_done) : G_CALLBACK (treeview_helper_constants_editing_done), treeview); } } }
CChooseApertureSimpleDlg::CChooseApertureSimpleDlg(GtkWindow *pParent):m_FrameSet(NULL), m_ApertureIndex(-1) { GtkWidget *scrwnd; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkTreeSelection *selection; // Dialog with buttons m_pDlg = gtk_dialog_new_with_buttons("Choose aperture", pParent, (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg)); g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this); // Dialog icon gchar *icon = get_icon_file("muniwin"); gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL)); g_free(icon); // List of apertures m_Apertures = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); m_AperView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(m_Apertures)); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "Apertures"); gtk_tree_view_append_column(GTK_TREE_VIEW(m_AperView), col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, FALSE); gtk_tree_view_column_add_attribute(col, renderer, "text", 1); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_AperView)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this); scrwnd = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwnd), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrwnd), m_AperView); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), scrwnd, FALSE, TRUE, 0); gtk_widget_set_size_request(scrwnd, 140, 300); gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox); }
/** * Assemble the list view. */ static GtkTreeView* get_tree_view(GDeviceSetup *gds) { GtkTreeStore *ts = query_devices(gds); GtkTreeView *tv; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkTargetEntry dnd_targets[] = {{"DEV_LIST", GTK_TARGET_SAME_WIDGET, 0xFF}}; int dnd_ntargets = sizeof(dnd_targets)/sizeof(GtkTargetEntry); tv = (GtkTreeView*)gtk_tree_view_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, ("Input Device Hierarchy")); gtk_tree_view_append_column(tv, col); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, renderer, FALSE); gtk_tree_view_column_set_attributes(col, renderer, "pixbuf", COL_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NAME); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(ts)); g_object_unref(ts); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_SINGLE); gtk_tree_view_enable_model_drag_source(tv, GDK_BUTTON1_MASK, dnd_targets, dnd_ntargets, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest(tv, dnd_targets, dnd_ntargets, GDK_ACTION_MOVE); gtk_tree_view_expand_all(tv); g_signal_connect(tv, "drag_data_received", G_CALLBACK(signal_dnd_recv), gds); g_signal_connect(tv, "button-press-event", G_CALLBACK(signal_button_press), gds); return tv; }
GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, data_func_t data_func, unsigned int flags) { GtkCellRenderer *renderer; GtkTreeViewColumn *col; double xalign = 0.0; /* left as default */ PangoAlignment align; gboolean visible; align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT : (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_CENTER; visible = !(flags & INVISIBLE); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, title); if (!(flags & UNSORTABLE)) gtk_tree_view_column_set_sort_column_id(col, index); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_pack_start(col, renderer, TRUE); if (data_func) gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL); else gtk_tree_view_column_add_attribute(col, renderer, "text", index); gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL); switch (align) { case PANGO_ALIGN_LEFT: xalign = 0.0; break; case PANGO_ALIGN_CENTER: xalign = 0.5; break; case PANGO_ALIGN_RIGHT: xalign = 1.0; break; } gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5); gtk_tree_view_column_set_visible(col, visible); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col); return col; }
static GtkWidget *gebr_gui_sequence_edit_create_tree_view_real(GebrGuiSequenceEdit *self) { GtkWidget *tree_view; GtkTreeViewColumn *col; GtkCellRenderer *renderer; tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->list_store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), FALSE); self->renderer = renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "editable", self->may_rename, NULL); g_signal_connect(renderer, "edited", G_CALLBACK(on_edited), self); g_signal_connect_swapped(renderer, "edited", G_CALLBACK(on_editing_canceled), self); g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(on_editing_canceled), self); g_signal_connect(renderer, "editing-started", G_CALLBACK(on_editing_started), self); col = gtk_tree_view_column_new_with_attributes("", renderer, NULL); gtk_tree_view_column_add_attribute(col, renderer, "text", 0); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col); return tree_view; }
void treeview2_set_up_news(GtkTreeView *treeview) { #ifdef DEBUG printf("treeview2_set_up_news\n"); #endif GtkTreeViewColumn *col; GtkCellRenderer *renderer; gint i; gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview), GTK_SELECTION_NONE); gtk_tree_view_set_headers_visible(treeview, FALSE); gtk_tree_view_set_rules_hint(treeview, FALSE); for(i = 0; i < 3; i++) { col = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, col); renderer = treeview_helper_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); if(i == 0) gtk_tree_view_column_add_attribute(col, renderer, "markup", 0); else if(i == 1) gtk_tree_view_column_set_cell_data_func(col, renderer, treeview_helper_news, NULL, NULL); else gtk_tree_view_column_set_cell_data_func(col, renderer, treeview_helper_news_additional, NULL, NULL); g_object_set(renderer, "wrap-mode", PANGO_WRAP_WORD, NULL); g_object_set(renderer, "wrap-width", 400, NULL); g_object_set(renderer, "yalign", 0.0, NULL); } }
static void create_column(GtkWidget* tree , FxMain* UNUSED(fxmain)) { GtkCellRenderer* renderer; GtkTreeViewColumn *col , *col0; renderer = gtk_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, renderer , FALSE); gtk_tree_view_column_add_attribute(col, renderer, "pixbuf", B_PIXBUF_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col); renderer = gtk_cell_renderer_text_new(); col0 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col0, renderer , FALSE); gtk_tree_view_column_set_cell_data_func(col0 , renderer , text_cell_data_func , NULL , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0); }
GtkWidget *create_dive_list(void) { GtkListStore *model; GtkWidget *tree_view; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkWidget *scroll_window; model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); gtk_widget_set_size_request(tree_view, 200, 100); fill_dive_list(model); 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", 0); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col); g_object_set(G_OBJECT(tree_view), "headers-visible", FALSE, "search-column", 0, "rules-hint", FALSE, NULL); g_signal_connect(selection, "changed", G_CALLBACK(selection_cb), model); scroll_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scroll_window), tree_view); return scroll_window; }
static VALUE tvc_initialize(int argc, VALUE *argv, VALUE self) { int i; int col; GtkTreeViewColumn *tvc; GtkCellRenderer *renderer; const gchar *name; VALUE ary, val; tvc = gtk_tree_view_column_new(); if (argc > 0){ gtk_tree_view_column_set_title(tvc, RVAL2CSTR(argv[0])); if (argc > 1) { gtk_tree_view_column_pack_start(tvc, RVAL2CELLRENDERER(argv[1]), TRUE); G_CHILD_ADD(self, argv[1]); } } RBGTK_INITIALIZE(self, tvc); if (argc == 3){ ary = rb_funcall(argv[2], rb_intern("to_a"), 0); renderer = RVAL2CELLRENDERER(argv[1]); for (i = 0; i < RARRAY_LEN(ary); i++) { val = RARRAY_PTR(RARRAY_PTR(ary)[i])[0]; if (SYMBOL_P(val)) { name = rb_id2name(SYM2ID(val)); } else { name = RVAL2CSTR(val); } col = NUM2INT(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]); gtk_tree_view_column_add_attribute(_SELF(self), renderer, name, col); } } return Qnil; }
GtkWidget * CreateView() { GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkTreeModel *model; GtkWidget *view; view = gtk_tree_view_new (); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (col,"Detected Devices"); gtk_tree_view_append_column (GTK_TREE_VIEW(view),col); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col,renderer,TRUE); gtk_tree_view_column_add_attribute (col,renderer,"text",COLUMN); model = CreateModel(); gtk_tree_view_set_model(GTK_TREE_VIEW(view),model); g_object_unref(model); return view; }
/** initialize this module */ gboolean ui_setup_ledlist_init( ) { _ui = ui_builder("niftyconf-setup-ledlist.ui"); /* set selection mode for tree */ GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(UI("treeview"))); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* connect signal handler */ g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), NULL); /* initialize setup treeview */ GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(UI("column_led")); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", C_CHAIN_LED); return TRUE; }
void create_a_column(const char *name, int num, bool visible) { for (int i = 0; i < 2; i++) { GtkCellRenderer *renderer; GtkTreeViewColumn *col; col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, name); /* pack tree view column into tree view */ gtk_tree_view_append_column(view[i], col); renderer = gtk_cell_renderer_text_new(); /* pack cell renderer into tree view column */ gtk_tree_view_column_pack_start(col, renderer, TRUE); /* connect 'text' property of the cell renderer to * model column that contains the first name */ gtk_tree_view_column_add_attribute(col, renderer, "text", num); gtk_tree_view_column_set_visible(col, visible); } }
static GtkWidget *create_view_and_model (void) { GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *view; GtkTreeModel *model; view = gtk_tree_view_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "UML Elements"); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", COLUMN); model = create_and_fill_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); g_object_unref(model); return view; }
static void bar_exif_add_column(GtkWidget *listview, const gchar *title, gint n, gint sizable) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, title); if (sizable) { gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width(column, BAR_EXIF_DATA_COLUMN_WIDTH); gtk_tree_view_column_set_resizable(column, TRUE); } else { gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); } renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", n); gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column); }
/** * query_favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * query_favorite_selector_new (TConnection *tcnc) { QueryFavoriteSelector *tsel; GdaTreeManager *manager; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); tsel = QUERY_FAVORITE_SELECTOR (g_object_new (QUERY_FAVORITE_SELECTOR_TYPE, NULL)); tsel->priv->tcnc = g_object_ref (tcnc); g_signal_connect (t_connection_get_favorites (tsel->priv->tcnc), "favorites-changed", G_CALLBACK (favorites_changed_cb), tsel); /* create tree managers */ tsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (tcnc, T_FAVORITES_QUERIES, ORDER_KEY_QUERIES); gda_tree_add_manager (tsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (! gda_tree_update_all (tsel->priv->tree, NULL)) { if (tsel->priv->idle_update_favorites == 0) tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel); } /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Favorites")); label = gdaui_bar_new (str); g_free (str); gdaui_bar_set_icon_from_resource (GDAUI_BAR (label), "/images/gda-browser-bookmark.png"); gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0); gtk_widget_show (label); /* tree model */ GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; model = gdaui_tree_store_new (tsel->priv->tree, 7, G_TYPE_INT, MGR_FAVORITES_POSITION_ATT_NAME, G_TYPE_OBJECT, "icon", G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME, G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME, G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME, G_TYPE_STRING, MGR_FAVORITES_NAME_ATT_NAME, G_TYPE_STRING, "summary"); treeview = ui_make_tree_view (model); tsel->priv->treeview = treeview; g_object_unref (model); /* icon */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON); g_object_set ((GObject*) renderer, "yalign", 0., NULL); /* text */ 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, (GtkTreeCellDataFunc) cell_data_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); /* scrolled window packing */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0); gtk_widget_show_all (sw); g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (selection_changed_cb), tsel); g_signal_connect (G_OBJECT (treeview), "key-press-event", G_CALLBACK (key_press_event_cb), tsel); g_signal_connect (G_OBJECT (treeview), "popup-menu", G_CALLBACK (popup_menu_cb), tsel); g_signal_connect (G_OBJECT (treeview), "button-press-event", G_CALLBACK (button_press_event_cb), tsel); /* DnD */ gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK, dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (model, "drag-drop", G_CALLBACK (tree_store_drag_drop_cb), tsel); g_signal_connect (model, "drag-can-drag", G_CALLBACK (tree_store_drag_can_drag_cb), tsel); g_signal_connect (model, "drag-get", G_CALLBACK (tree_store_drag_get_cb), tsel); return (GtkWidget*) tsel; }
void gui_init (dt_lib_module_t *self) { dt_lib_collect_t *d = (dt_lib_collect_t *)malloc(sizeof(dt_lib_collect_t)); self->data = (void *)d; self->widget = gtk_vbox_new(FALSE, 5); gtk_widget_set_size_request(self->widget, 100, -1); d->active_rule = 0; d->params = (dt_lib_collect_params_t*)malloc(sizeof(dt_lib_collect_params_t)); dt_control_signal_connect(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED, G_CALLBACK(collection_updated), self); GtkBox *box; GtkWidget *w; GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); GtkTreeView *view = GTK_TREE_VIEW(gtk_tree_view_new()); d->view = view; GtkListStore *liststore; for(int i=0; i<MAX_RULES; i++) { d->rule[i].num = i; box = GTK_BOX(gtk_hbox_new(FALSE, 5)); d->rule[i].hbox = GTK_WIDGET(box); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_combo_box_new_text(); d->rule[i].combo = GTK_COMBO_BOX(w); for(int k=0; k<dt_lib_collect_string_cnt; k++) gtk_combo_box_append_text(GTK_COMBO_BOX(w), _(dt_lib_collect_string[k])); g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(combo_changed), d->rule + i); gtk_box_pack_start(box, w, FALSE, FALSE, 0); w = gtk_entry_new(); dt_gui_key_accel_block_on_focus(w); d->rule[i].text = w; gtk_widget_add_events(w, GDK_FOCUS_CHANGE_MASK); g_signal_connect(G_OBJECT(w), "focus-in-event", G_CALLBACK(entry_focus_in_callback), d->rule + i); /* xgettext:no-c-format */ g_object_set(G_OBJECT(w), "tooltip-text", _("type your query, use `%' as wildcard"), (char *)NULL); gtk_widget_add_events(w, GDK_KEY_PRESS_MASK); g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(changed_callback), d->rule + i); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), d->rule + i); gtk_box_pack_start(box, w, TRUE, TRUE, 0); w = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); d->rule[i].button = w; gtk_widget_set_events(w, GDK_BUTTON_PRESS_MASK); g_signal_connect(G_OBJECT(w), "button-press-event", G_CALLBACK(popup_button_callback), d->rule + i); gtk_box_pack_start(box, w, FALSE, FALSE, 0); gtk_widget_set_size_request(w, 13, 13); } d->scrolledwindow = GTK_SCROLLED_WINDOW(sw); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(view)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(sw), TRUE, TRUE, 0); gtk_tree_view_set_headers_visible(view, FALSE); liststore = gtk_list_store_new(DT_LIB_COLLECT_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, col); gtk_widget_set_size_request(GTK_WIDGET(view), -1, 300); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_COLLECT_COL_TEXT); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(view, GTK_TREE_MODEL(liststore)); g_signal_connect(G_OBJECT (view), "row-activated", G_CALLBACK (row_activated), d); /* setup proxy */ darktable.view_manager->proxy.module_collect.module = self; darktable.view_manager->proxy.module_collect.update = _lib_collect_gui_update; _lib_collect_gui_update(self); }
static SyncDialog *sync_dialog_new(void) { SyncDialog *sd; GtkWidget *dialog; GtkWidget *dialog1_vbox; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *dialog1_action_area; GtkWidget *button8; GtkWidget *button7; GtkWidget *button6; GtkWidget *label; GtkWidget *hbox; GtkTreeViewColumn *column; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *cr_text, *cr_toggle; sd = g_new0(SyncDialog, 1); sd->sna = sync_dialog_netarea_new(); dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater"); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_icon(GTK_WINDOW(dialog), icon_cache_get_pixbuf("syncmanager.png")); gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); dialog1_vbox = GTK_DIALOG(dialog)->vbox; gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5); gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4); gtk_widget_show(dialog1_vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(LABEL_SYNC_DEFAULT); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), icon_cache_get_image("syncmanager.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_widget_show_all(hbox); gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE, 0); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow2, -1, 200); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); model = GTK_TREE_MODEL(store); treeview2 = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE); gtk_widget_show(treeview2); gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column); cr_toggle = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, cr_toggle, FALSE); g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model); gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0); cr_text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cr_text, TRUE); gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1); populate_store(store); dialog1_action_area = GTK_DIALOG(dialog)->action_area; gtk_widget_show(dialog1_action_area); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area), GTK_BUTTONBOX_END); button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(button8); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT); button7 = gtk_button_new_with_mnemonic("_Synchronize"); gtk_widget_show(button7); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT); button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(G_OBJECT(button6), "clicked", (GCallback) close_clicked, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT); sd->dialog = dialog; sd->button_sync = button7; sd->button_cancel = button8; sd->button_close = button6; sd->scroll_box = scrolledwindow2; sd->label = label; return sd; }
void gui_init (dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc (sizeof (dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_vbox_new (FALSE, 5); GtkWidget *w; /* list */ d->list = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible(d->list,FALSE); GtkListStore *liststore = gtk_list_store_new (DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", DT_STYLES_COL_NAME); int ht = get_font_height( GTK_WIDGET (d->list), "Dreggn"); gtk_widget_set_size_request (GTK_WIDGET (d->list), -1, 5*ht); gtk_tree_selection_set_mode (gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model (GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref (liststore); g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL); g_signal_connect (d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry=GTK_ENTRY(w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL); g_signal_connect (d->entry, "changed", G_CALLBACK(entry_callback),d); g_signal_connect (d->entry, "activate", G_CALLBACK(entry_activated),d); dt_gui_key_accel_block_on_focus ( GTK_WIDGET (d->entry)); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->entry),TRUE,FALSE,0); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->list),TRUE,FALSE,0); GtkWidget *hbox=gtk_hbox_new (FALSE,5); GtkWidget *widget; d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->duplicate),TRUE,FALSE,0); g_signal_connect (d->duplicate, "toggled", G_CALLBACK(duplicate_callback),d); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); g_object_set (d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"), (char *)NULL); #if 0 // TODO: Unfinished stuff GtkWidget *widget=gtk_button_new_with_label(_("edit")); d->edit_button = widget; also add to the init function g_signal_connect (widget, "clicked", G_CALLBACK(edit_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),widget,TRUE,TRUE,0); #endif widget=gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect (widget, "clicked", G_CALLBACK(delete_clicked),d); g_object_set (widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX (hbox),widget,TRUE,TRUE,0); gtk_box_pack_start(GTK_BOX (self->widget),hbox,TRUE,FALSE,0); // Export Button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; g_object_set (exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL); g_signal_connect (exportButton, "clicked", G_CALLBACK(export_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),exportButton,TRUE,TRUE,0); // Import Button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; g_object_set (importButton, "tooltip-text", _("import style from a style file"), (char *)NULL); g_signal_connect (importButton, "clicked", G_CALLBACK(import_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),importButton,TRUE,TRUE,0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); }
GtkWidget * module_dialog_new (Gimp *gimp) { GtkWidget *shell; GtkWidget *vbox; GtkWidget *listbox; GtkWidget *view; GtkWidget *image; ModuleDialog *dialog; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreeViewColumn *col; GtkCellRenderer *rend; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); dialog = g_slice_new0 (ModuleDialog); dialog->gimp = gimp; shell = gimp_dialog_new (_("Module Manager"), "gimp-modules", NULL, 0, gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG, GTK_STOCK_REFRESH, RESPONSE_REFRESH, GTK_STOCK_CLOSE, GTK_STOCK_CLOSE, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell), GTK_RESPONSE_CLOSE, RESPONSE_REFRESH, -1); g_signal_connect (shell, "response", G_CALLBACK (dialog_response), dialog); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (shell)->vbox), vbox); gtk_widget_show (vbox); dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP " "for the changes to take effect.")); gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0); if (gimp->write_modulerc) gtk_widget_show (dialog->hint); listbox = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (listbox), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (listbox), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), listbox, TRUE, TRUE, 0); gtk_widget_set_size_request (listbox, 124, 100); gtk_widget_show (listbox); dialog->list = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GIMP_TYPE_MODULE); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list)); g_object_unref (dialog->list); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); g_list_foreach (gimp->module_db->modules, make_list_item, dialog); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (dialog_enabled_toggled), dialog); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED); gtk_tree_view_append_column (GTK_TREE_VIEW (view), col); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1, _("Module"), gtk_cell_renderer_text_new (), "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (listbox), view); gtk_widget_show (view); dialog->table = gtk_table_new (2, NUM_INFOS, FALSE); gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0); gtk_widget_show (dialog->table); dialog->error_box = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0); gtk_widget_show (image); dialog->error_label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (dialog->error_box), dialog->error_label, TRUE, TRUE, 0); gtk_widget_show (dialog->error_label); dialog_info_init (dialog, dialog->table); dialog_info_update (gimp->module_db, dialog->selected, dialog); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_connect (sel, "changed", G_CALLBACK (dialog_select_callback), dialog); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter)) gtk_tree_selection_select_iter (sel, &iter); /* hook the GimpModuleDB signals so we can refresh the display * appropriately. */ g_signal_connect (gimp->module_db, "add", G_CALLBACK (dialog_info_add), dialog); g_signal_connect (gimp->module_db, "remove", G_CALLBACK (dialog_info_remove), dialog); g_signal_connect (gimp->module_db, "module-modified", G_CALLBACK (dialog_info_update), dialog); g_signal_connect (shell, "destroy", G_CALLBACK (dialog_destroy_callback), dialog); return shell; }
/* * Public API */ GtkWidget * addressbook_window_new (boost::shared_ptr<Ekiga::ContactCore> core) { AddressBookWindow *self = NULL; boost::signals::connection conn; GtkWidget *menu_bar = NULL; GtkWidget *frame = NULL; GtkWidget *vbox = NULL; GtkWidget *hpaned = NULL; GtkCellRenderer *cell = NULL; GtkTreeViewColumn *column = NULL; GtkTreeStore *store = NULL; self = (AddressBookWindow *) g_object_new (ADDRESSBOOK_WINDOW_TYPE, NULL); self->priv = new AddressBookWindowPrivate (core); gtk_window_set_title (GTK_WINDOW (self), _("Address Book")); gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (self), "x-office-address-book"); /* Start building the window */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); /* The menu */ menu_bar = gtk_menu_bar_new (); self->priv->accel = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel); g_object_unref (self->priv->accel); self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("Address _Book")); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core); g_object_ref (self->priv->menu_item_core); conn = core->updated.connect (boost::bind (&on_core_updated, (gpointer) self)); self->priv->connections.add (conn); on_core_updated (self); // This will add static and dynamic actions self->priv->menu_item_view = gtk_menu_item_new_with_mnemonic (_("_Action")); gtk_widget_set_sensitive (self->priv->menu_item_view, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_view); g_object_ref (self->priv->menu_item_view); gtk_container_add (GTK_CONTAINER (vbox), menu_bar); gtk_box_set_child_packing (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 2, GTK_PACK_START); gtk_container_add (GTK_CONTAINER (self), vbox); /* A hpaned to put the list of Books and their content */ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_container_set_border_width (GTK_CONTAINER (hpaned), 6); gtk_container_add (GTK_CONTAINER (vbox), hpaned); gtk_box_set_child_packing (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0, GTK_PACK_START); /* The store listing the Books */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); store = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_OBJECT); self->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_container_add (GTK_CONTAINER (frame), self->priv->tree_view); gtk_widget_set_size_request (GTK_WIDGET (self->priv->tree_view), 185, -1); gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, TRUE); /* Several renderers for one column */ column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "icon-name", COLUMN_PIXBUF); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_tree_view_column_set_title (column, _("Category")); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), true); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->tree_view), GTK_TREE_VIEW_COLUMN (column)); self->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (self->priv->selection), GTK_SELECTION_SINGLE); g_signal_connect (self->priv->selection, "changed", G_CALLBACK (on_book_selection_changed), self); g_signal_connect (self->priv->tree_view, "event-after", G_CALLBACK (on_book_clicked), self); /* The notebook containing the books */ self->priv->notebook = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE); g_signal_connect (self->priv->notebook, "realize", G_CALLBACK (on_notebook_realize), self); gtk_paned_pack2 (GTK_PANED (hpaned), self->priv->notebook, TRUE, TRUE); conn = core->source_added.connect (boost::bind (&on_source_added, _1, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_updated.connect (boost::bind (&on_book_updated, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_added.connect (boost::bind (&on_book_added, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_removed.connect (boost::bind (&on_book_removed, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self)); self->priv->connections.add (conn); core->visit_sources (boost::bind (on_visit_sources, _1, (gpointer) self)); return GTK_WIDGET (self); }
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc, gboolean back) { GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkRequisition size; GtkTreePath *path; GtkTreeIter iter; int height, width; /* if there is only one match - don't build the tree view */ if (gtk_tree_model_iter_n_children(model, NULL) == 1) { char *value; path = gtk_tree_path_new_from_indices(0, -1); if (gtk_tree_model_get_iter(model, &iter, path)) { gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1); /* call the select function */ selfunc(value); g_free(value); g_object_unref(model); return false; } } comp.selfunc = selfunc; /* prepare the tree view */ comp.win = gtk_scrolled_window_new(NULL, NULL); comp.tree = gtk_tree_view_new(); #ifndef HAS_GTK3 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER); #endif gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0); gtk_container_add(GTK_CONTAINER(comp.win), comp.tree); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false); /* we have only on line per item so we can use the faster fixed heigh mode */ gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true); gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model); g_object_unref(model); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]); /* prepare the selection */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL); /* get window dimension */ gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height); /* prepare first column */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST); gtk_tree_view_column_set_min_width(column, 2 * width/3); /* prepare second column */ #ifdef FEATURE_TITLE_IN_COMPLETION column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_END, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND); #endif /* to set the height for the treeview the tree must be realized first */ gtk_widget_show(comp.tree); /* this prevents the first item to be placed out of view if the completion * is shown */ while (gtk_events_pending()) { gtk_main_iteration(); } /* use max 1/3 of window height for the completion */ #ifdef HAS_GTK3 gtk_widget_get_preferred_size(comp.tree, NULL, &size); height /= 3; gtk_scrolled_window_set_min_content_height( GTK_SCROLLED_WINDOW(comp.win), size.height > height ? height : size.height ); #else gtk_widget_size_request(comp.tree, &size); height /= 3; if (size.height > height) { gtk_widget_set_size_request(comp.win, -1, height); } #endif vb.mode->flags |= FLAG_COMPLETION; /* set to -1 to have the cursor on first or last item set in move_cursor */ comp.active = -1; completion_next(back); gtk_widget_show(comp.win); return true; }
void setup_input_tabs (GtkBuilder *builder, GisKeyboardPage *page) { GtkWidget *treeview; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkListStore *store; GtkTreeSelection *selection; /* set up the list of active inputs */ treeview = WID("active_input_sources"); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DESKTOP_APP_INFO); gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store)); input_sources_settings = g_settings_new (GNOME_DESKTOP_INPUT_SOURCES_DIR); g_settings_delay (input_sources_settings); g_object_weak_ref (G_OBJECT (builder), (GWeakNotify) g_object_unref, input_sources_settings); if (!xkb_info) xkb_info = gnome_xkb_info_new (); #ifdef HAVE_IBUS ibus_init (); if (!ibus) { ibus = ibus_bus_new_async (); if (ibus_bus_is_connected (ibus)) fetch_ibus_engines (builder); else g_signal_connect_swapped (ibus, "connected", G_CALLBACK (fetch_ibus_engines), builder); g_object_weak_ref (G_OBJECT (builder), (GWeakNotify) clear_ibus, NULL); } maybe_start_ibus (); #endif populate_with_active_sources (store); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect_swapped (selection, "changed", G_CALLBACK (update_button_sensitivity), builder); /* set up the buttons */ g_signal_connect (WID("input_source_add"), "clicked", G_CALLBACK (add_input), builder); g_signal_connect (WID("input_source_remove"), "clicked", G_CALLBACK (remove_selected_input), builder); g_signal_connect (WID("input_source_move_up"), "clicked", G_CALLBACK (move_selected_input_up), builder); g_signal_connect (WID("input_source_move_down"), "clicked", G_CALLBACK (move_selected_input_down), builder); g_signal_connect (WID("input_source_show"), "clicked", G_CALLBACK (show_selected_layout), builder); g_signal_connect (WID("input_source_settings"), "clicked", G_CALLBACK (show_selected_settings), builder); /* use an em dash is no shortcut */ update_shortcuts (builder); /* g_signal_connect (WID("jump-to-shortcuts"), "activate-link", G_CALLBACK (go_to_shortcuts), page);*/ g_signal_connect (G_OBJECT (input_sources_settings), "changed::" KEY_INPUT_SOURCES, G_CALLBACK (input_sources_changed), builder); }
static void editor_list_window_create(void) { GtkWidget *win_vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *scrolled; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkTreeModel *store; GtkTreeSortable *sortable; EditorListWindow *ewl; editor_list_window = ewl = g_new0(EditorListWindow, 1); ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Editors")); gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect(G_OBJECT(ewl->window), "delete_event", G_CALLBACK(editor_list_window_delete), NULL); gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT); gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER); win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE); gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox); gtk_widget_show(win_vbox); hbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP); gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE, G_CALLBACK(editor_list_window_new_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_show(button); button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE, G_CALLBACK(editor_list_window_edit_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->edit_button = button; button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE, G_CALLBACK(editor_list_window_delete_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->delete_button = button; button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(editor_list_window_close_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_show(button); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5); gtk_widget_show(scrolled); ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Name")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Hidden")); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_column_set_alignment(column, 0.5); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Desktop file")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Path")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH); /* set up sorting */ store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view)); sortable = GTK_TREE_SORTABLE(store); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL); /* set initial sort order */ //gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_KEY, GTK_SORT_ASCENDING); gtk_container_add(GTK_CONTAINER(scrolled), ewl->view); gtk_widget_show(ewl->view); gtk_widget_show(ewl->window); }
void plugin_init(GeanyData *data) { conf = g_build_path(G_DIR_SEPARATOR_S, geany_data->app->configdir, "plugins", "quick-find.conf", NULL); config = g_key_file_new(); g_key_file_load_from_file(config, conf, G_KEY_FILE_NONE, NULL); executable = utils_get_setting_string(config, "main", "executable", DEFAULT_EXECUTABLE); trim_file = g_regex_new(g_strconcat("^.*", G_DIR_SEPARATOR_S, NULL), G_REGEX_OPTIMIZE | G_REGEX_CASELESS, 0, NULL); trim_regex = g_regex_new("\n$", G_REGEX_OPTIMIZE | G_REGEX_CASELESS, 0, NULL); label = gtk_label_new(_("Find")); panel = gtk_vbox_new(FALSE, 6); scrollable_table = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollable_table), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(panel), scrollable_table, TRUE, TRUE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(geany->main_widgets->sidebar_notebook), panel, label); entry = gtk_entry_new(); gtk_entry_set_icon_from_stock(GTK_ENTRY(entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FIND); g_signal_connect(entry, "activate", G_CALLBACK(on_activate), NULL); GtkWidget *button_box = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(button_box), entry, TRUE, TRUE, 0); GtkWidget *button = gtk_button_new_with_label(_("Find")); g_signal_connect(button, "clicked", G_CALLBACK(on_click), NULL); gtk_box_pack_end(GTK_BOX(button_box), button, FALSE, TRUE, 0); check_case = gtk_check_button_new_with_label(_("Case Sensitive")); ui_widget_set_tooltip_text(check_case, _("Perform a case-sensitive search.")); gtk_box_pack_end(GTK_BOX(panel), check_case, FALSE, TRUE, 0); gtk_box_pack_end(GTK_BOX(panel), button_box, FALSE, TRUE, 0); gtk_container_set_focus_child(GTK_CONTAINER(panel), entry); GtkTreeViewColumn *number_column, *line_column, *file_column, *text_column; GtkCellRenderer *render; list = gtk_tree_store_new(4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); render = gtk_cell_renderer_text_new(); number_column = gtk_tree_view_column_new_with_attributes("#", render, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), number_column); gtk_tree_view_column_set_alignment(number_column, 1.0); gtk_cell_renderer_set_alignment(render, 1.0, 0.0); gtk_tree_view_column_add_attribute(number_column, render, "text", 0); render = gtk_cell_renderer_text_new(); line_column = gtk_tree_view_column_new_with_attributes("Line", render, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), line_column); gtk_tree_view_column_set_alignment(line_column, 1.0); gtk_cell_renderer_set_alignment(render, 1.0, 0.0); gtk_tree_view_column_add_attribute(line_column, render, "text", 1); render = gtk_cell_renderer_text_new(); file_column = gtk_tree_view_column_new_with_attributes("File", render, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), file_column); gtk_tree_view_column_add_attribute(file_column, render, "text", 2); gtk_tree_view_column_set_cell_data_func(file_column, render, (GtkTreeCellDataFunc)cell_data, NULL, NULL); render = gtk_cell_renderer_text_new(); text_column = gtk_tree_view_column_new_with_attributes("Text", render, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), text_column); gtk_tree_view_column_add_attribute(text_column, render, "text", 3); g_object_unref(GTK_TREE_MODEL(list)); GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); g_signal_connect(select, "changed", G_CALLBACK(selected_row), NULL); gtk_container_add(GTK_CONTAINER(scrollable_table), tree); gtk_widget_show(label); gtk_widget_show_all(panel); g_signal_connect(geany->main_widgets->window, "key-release-event", G_CALLBACK(panel_focus_tab), NULL); GeanyKeyGroup *key_group; key_group = plugin_set_key_group(geany_plugin, "quick_find_keyboard_shortcut", KB_GROUP, NULL); keybindings_set_item(key_group, KB_QUICK_FIND, entry_focus, 0, 0, "quick_find", _("Quick Find..."), NULL); }
static void setup_view(GtkWidget* view) { GtkListStore* store = gtk_list_store_new (23, G_TYPE_STRING, /* 0 Country */ G_TYPE_STRING, /* 1 Good Name */ GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */ G_TYPE_STRING, /* 3 User Comments */ G_TYPE_STRING, /* 4 File Name */ G_TYPE_STRING, /* 5 MD5 Hash */ G_TYPE_STRING, /* 6 CRC1 */ G_TYPE_STRING, /* 7 CRC2 */ G_TYPE_STRING, /* 8 Internal Name */ G_TYPE_STRING, /* 9 Save Type */ G_TYPE_STRING, /* 10 Players */ G_TYPE_STRING, /* 11 Size */ G_TYPE_STRING, /* 12 Compression */ G_TYPE_STRING, /* 13 Image Type */ G_TYPE_STRING, /* 14 CIC Chip */ G_TYPE_STRING, /* 15 Rumble */ GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */ GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, /* 21 Flag */ G_TYPE_POINTER, /* 22 RCS Entry */ -1); GtkCellRenderer* renderer; GtkTreeViewColumn* column; GtkWidget* item; char buffer[128]; int i; unsigned char visible; /* Create country flag / string dual rendered cell. */ renderer = gtk_cell_renderer_pixbuf_new(); g_MainWindow.column[0] = gtk_tree_view_column_new(); column = g_MainWindow.column[0]; gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21); g_object_set(renderer, "xpad", 5, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", 0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); renderer = gtk_cell_renderer_text_new(); g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL); column = g_MainWindow.column[1]; gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 1); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); /* Status stars. */ g_MainWindow.column[2] = gtk_tree_view_column_new(); column = g_MainWindow.column[2]; gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]); renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(renderer, "xpad", 2, NULL); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2); for(i = 0; i < 5; ++i) { renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i); } renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(renderer, "xpad", 2, NULL); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, 2); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); for(i = 3; i < 16; ++i) { renderer = gtk_cell_renderer_text_new(); g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL); column = g_MainWindow.column[i]; gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); } renderer = gtk_cell_renderer_text_new (); g_MainWindow.column[16] = gtk_tree_view_column_new(); column = g_MainWindow.column[16]; gtk_tree_view_column_set_visible(column, FALSE); gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2); g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column); gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store)); g_MainWindow.romHeaderMenu = gtk_menu_new(); /* Toggle column visibility from config file, make menu. */ for(i = 0; i < 16; ++i) { snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]); item = gtk_check_menu_item_new_with_mnemonic(buffer); if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2) { visible = (i<5) ? TRUE: FALSE; config_put_bool(g_MainWindow.column_names[i][1], visible); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible); gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible); gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item); g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i)); } gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE); for(i = 0; i < 16; ++i) { if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i]))) return; } gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE); }