void init_right_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree2_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gint i; gtk_tree_view_set_model(view, model2); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COL_PIXBUF, "visible", COL_PIXVIS, NULL); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); /*g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(renderer_toggled), NULL); */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COL_NAME, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "N", renderer, "text", COL_NO, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "M", renderer, "text", COL_MOD, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Y", renderer, "text", COL_YES, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Value"), renderer, "text", COL_VALUE, "editable", COL_EDIT, "foreground-gdk", COL_COLOR, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); column = gtk_tree_view_get_column(view, COL_NAME); gtk_tree_view_column_set_visible(column, show_name); column = gtk_tree_view_get_column(view, COL_NO); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_MOD); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_YES); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_VALUE); gtk_tree_view_column_set_visible(column, show_value); if (resizeable) { for (i = 0; i < COL_VALUE; i++) { column = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(column, TRUE); } } sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); }
void l_zar_dok_create_list (class l_zar_dok_data *data) { iceb_clock sss(data->window); GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur,cur1; char strsql[512]; int kolstr=0; SQL_str row,row1; //GdkColor color; data->kl_shift=0; //0-отжата 1-нажата if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(l_zar_dok_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(l_zar_dok_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); if(data->dk != 0) sprintf(strsql,"select * from Zardok where datd >='%04d-%02d-%02d' and \ datd <= '%04d-%02d-%02d' order by datd,nomd asc",data->gn,data->mn,data->dn,data->gk,data->mk,data->dk); else sprintf(strsql,"select * from Zardok where datd >='%04d-%02d-%02d' order by datd,nomd asc",data->gn,data->mn,data->dn); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } data->zapros.new_plus(strsql); //gtk_list_store_clear(model); iceb_u_str ss[NUM_COLUMNS]; data->kolzap=0; double suma_dok=0.; while(cur.read_cursor(&row) != 0) { /*printf("%s %s %s %s %s\n",row[0],row[1],row[2],row[3],row[7]);*/ if(l_zar_dok_prov_row(row,data) != 0) continue; if(iceb_u_SRAV(data->nomdok_tv.ravno(),row[2],0) == 0 && iceb_u_SRAV(data->datad.ravno(),iceb_u_datzap(row[1]),0) == 0) data->snanomer=data->kolzap; suma_dok=0.; //Узнаём сумму по документа sprintf(strsql,"select SUM(suma) from Zarp where datz='%s' and nd='%s'",row[1],row[2]); if(iceb_sql_readkey(strsql,&row1,&cur1,data->window) == 1) { if(row1[0] != NULL) suma_dok=atof(row1[0]); } ss[COL_SUMA].new_plus(suma_dok); //Дата ss[COL_DATAD].new_plus(iceb_u_datzap(row[1])); //Номер документа ss[COL_NOMD].new_plus(iceb_u_toutf(row[2])); //Подразделение ss[COL_PODR].new_plus(iceb_u_toutf(row[3])); sprintf(strsql,"select naik from Podr where kod=%s",row[3]); if(iceb_sql_readkey(strsql,&row1,&cur1,data->window) == 1) { ss[COL_PODR].plus(" "); ss[COL_PODR].plus(iceb_u_toutf(row1[0])); } //Коментарий ss[COL_KOMENT].new_plus(iceb_u_toutf(row[4])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[6]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[5],0,data->window)); /*Метка прихода/расхода*/ if(row[7][0] == '2') ss[COL_METKA_ZAP].new_plus("-"); else ss[COL_METKA_ZAP].new_plus("+"); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_DATAD,ss[COL_DATAD].ravno(), COL_NOMD,ss[COL_NOMD].ravno(), COL_PODR,ss[COL_PODR].ravno(), COL_KOMENT,ss[COL_KOMENT].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), COL_METKA_ZAP,ss[COL_METKA_ZAP].ravno(), COL_SUMA,ss[COL_SUMA].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } data->datad_tv.new_plus(""); data->nomdok_tv.new_plus(""); gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); l_zar_dok_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { // gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна } else { // gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); //Стать подсветкой стороки на нужный номер строки iceb_snanomer(data->kolzap,&data->snanomer,data->treeview); iceb_u_str stroka; iceb_u_str zagolov; zagolov.plus(gettext("Список документов")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); if(data->poisk.metka_poi == 1) { zagolov.new_plus(gettext("Поиск")); zagolov.plus(" !!!"); iceb_str_poisk(&zagolov,data->poisk.datan.ravno(),gettext("Дата начала")); iceb_str_poisk(&zagolov,data->poisk.datak.ravno(),gettext("Дата конца")); iceb_str_poisk(&zagolov,data->poisk.podr.ravno(),gettext("Подразделение")); iceb_str_poisk(&zagolov,data->poisk.koment.ravno(),gettext("Коментарий")); iceb_str_poisk(&zagolov,data->poisk.nomdok.ravno(),gettext("Номер документа")); gtk_label_set_text(GTK_LABEL(data->label_poisk),zagolov.ravno_toutf()); gtk_widget_show(data->label_poisk); } else gtk_widget_hide(data->label_poisk); gtk_widget_show(data->label_kolstr); }
/* trash_init */ static Trash * _trash_init(BrowserPluginHelper * helper) { Trash * trash; GtkWidget * widget; GtkToolItem * toolitem; GtkTreeSelection * treesel; GtkCellRenderer * renderer; GtkTreeViewColumn * column; if((trash = object_new(sizeof(*trash))) == NULL) return NULL; trash->helper = helper; trash->source = 0; trash->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); widget = gtk_toolbar_new(); /* move to trash */ /* FIXME handle sensitiveness of this button */ #if GTK_CHECK_VERSION(2, 8, 0) toolitem = gtk_tool_button_new(NULL, _(TEXT_MOVETOTRASH)); # if GTK_CHECK_VERSION(2, 12, 0) gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _(TEXT_MOVETOTRASH)); # endif gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), PLUGIN_ICON); #else toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name(PLUGIN_ICON, GTK_ICON_SIZE_SMALL_TOOLBAR), _(TEXT_MOVETOTRASH)); #endif g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK( _trash_on_move_to_trash), trash); gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1); toolitem = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1); toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_ALL); #if GTK_CHECK_VERSION(2, 12, 0) gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _(TEXT_SELECTALL)); #endif g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK( _trash_on_select_all), trash); gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1); /* restore */ trash->tb_restore = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO); #if GTK_CHECK_VERSION(2, 12, 0) gtk_widget_set_tooltip_text(GTK_WIDGET(trash->tb_restore), _(TEXT_RESTORE)); #endif g_signal_connect_swapped(trash->tb_restore, "clicked", G_CALLBACK( _trash_on_restore), trash); gtk_toolbar_insert(GTK_TOOLBAR(widget), trash->tb_restore, -1); /* delete */ trash->tb_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE); #if GTK_CHECK_VERSION(2, 12, 0) gtk_widget_set_tooltip_text(GTK_WIDGET(trash->tb_delete), _(TEXT_DELETE)); #endif g_signal_connect_swapped(trash->tb_delete, "clicked", G_CALLBACK( _trash_on_delete), trash); gtk_toolbar_insert(GTK_TOOLBAR(widget), trash->tb_delete, -1); gtk_box_pack_start(GTK_BOX(trash->widget), widget, FALSE, TRUE, 0); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); trash->store = gtk_list_store_new(TC_COUNT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_BOOLEAN); trash->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( trash->store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(trash->view), TRUE); treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(trash->view)); gtk_tree_selection_set_mode(treesel, GTK_SELECTION_MULTIPLE); g_signal_connect(treesel, "changed", G_CALLBACK( _trash_on_selection_changed), trash); _trash_on_selection_changed(treesel, trash); /* icon */ renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", TC_PIXBUF, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column); /* path to the original file */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer, "text", TC_PATH_ORIGINAL, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column); /* timestamp */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_(TEXT_DELETED), renderer, "text", TC_DELETED_DISPLAY, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column); gtk_container_add(GTK_CONTAINER(widget), trash->view); gtk_box_pack_start(GTK_BOX(trash->widget), widget, TRUE, TRUE, 0); gtk_widget_show_all(trash->widget); return trash; }
void gglk_do_styles(GtkMenuItem *unused_menuitem, gpointer unused_data) { static GtkWidget *dialog_styles; GtkTreeView *tree; GtkTreeStore *store; GtkTreeSelection *select; GtkTreeIter parent_iter, iter; int i; if(dialog_styles) { gtk_window_present(GTK_WINDOW(dialog_styles)); return; } dialog_styles = create_dialog_styles(); g_signal_connect(dialog_styles, "destroy", G_CALLBACK(gtk_widget_destroyed), &dialog_styles); g_signal_connect(dialog_styles, "response", G_CALLBACK(gglk_style_response), NULL); if(!gglk_style_changeset) { gglk_style_changeset = gconf_change_set_new(); } else { gconf_change_set_clear(gglk_style_changeset); } { GtkTextBuffer *buffer; GtkTextIter text_start, text_end; buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lookup_widget(dialog_styles, "preview"))); gtk_text_buffer_create_tag(buffer, "default", NULL); gtk_text_buffer_get_bounds(buffer, &text_start, &text_end); gtk_text_buffer_apply_tag_by_name(buffer, "default", &text_start, &text_end); } tree = GTK_TREE_VIEW(lookup_widget(dialog_styles, "treeview_styles")); store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_INT); gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store)); gtk_tree_view_insert_column_with_attributes(tree, -1, "Style", gtk_cell_renderer_text_new(), "text", 0, NULL); select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect(select, "changed", G_CALLBACK(gglk_style_selection_changed), dialog_styles); gtk_tree_store_append(store, &parent_iter, NULL); gtk_tree_store_set(store, &parent_iter, 0, gglk_get_tag(style_AllStyles), 1, style_AllStyles, -1); gtk_tree_selection_select_iter(select, &parent_iter); for(i = 0; i < style_NUMSTYLES; i++) { gtk_tree_store_append(store, &iter, &parent_iter); gtk_tree_store_set(store, &iter, 0, gglk_get_tag(i), 1, i, -1); } gtk_tree_store_append(store, &iter, NULL); gtk_tree_store_set(store, &iter, 0, gglk_get_tag(style_TextGrid), 1, style_TextGrid, -1); gtk_tree_store_append(store, &iter, NULL); gtk_tree_store_set(store, &iter, 0, gglk_get_tag(style_Hyperlinks), 1, style_Hyperlinks, -1); gtk_tree_view_expand_all(tree); #if 0 g_signal_connect(lookup_widget(dialog_styles, "important_toggle"), "clicked", G_CALLBACK(gglk_style_toggle), NULL); #endif gtk_widget_show(dialog_styles); }
static void quick_opener() { GtkWidget *entry, *label, *hbox; GtkTreeViewColumn *path_column, *name_column; GtkCellRenderer *renderLeft, *renderRight; dialog = gtk_dialog_new_with_buttons(_("Quick Open:"), GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_DESTROY_WITH_PARENT,NULL); gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 250); gtk_dialog_add_button(GTK_DIALOG(dialog),_("_Open"), GTK_RESPONSE_APPLY); gtk_dialog_add_button(GTK_DIALOG(dialog),_("_Cancel"), GTK_RESPONSE_CANCEL); hbox=gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),hbox, FALSE, FALSE, 0); label=gtk_label_new(_("File:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2); entry = gtk_entry_new(); g_signal_connect(entry, "key-press-event", G_CALLBACK(onkeypress), NULL); g_signal_connect(entry, "key-release-event", G_CALLBACK(onkeyrelease), NULL); gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 2); //Table: list = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); path_column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), path_column); name_column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), name_column); renderRight = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_alignment(renderRight, 1.0, 0.0); gtk_cell_renderer_set_padding(renderRight, 0, 1); g_object_set(renderRight, "foreground", "#777", "foreground-set", TRUE, NULL); renderLeft = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_padding(renderLeft, 0, 1); gtk_tree_view_column_pack_start(path_column, renderRight, TRUE); gtk_tree_view_column_add_attribute(path_column, renderRight, "text", 0); gtk_tree_view_column_pack_start(name_column, renderLeft, TRUE); gtk_tree_view_column_add_attribute(name_column, renderLeft, "text", 1); g_object_unref(list); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); //Scrollable: scrollable = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollable), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrollable), tree); g_signal_connect(tree, "key-press-event", G_CALLBACK(tree_keypress), entry); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollable, TRUE, TRUE, 10); gtk_widget_show_all(dialog); adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrollable)); first = gtk_tree_path_new_from_string("0"); second = gtk_tree_path_new_from_string("1"); gint response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_APPLY) { submit(); } gtk_widget_destroy(dialog); }
static void policy_components_view_init_lists(struct polcomp_view *pv) { GtkTreeIter iter; size_t i, j; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; if ((pv->both_items = apol_vector_create_from_vector(pv->log_items, NULL, NULL, NULL)) == NULL) { toplevel_ERR(pv->top, "Error generating union list: %s", strerror(errno)); return; } if (pv->policy_items == NULL) { gtk_widget_set_sensitive(GTK_WIDGET(pv->policy_radio), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(pv->both_radio), FALSE); } else { if (apol_vector_cat(pv->both_items, pv->policy_items) < 0) { toplevel_ERR(pv->top, "Error generating union list: %s", strerror(errno)); return; } apol_vector_sort_uniquify(pv->both_items, apol_str_strcmp, NULL); } pv->master_store = gtk_list_store_new(ISINC_COLUMN + 1, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); for (i = 0; i < apol_vector_get_size(pv->both_items); i++) { char *s = apol_vector_get_element(pv->both_items, i); gboolean is_log = FALSE, is_policy = FALSE, is_included = FALSE; if (apol_vector_get_index(pv->log_items, s, NULL, NULL, &j) == 0) { is_log = TRUE; } if (pv->policy_items != NULL && apol_vector_get_index(pv->policy_items, s, NULL, NULL, &j) == 0) { is_policy = TRUE; } if (apol_vector_get_index(pv->included_items, s, apol_str_strcmp, NULL, &j) == 0) { is_included = TRUE; } gtk_list_store_append(pv->master_store, &iter); gtk_list_store_set(pv->master_store, &iter, POINTER_COLUMN, s, NAME_COLUMN, s, ISLOG_COLUMN, is_log, ISPOLICY_COLUMN, is_policy, ISINC_COLUMN, is_included, -1); } pv->inc_store = gtk_tree_model_filter_new(GTK_TREE_MODEL(pv->master_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(pv->inc_store), policy_components_view_is_visible_included, pv, NULL); pv->exc_store = gtk_tree_model_filter_new(GTK_TREE_MODEL(pv->master_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(pv->exc_store), policy_components_view_is_visible_excluded, pv, NULL); gtk_tree_view_set_model(pv->inc_view, pv->inc_store); gtk_tree_view_set_model(pv->exc_view, pv->exc_store); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Item names", renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_clickable(column, FALSE); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_visible(column, TRUE); gtk_tree_view_append_column(pv->inc_view, column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Item names", renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_clickable(column, FALSE); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_visible(column, TRUE); gtk_tree_view_append_column(pv->exc_view, column); selection = gtk_tree_view_get_selection(pv->inc_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); selection = gtk_tree_view_get_selection(pv->exc_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); }
GtkWidget *load_gtk_widget(void) { GtkTreeStore *store; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *pScrollbar, *pvbox; GtkTreeSelection *selection; /* Create a list for keyboards */ store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); viewlayout = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", 0, NULL); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col); col = gtk_tree_view_column_new_with_attributes (_("X Layout"), renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col); col = gtk_tree_view_column_new_with_attributes (_("X Variant"), renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col); col = gtk_tree_view_column_new_with_attributes (_("Console keymap"), renderer, "text", 3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col); /* change tree selection mode */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (viewlayout)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (selection_changed),NULL); pScrollbar = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrollbar), viewlayout); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); pvbox = gtk_vbox_new(FALSE, 5); /* top info label */ GtkWidget *labelhelp = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(labelhelp), _("<b>You may select one of the following keyboard maps.</b>")); gtk_box_pack_start(GTK_BOX(pvbox), labelhelp, FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(pvbox), pScrollbar, TRUE, TRUE, 0); /* lower label and button for personalized keyboard */ GtkWidget *hboxbas = gtk_hbox_new(FALSE, 5); GtkWidget *entrytest = gtk_entry_new(); GtkWidget *labeltest = gtk_label_new(_("Test your keyboard here :")); GtkWidget *persokeyb = gtk_button_new_with_label(_("Personalized keyboard")); char *imgpath = g_strdup_printf("%s/key24.png", IMAGEDIR); GtkWidget *image = gtk_image_new_from_file(imgpath); free(imgpath); gtk_button_set_image(GTK_BUTTON(persokeyb), image); g_signal_connect (persokeyb, "clicked", G_CALLBACK (add_keyboard),NULL); gtk_box_pack_start(GTK_BOX(hboxbas), labeltest, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hboxbas), entrytest, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hboxbas), persokeyb, FALSE, TRUE, 5); gtk_box_pack_start(GTK_BOX(pvbox), hboxbas, FALSE, FALSE, 5); /* Load keymaps use for personalized keyboard */ find_console_layout(CKEYDIR); find_x_layout(XKEYDIR); /* Loads keymaps from files */ find_languages(KEYDIR); return pvbox; }
extern void get_info_bb(GtkTable *table, display_data_t *display_data) { int error_code = SLURM_SUCCESS; List info_list = NULL; static int view = -1; static burst_buffer_info_msg_t *bb_info_ptr = NULL; char error_char[100]; GtkWidget *label = NULL; GtkTreeView *tree_view = NULL; static GtkWidget *display_widget = NULL; GtkTreePath *path = NULL; static bool set_opts = false; if (!set_opts) { set_page_opts(BB_PAGE, display_data_bb, SORTID_CNT, _initial_page_opts); } set_opts = true; /* reset */ if (!table && !display_data) { if (display_widget) gtk_widget_destroy(display_widget); display_widget = NULL; bb_info_ptr = NULL; goto reset_curs; } if (display_data) local_display_data = display_data; if (!table) { display_data_bb->set_menu = local_display_data->set_menu; goto reset_curs; } if (display_widget && toggled) { gtk_widget_destroy(display_widget); display_widget = NULL; goto display_it; } error_code = get_new_info_bb(&bb_info_ptr, force_refresh); if (error_code == SLURM_NO_CHANGE_IN_DATA) { } else if (error_code != SLURM_SUCCESS) { if (view == ERROR_VIEW) goto end_it; if (display_widget) gtk_widget_destroy(display_widget); view = ERROR_VIEW; sprintf(error_char, "slurm_load_reservations: %s", slurm_strerror(slurm_get_errno())); label = gtk_label_new(error_char); gtk_table_attach_defaults(table, label, 0, 1, 0, 1); gtk_widget_show(label); display_widget = gtk_widget_ref(GTK_WIDGET(label)); goto end_it; } display_it: info_list = _create_bb_info_list(bb_info_ptr); if (!info_list) { goto reset_curs; } /* set up the grid */ if (display_widget && GTK_IS_TREE_VIEW(display_widget) && gtk_tree_selection_count_selected_rows( gtk_tree_view_get_selection( GTK_TREE_VIEW(display_widget)))) { GtkTreeViewColumn *focus_column = NULL; /* highlight the correct nodes from the last selection */ gtk_tree_view_get_cursor(GTK_TREE_VIEW(display_widget), &path, &focus_column); } change_grid_color(grid_button_list, -1, -1, MAKE_WHITE, true, 0); if (view == ERROR_VIEW && display_widget) { gtk_widget_destroy(display_widget); display_widget = NULL; } if (!display_widget) { tree_view = create_treeview(local_display_data, &grid_button_list); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(tree_view), GTK_SELECTION_MULTIPLE); display_widget = gtk_widget_ref(GTK_WIDGET(tree_view)); gtk_table_attach_defaults(table, GTK_WIDGET(tree_view), 0, 1, 0, 1); /* since this function sets the model of the tree_view to the treestore we don't really care about the return value */ create_treestore(tree_view, display_data_bb, SORTID_CNT, SORTID_NAME, SORTID_COLOR); } view = INFO_VIEW; _update_info_bb(info_list, GTK_TREE_VIEW(display_widget)); end_it: toggled = false; force_refresh = false; reset_curs: if (main_window && main_window->window) gdk_window_set_cursor(main_window->window, NULL); return; }
/* Function for full information about a Burst Buffer */ extern void specific_info_bb(popup_info_t *popup_win) { int bb_error_code = SLURM_SUCCESS; static burst_buffer_info_msg_t *bb_info_ptr = NULL; specific_info_t *spec_info = popup_win->spec_info; char error_char[100]; GtkWidget *label = NULL; GtkTreeView *tree_view = NULL; List bb_list = NULL; List send_bb_list = NULL; sview_bb_info_t *sview_bb_info_ptr = NULL; int i=-1; ListIterator itr = NULL; if (!spec_info->display_widget) { setup_popup_info(popup_win, display_data_bb, SORTID_CNT); } if (spec_info->display_widget && popup_win->toggled) { gtk_widget_destroy(spec_info->display_widget); spec_info->display_widget = NULL; goto display_it; } if ((bb_error_code = get_new_info_bb(&bb_info_ptr, popup_win->force_refresh)) == SLURM_NO_CHANGE_IN_DATA) { if (!spec_info->display_widget || spec_info->view == ERROR_VIEW) goto display_it; } else if (bb_error_code != SLURM_SUCCESS) { if (spec_info->view == ERROR_VIEW) goto end_it; spec_info->view = ERROR_VIEW; if (spec_info->display_widget) gtk_widget_destroy(spec_info->display_widget); sprintf(error_char, "get_new_info_bb: %s", slurm_strerror(slurm_get_errno())); label = gtk_label_new(error_char); gtk_table_attach_defaults(popup_win->table, label, 0, 1, 0, 1); gtk_widget_show(label); spec_info->display_widget = gtk_widget_ref(label); goto end_it; } display_it: bb_list = _create_bb_info_list(bb_info_ptr); if (!bb_list) return; if (spec_info->view == ERROR_VIEW && spec_info->display_widget) { gtk_widget_destroy(spec_info->display_widget); spec_info->display_widget = NULL; } if (spec_info->type != INFO_PAGE && !spec_info->display_widget) { tree_view = create_treeview(local_display_data, &popup_win->grid_button_list); gtk_tree_selection_set_mode( gtk_tree_view_get_selection(tree_view), GTK_SELECTION_MULTIPLE); spec_info->display_widget = gtk_widget_ref(GTK_WIDGET(tree_view)); gtk_table_attach_defaults(popup_win->table, GTK_WIDGET(tree_view), 0, 1, 0, 1); /* since this function sets the model of the tree_view * to the treestore we don't really care about * the return value */ create_treestore(tree_view, popup_win->display_data, SORTID_CNT, SORTID_NAME, SORTID_COLOR); } setup_popup_grid_list(popup_win); spec_info->view = INFO_VIEW; if (spec_info->type == INFO_PAGE) { _display_info_bb(bb_list, popup_win); goto end_it; } /* just linking to another list, don't free the inside, just the list */ send_bb_list = list_create(NULL); itr = list_iterator_create(bb_list); i = -1; /* Set up additional menu options(ie the right click menu stuff) */ while ((sview_bb_info_ptr = list_next(itr))) { i++; /* Since we will not use any of these pages we will */ /* leave them blank */ switch(spec_info->type) { case PART_PAGE: case BLOCK_PAGE: case NODE_PAGE: case JOB_PAGE: case RESV_PAGE: default: g_print("Unknown type %d\n", spec_info->type); continue; } list_push(send_bb_list, sview_bb_info_ptr); } list_iterator_destroy(itr); post_setup_popup_grid_list(popup_win); _update_info_bb(send_bb_list, GTK_TREE_VIEW(spec_info->display_widget)); FREE_NULL_LIST(send_bb_list); end_it: popup_win->toggled = 0; popup_win->force_refresh = 0; return; }
void uosopr_create_list (class uosopr_data *data) { GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur; SQLCURSOR cur1; char strsql[512]; int kolstr=0; SQL_str row; iceb_u_str zagolov; //printf("uosopr_create_list %d\n",data->snanomer); data->kl_shift=0; //0-отжата 1-нажата gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); iceb_refresh(); if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(uosopr_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(uosopr_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); sprintf(strsql,"select * from Uosras order by kod asc"); data->zapros.new_plus(strsql); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } //gtk_list_store_clear(model); iceb_u_str ss[NUM_COLUMNS]; data->kolzap=0; while(cur.read_cursor(&row) != 0) { // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); if(uosopr_prov_row(row,data) != 0) continue; if(iceb_u_SRAV(data->kodtv.ravno(),row[0],0) == 0) data->snanomer=data->kolzap; //Код группы ss[COL_KOD].new_plus(iceb_u_toutf(row[0])); //Наименование группы ss[COL_NAIM].new_plus(iceb_u_toutf(row[1])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[3]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[2],0,data->window)); //Вид операции ss[COL_VIDO].new_plus(""); if(row[4][0] == '0') ss[COL_VIDO].new_plus(gettext("Внешняя")); if(row[4][0] == '1') ss[COL_VIDO].new_plus(gettext("Внутренняя")); if(row[4][0] == '2') ss[COL_VIDO].new_plus(gettext("Смена стоимости")); //Проводки if(row[5][0] == '0') ss[COL_PROV].new_plus(gettext("Нужно делать")); if(row[5][0] == '1') ss[COL_PROV].new_plus(gettext("Не нужно делать")); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_KOD,ss[COL_KOD].ravno(), COL_NAIM,ss[COL_NAIM].ravno(), COL_VIDO,ss[COL_VIDO].ravno(), COL_PROV,ss[COL_PROV].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } data->kodtv.new_plus(""); gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); uosopr_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); iceb_snanomer(data->kolzap,&data->snanomer,data->treeview); if(data->poi.metka_poi == 1 ) { // printf("Формирование заголовка с реквизитами поиска.\n"); iceb_u_str strpoi; strpoi.new_plus(gettext("Поиск")); strpoi.plus(" !!!"); iceb_str_poisk(&strpoi,data->poi.kod.ravno(),gettext("Код")); iceb_str_poisk(&strpoi,data->poi.naim.ravno(),gettext("Наименование")); gtk_label_set_text(GTK_LABEL(data->label_poisk),strpoi.ravno_toutf()); gtk_widget_show(data->label_poisk); } else { gtk_widget_hide(data->label_poisk); } zagolov.new_plus(gettext("Список операций расходов")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
GtkWidget * do_editable_cells (GtkWidget *do_widget) { if (!window) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *sw; GtkWidget *treeview; GtkWidget *button; GtkTreeModel *items_model; GtkTreeModel *numbers_model; /* create window, etc */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); // gtk_window_set_screen (GTK_WINDOW (window), // gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Booklist"); gtk_container_set_border_width (GTK_CONTAINER (window), 5); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_add (GTK_CONTAINER (window), vbox); // gtk_box_pack_start (GTK_BOX (vbox), // gtk_label_new ("Shopping list (you can edit the cells!)"), // FALSE, FALSE, 0); 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_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); /* create models */ items_model = create_items_model (); numbers_model = create_numbers_model (); /* create tree view */ treeview = gtk_tree_view_new_with_model (items_model); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_SINGLE); add_columns (GTK_TREE_VIEW (treeview), items_model, numbers_model); g_object_unref (numbers_model); g_object_unref (items_model); gtk_container_add (GTK_CONTAINER (sw), treeview); /* some buttons */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Add item"); g_signal_connect (button, "clicked", G_CALLBACK (add_item), treeview); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Remove item"); g_signal_connect (button, "clicked", G_CALLBACK (remove_item), treeview); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (window), 320, 200); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }
/** * Display a list with projects and let the user select one. Returns the project * id of the selected one. */ static gint sql_plugin_retrieve_project_id (PlannerPlugin *plugin, gchar *server, gchar *port, gchar *database, gchar *login, gchar *password) { GdaConnection *conn; GdaDataModel *model; gboolean success; GdaClient *client; GladeXML *gui; GtkWidget *dialog; GtkWidget *treeview; GtkWidget *ok_button; GtkListStore *liststore; GtkCellRenderer *cell; GtkTreeViewColumn *col; gint i; gint response; gint project_id; GtkTreeSelection *selection; GtkTreeIter iter; gchar *db_txt; const gchar *dsn_name = "planner-auto"; const gchar *provider = "PostgreSQL"; gchar *filename; db_txt = g_strdup_printf (CONNECTION_FORMAT_STRING,server,database); gda_config_save_data_source (dsn_name, provider, db_txt, "planner project", login, password, FALSE); g_free (db_txt); client = gda_client_new (); conn = sql_get_tested_connection (dsn_name, server, database, client, plugin); if (conn == NULL) { return -1; } success = sql_execute_command (conn, "BEGIN"); if (!success) { g_warning ("BEGIN command failed."); return -1; } success = sql_execute_command (conn, "DECLARE mycursor CURSOR FOR SELECT proj_id, name," "phase, revision FROM project ORDER by proj_id ASC"); if (!success) { g_warning ("DECLARE CURSOR command failed (project)."); return -1; } model = sql_execute_query (conn, "FETCH ALL in mycursor"); if (model == NULL) { g_warning ("FETCH ALL failed."); return -1; } filename = mrp_paths_get_glade_dir ("sql.glade"); gui = glade_xml_new (filename, "select_dialog", NULL); g_free (filename); dialog = glade_xml_get_widget (gui, "select_dialog"); treeview = glade_xml_get_widget (gui, "project_treeview"); ok_button = glade_xml_get_widget (gui, "ok_button"); g_object_unref (gui); liststore = gtk_list_store_new (4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore)); cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("ID"), cell, "text", COL_ID, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Project"), cell, "text", COL_NAME, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Phase"), cell, "text", COL_PHASE, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Revision"), cell, "text", COL_REVISION, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); gtk_tree_view_columns_autosize (GTK_TREE_VIEW (treeview)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (selection_changed_cb), ok_button); g_signal_connect (treeview, "row_activated", G_CALLBACK (row_activated_cb), ok_button); for (i = 0; i < gda_data_model_get_n_rows (model); i++) { gint id; gchar *name; gchar *phase; gint revision; id = get_int (model, i, 0); name = get_string (model, i, 1); phase = get_string (model, i, 2); revision = get_int (model, i, 3); /* FIXME: needs fixing in the database backend. */ if (strcmp (phase, "NULL") == 0) { g_free (phase); phase = g_strdup (""); } gtk_list_store_append (GTK_LIST_STORE (liststore), &iter); gtk_list_store_set (GTK_LIST_STORE (liststore), &iter, COL_ID, id, COL_NAME, name, COL_PHASE, phase, COL_REVISION, revision, -1); g_free (name); g_free (phase); } if (gda_data_model_get_n_columns (model) == 0) { gtk_widget_set_sensitive (ok_button, FALSE); } g_object_unref (model); sql_execute_command (conn,"CLOSE mycursor"); gtk_widget_show_all (dialog); response = gtk_dialog_run (GTK_DIALOG (dialog)); project_id = -1; switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: break; case GTK_RESPONSE_OK: if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) { break; } gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, COL_ID, &project_id, -1); break; }; gtk_widget_destroy (dialog); return project_id; }
CChooseApertureDlg::CChooseApertureDlg(GtkWindow *pParent):m_FrameSet(NULL), m_Table(NULL), m_GraphData(NULL), m_ApertureIndex(-1), m_Row(-1), m_Column(-1) { GdkRectangle rc; GtkWidget *hbox, *vbox, *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 size GdkScreen *scr = gdk_screen_get_default(); gdk_screen_get_monitor_geometry(scr, 0, &rc); if (rc.width>0 && rc.height>0) gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.6*rc.width), RoundToInt(0.5*rc.height)); // 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); // Preview box hbox = gtk_hbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), hbox, TRUE, TRUE, 0); vbox = gtk_vbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, TRUE, 0); // 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)); gtk_widget_set_tooltip_text(m_AperView, "Click on a item to select an aperture"); 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(vbox), scrwnd, FALSE, TRUE, 0); gtk_widget_set_size_request(scrwnd, 140, 300); // List of data columns m_Channels = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); m_DataView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(m_Channels)); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(col, "Data sets"); gtk_tree_view_append_column(GTK_TREE_VIEW(m_DataView), 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", 1); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_DataView)); 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_DataView); gtk_box_pack_start(GTK_BOX(vbox), scrwnd, TRUE, TRUE, 0); gtk_widget_set_size_request(scrwnd, -1, 120); // Graph m_GraphView = cmpack_graph_view_new_with_model(NULL); gtk_widget_set_tooltip_text(m_GraphView, "Click on a point to select an aperture"); cmpack_graph_view_set_mouse_control(CMPACK_GRAPH_VIEW(m_GraphView), FALSE); cmpack_graph_view_set_scales(CMPACK_GRAPH_VIEW(m_GraphView), TRUE, TRUE); cmpack_graph_view_set_activation_mode(CMPACK_GRAPH_VIEW(m_GraphView), CMPACK_ACTIVATION_CLICK); g_signal_connect(G_OBJECT(m_GraphView), "item-activated", G_CALLBACK(item_activated), this); gtk_widget_set_size_request(m_GraphView, 200, -1); gtk_box_pack_start(GTK_BOX(hbox), m_GraphView, TRUE, TRUE, 0); gtk_widget_show_all(hbox); }
static void log_window_find_setup (EmpathyLogWindow *window) { GtkTreeView *view; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeSortable *sortable; GtkTreeViewColumn *column; GtkListStore *store; GtkCellRenderer *cell; gint offset; view = GTK_TREE_VIEW (window->treeview_find); selection = gtk_tree_view_get_selection (view); /* New store */ store = gtk_list_store_new (COL_FIND_COUNT, G_TYPE_STRING, /* account icon name */ G_TYPE_STRING, /* account name */ TP_TYPE_ACCOUNT, /* account */ G_TYPE_STRING, /* chat name */ G_TYPE_STRING, /* chat id */ G_TYPE_BOOLEAN, /* is chatroom */ G_TYPE_STRING, /* date */ G_TYPE_STRING); /* date_readable */ model = GTK_TREE_MODEL (store); sortable = GTK_TREE_SORTABLE (store); gtk_tree_view_set_model (view, model); /* New 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", COL_FIND_ACCOUNT_ICON); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_FIND_ACCOUNT_NAME); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_append_column (view, column); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); cell = gtk_cell_renderer_text_new (); offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"), cell, "text", COL_FIND_CHAT_NAME, NULL); column = gtk_tree_view_get_column (view, offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); cell = gtk_cell_renderer_text_new (); offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"), cell, "text", COL_FIND_DATE_READABLE, NULL); column = gtk_tree_view_get_column (view, offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); /* Set up treeview properties */ gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gtk_tree_sortable_set_sort_column_id (sortable, COL_FIND_DATE, GTK_SORT_ASCENDING); /* Set up signals */ g_signal_connect (selection, "changed", G_CALLBACK (log_window_find_changed_cb), window); g_object_unref (store); }
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self) { /* load addon */ FcitxAddon* addon; utarray_new(self->addons, &addonicd); FcitxAddonsLoad(self->addons); GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); /* advance check box */ self->advancecheckbox = gtk_check_button_new_with_label(_("Advance")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE); g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self); /* filter entry */ self->filterentry = gtk_entry_new(); gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL); #if GTK_CHECK_VERSION(3,2,0) gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon")); #endif g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL); gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5); /* list view */ self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER); for (addon = (FcitxAddon *) utarray_front(self->addons); addon != NULL; addon = (FcitxAddon *) utarray_next(self->addons, addon)) { GtkTreeIter iter; gtk_list_store_append(self->addonstore, &iter); gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1); } self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel), (GtkTreeModelFilterVisibleFunc) _filter_addon_func, self, NULL); self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel)); /* add column check box */ self->togglecell = gtk_cell_renderer_toggle_new(); gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE); self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn), self->togglecell, _fcitx_main_window_enabled_data_func, NULL, NULL); gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE); /* add column text */ GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column), renderer, _fcitx_main_window_name_data_func, NULL, NULL); /* add addon list to vbox */ GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL); g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL); g_object_set(self->addonview, "headers-visible", FALSE, NULL); gtk_container_add(GTK_CONTAINER(swin), self->addonview); gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0); g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL); g_signal_connect(G_OBJECT(self->togglecell), "toggled", G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore)); gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0); g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL); /* configure button */ GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0); g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL); self->button = gtk_button_new_with_label(_("Configure")); gtk_widget_set_sensitive(self->button, FALSE); gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_fcitx_main_window_addon_selection_changed), self); g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self); gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel)); _fcitx_main_window_add_page(self, _("Addon"), vbox, GTK_STOCK_ADD); }
GtkWidget * do_tree_store (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *vbox; GtkWidget *sw; GtkWidget *treeview; GtkTreeModel *model; /* create window, etc */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Tree Store"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Jonathan's Holiday Card Planning Sheet"), FALSE, FALSE, 0); 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_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); /* create model */ model = create_model (); /* create tree view */ treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); /* expand all rows after the treeview widget has been realized */ g_signal_connect (treeview, "realize", G_CALLBACK (gtk_tree_view_expand_all), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 650, 400); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); return window; }
/* Create list */ static GtkWidget * create_list(void) { GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSortable *sortable; GtkTreeView *list_view; GtkTreeSelection *selection; /* Create the store */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/ G_TYPE_STRING, /* SI */ G_TYPE_INT, /* Num MSUs */ G_TYPE_STRING, /* MSUs/sec */ G_TYPE_INT, /* Num Bytes */ G_TYPE_STRING, /* Bytes/MSU */ G_TYPE_STRING); /* Bytes/sec */ /* Create a view */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); sortable = GTK_TREE_SORTABLE(list_store); /* Speed up the list display */ gtk_tree_view_set_fixed_height_mode(list_view, TRUE); /* Setup the sortable columns */ gtk_tree_sortable_set_sort_column_id(sortable, SI_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_headers_clickable(list_view, FALSE); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ /* 1:st column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("SI", renderer, "text", SI_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, SI_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 110); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* 2:nd column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num MSUs", renderer, "text", NUM_MSUS_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 3:d column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("MSUs/sec", renderer, "text", NUM_MSUS_SEC_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_SEC_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 4:d column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 5:th column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Bytes/MSU", renderer, "text", NUM_BYTES_MSU_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_MSU_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 6:th column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Bytes/sec", renderer, "text", NUM_BYTES_SEC_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_SEC_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* Now enable the sorting of each column */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE); /* Setup the selection handler */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); return list; }
/** * create the tree_view for the form configuration * set the model given in param * set the columns and all the connections * * \param model the model to set in the tree_view * * \return the tree_view * */ GtkWidget *gsb_form_config_create_tree_view ( GtkListStore *store ) { GtkWidget *tree_view; gint column; GtkTargetEntry target_entry[] = { { "text", GTK_TARGET_SAME_WIDGET, 0 } }; gchar *columns_titles[6] = { N_("Col 1"), N_("Col 2"), N_("Col 3"), N_("Col 4"), N_("Col 5"), N_("Col 6") }; if ( !store ) return NULL; /* create the tree_view, it would be better to set it into a scrolled window, * but when we do that, there is automatickly a line on the bottom of the list * and it's annoying for the drag'n drop ; i didn't succeed in removing that line...[cedric] * the problem of the choice here is if we try to increase too much the width of the column, * the config box increase too */ tree_view = gtk_tree_view_new_with_model ( GTK_TREE_MODEL ( store )); gtk_tree_selection_set_mode ( GTK_TREE_SELECTION ( gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view))), GTK_SELECTION_NONE ); /* set the columns */ for ( column=0 ; column< MAX_WIDTH ; column++ ) { GtkTreeViewColumn *tree_view_column; tree_view_column = gtk_tree_view_column_new_with_attributes ( columns_titles[column], gtk_cell_renderer_text_new (), "text", column, NULL ); gtk_tree_view_append_column ( GTK_TREE_VIEW ( tree_view ), GTK_TREE_VIEW_COLUMN ( tree_view_column)); gtk_tree_view_column_set_sizing ( GTK_TREE_VIEW_COLUMN (tree_view_column), GTK_TREE_VIEW_COLUMN_FIXED ); gtk_tree_view_column_set_resizable ( GTK_TREE_VIEW_COLUMN (tree_view_column), TRUE ); } /* we will fill the form and size the columns when the window will be realized */ g_signal_connect ( G_OBJECT ( tree_view ), "realize", G_CALLBACK ( gsb_form_config_realized ), NULL ); /* save and modify the form when change the size of the columns */ g_signal_connect ( G_OBJECT (tree_view), "size_allocate", G_CALLBACK ( gsb_form_config_change_column_size ), NULL ); /* enable the drag'n drop, we need to use low-level api because * gtk_tree_view api can only move the entire row, not only a cell * (at least, didn't find how...) */ gtk_drag_source_set ( tree_view, GDK_BUTTON1_MASK, target_entry, 1, GDK_ACTION_MOVE ); g_signal_connect ( G_OBJECT (tree_view), "drag-begin", G_CALLBACK ( gsb_form_config_drag_begin ), NULL ); gtk_drag_dest_set ( tree_view, GTK_DEST_DEFAULT_ALL, target_entry, 1, GDK_ACTION_MOVE ); g_signal_connect ( G_OBJECT (tree_view), "drag-end", G_CALLBACK ( gsb_form_config_drag_end ), NULL ); return tree_view; }
void gui_init(dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); // gtk_widget_set_size_request(self->widget, DT_PIXEL_APPLY_DPI(100), -1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, 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_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->current), _("attached tags,\ndoubleclick to detach")); g_signal_connect(G_OBJECT(d->current), "row-activated", G_CALLBACK(detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; gtk_widget_set_tooltip_text(button, _("attach tag to all selected images")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; gtk_widget_set_tooltip_text(button, _("detach tag from all selected images")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); gtk_widget_set_tooltip_text(w, _("enter tag name")); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, 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", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->related), _("related tags,\ndoubleclick to attach")); g_signal_connect(G_OBJECT(d->related), "row-activated", G_CALLBACK(attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; gtk_widget_set_tooltip_text(button, _("create a new tag with the\nname you entered")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; gtk_widget_set_tooltip_text(button, _("delete selected tag")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self); button = gtk_button_new_with_label(C_("verb", "import")); d->import_button = button; gtk_widget_set_tooltip_text(button, _("import tags from a Lightroom keyword file")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(import_button_clicked), (gpointer)self); button = gtk_button_new_with_label(C_("verb", "export")); d->export_button = button; gtk_widget_set_tooltip_text(button, _("export all tags to a Lightroom keyword file")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(export_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, 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->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED, G_CALLBACK(_lib_tagging_tags_changed_callback), self); update(self, 0); set_keyword(self, d); }
/** * vik_trw_layer_waypoint_list_internal: * @dialog: The dialog to create the widgets in * @waypoints_and_layers: The list of waypoints (and it's layer) to be shown * @show_layer_names: Show the layer names that each waypoint belongs to * * Create a table of waypoints with corresponding waypoint information * This table does not support being actively updated */ static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog, GList *waypoints_and_layers, gboolean show_layer_names ) { if ( !waypoints_and_layers ) return; // It's simple storing the gdouble values in the tree store as the sort works automatically // Then apply specific cell data formatting (rather default double is to 6 decimal places!) // However not storing any doubles for waypoints ATM // TODO: Consider adding the waypoint icon into this store for display in the list GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS, G_TYPE_STRING, // 0: Layer Name G_TYPE_STRING, // 1: Waypoint Name G_TYPE_STRING, // 2: Date G_TYPE_BOOLEAN, // 3: Visible G_TYPE_STRING, // 4: Comment G_TYPE_INT, // 5: Height GDK_TYPE_PIXBUF, // 6: Symbol Icon G_TYPE_POINTER, // 7: TrackWaypoint Layer pointer G_TYPE_POINTER ); // 8: Waypoint pointer //gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL ); vik_units_height_t height_units = a_vik_get_units_height (); //GList *gl = get_waypoints_and_layers_cb ( vl, user_data ); //g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store ); GList *gl = waypoints_and_layers; while ( gl ) { trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units ); gl = g_list_next ( gl ); } GtkWidget *view = gtk_tree_view_new(); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); GtkTreeViewColumn *column; GtkTreeViewColumn *sort_by_column; gint column_runner = 0; if ( show_layer_names ) { // Insert column for the layer name when viewing multi layers column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ ); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); // remember the layer column so we can sort by it later sort_by_column = column; } else column_runner++; column = my_new_column_text ( _("Name"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( !show_layer_names ) // remember the name column so we can sort by it later sort_by_column = column; column = my_new_column_text ( _("Date"), renderer, view, column_runner++ ); gtk_tree_view_column_set_resizable ( column, TRUE ); GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); column_runner++; column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( height_units == VIK_UNITS_HEIGHT_FEET ) column = my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ ); else column = my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ ); GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL); column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL ); // Special sort required for pixbufs gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); gtk_tree_view_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) ); gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE ); // GTK_SELECTION_MULTIPLE gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE ); g_object_unref(store); GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_container_add ( GTK_CONTAINER(scrolledwindow), view ); g_object_set ( view, "has-tooltip", TRUE, NULL); g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL ); //g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view ); g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers ); g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers ); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0); // Set ordering of the initial view by one of the name columns gtk_tree_view_column_clicked ( sort_by_column ); // Ensure a reasonable number of items are shown // TODO: may be save window size, column order, sorted by between invocations. gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 ); }
void gglk_do_glk_objects(GtkMenuItem *unused_menuitem, gpointer unused_data) { GtkTreeView *tree; GtkTreeStore *store; GtkTreeSelection *select; if(win_glk_objects) { gtk_window_present(GTK_WINDOW(win_glk_objects)); return; } win_glk_objects = create_win_glk_objects(); g_signal_connect(win_glk_objects, "destroy", G_CALLBACK(gtk_widget_destroyed), &win_glk_objects); { GtkSizeGroup *group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); int i; const char *p; static const char group_widget_names[] = "char" "\0" "line" "\0" "mouse" "\0" "hyper" "\0" "arrange" "\0" "redraw" "\0"; for(p = group_widget_names; *p; p += strlen(p) + 1) { char name[30]; sprintf(name, "request_%s", p); gtk_size_group_add_widget(group, lookup_widget(win_glk_objects, name)); } for(i = 1; i <= 15; i++) { char labelname[30]; sprintf(labelname, "glabel%d", i); gtk_size_group_add_widget(group, lookup_widget(win_glk_objects, labelname)); } g_object_unref(group); } tree = GTK_TREE_VIEW(lookup_widget(win_glk_objects, "treeview1")); store = gtk_tree_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER); gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store)); gtk_tree_view_insert_column_with_attributes(tree, -1, "ID", gtk_cell_renderer_text_new(), "text", 0, NULL); gtk_tree_view_insert_column_with_attributes(tree, -1, "Type", gtk_cell_renderer_text_new(), "text", 1, NULL); gtk_tree_view_insert_column_with_data_func(tree, -1, "Key", gtk_cell_renderer_text_new(), gglk_key_render, GINT_TO_POINTER(2), NULL); select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect(select, "changed", G_CALLBACK(gglk_objects_tree_selection_changed), win_glk_objects); gglk_object_tree_update(); gtk_widget_show(win_glk_objects); }
static GtkWidget *create_right(void) { GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *scrolled; GtkWidget *tree; GtkTreeViewColumn *column; GtkCellRenderer *renderer; mainbox = gtk_vbox_new(FALSE, 24); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8); vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0); label = create_label("Networks"); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_OUT); gtk_container_add(GTK_CONTAINER(vbox), scrolled); tree = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); gtk_container_add(GTK_CONTAINER(scrolled), tree); gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0, NULL, gtk_cell_renderer_pixbuf_new(), status_to_icon, NULL, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0); gtk_tree_view_column_set_min_width(column, 24); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", CONNMAN_COLUMN_NAME); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_end(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, security_to_icon, NULL, NULL); tree_networks = tree; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(select_callback), NULL); return mainbox; }
/* Create list */ static GtkWidget* create_list(void) { GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSortable *sortable; GtkTreeView *list_view; GtkTreeSelection *selection; /* Create the store */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/ G_TYPE_UINT, /* ID */ G_TYPE_STRING, /* Operation Code */ G_TYPE_INT, /* Invokes */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* RetResult */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* Total Bytes */ G_TYPE_FLOAT); /* Avg Bytes */ /* Create a view */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); sortable = GTK_TREE_SORTABLE(list_store); /* Speed up the list display */ gtk_tree_view_set_fixed_height_mode(list_view, TRUE); /* Setup the sortable columns */ gtk_tree_sortable_set_sort_column_id(sortable, ID_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_headers_clickable(list_view, FALSE); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ /* 1:st column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("ID", renderer, "text", ID_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, ID_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 40); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* 2:nd column..Operation Code. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer, "text", OP_CODE_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, OP_CODE_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 210); gtk_tree_view_append_column (list_view, column); /* 3:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer, "text", INVOKES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, INVOKES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 60); gtk_tree_view_append_column (list_view, column); /* 4:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 5:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column (list_view, column); /* 6:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer, "text", RET_RES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, RET_RES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 60); gtk_tree_view_append_column (list_view, column); /* 7:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 8:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column (list_view, column); /* 9:th column.. Total Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer, "text", TOT_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 10:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 60); gtk_tree_view_append_column (list_view, column); /* Now enable the sorting of each column */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE); /* Setup the selection handler */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); return list; }
static void gimp_controller_list_init (GimpControllerList *list) { GtkWidget *hbox; GtkWidget *sw; GtkWidget *tv; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *vbox; GtkWidget *image; GtkIconSize icon_size; gint icon_width; gint icon_height; GType *controller_types; guint n_controller_types; gint i; gtk_orientable_set_orientation (GTK_ORIENTABLE (list), GTK_ORIENTATION_VERTICAL); list->gimp = NULL; list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); gtk_widget_show (sw); list->src = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_GTYPE); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src)); g_object_unref (list->src); gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Available Controllers")); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "stock-id", COLUMN_ICON, NULL); g_object_get (cell, "stock-size", &icon_size, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (tv); g_signal_connect_object (tv, "row-activated", G_CALLBACK (gimp_controller_list_row_activated), G_OBJECT (list), 0); list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE); g_signal_connect_object (list->src_sel, "changed", G_CALLBACK (gimp_controller_list_src_sel_changed), G_OBJECT (list), 0); controller_types = g_type_children (GIMP_TYPE_CONTROLLER, &n_controller_types); for (i = 0; i < n_controller_types; i++) { GimpControllerClass *controller_class; GtkTreeIter iter; controller_class = g_type_class_ref (controller_types[i]); gtk_list_store_append (list->src, &iter); gtk_list_store_set (list->src, &iter, COLUMN_ICON, controller_class->stock_id, COLUMN_NAME, controller_class->name, COLUMN_TYPE, controller_types[i], -1); g_type_class_unref (controller_class); } g_free (controller_types); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); list->add_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->add_button, FALSE); gtk_widget_show (list->add_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->add_button), image); gtk_widget_show (image); g_signal_connect (list->add_button, "clicked", G_CALLBACK (gimp_controller_list_add_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->add_button), (gpointer) &list->add_button); list->remove_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->remove_button, FALSE); gtk_widget_show (list->remove_button); image = gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->remove_button), image); gtk_widget_show (image); g_signal_connect (list->remove_button, "clicked", G_CALLBACK (gimp_controller_list_remove_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->remove_button), (gpointer) &list->remove_button); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)), icon_size, &icon_width, &icon_height); list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0); gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest), _("Active Controllers")); gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view, TRUE); gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0); gtk_widget_show (list->dest); g_signal_connect_object (list->dest, "select-item", G_CALLBACK (gimp_controller_list_select_item), G_OBJECT (list), 0); g_signal_connect_object (list->dest, "activate-item", G_CALLBACK (gimp_controller_list_activate_item), G_OBJECT (list), 0); list->edit_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), GTK_STOCK_PROPERTIES, _("Configure the selected controller"), NULL, G_CALLBACK (gimp_controller_list_edit_clicked), NULL, list); list->up_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), GTK_STOCK_GO_UP, _("Move the selected controller up"), NULL, G_CALLBACK (gimp_controller_list_up_clicked), NULL, list); list->down_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), GTK_STOCK_GO_DOWN, _("Move the selected controller down"), NULL, G_CALLBACK (gimp_controller_list_down_clicked), NULL, list); gtk_widget_set_sensitive (list->edit_button, FALSE); gtk_widget_set_sensitive (list->up_button, FALSE); gtk_widget_set_sensitive (list->down_button, FALSE); }
bool wxListBox::Create( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int n, const wxString choices[], long style, const wxValidator& validator, const wxString &name ) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxListBox creation failed") ); return false; } m_widget = gtk_scrolled_window_new( NULL, NULL ); g_object_ref(m_widget); if (style & wxLB_ALWAYS_SB) { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS ); } else { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); } GTKScrolledWindowSetBorder(m_widget, style); m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) ); //wxListBox doesn't have a header :) //NB: If enabled SetFirstItem doesn't work correctly gtk_tree_view_set_headers_visible(m_treeview, FALSE); #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) ((wxCheckListBox*)this)->DoCreateCheckList(); #endif // wxUSE_CHECKLISTBOX // Create the data column gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "", gtk_cell_renderer_text_new(), "text", WXLISTBOX_DATACOLUMN, NULL); // Now create+set the model (GtkListStore) - first argument # of columns #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN, GTK_TYPE_TREE_ENTRY); else #endif m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY); gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore)); g_object_unref (m_liststore); //free on treeview destruction // Disable the pop-up textctrl that enables searching - note that // the docs specify that even if this disabled (which we are doing) // the user can still have it through the start-interactive-search // key binding...either way we want to provide a searchequal callback // NB: If this is enabled a doubleclick event (activate) gets sent // on a successful search gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN); gtk_tree_view_set_search_equal_func(m_treeview, (GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback, this, NULL); gtk_tree_view_set_enable_search(m_treeview, FALSE); GtkSelectionMode mode; // GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) ) { mode = GTK_SELECTION_MULTIPLE; } else // no multi-selection flags specified { m_windowStyle |= wxLB_SINGLE; // Notice that we must use BROWSE and not GTK_SELECTION_SINGLE because // the latter allows to not select any items at all while a single // selection listbox is supposed to always have a selection (at least // once the user selected something, it might not have any initially). mode = GTK_SELECTION_BROWSE; } GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview ); gtk_tree_selection_set_mode( selection, mode ); // Handle sortable stuff if(HasFlag(wxLB_SORT)) { // Setup sorting in ascending (wx) order gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, GTK_SORT_ASCENDING); // Set the sort callback gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, (GtkTreeIterCompareFunc) gtk_listbox_sort_callback, this, //userdata NULL //"destroy notifier" ); } gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) ); gtk_widget_show( GTK_WIDGET(m_treeview) ); m_focusWidget = GTK_WIDGET(m_treeview); Append(n, choices); // insert initial items // generate dclick events g_signal_connect_after(m_treeview, "row-activated", G_CALLBACK(gtk_listbox_row_activated_callback), this); // for intercepting dclick generation by <ENTER> g_signal_connect (m_treeview, "key_press_event", G_CALLBACK (gtk_listbox_key_press_callback), this); m_parent->DoAddChild( this ); PostCreation(size); SetInitialSize(size); // need this too because this is a wxControlWithItems g_signal_connect_after (selection, "changed", G_CALLBACK (gtk_listitem_changed_callback), this); return true; }
static GtkWidget* setup_card_list_pane(GtkTextBuffer *text_buffer) { GtkListStore *store = gtk_list_store_new(N_COLS, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* faction */ G_TYPE_STRING, /* type */ G_TYPE_STRING, /* set */ G_TYPE_INT, /* number */ G_TYPE_POINTER /* struct card* */); /* Build the list store. */ for (guint i = 0; i < DB->sets->len; i++) { struct card_set *set = g_ptr_array_index(DB->sets, i); for (guint j = 0; j < set->cards->len; j++) { struct card *card = g_ptr_array_index(set->cards, j); GtkTreeIter iter; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, COL_NAME, card->name, COL_FACTION, faction_to_string(card->faction), COL_TYPE, card->type_str, COL_SET, card->set, COL_NUMBER, card->number, COL_CARD_PTR, card, -1); } } /* Build the actual tree view. */ GtkWidget *tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_signal_connect(tree_view, "realize", G_CALLBACK(realize), NULL); static const struct { const char *name; gint column; } *p, table[] = { { "Name" , COL_NAME }, { "Faction", COL_FACTION }, { "Type" , COL_TYPE }, { "Set" , COL_SET }, { "Number" , COL_NUMBER }, { NULL , -1 } }; for (p = table; p->name != NULL; p++) { GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(p->name, renderer, "text", p->column, NULL); gtk_tree_view_column_set_sort_column_id(column, p->column); if (p->column == COL_NAME || p->column == COL_TYPE || p->column == COL_SET) { g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); } gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column); } GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_BROWSE); g_signal_connect_object(sel, "changed", G_CALLBACK(cursor_changed), text_buffer, 0); GtkTreeIter iter; gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter); gtk_tree_selection_select_iter(sel, &iter); return widget_wrap_frame(widget_wrap_scroller(tree_view)); }
GtkWidget * userlist_create (GtkWidget *box) { static const GtkTargetEntry dnd_dest_targets[] = { {"text/uri-list", 0, 1}, {"HEXCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_src_target[] = { {"HEXCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; auto 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), prefs.hex_gui_ulist_show_hosts ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0); gtk_widget_show (sw); auto treeview = gtk_tree_view_new (); gtk_widget_set_name (treeview, "hexchat-userlist"); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_MULTIPLE); /* set up drops */ gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2, static_cast<GdkDragAction>(GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK)); gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE); /* file DND (for DCC) */ g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (userlist_dnd_motion), treeview); g_signal_connect (G_OBJECT (treeview), "drag_leave", G_CALLBACK (userlist_dnd_leave), 0); g_signal_connect (G_OBJECT (treeview), "drag_data_received", G_CALLBACK (userlist_dnd_drop), treeview); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (userlist_click_cb), 0); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (userlist_key_cb), 0); /* tree/chanview DND */ g_signal_connect (G_OBJECT (treeview), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (treeview), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); userlist_add_columns (GTK_TREE_VIEW (treeview)); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_widget_show (treeview); return treeview; }
static int gtkListMapMethod(Ihandle* ih) { GtkScrolledWindow* scrolled_window = NULL; GtkListStore *store; store = gtk_list_store_new(1, G_TYPE_STRING); if (ih->data->is_dropdown) { GtkCellRenderer *renderer = NULL; if (ih->data->has_editbox) ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0); else ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL); if (ih->data->has_editbox) { GtkWidget *entry; #if GTK_CHECK_VERSION(2, 12, 0) GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle)); renderer = list->data; g_list_free(list); #endif entry = gtk_bin_get_child(GTK_BIN(ih->handle)); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; } else { /* had to add an event box just to get get/killfocus,enter/leave events */ GtkWidget *box = gtk_event_box_new(); gtk_container_add((GtkContainer*)box, ih->handle); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL); g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; else GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS; } g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih); g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih); if (renderer) { renderer->xpad = 0; renderer->ypad = 0; iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); } } else { GtkCellRenderer *renderer; GtkTreeSelection* selection; GtkTreeViewColumn *column; GtkPolicyType scrollbar_policy; ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); if (!ih->handle) return IUP_ERROR; scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL); if (ih->data->has_editbox) { GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0); GtkWidget *entry = gtk_entry_new(); gtk_widget_show(entry); gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0); iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry); gtk_widget_show((GtkWidget*)vbox); gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox); iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window); GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */ if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih); g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih); g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */ g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih); g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */ g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih); } else { iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window); if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS"))) GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); } column = gtk_tree_view_column_new(); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL); iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer); g_object_set(G_OBJECT(renderer), "xpad", 0, NULL); g_object_set(G_OBJECT(renderer), "ypad", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE); gtk_container_add((GtkContainer*)scrolled_window, ih->handle); gtk_widget_show((GtkWidget*)scrolled_window); gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); if (ih->data->sb) { if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE"))) scrollbar_policy = GTK_POLICY_AUTOMATIC; else scrollbar_policy = GTK_POLICY_ALWAYS; } else scrollbar_policy = GTK_POLICY_NEVER; gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle)); if (!ih->data->has_editbox && ih->data->is_multiple) { gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE); #endif } else gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih); g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih); g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih); } /* add to the parent, all GTK controls must call this. */ iupgtkBaseAddToParent(ih); if (scrolled_window) gtk_widget_realize((GtkWidget*)scrolled_window); gtk_widget_realize(ih->handle); /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); iupListSetInitialItems(ih); return IUP_NOERROR; }
GotoReferenceDialog::GotoReferenceDialog(unsigned int currentbook, unsigned int currentchapter, const ustring & currentverse) { // Init variables extern Settings *settings; ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get()); language = projectconfig->language_get(); newreference = false; oldbook = currentbook; oldchapter = currentchapter; oldverse = currentverse; go_back = false; go_forward = false; Shortcuts shortcuts(0); gtkbuilder = gtk_builder_new (); gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.gotoreferencedialog.xml").c_str(), NULL); dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog")); g_signal_connect((gpointer) dialog, "key_press_event", G_CALLBACK(on_key_press_event), gpointer(this)); notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook")); // Enter current reference into the free entry, and select it, so user can use that. entry_free = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_free")); gtk_widget_grab_focus(entry_free); ustring ref = books_id_to_name(language, currentbook) + " " + convert_to_string(currentchapter) + ":" + currentverse; gtk_entry_set_text(GTK_ENTRY(entry_free), ref.c_str()); gtk_editable_select_region(GTK_EDITABLE(entry_free), 0, -1); // Completion for the reference entry. completion_setup(entry_free, cpGoto); // Signals entry. g_signal_connect((gpointer) entry_free, "activate", G_CALLBACK(on_entry_free_activate), gpointer(this)); // Aided entry widgets. treeview_book = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_book")); treeview_chapter = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_chapter")); treeview_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_verse")); // Connect to the signals of the treeviews. g_signal_connect_after((gpointer) treeview_book, "move_cursor", G_CALLBACK(on_treeview_book_move_cursor), gpointer(this)); g_signal_connect_after((gpointer) treeview_book, "row_activated", G_CALLBACK(on_treeview_book_row_activated), gpointer(this)); g_signal_connect_after((gpointer) treeview_chapter, "move_cursor", G_CALLBACK(on_treeview_chapter_move_cursor), gpointer(this)); g_signal_connect_after((gpointer) treeview_chapter, "row_activated", G_CALLBACK(on_treeview_chapter_row_activated), gpointer(this)); g_signal_connect_after((gpointer) treeview_verse, "move_cursor", G_CALLBACK(on_treeview_verse_move_cursor), gpointer(this)); g_signal_connect_after((gpointer) treeview_verse, "row_activated", G_CALLBACK(on_treeview_verse_row_activated), gpointer(this)); // Create stores and fill the book store. store_book = gtk_list_store_new(1, G_TYPE_STRING); store_chapter = gtk_list_store_new(1, G_TYPE_STRING); store_verse = gtk_list_store_new(1, G_TYPE_STRING); vector < unsigned int >ibooks = project_get_books(settings->genconfig.project_get()); vector < ustring > ubooks; for (unsigned int i = 0; i < ibooks.size(); i++) ubooks.push_back(books_id_to_name(language, ibooks[i])); listview_set_strings(treeview_book, store_book, ubooks); // Set the stores as models for the treeviews. gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_book), GTK_TREE_MODEL(store_book)); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_chapter), GTK_TREE_MODEL(store_chapter)); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_verse), GTK_TREE_MODEL(store_verse)); // Unreference the stores once, so they get destroyed with the treeview. g_object_unref(store_book); g_object_unref(store_chapter); g_object_unref(store_verse); // Text cell renderer. GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new(); // Columns. GtkTreeViewColumn *column_book; column_book = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_book), column_book); GtkTreeViewColumn *column_chapter; column_chapter = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_chapter), column_chapter); GtkTreeViewColumn *column_verse; column_verse = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_verse), column_verse); // Set up the selection for each of the tree views. GtkTreeSelection *select_book; select_book = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_book)); gtk_tree_selection_set_mode(select_book, GTK_SELECTION_SINGLE); GtkTreeSelection *select_chapter; select_chapter = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_chapter)); gtk_tree_selection_set_mode(select_chapter, GTK_SELECTION_SINGLE); GtkTreeSelection *select_verse; select_verse = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_verse)); gtk_tree_selection_set_mode(select_verse, GTK_SELECTION_SINGLE); // History back. radiobutton_back = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_back")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_back), true); // History forward. radiobutton_forward = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_forward")); // Link history button. GSList *history_button_group = NULL; gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_back), history_button_group); history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_back)); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_forward), history_button_group); history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_forward)); // Dialog action area. InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, &shortcuts, NULL); cancelbutton = indialoghelp->cancelbutton; okbutton = indialoghelp->okbutton; gtk_widget_grab_default(okbutton); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); }
static void * pidgin_notify_searchresults(PurpleConnection *gc, const char *title, const char *primary, const char *secondary, PurpleNotifySearchResults *results, gpointer user_data) { GtkWidget *window; GtkWidget *treeview; GtkWidget *close_button; GType *col_types; GtkListStore *model; GtkCellRenderer *renderer; guint col_num; GList *columniter; guint i; GList *l; GtkWidget *vbox; GtkWidget *label; GtkWidget *sw; PidginNotifySearchResultsData *data; char *label_text; char *primary_esc, *secondary_esc; g_return_val_if_fail(gc != NULL, NULL); g_return_val_if_fail(results != NULL, NULL); data = g_malloc(sizeof(PidginNotifySearchResultsData)); data->user_data = user_data; data->results = results; /* Create the window */ window = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(window), title ? title :_("Search Results")); gtk_container_set_border_width(GTK_CONTAINER(window), PIDGIN_HIG_BORDER); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); g_signal_connect_swapped(G_OBJECT(window), "delete_event", G_CALLBACK(searchresults_close_cb), data); /* Setup the main vbox */ vbox = GTK_DIALOG(window)->vbox; /* Setup the descriptive label */ primary_esc = (primary != NULL) ? g_markup_escape_text(primary, -1) : NULL; secondary_esc = (secondary != NULL) ? g_markup_escape_text(secondary, -1) : NULL; label_text = g_strdup_printf( "<span weight=\"bold\" size=\"larger\">%s</span>%s%s", (primary ? primary_esc : ""), (primary && secondary ? "\n" : ""), (secondary ? secondary_esc : "")); g_free(primary_esc); g_free(secondary_esc); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), label_text); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); g_free(label_text); /* +1 is for the automagically created Status column. */ col_num = g_list_length(results->columns) + 1; /* Setup the list model */ col_types = g_new0(GType, col_num); /* There always is this first column. */ col_types[0] = GDK_TYPE_PIXBUF; for (i = 1; i < col_num; i++) { col_types[i] = G_TYPE_STRING; } model = gtk_list_store_newv(col_num, col_types); g_free(col_types); /* Setup the scrolled window containing the treeview */ sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show(sw); /* Setup the treeview */ treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_object_unref(G_OBJECT(model)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_widget_set_size_request(treeview, 500, 400); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); gtk_container_add(GTK_CONTAINER(sw), treeview); gtk_widget_show(treeview); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, "", renderer, "pixbuf", 0, NULL); i = 1; for (columniter = results->columns; columniter != NULL; columniter = columniter->next) { PurpleNotifySearchColumn *column = columniter->data; renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1, column->title, renderer, "text", i, NULL); i++; } for (l = results->buttons; l; l = l->next) { PurpleNotifySearchButton *b = l->data; GtkWidget *button = NULL; switch (b->type) { case PURPLE_NOTIFY_BUTTON_LABELED: if(b->label) { button = gtk_button_new_with_label(b->label); } else { purple_debug_warning("gtknotify", "Missing button label\n"); } break; case PURPLE_NOTIFY_BUTTON_CONTINUE: button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_GO_FORWARD, GTK_RESPONSE_NONE); break; case PURPLE_NOTIFY_BUTTON_ADD: button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_ADD, GTK_RESPONSE_NONE); break; case PURPLE_NOTIFY_BUTTON_INFO: button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_TOOLBAR_USER_INFO, GTK_RESPONSE_NONE); break; case PURPLE_NOTIFY_BUTTON_IM: button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_TOOLBAR_MESSAGE_NEW, GTK_RESPONSE_NONE); break; case PURPLE_NOTIFY_BUTTON_JOIN: button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_CHAT, GTK_RESPONSE_NONE); break; case PURPLE_NOTIFY_BUTTON_INVITE: button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_INVITE, GTK_RESPONSE_NONE); break; default: purple_debug_warning("gtknotify", "Incorrect button type: %d\n", b->type); } if (button != NULL) { PidginNotifySearchResultsButtonData *bd; bd = g_new0(PidginNotifySearchResultsButtonData, 1); bd->button = b; bd->data = data; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(searchresults_callback_wrapper_cb), bd); g_signal_connect_swapped(G_OBJECT(button), "destroy", G_CALLBACK(g_free), bd); } } /* Add the Close button */ close_button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(searchresults_close_cb), data); data->account = gc->account; data->model = model; data->treeview = treeview; data->window = window; /* Insert rows. */ pidgin_notify_searchresults_new_rows(gc, results, data); /* Show the window */ pidgin_auto_parent_window(window); gtk_widget_show(window); return data; }