/*----------导入功能up----------------------------------------------------------------*/ void create_view(GtkWidget *container,gpointer data)//容器管理的主界面 { GtkTreeViewColumn *column22; GtkTreeViewColumn *column33; GtkTreeViewColumn *column44; GtkWidget *window; //GtkWidget *combox_images; GtkBuilder *builder; GtkTreeIter iter; GtkWidget *button11; GtkWidget *button22; GtkWidget *button33; GtkWidget *button44; GtkWidget *button55; GtkWidget *button66; GtkWidget *button77; GtkWidget *button88; GtkWidget *button99; GtkWidget *button110; GtkCellRenderer *cell11; GtkListStore *list11; GtkCellRenderer *cell; GtkTreeSelection *selection; static int j; docker_contain(); builder=gtk_builder_new (); gtk_builder_add_from_file (builder,CONTAINER_MANAGE_FILE,NULL); window=GTK_WIDGET(gtk_builder_get_object (builder,CONTAINER_MANAGE_WINDOW)); gtk_window_set_title (window,_("contians manage")); gtk_widget_set_name(window, "nfs_container_mange_window"); button11=GTK_WIDGET(gtk_builder_get_object (builder,"button1")); button22=GTK_WIDGET(gtk_builder_get_object (builder,"button2")); button33=GTK_WIDGET(gtk_builder_get_object (builder,"button3")); button44=GTK_WIDGET(gtk_builder_get_object (builder,"button4")); button55=GTK_WIDGET(gtk_builder_get_object (builder,"button5")); button66=GTK_WIDGET(gtk_builder_get_object (builder,"button6")); button77=GTK_WIDGET(gtk_builder_get_object (builder,"button7")); button88=GTK_WIDGET(gtk_builder_get_object (builder,"button8")); button99=GTK_WIDGET(gtk_builder_get_object (builder,"button9")); button110=GTK_WIDGET(gtk_builder_get_object (builder,"button10")); column22=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn1")); column33=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn2")); column44=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn3")); gtk_tree_view_column_set_title (column22,_("Mirror image")); cell=gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column22, cell,FALSE); gtk_tree_view_column_set_attributes(column22,cell,"text",0,NULL); gtk_tree_view_column_set_title (column33,"ID"); cell=gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column33,cell,FALSE); gtk_tree_view_column_set_attributes(column33,cell,"text",1,NULL); gtk_tree_view_column_set_title (column44,_("name_colum")); cell=gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column44,cell,FALSE); gtk_tree_view_column_set_attributes(column44,cell,"text",2,NULL); gtk_button_set_label (GTK_BUTTON(button11),_("starting contain and enter")); gtk_button_set_label (GTK_BUTTON(button22),_("stop contian")); gtk_button_set_label (GTK_BUTTON(button33),_("create gurd contian")); gtk_button_set_label (GTK_BUTTON(button44),_("create contian")); gtk_button_set_label (GTK_BUTTON(button55),_("export")); gtk_button_set_label (GTK_BUTTON(button66),_("ls starting contain")); gtk_button_set_label (GTK_BUTTON(button77),_("ls gurd contain")); gtk_button_set_label (GTK_BUTTON(button88),_("dele on contian")); gtk_button_set_label (GTK_BUTTON(button99),_("dele mul contians")); gtk_button_set_label (GTK_BUTTON(button110),_("import")); tree_view=GTK_WIDGET(gtk_builder_get_object (builder,"treeview1")); list11=gtk_list_store_new (4, G_TYPE_STRING,G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW(tree_view),GTK_TREE_MODEL(list11)); selection=gtk_tree_view_get_selection (GTK_TREE_VIEW(tree_view)); //mod=gtk_tree_view_get_model (GTK_TREE_VIEW(tree_view)); g_signal_connect(G_OBJECT(tree_view),"cursor-changed",G_CALLBACK(clicked_row11),selection); //g_signal_connect(G_OBJECT(selection),"changed",G_CALLBACK(clicked_row11),selection); g_signal_connect(G_OBJECT(button11),"clicked",G_CALLBACK(button11_treeview_fun),selection); g_signal_connect(G_OBJECT(button88),"clicked",G_CALLBACK(button88_treeview_fun),selection); g_signal_connect(G_OBJECT(button44),"clicked",G_CALLBACK(button44_treeview_fun),selection); g_signal_connect(G_OBJECT(button33),"clicked",G_CALLBACK(button33_treeview_fun),selection); g_signal_connect(G_OBJECT(button99),"clicked",G_CALLBACK(button99_treeview_fun),selection); g_signal_connect(G_OBJECT(button66),"clicked",G_CALLBACK(button33_fun),"docker ps"); g_signal_connect(G_OBJECT(button22),"clicked",G_CALLBACK(button22_treeview_fun),selection); g_signal_connect(G_OBJECT(button110),"clicked",G_CALLBACK(import_selcet_file),window); g_signal_connect(G_OBJECT(button55),"clicked",G_CALLBACK(export_selcet_file),selection); g_signal_connect(G_OBJECT(button77),"clicked",G_CALLBACK(button77_lsgurd_fun),window); for(j=0;j<contains_num;j++){ gtk_list_store_append (list11,&iter); gtk_list_store_set (list11, &iter, 0,&a[j].image,-1); gtk_list_store_set (list11, &iter, 1,&a[j].id,-1); gtk_list_store_set (list11, &iter, 2,&a[j].name,-1); } g_object_unref (builder); gtk_widget_show_all (window); //return tree_view; }
static void fcitx_im_dialog_init(FcitxImDialog* self) { gtk_window_set_title(GTK_WINDOW(self), _("Add input method")); gtk_window_set_modal(GTK_WINDOW(self), TRUE); gtk_dialog_add_buttons(GTK_DIALOG(self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL ); gtk_dialog_set_alternative_button_order (GTK_DIALOG (self), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect(self, "response", G_CALLBACK(_fcitx_im_dialog_response_cb), NULL); GtkCellRenderer* renderer; GtkTreeViewColumn* column; gtk_widget_set_size_request(GTK_WIDGET(self), 400, 300); self->availimstore = gtk_list_store_new(IM_N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->availimstore), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel), (GtkTreeModelFilterVisibleFunc) _fcitx_im_dialog_filter_func, self , NULL); self->sortmodel = gtk_tree_model_sort_new_with_model(self->filtermodel); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(self->sortmodel), IM_LIST_IM_STRING, GTK_SORT_ASCENDING); self->availimview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->sortmodel)); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Input Method"), renderer, "text", IM_LIST_IM_STRING, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(self->availimview), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->availimview), FALSE); GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->availimview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_fcitx_im_dialog_im_selection_changed), self); GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolledwindow), self->availimview); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(self))), scrolledwindow, TRUE, TRUE, 0); g_object_set(G_OBJECT(scrolledwindow), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL); self->onlycurlangcheckbox = gtk_check_button_new_with_label(_("Only Show Current Language")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->onlycurlangcheckbox), TRUE); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(self))), self->onlycurlangcheckbox, FALSE, TRUE, 0); g_object_set(G_OBJECT(self->onlycurlangcheckbox), "margin-left", 5, "margin-right", 5, NULL); self->filterentry = gtk_entry_new(); gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); #if GTK_CHECK_VERSION(3,2,0) gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Input Method")); #endif gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(self))), self->filterentry, FALSE, TRUE, 0); g_object_set(G_OBJECT(self->filterentry), "margin-left", 5, "margin-right", 5, NULL); g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_im_dialog_filtertext_changed), self); g_signal_connect(G_OBJECT(self->onlycurlangcheckbox), "toggled", G_CALLBACK(_fcitx_im_dialog_onlycurlangcheckbox_toggled), self); g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL); _fcitx_im_dialog_connect(self); }
static GtkWidget* gwy_module_browser_construct(GtkWidget *parent) { static const struct { const gchar *title; const guint id; } columns[] = { { N_("Module"), MODULE_NAME }, { N_("Version"), MODULE_VERSION }, { N_("Author"), MODULE_AUTHOR }, }; GtkWidget *tree; GtkListStore *store; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GSList *l, *list = NULL; GtkTreeIter iter; gsize i; store = gtk_list_store_new(MODULE_LAST, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gwy_module_foreach(gwy_hash_table_to_slist_cb, &list); list = g_slist_sort(list, (GCompareFunc)module_name_compare_cb); for (l = list; l; l = g_slist_next(l)) { const GwyModuleInfo *mod_info = (const GwyModuleInfo*)l->data; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, MODULE_NAME, mod_info->name, MODULE_VERSION, mod_info->version, MODULE_AUTHOR, mod_info->author, -1); } g_slist_free(list); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); g_object_unref(store); for (i = 0; i < G_N_ELEMENTS(columns); i++) { renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_(columns[i].title), renderer, "text", columns[i].id, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); } selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(tree), "cursor-changed", G_CALLBACK(update_module_info_cb), parent); return tree; }
static void ifopts_edit_cb(GtkWidget *w, gpointer data _U_) { GtkWidget *ifopts_edit_dlg, *cur_scr_win, *main_hb, *main_tb, *cur_opts_fr, *ed_opts_fr, *main_vb, *if_linktype_lb, *if_descr_lb, *if_hide_lb, *bbox, *ok_bt, *cancel_bt, *help_bt; GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeView *list_view; GtkTreeSelection *selection; int row = 0; GtkWidget *caller = gtk_widget_get_toplevel(w); GtkTooltips *tooltips = gtk_tooltips_new(); /* Has an edit dialog box already been opened for that top-level widget? */ ifopts_edit_dlg = g_object_get_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY); if (ifopts_edit_dlg != NULL) { /* Yes. Just re-activate that dialog box. */ reactivate_window(ifopts_edit_dlg); return; } /* create a new dialog */ ifopts_edit_dlg = dlg_conf_window_new("Wireshark: Preferences: Interface Options"); gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), DEF_WIDTH, 340); main_vb = gtk_vbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb); gtk_widget_show(main_vb); /* create current options frame */ cur_opts_fr = gtk_frame_new("Interfaces"); gtk_container_add(GTK_CONTAINER(main_vb), cur_opts_fr); gtk_widget_show(cur_opts_fr); /* create a scrolled window to pack the current options TreeView widget into */ cur_scr_win = scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(cur_scr_win), 3); gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win); gtk_widget_show(cur_scr_win); /* * Create current options TreeView. */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */ G_TYPE_STRING, /* Device */ G_TYPE_STRING, /* Description */ G_TYPE_STRING, /* Default link-layer */ G_TYPE_STRING, /* Comment */ G_TYPE_STRING, /* Hide? */ G_TYPE_INT); /* Dlt */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); /* 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 */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Device", renderer, "text", DEVICE_COLUMN, NULL); 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, 230); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", DESC_COLUMN, NULL); 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, 260); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer, "text", DEF_LINK_LAYER_COLUMN, NULL); 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, 260); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); column = gtk_tree_view_column_new_with_attributes ("Comment", renderer, "text", COMMENT_COLUMN, NULL); 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); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); column = gtk_tree_view_column_new_with_attributes ("Hide?", renderer, "text", HIDE_COLUMN, NULL); 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); #if 0 /* Don't show the DLT column */ column = gtk_tree_view_column_new_with_attributes ("DLT", renderer, "text", DLT_COLUMN, NULL); 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); #endif /* Setup the selection handler */ selection = gtk_tree_view_get_selection(list_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); cur_list = list; gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_list); if_selection = selection; g_signal_connect (G_OBJECT (selection), "changed", /* select_row */ G_CALLBACK (ifopts_edit_ifsel_cb), NULL); gtk_widget_show(cur_list); /* add interface names to cell */ ifopts_if_liststore_add(); /* create edit options frame */ ed_opts_fr = gtk_frame_new("Properties"); gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0); gtk_widget_show(ed_opts_fr); main_hb = gtk_hbox_new(TRUE, 5); gtk_container_set_border_width(GTK_CONTAINER(main_hb), 3); gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb); gtk_widget_show(main_hb); /* table to hold description text entry and hide button */ main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE); gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10); gtk_widget_show(main_tb); if_dev_lb = gtk_label_new("Device:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0f, 0.5f); gtk_widget_show(if_dev_lb); if_dev_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0f, 0.5f); gtk_widget_show(if_dev_lb); row++; if_name_lb = gtk_label_new("Description:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0f, 0.5f); gtk_widget_show(if_name_lb); if_name_lb = gtk_label_new(""); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0f, 0.5f); gtk_widget_show(if_name_lb); row++; if_linktype_lb = gtk_label_new("Default link-layer header type:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f); gtk_widget_show(if_linktype_lb); if_linktype_cb = gtk_combo_box_new_text(); num_linktypes = 0; interfaces_info_nochange = FALSE; g_signal_connect(if_linktype_cb, "changed", G_CALLBACK(ifopts_edit_linktype_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_cb, 1, 2, row, row+1); gtk_widget_show(if_linktype_cb); row++; /* create interface description label and text entry */ if_descr_lb = gtk_label_new("Comment:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0f, 0.5f); gtk_widget_show(if_descr_lb); if_descr_te = gtk_entry_new(); g_signal_connect(if_descr_te, "changed", G_CALLBACK(ifopts_edit_descr_changed_cb), cur_list); gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1); gtk_widget_show(if_descr_te); row++; /* create "hide interface" label and button */ if_hide_lb = gtk_label_new("Hide interface?:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0f, 0.5f); gtk_widget_show(if_hide_lb); if_hide_cb = gtk_check_button_new(); g_signal_connect(if_hide_cb, "toggled", G_CALLBACK(ifopts_edit_hide_changed_cb), cur_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1); gtk_widget_show(if_hide_cb); row++; /* button row: OK and Cancel buttons */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); gtk_tooltips_set_tip(tooltips, ok_bt, "Save changes and exit dialog", NULL); g_signal_connect(ok_bt, "clicked", G_CALLBACK(ifopts_edit_ok_cb), ifopts_edit_dlg); cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); gtk_tooltips_set_tip(tooltips, cancel_bt, "Cancel and exit dialog", NULL); window_set_cancel_button(ifopts_edit_dlg, cancel_bt, window_cancel_button_cb); help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_CAPTURE_INTERFACE_OPTIONS_DIALOG); gtk_tooltips_set_tip (tooltips, help_bt, "Show topic specific help", NULL); gtk_widget_grab_default(ok_bt); g_signal_connect(ifopts_edit_dlg, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); /* Call a handler when we're destroyed, so we can inform our caller, if any, that we've been destroyed. */ g_signal_connect(ifopts_edit_dlg, "destroy", G_CALLBACK(ifopts_edit_destroy_cb), NULL); /* Set the key for the new dialog to point to our caller. */ g_object_set_data(G_OBJECT(ifopts_edit_dlg), IFOPTS_CALLER_PTR_KEY, caller); /* Set the key for the caller to point to us */ g_object_set_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY, ifopts_edit_dlg); gtk_widget_show(ifopts_edit_dlg); /* triggers ifopts_edit_ifsel_cb() with the */ /* "interfaces" TreeView first row selected */ window_present(ifopts_edit_dlg); }
void zkartmat_add_columns(GtkTreeView *treeview) { GtkCellRenderer *renderer; //GtkTreeModel *model = gtk_tree_view_get_model (treeview); //GdkColor color; printf("zkartmat_add_columns\n"); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Дата подт-ния"), renderer,"text", COL_DATAP,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Дата док-та"), renderer,"text", COL_DATADOK,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Номер документа"), renderer,"text", COL_NOMDOK,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Операция"), renderer,"text", COL_KODOP,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Контрагент"), renderer,"text", COL_KONTR,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Количество"), renderer,"text", COL_KOLIH,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,"+\\-", renderer,"text", COL_PR,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1,gettext("Цена"), renderer,"text", COL_CENA,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),-1, gettext("Дополнительное наименование"), renderer, "text", COL_DOPNAIM,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),-1, gettext("Дата и время записи"), renderer, "text", COL_DATA_VREM,NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),-1, gettext("Кто записал"), renderer, "text", COL_KTO,NULL); printf("zkartmat_add_columns end\n"); }
static void ft_manager_build_ui (EmpathyFTManager *manager) { GtkBuilder *gui; GtkTreeView *view; GtkListStore *liststore; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; gchar *filename; EmpathyFTManagerPriv *priv = GET_PRIV (manager); filename = empathy_file_lookup ("empathy-ft-manager.ui", "src"); gui = empathy_builder_get_file (filename, "ft_manager_dialog", &priv->window, "ft_list", &priv->treeview, "clear_button", &priv->clear_button, "open_button", &priv->open_button, "abort_button", &priv->abort_button, NULL); g_free (filename); empathy_builder_connect (gui, manager, "ft_manager_dialog", "destroy", ft_manager_destroy_cb, "ft_manager_dialog", "response", ft_manager_response_cb, "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb, "ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb, NULL); empathy_builder_unref_and_keep_widget (gui, priv->window); /* Window geometry. */ empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager"); /* Setup the tree view */ view = GTK_TREE_VIEW (priv->treeview); selection = gtk_tree_view_get_selection (view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (ft_manager_selection_changed), manager); gtk_tree_view_set_headers_visible (view, TRUE); gtk_tree_view_set_enable_search (view, FALSE); /* Setup the model */ liststore = gtk_list_store_new (5, G_TYPE_INT, /* percent */ G_TYPE_ICON, /* icon */ G_TYPE_STRING, /* message */ G_TYPE_STRING, /* remaining */ G_TYPE_OBJECT); /* ft_handler */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore)); priv->model = GTK_TREE_MODEL (liststore); g_object_unref (liststore); /* Progress column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("%")); gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, ft_manager_progress_cell_data_func, NULL, NULL); /* Icon and filename column*/ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("File")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE); gtk_tree_view_column_set_spacing (column, 3); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 3, "stock-size", GTK_ICON_SIZE_DND, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "gicon", COL_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_MESSAGE, NULL); /* Remaining time column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Remaining")); gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_REMAINING, NULL); /* clear button should be sensitive only if there are completed/cancelled * handlers in the store. */ gtk_widget_set_sensitive (priv->clear_button, FALSE); }
void poimatdok_create_list (class poimatdok_data *data) { GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur; char strsql[512]; int kolstr=0; SQL_str row; 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(poimatdok_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(poimatdok_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); sprintf(strsql,"select datd,sklad,nomd,kontr,kodop,pod,pro,tip,ktoi,vrem from Dokummat where nomd='%s' \ order by datd desc",data->nomdok_p.ravno()); 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(row[7][0] == '1') ss[COL_METKA].new_plus("+"); if(row[7][0] == '2') ss[COL_METKA].new_plus("-"); if(row[5][0] == '0') ss[COL_METKA].plus("?"); if(row[6][0] == '0') ss[COL_METKA].plus("*"); //склад ss[COL_SKLAD].new_plus(row[1]); //Дата документа ss[COL_DATADOK].new_plus(iceb_u_sqldata(row[0])); //Номер документа ss[COL_NOMDOK].new_plus(iceb_u_toutf(row[2])); //Код операции ss[COL_KODOP].new_plus(iceb_u_toutf(row[4])); //Код контрагента ss[COL_KONTR].new_plus(iceb_u_toutf(row[3])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[9]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[8],0,data->window)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_METKA,ss[COL_METKA].ravno(), COL_SKLAD,ss[COL_SKLAD].ravno(), COL_DATADOK,ss[COL_DATADOK].ravno(), COL_NOMDOK,ss[COL_NOMDOK].ravno(), COL_KODOP,ss[COL_KODOP].ravno(), COL_KONTR,ss[COL_KONTR].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); poimatdok_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); iceb_snanomer(data->kolzap,&data->snanomer,data->treeview); iceb_u_str zagolov; zagolov.plus(gettext("Поиск документа по номеру")); zagolov.plus(" "); zagolov.plus(data->nomdok_p.ravno()); zagolov.plus(" "); zagolov.plus(gettext("Количество записей")); zagolov.plus(":"); zagolov.plus(data->kolzap); 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)); }
static GtkWidget * make_results_view (XpathExplorer * ttt) { g_return_val_if_fail(ttt != NULL, NULL); GtkTreeViewColumn *col; GtkCellRenderer *renderer, *icon_renderer; GtkWidget *view; view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(make_results_blank())); //view = gtk_tree_view_new(); gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(view), TRUE); g_signal_connect(view, "button-press-event", G_CALLBACK(xpath_explorer_button_press_event), ttt); /* g_signal_connect(view, "popup-menu", G_CALLBACK(xpath_view_onPopupMenu), ttt);*/ g_signal_connect(view, "row-activated", G_CALLBACK(xpath_explorer_row_activated), ttt); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (col, _("Name")); gtk_tree_view_column_set_resizable(col, TRUE); icon_renderer = xml_cell_renderer_new(); gtk_tree_view_column_pack_start(col, icon_renderer, FALSE); gtk_tree_view_column_set_attributes(col, icon_renderer, "node-id", XML_TREE_MODEL_COL_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_XPATH); gtk_tree_view_column_set_title (col, _("XPath")); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_LINE); gtk_tree_view_column_set_title (col, _("Line")); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer,"ellipsize", PANGO_ELLIPSIZE_END, NULL); g_object_set(renderer,"single-paragraph-mode", TRUE, NULL); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", XML_TREE_MODEL_COL_CONTENT); gtk_tree_view_column_set_title (col, _("Value")); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(view),col); return view; }
void dialog_zoom (WBCGtk *wbcg, Sheet *sheet) { ZoomState *state; GSList *l, *sheets; int i, row, cur_row; gboolean is_custom = TRUE; GtkRadioButton *radio; GtkWidget *focus_target; GladeXML *gui; GtkTreeViewColumn *column; g_return_if_fail (wbcg != NULL); g_return_if_fail (sheet != NULL); if (gnumeric_dialog_raise_if_exists (wbcg, ZOOM_DIALOG_KEY)) return; gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg), "dialog-zoom.glade", NULL, NULL); if (gui == NULL) return; state = g_new (ZoomState, 1); state->wbcg = wbcg; state->gui = gui; state->dialog = glade_xml_get_widget (state->gui, "Zoom"); g_return_if_fail (state->dialog != NULL); /* Get the list of sheets */ state->sheet_list_model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); state->sheet_list = GTK_TREE_VIEW (glade_xml_get_widget (state->gui, "sheet_list")); gtk_tree_view_set_headers_visible (state->sheet_list, FALSE); gtk_tree_view_set_model (state->sheet_list, GTK_TREE_MODEL (state->sheet_list_model)); state->sheet_list_selection = gtk_tree_view_get_selection (state->sheet_list); gtk_tree_selection_set_mode (state->sheet_list_selection, GTK_SELECTION_MULTIPLE); column = gtk_tree_view_column_new_with_attributes (_("Name"), gtk_cell_renderer_text_new (), "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_SHEET_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (state->sheet_list), column); sheets = workbook_sheets (wb_control_get_workbook (WORKBOOK_CONTROL (wbcg))); cur_row = row = 0; for (l = sheets; l; l = l->next) { GtkTreeIter iter; Sheet *this_sheet = l->data; gtk_list_store_append (state->sheet_list_model, &iter); gtk_list_store_set (state->sheet_list_model, &iter, COL_SHEET_NAME, this_sheet->name_unquoted, COL_SHEET_PTR, this_sheet, -1); if (this_sheet == sheet) cur_row = row; row++; } g_slist_free (sheets); { GtkTreePath *path = gtk_tree_path_new_from_indices (cur_row, -1); gtk_tree_view_set_cursor (state->sheet_list, path, NULL, FALSE); gtk_tree_path_free (path); } state->zoom = GTK_SPIN_BUTTON (glade_xml_get_widget (state->gui, "zoom")); g_return_if_fail (state->zoom != NULL); state->custom = GTK_RADIO_BUTTON (glade_xml_get_widget (state->gui, "radio_custom")); g_return_if_fail (state->custom != NULL); focus_target = GTK_WIDGET (state->custom); g_signal_connect (G_OBJECT (state->custom), "clicked", G_CALLBACK (focus_to_custom), (gpointer) state); g_signal_connect (G_OBJECT (state->zoom), "focus_in_event", G_CALLBACK (custom_selected), state); for (i = 0; buttons[i].name != NULL; i++) { radio = GTK_RADIO_BUTTON (glade_xml_get_widget (state->gui, buttons[i].name)); g_return_if_fail (radio != NULL); g_object_set_data (G_OBJECT (radio), ZOOM_DIALOG_FACTOR_KEY, GINT_TO_POINTER(buttons[i].factor)); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (radio_toggled), state); if (((int)(sheet->last_zoom_factor_used * 100. + .5)) == buttons[i].factor) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); is_custom = FALSE; focus_target = GTK_WIDGET (radio); } } if (is_custom) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->custom), TRUE); gtk_spin_button_set_value (state->zoom, (int)(sheet->last_zoom_factor_used * 100. + .5)); } state->ok_button = glade_xml_get_widget (state->gui, "ok_button"); g_signal_connect (G_OBJECT (state->ok_button), "clicked", G_CALLBACK (cb_zoom_ok_clicked), state); state->cancel_button = glade_xml_get_widget (state->gui, "cancel_button"); g_signal_connect (G_OBJECT (state->cancel_button), "clicked", G_CALLBACK (cb_zoom_cancel_clicked), state); gnumeric_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (&state->zoom->entry)); gnumeric_init_help_button ( glade_xml_get_widget (state->gui, "help_button"), GNUMERIC_HELP_LINK_ZOOM); gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog), wbcg, GNM_DIALOG_DESTROY_SHEET_REMOVED); gnumeric_keyed_dialog (wbcg, GTK_WINDOW (state->dialog), ZOOM_DIALOG_KEY); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_zoom_destroy); wbc_gtk_attach_guru (state->wbcg, state->dialog); gtk_widget_show (state->dialog); gtk_widget_grab_focus (focus_target); }
static void questions_tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data); GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv; GPInstructObject *object; GtkTreeIter iter; GtkWidget *scrolled_window, *text_view, *explanation_view, *answer_combobox; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->questions_store), &iter, path)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->questions_store), &iter, DATA_COLUMN, &object, -1); if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object)) { GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object); guint choices_num = gpinstruct_lesson_test_multi_choice_question_get_choices_length (question); GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Question Properties"), GTK_WINDOW (priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); text_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), gpinstruct_lesson_test_multi_choice_question_get_text (question), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Text:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); explanation_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (explanation_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)), gpinstruct_lesson_test_multi_choice_question_get_explanation (question), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), explanation_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Explanation:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); if (choices_num) { answer_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->choices_store)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (answer_combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (answer_combobox), renderer, "text", TITLE_COLUMN, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (answer_combobox), gpinstruct_lesson_test_multi_choice_question_get_answer (question)); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Answer:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), answer_combobox, FALSE, TRUE, 0); } gtk_widget_show_all (content_area); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { GtkTextIter start, end; gchar *text; gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), &start, &end); text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_text (question, text); g_free (text); gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)), &start, &end); text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_explanation (question, text); g_free (text); if (choices_num) gpinstruct_lesson_test_multi_choice_question_set_answer (question, gtk_combo_box_get_active (GTK_COMBO_BOX (answer_combobox))); update_questions_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data)); gpinstruct_editor_window_set_modified (priv->window, TRUE); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->questions_store), &iter, NULL, gtk_tree_path_get_indices (path)[0]); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), &iter); } gtk_widget_destroy (dialog); } } }
static void activate (GApplication *app) { GtkBuilder *builder; GtkWindow *window; GtkWidget *widget; GtkTreeModel *model; GtkTreeIter iter; GError *error = NULL; GtkWidget *sw; GtkWidget *scrollbar; GtkWidget *menu; GtkWidget *item; static GActionEntry win_entries[] = { { "run", activate_run, NULL, NULL, NULL } }; builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, "/ui/main.ui", &error); if (error != NULL) { g_critical ("%s", error->message); exit (1); } window = (GtkWindow *)gtk_builder_get_object (builder, "window"); gtk_application_add_window (GTK_APPLICATION (app), window); g_action_map_add_action_entries (G_ACTION_MAP (window), win_entries, G_N_ELEMENTS (win_entries), window); notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook"); info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview"); source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview"); headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar"); treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview"); model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow"); scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw)); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label ("Start"); g_signal_connect (item, "activate", G_CALLBACK (start_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label ("End"); g_signal_connect (item, "activate", G_CALLBACK (end_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show_all (menu); g_signal_connect (scrollbar, "popup-menu", G_CALLBACK (scrollbar_popup), menu); load_file (gtk_demos[0].name, gtk_demos[0].filename); populate_model (model); g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model); widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection"); g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model); gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter); gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter); gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview)); gtk_widget_show_all (GTK_WIDGET (window)); g_object_unref (builder); }
static void gpinstruct_lesson_test_multi_choice_editor_init (GPInstructLessonTestMultiChoiceEditor *object) { object->priv = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR_GET_PRIVATE (object); GPInstructLessonTestMultiChoiceEditorPrivate *priv = object->priv; priv->questions_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); priv->choices_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); priv->title_label = gtk_label_new (_("Title:")); gtk_table_attach (GTK_TABLE (object), priv->title_label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 3, 3); priv->title_entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (object), priv->title_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL, 3, 3); priv->directions_label = gtk_label_new (_("Directions:")); gtk_table_attach (GTK_TABLE (object), priv->directions_label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 3, 3); GtkWidget *directions_view_scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (directions_view_scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); priv->directions_view = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (directions_view_scrolled_window), priv->directions_view); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (priv->directions_view), GTK_WRAP_WORD_CHAR); gtk_table_attach (GTK_TABLE (object), directions_view_scrolled_window, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 3, 3); priv->explain_label = gtk_label_new (_("Explain:")); gtk_table_attach (GTK_TABLE (object), priv->explain_label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 3, 3); priv->explain_switch = gtk_switch_new (); gtk_table_attach (GTK_TABLE (object), priv->explain_switch, 1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK | GTK_FILL, 3, 3); GtkWidget *questions_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_table_attach (GTK_TABLE (object), questions_hbox, 0, 2, 3, 4, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 3, 3); GtkWidget *questions_tree_view_scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (questions_tree_view_scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (questions_hbox), questions_tree_view_scrolled_window, TRUE, TRUE, 0); priv->questions_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->questions_store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->questions_tree_view), TRUE); gtk_widget_set_events (priv->questions_tree_view, GDK_BUTTON_PRESS_MASK | GDK_KEY_RELEASE_MASK); g_signal_connect (priv->questions_tree_view, "row-activated", G_CALLBACK (questions_tree_view_row_activated), object); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->questions_tree_view)), "changed", G_CALLBACK (questions_tree_selection_changed), object); gtk_container_add (GTK_CONTAINER (questions_tree_view_scrolled_window), priv->questions_tree_view); GtkTreeViewColumn *questions_column = gtk_tree_view_column_new_with_attributes (_("Questions:"), gtk_cell_renderer_text_new (), "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->questions_tree_view), questions_column); GtkWidget *questions_buttonbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (questions_buttonbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (questions_hbox), questions_buttonbox, FALSE, TRUE, 0); GtkWidget *questions_add_button = gtk_button_new_from_stock (GTK_STOCK_ADD); g_signal_connect (questions_add_button, "clicked", G_CALLBACK (questions_add_button_clicked), object); gtk_box_pack_start (GTK_BOX (questions_buttonbox), questions_add_button, FALSE, TRUE, 0); GtkWidget *questions_remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); g_signal_connect (questions_remove_button, "clicked", G_CALLBACK (questions_remove_button_clicked), object); gtk_box_pack_start (GTK_BOX (questions_buttonbox), questions_remove_button, FALSE, TRUE, 0); GtkWidget *choices_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_table_attach (GTK_TABLE (object), choices_hbox, 0, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 3, 3); GtkWidget *choices_tree_view_scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (choices_tree_view_scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (choices_hbox), choices_tree_view_scrolled_window, TRUE, TRUE, 0); priv->choices_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->choices_store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->choices_tree_view), TRUE); gtk_widget_set_events (priv->choices_tree_view, GDK_BUTTON_PRESS_MASK | GDK_KEY_RELEASE_MASK); g_signal_connect (priv->choices_tree_view, "row-activated", G_CALLBACK (choices_tree_view_row_activated), object); gtk_container_add (GTK_CONTAINER (choices_tree_view_scrolled_window), priv->choices_tree_view); GtkTreeViewColumn *choices_column = gtk_tree_view_column_new_with_attributes (_("Choices:"), gtk_cell_renderer_text_new (), "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->choices_tree_view), choices_column); GtkWidget *choices_buttonbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (choices_buttonbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (choices_hbox), choices_buttonbox, FALSE, TRUE, 0); GtkWidget *choices_add_button = gtk_button_new_from_stock (GTK_STOCK_ADD); g_signal_connect (choices_add_button, "clicked", G_CALLBACK (choices_add_button_clicked), object); gtk_box_pack_start (GTK_BOX (choices_buttonbox), choices_add_button, FALSE, TRUE, 0); GtkWidget *choices_remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); g_signal_connect (choices_remove_button, "clicked", G_CALLBACK (choices_remove_button_clicked), object); gtk_box_pack_start (GTK_BOX (choices_buttonbox), choices_remove_button, FALSE, TRUE, 0); }
static void choices_tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data); GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv; GPInstructObject *object; GtkTreeIter iter; GtkWidget *scrolled_window, *text_view; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->choices_store), &iter, path)) { object = questions_tree_view_get_current_data (editor); if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object)) { guint choice = gtk_tree_path_get_indices (path)[0]; GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object); GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Choice Properties"), GTK_WINDOW (priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); text_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), gpinstruct_lesson_test_multi_choice_question_get_choice (question, choice), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Text:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); gtk_widget_show_all (content_area); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { GtkTextIter start, end; gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), &start, &end); gchar *text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_choice (question, choice, text); g_free (text); update_choices_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data)); gpinstruct_editor_window_set_modified (priv->window, TRUE); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->choices_store), &iter, NULL, choice); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), &iter); } gtk_widget_destroy (dialog); } } }
static void gimp_container_popup_create_view (GimpContainerPopup *popup) { GimpEditor *editor; GtkWidget *button; popup->editor = g_object_new (GIMP_TYPE_CONTAINER_EDITOR, "view-type", popup->view_type, "container", popup->container, "context", popup->context, "view-size", popup->view_size, "view-border-width", popup->view_border_width, NULL); gimp_container_view_set_reorderable (GIMP_CONTAINER_VIEW (popup->editor->view), FALSE); if (popup->view_type == GIMP_VIEW_TYPE_LIST) { GtkWidget *search_entry; search_entry = gtk_entry_new (); gtk_box_pack_end (GTK_BOX (popup->editor->view), search_entry, FALSE, FALSE, 0); gtk_tree_view_set_search_entry (GTK_TREE_VIEW (GIMP_CONTAINER_TREE_VIEW (GIMP_CONTAINER_VIEW (popup->editor->view))->view), GTK_ENTRY (search_entry)); gtk_widget_show (search_entry); } gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (popup->editor->view), 6 * (popup->default_view_size + 2 * popup->view_border_width), 10 * (popup->default_view_size + 2 * popup->view_border_width)); if (GIMP_IS_EDITOR (popup->editor->view)) gimp_editor_set_show_name (GIMP_EDITOR (popup->editor->view), FALSE); gtk_container_add (GTK_CONTAINER (popup->frame), GTK_WIDGET (popup->editor)); gtk_widget_show (GTK_WIDGET (popup->editor)); editor = GIMP_EDITOR (popup->editor->view); gimp_editor_add_button (editor, "zoom-out", _("Smaller Previews"), NULL, G_CALLBACK (gimp_container_popup_smaller_clicked), NULL, popup); gimp_editor_add_button (editor, "zoom-in", _("Larger Previews"), NULL, G_CALLBACK (gimp_container_popup_larger_clicked), NULL, popup); button = gimp_editor_add_icon_box (editor, GIMP_TYPE_VIEW_TYPE, "gimp", G_CALLBACK (gimp_container_popup_view_type_toggled), popup); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), popup->view_type); if (popup->dialog_factory) gimp_editor_add_button (editor, popup->dialog_icon_name, popup->dialog_tooltip, NULL, G_CALLBACK (gimp_container_popup_dialog_clicked), NULL, popup); gtk_widget_grab_focus (GTK_WIDGET (popup->editor)); }
extern void MoveListCreate(hintdata * phd) { static const char *aszTitleDetails[] = { N_("Rank"), N_("Type"), N_("Win"), N_("W g"), N_("W bg"), N_("Lose"), N_("L g"), N_("L bg"), NULL, N_("Diff."), N_("Move") }; unsigned int i; int showWLTree = showMoveListDetail && !phd->fDetails; /* Create list widget */ GtkListStore *store; GtkTreeIter iter; GtkTreeSelection *sel; GtkWidget *view = gtk_tree_view_new(); int offset = (phd->fDetails) ? 0 : MIN_COLUMN_COUNT - DETAIL_COLUMN_COUNT; if (showWLTree) { GtkStyle *psDefault = gtk_widget_get_style(view); GtkCellRenderer *renderer = custom_cell_renderer_movelist_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_RANK], renderer, "movelist", 0, "rank", 1, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); g_object_set(renderer, "cell-background-gdk", &psDefault->bg[GTK_STATE_NORMAL], "cell-background-set", TRUE, NULL); g_object_set_data(G_OBJECT(view), "hintdata", phd); } else { GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "ypad", 0, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_RANK], renderer, "text", ML_COL_RANK, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_TYPE], renderer, "text", ML_COL_TYPE, "foreground", ML_COL_FGCOL + offset, NULL); if (phd->fDetails) { gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_WIN], renderer, "text", ML_COL_WIN, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_GWIN], renderer, "text", ML_COL_GWIN, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_BGWIN], renderer, "text", ML_COL_BGWIN, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_LOSS], renderer, "text", ML_COL_LOSS, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_GLOSS], renderer, "text", ML_COL_GLOSS, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_BGLOSS], renderer, "text", ML_COL_BGLOSS, "foreground", ML_COL_FGCOL + offset, NULL); } gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_EQUITY], renderer, "text", ML_COL_EQUITY + offset, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_DIFF], renderer, "text", ML_COL_DIFF + offset, "foreground", ML_COL_FGCOL + offset, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, aszTitleDetails[ML_COL_MOVE], renderer, "text", ML_COL_MOVE + offset, "foreground", ML_COL_FGCOL + offset, NULL); } phd->pwMoves = view; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE); g_signal_connect(view, "row-activated", G_CALLBACK(HintDoubleClick), phd); g_signal_connect(sel, "changed", G_CALLBACK(HintSelect), phd); /* Add empty rows */ if (phd->fDetails) store = gtk_list_store_new(DETAIL_COLUMN_COUNT + 2, 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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); else { if (showWLTree) store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_INT); else store = gtk_list_store_new(MIN_COLUMN_COUNT + 2, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); } for (i = 0; i < phd->pml->cMoves; i++) gtk_list_store_append(store, &iter); gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store)); MoveListUpdate(phd); }
GtkWidget * ip4_routes_dialog_new (NMSettingIP4Config *s_ip4, gboolean automatic) { GtkBuilder *builder; GtkWidget *dialog, *widget, *ok_button; GtkListStore *store; GtkTreeIter model_iter; GtkTreeSelection *selection; gint offset; GtkTreeViewColumn *column; GtkCellRenderer *renderer; int i; GSList *renderers = NULL; GError* error = NULL; /* Initialize temporary storage vars */ g_free (last_edited); last_edited = NULL; last_path = NULL; g_free (last_path); last_column = -1; builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UIDIR "/ce-ip4-routes.ui", &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free (error); return NULL; } dialog = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes_dialog")); if (!dialog) { g_warning ("%s: Couldn't load ip4 routes dialog from .ui file.", __func__); g_object_unref (builder); return NULL; } gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); g_object_set_data_full (G_OBJECT (dialog), "builder", builder, (GDestroyNotify) g_object_unref); ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "ok_button")); store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); /* Add existing routes */ for (i = 0; i < nm_setting_ip4_config_get_num_routes (s_ip4); i++) { NMIP4Route *route = nm_setting_ip4_config_get_route (s_ip4, i); struct in_addr tmp_addr; char ip_string[INET_ADDRSTRLEN]; char *tmp; if (!route) { g_warning ("%s: empty IP4 route structure!", __func__); continue; } gtk_list_store_append (store, &model_iter); tmp_addr.s_addr = nm_ip4_route_get_dest (route);; if (inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string))) gtk_list_store_set (store, &model_iter, COL_ADDRESS, ip_string, -1); tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_route_get_prefix (route)); if (inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string))) gtk_list_store_set (store, &model_iter, COL_PREFIX, ip_string, -1); tmp_addr.s_addr = nm_ip4_route_get_next_hop (route); if (tmp_addr.s_addr && inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string))) gtk_list_store_set (store, &model_iter, COL_NEXT_HOP, ip_string, -1); if (nm_ip4_route_get_metric (route)) { tmp = g_strdup_printf ("%d", nm_ip4_route_get_metric (route)); gtk_list_store_set (store, &model_iter, COL_METRIC, tmp, -1); g_free (tmp); } } widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes")); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store)); g_object_unref (store); /* IP Address column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS)); g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder); renderers = g_slist_append (renderers, renderer); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, _("Address"), renderer, "text", COL_ADDRESS, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* Prefix column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX)); g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder); renderers = g_slist_append (renderers, renderer); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, _("Netmask"), renderer, "text", COL_PREFIX, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* Gateway column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_NEXT_HOP)); g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder); renderers = g_slist_append (renderers, renderer); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, _("Gateway"), renderer, "text", COL_NEXT_HOP, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* Metric column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_METRIC)); g_signal_connect (renderer, "editing-started", G_CALLBACK (uint_cell_editing_started), ok_button); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder); renderers = g_slist_append (renderers, renderer); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, _("Metric"), renderer, "text", COL_METRIC, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); g_object_set_data_full (G_OBJECT (dialog), "renderers", renderers, (GDestroyNotify) g_slist_free); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); g_signal_connect (selection, "changed", G_CALLBACK (list_selection_changed), GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button"))); g_signal_connect (widget, "button-press-event", G_CALLBACK (tree_view_button_pressed_cb), builder); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_add_button")); gtk_widget_set_sensitive (widget, TRUE); g_signal_connect (widget, "clicked", G_CALLBACK (route_add_clicked), builder); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button")); gtk_widget_set_sensitive (widget, FALSE); g_signal_connect (widget, "clicked", G_CALLBACK (route_delete_clicked), builder); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_ignore_auto_routes")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), nm_setting_ip4_config_get_ignore_auto_routes (s_ip4)); gtk_widget_set_sensitive (widget, automatic); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_never_default")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), nm_setting_ip4_config_get_never_default (s_ip4)); /* Update initial validity */ validate (dialog); return dialog; }
static void ft_manager_add_handler_to_list (EmpathyFTManager *manager, EmpathyFTHandler *handler, const GError *error) { GtkTreeRowReference *row_ref; GtkTreeIter iter; GtkTreeSelection *selection; GtkTreePath *path; GIcon *icon; const char *content_type, *second_line; char *first_line, *message; EmpathyFTManagerPriv *priv = GET_PRIV (manager); icon = NULL; /* get the icon name from the mime-type of the file. */ content_type = empathy_ft_handler_get_content_type (handler); if (content_type != NULL) icon = g_content_type_get_icon (content_type); /* append the handler in the store */ gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model), &iter, G_MAXINT, COL_FT_OBJECT, handler, COL_ICON, icon, -1); if (icon != NULL) g_object_unref (icon); /* insert the new row_ref in the hash table */ path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path); gtk_tree_path_free (path); g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler), row_ref); /* select the new row */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); if (error != NULL) { message = ft_manager_format_error_message (handler, error); ft_manager_update_handler_message (manager, row_ref, message); g_free (message); return; } /* update the row with the initial values. * the only case where we postpone this is in case we're managing * an outgoing+hashing transfer, as the hashing started signal will * take care of updating the information. */ if (empathy_ft_handler_is_incoming (handler) || !empathy_ft_handler_get_use_hash (handler)) { first_line = ft_manager_format_contact_info (handler); second_line = _("Waiting for the other participant's response"); message = g_strdup_printf ("%s\n%s", first_line, second_line); ft_manager_update_handler_message (manager, row_ref, message); g_free (first_line); g_free (message); } /* hook up the signals and start the transfer */ ft_manager_start_transfer (manager, handler); }
void ip4_routes_dialog_update_setting (GtkWidget *dialog, NMSettingIP4Config *s_ip4) { GtkBuilder *builder; GtkWidget *widget; GtkTreeModel *model; GtkTreeIter tree_iter; gboolean iter_valid; g_return_if_fail (dialog != NULL); g_return_if_fail (s_ip4 != NULL); builder = g_object_get_data (G_OBJECT (dialog), "builder"); g_return_if_fail (builder != NULL); g_return_if_fail (GTK_IS_BUILDER (builder)); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes")); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter); nm_setting_ip4_config_clear_routes (s_ip4); while (iter_valid) { guint32 addr = 0, prefix = 0, next_hop = 0, metric = 0; NMIP4Route *route; /* Address */ if (!get_one_addr (model, &tree_iter, COL_ADDRESS, TRUE, &addr)) { g_warning ("%s: IPv4 address missing or invalid!", __func__); goto next; } /* Prefix */ if (!get_one_prefix (model, &tree_iter, COL_PREFIX, TRUE, &prefix)) { g_warning ("%s: IPv4 prefix/netmask missing or invalid!", __func__); goto next; } /* Next hop (optional) */ if (!get_one_addr (model, &tree_iter, COL_NEXT_HOP, FALSE, &next_hop)) { g_warning ("%s: IPv4 next hop invalid!", __func__); goto next; } /* Metric (optional) */ if (!get_one_int (model, &tree_iter, COL_METRIC, G_MAXUINT32, FALSE, &metric)) { g_warning ("%s: IPv4 metric invalid!", __func__); goto next; } route = nm_ip4_route_new (); nm_ip4_route_set_dest (route, addr); nm_ip4_route_set_prefix (route, prefix); nm_ip4_route_set_next_hop (route, next_hop); nm_ip4_route_set_metric (route, metric); nm_setting_ip4_config_add_route (s_ip4, route); nm_ip4_route_unref (route); next: iter_valid = gtk_tree_model_iter_next (model, &tree_iter); } widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_ignore_auto_routes")); g_object_set (s_ip4, NM_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)), NULL); widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_never_default")); g_object_set (s_ip4, NM_SETTING_IP4_CONFIG_NEVER_DEFAULT, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)), NULL); }
GtkWidget * do_filtermodel (GtkWidget *do_widget) { static GtkWidget *window; GtkWidget *tree; GtkListStore *store; GtkTreeModel *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; GType types[4]; if (!window) { GtkBuilder *builder; builder = gtk_builder_new_from_resource ("/filtermodel/filtermodel.ui"); gtk_builder_connect_signals (builder, NULL); window = GTK_WIDGET (gtk_builder_get_object (builder, "window1")); gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget)); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); store = (GtkListStore*)gtk_builder_get_object (builder, "liststore1"); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn1"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext1"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (WIDTH_COLUMN), NULL); g_object_set_data (G_OBJECT (cell), "column", GINT_TO_POINTER (WIDTH_COLUMN)); g_signal_connect (cell, "edited", G_CALLBACK (cell_edited), store); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn2"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext2"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (HEIGHT_COLUMN), NULL); g_object_set_data (G_OBJECT (cell), "column", GINT_TO_POINTER (HEIGHT_COLUMN)); g_signal_connect (cell, "edited", G_CALLBACK (cell_edited), store); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn3"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext3"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (WIDTH_COLUMN), NULL); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn4"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext4"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (HEIGHT_COLUMN), NULL); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn5"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext5"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (AREA_COLUMN), NULL); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn6"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrendererpixbuf1"); gtk_tree_view_column_add_attribute (column, cell, "visible", SQUARE_COLUMN); tree = (GtkWidget*)gtk_builder_get_object (builder, "treeview2"); types[WIDTH_COLUMN] = G_TYPE_INT; types[HEIGHT_COLUMN] = G_TYPE_INT; types[AREA_COLUMN] = G_TYPE_INT; types[SQUARE_COLUMN] = G_TYPE_BOOLEAN; model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); gtk_tree_model_filter_set_modify_func (GTK_TREE_MODEL_FILTER (model), G_N_ELEMENTS (types), types, filter_modify_func, NULL, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (tree), model); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn7"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext6"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (WIDTH_COLUMN), NULL); column = (GtkTreeViewColumn*)gtk_builder_get_object (builder, "treeviewcolumn8"); cell = (GtkCellRenderer*)gtk_builder_get_object (builder, "cellrenderertext7"); gtk_tree_view_column_set_cell_data_func (column, cell, format_number, GINT_TO_POINTER (HEIGHT_COLUMN), NULL); tree = (GtkWidget*)gtk_builder_get_object (builder, "treeview3"); model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model), visible_func, NULL, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (tree), model); g_object_unref (builder); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
int mc_show_history (GtkWidget *widget, MCData *mc) { GtkWidget *window; GtkWidget *frame; GtkWidget *scrolled_window; GtkListStore *store; GtkTreeIter iter; GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *cell_renderer; GtkTreeViewColumn *column; GtkRequisition req; gchar *command_list[1]; int i, j; gint x, y, width, height, screen_width, screen_height; /* count commands stored in history list */ for(i = 0, j = 0; i < MC_HISTORY_LIST_LENGTH; i++) if(exists_history_entry(i)) j++; window = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (GTK_WIDGET (mc->applet))); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_COMBO); /* cb */ g_signal_connect_after(GTK_OBJECT(window), "button_press_event", G_CALLBACK(history_popup_clicked_cb), NULL); g_signal_connect_after (G_OBJECT (window), "key_press_event", G_CALLBACK (history_key_press_cb), NULL); /* size */ gtk_widget_set_size_request(GTK_WIDGET(window), 200, 350); /* frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); gtk_widget_show(frame); gtk_container_add(GTK_CONTAINER(window), frame); /* scrollbars */ /* create scrolled window to put the Gtk_list widget inside */ scrolled_window=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); g_signal_connect(GTK_OBJECT(scrolled_window), "button_press_event", G_CALLBACK(history_popup_clicked_inside_cb), NULL); gtk_container_add(GTK_CONTAINER(frame), scrolled_window); gtk_container_set_border_width (GTK_CONTAINER(scrolled_window), 2); gtk_widget_show(scrolled_window); store = gtk_list_store_new (1, G_TYPE_STRING); /* add history entries to list */ if (j == 0) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter,0, _("No items in history"), -1); } else { for(i = 0; i < MC_HISTORY_LIST_LENGTH; i++) { if(exists_history_entry(i)) { command_list[0] = get_history_entry(i); gtk_list_store_prepend (store, &iter); gtk_list_store_set (store, &iter,0,command_list[0],-1); } } } model = GTK_TREE_MODEL(store); treeview = gtk_tree_view_new_with_model (model); g_object_set_data (G_OBJECT (mc->applet), "tree", treeview); cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, cell_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); if (j == 0) { gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_NONE); } else { gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (history_list_button_press_cb), mc); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (history_list_key_press_cb), mc); } g_object_unref (G_OBJECT (model)); gtk_container_add(GTK_CONTAINER(scrolled_window),treeview); gtk_widget_show (treeview); gtk_widget_size_request (window, &req); gdk_window_get_origin (GTK_WIDGET (mc->applet)->window, &x, &y); gdk_window_get_geometry (GTK_WIDGET (mc->applet)->window, NULL, NULL, &width, &height, NULL); switch (mate_panel_applet_get_orient (mc->applet)) { case MATE_PANEL_APPLET_ORIENT_DOWN: y += height; break; case MATE_PANEL_APPLET_ORIENT_UP: y -= req.height; break; case MATE_PANEL_APPLET_ORIENT_LEFT: x -= req.width; break; case MATE_PANEL_APPLET_ORIENT_RIGHT: x += width; break; } screen_width = gdk_screen_width (); screen_height = gdk_screen_height (); x = CLAMP (x - 2, 0, MAX (0, screen_width - req.width)); y = CLAMP (y - 2, 0, MAX (0, screen_height - req.height)); gtk_window_move (GTK_WINDOW (window), x, y); gtk_widget_show(window); /* grab focus */ gdk_pointer_grab (window->window, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK, NULL, NULL, GDK_CURRENT_TIME); gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME); gtk_grab_add(window); gtk_widget_grab_focus (treeview); return FALSE; }
void create_disk_view(GsmApplication *app, GtkBuilder *builder) { GtkScrolledWindow *scrolled; GsmTreeView *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; init_volume_monitor (app); const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "disks_scrolled")); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gsm_tree_view_new (g_settings_get_child (app->settings->gobj(), GSM_SETTINGS_CHILD_DISKS), TRUE); gtk_tree_view_set_model (GTK_TREE_VIEW (disk_tree), GTK_TREE_MODEL (model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); app->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (disk_tree)); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_si_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_si_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); cell = gtk_cell_renderer_progress_new(); gtk_cell_renderer_set_padding(cell, 4.0f, 4.0f); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); /* numeric sort */ gsm_tree_view_load_state (GSM_TREE_VIEW (disk_tree)); g_signal_connect (G_OBJECT(disk_tree), "destroy", G_CALLBACK(cb_disk_list_destroying), app); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), app); g_signal_connect (G_OBJECT (model), "sort-column-changed", G_CALLBACK (cb_sort_changed), app); app->settings->signal_changed(GSM_SETTING_SHOW_ALL_FS).connect ([app](const Glib::ustring&) { disks_update (app); disks_reset_timeout (app); }); gtk_widget_show (GTK_WIDGET (disk_tree)); }
void cardtree_bind_to_treeview(cardtree_t* ct, GtkWidget *view) { ct->_view=GTK_TREE_VIEW(view); gtk_tree_view_set_model(GTK_TREE_VIEW(view),GTK_TREE_MODEL(ct->_store)); }
void zkartmat_create_list (class zkartmat_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); class iceb_clock sss(data->window); GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur; SQLCURSOR cur1; char strsql[1024]; int kolstr=0; SQL_str row; SQL_str row1; short dpk,mpk,gpk; iceb_u_str zagolov; //printf("zkartmat_create_list %d\n",data->snanomer); 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(zkartmat_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(zkartmat_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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); if(data->poi.metka_poi == 0) { data->gpn=data->gn; data->mpn=data->mn; data->dpn=data->dn; gpk=data->gk; mpk=data->mk; dpk=data->dk; } if(data->poi.metka_poi == 1) { iceb_rsdatp(&data->dpn,&data->mpn,&data->gpn,data->poi.datan.ravno(),&dpk,&mpk,&gpk,data->poi.datak.ravno(),data->window); } ostatok data_ost; ostatok data_ostdok; if(data->metka_viv_ost == 0) { ostkarw(data->dpn,data->mpn,data->gpn,dpk,mpk,gpk,data->rk.skl.ravno(),data->rk.n_kart.ravno(),&data_ost); vivostw(0,data->dpn,data->mpn,data->gpn,dpk,mpk,gpk,&zagolov,&data_ost); } if(data->metka_viv_ost == 1) { ostdokw(data->dpn,data->mpn,data->gpn,dpk,mpk,gpk,data->rk.skl.ravno(),data->rk.n_kart.ravno(),&data_ostdok); vivostw(1,data->dpn,data->mpn,data->gpn,dpk,mpk,gpk,&zagolov,&data_ostdok); } gtk_label_set_text(GTK_LABEL(data->label_ost),zagolov.ravno_toutf()); gtk_widget_show(data->label_ost); sprintf(strsql,"select * from Zkart where sklad=%s and nomk=%s and \ datdp >= '%04d-%02d-%02d' and datdp <= '%04d-%02d-%02d' order by datdp asc", data->rk.skl.ravno(),data->rk.n_kart.ravno(),data->gpn,data->mpn,data->dpn,gpk,mpk,dpk); 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; float kolstr1=0.; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); if( zkartmat_prow_row(row,&data->poi,data->window) != 0) continue; //Дата подтверждения ss[COL_DATAP].new_plus(iceb_u_sqldata(row[3])); //Дата документа ss[COL_DATADOK].new_plus(iceb_u_sqldata(row[4])); //Номер документа ss[COL_NOMDOK].new_plus(iceb_u_toutf(row[2])); //читаем шапку документа sprintf(strsql,"select kodop,kontr from Dokummat where datd='%s' and sklad=%s and nomd='%s' \ and tip=%s", row[4],data->rk.skl.ravno(),row[2],row[5]); if(iceb_sql_readkey(strsql,&row1,&cur1,data->window) > 0) { //Код операции ss[COL_KODOP].new_plus(iceb_u_toutf(row1[0])); //Код контрагента ss[COL_KONTR].new_plus(iceb_u_toutf(row1[1])); } else { iceb_u_str repl; repl.plus(gettext("Не найден документ")); repl.plus(" !!!"); repl.ps_plus(row[4]); repl.plus(" "); repl.plus(data->rk.skl.ravno()); repl.plus(" "); repl.plus(row[2]); repl.plus(" "); repl.plus(row[5]); iceb_menu_soob(&repl,data->window); //Код операции ss[COL_KODOP].new_plus(iceb_u_toutf(" ")); //Код контрагента ss[COL_KONTR].new_plus(iceb_u_toutf(" ")); } //количество sprintf(strsql,"%.10g",atof(row[6])); ss[COL_KOLIH].new_plus(strsql); //приход/расход if(row[5][0] == '1') ss[COL_PR].new_plus("+"); else ss[COL_PR].new_plus("-"); //цена sprintf(strsql,"%.10g",atof(row[7])); ss[COL_CENA].new_plus(strsql); ss[COL_DOPNAIM].new_plus(""); sprintf(strsql,"select dnaim from Dokummat1 where sklad=%s and \ nomd='%s' and kodm=%s and nomkar=%s and datd='%s'", data->rk.skl.ravno(),row[2],data->rk.kodm.ravno(),row[1],row[4]); if(sql_readkey(&bd,strsql,&row1,&cur1) > 0) ss[COL_DOPNAIM].new_plus(iceb_u_toutf(row1[0])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[9]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[8],0,data->window)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_DATAP,ss[COL_DATAP].ravno(), COL_DATADOK,ss[COL_DATADOK].ravno(), COL_NOMDOK,ss[COL_NOMDOK].ravno(), COL_KODOP,ss[COL_KODOP].ravno(), COL_KONTR,ss[COL_KONTR].ravno(), COL_KOLIH,ss[COL_KOLIH].ravno(), COL_PR,ss[COL_PR].ravno(), COL_CENA,ss[COL_CENA].ravno(), COL_DOPNAIM,ss[COL_DOPNAIM].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); zkartmat_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),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[FK2]),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); iceb_u_str stroka; data->zagolov.new_plus(gettext("Склад")); data->zagolov.plus(" N"); data->zagolov.plus(data->rk.skl.ravno()); data->zagolov.plus(" "); data->zagolov.plus(data->rk.naimskl.ravno()); data->zagolov.ps_plus(gettext("Просмотр карточки")); data->zagolov.plus(" N"); data->zagolov.plus(data->rk.n_kart.ravno()); //data->zagolov.plus(" "); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); data->zagolov.plus(strsql); if(data->poi.metka_poi == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна data->zagolov.plus(" "); data->zagolov.plus(gettext("Просмотр")); data->zagolov.plus(" "); sprintf(strsql,"%d.%d.%d",data->dn,data->mn,data->gn); data->zagolov.plus(strsql); data->zagolov.plus(" => "); sprintf(strsql,"%d.%d.%d",data->dk,data->mk,data->gk); data->zagolov.plus(strsql); } data->zagolov.ps_plus(data->rk.kodm.ravno()); data->zagolov.plus(" "); data->zagolov.plus(data->rk.naimat.ravno()); if(data->rk.data_kon_is.getdlinna() > 1) { data->zagolov.ps_plus(gettext("Конечная дата использования")); data->zagolov.plus(":"); data->zagolov.plus(data->rk.data_kon_is.ravno()); } data->zagolov.ps_plus(gettext("Группа")); data->zagolov.plus(" N"); data->zagolov.plus(data->rk.kodgr.ravno()); data->zagolov.plus(" "); data->zagolov.plus(data->rk.naimgr.ravno()); sprintf(strsql,"%s:%s",gettext("Счет"),data->rk.shet.ravno()); data->zagolov.ps_plus(strsql); sprintf(strsql," %s:%.10g",gettext("Цена"),data->rk.cena.ravno_atof()); data->zagolov.plus(strsql); sprintf(strsql," %s:%s",gettext("Е/и"),data->rk.ei.ravno()); data->zagolov.plus(strsql); sprintf(strsql," %s:%s",gettext("НДС"),data->rk.nds.ravno()); data->zagolov.plus(strsql); sprintf(strsql," %s:%s",gettext("Кратность"),data->rk.krat.ravno()); data->zagolov.plus(strsql); if(data->rk.nomzak.getdlinna() > 1) { sprintf(strsql," %s:%s",gettext("Номер заказа"),data->rk.nomzak.ravno()); data->zagolov.plus(strsql); } if(data->rk.innom.getdlinna() > 1) { if(data->rk.rnd.getdlinna() > 1) sprintf(strsql," %s:%s",gettext("Серия"),data->rk.innom.ravno()); else sprintf(strsql," %s:%s",gettext("Инв-ный номер"),data->rk.innom.ravno()); data->zagolov.plus(strsql); } if(data->rk.rnd.getdlinna() > 1) { sprintf(strsql," %s:%s",gettext("Рег.N"),data->rk.rnd.ravno()); data->zagolov.plus(strsql); } gtk_label_set_text(GTK_LABEL(data->label_kolstr),data->zagolov.ravno_toutf()); if(data->poi.metka_poi == 1 ) { //При поиске это не работает gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),FALSE);//Недоступна // printf("Формирование заголовка с реквизитами поиска.\n"); data->zagolov_poi.new_plus(gettext("Поиск")); data->zagolov_poi.plus(" !!!"); iceb_str_poisk(&data->zagolov_poi,data->poi.datan.ravno(),gettext("Дата начала")); iceb_str_poisk(&data->zagolov_poi,data->poi.datak.ravno(),gettext("Дата конца")); iceb_str_poisk(&data->zagolov_poi,data->poi.kontr.ravno(),gettext("Код контрагента")); iceb_str_poisk(&data->zagolov_poi,data->poi.kodop.ravno(),gettext("Код операции")); iceb_str_poisk(&data->zagolov_poi,data->poi.nomdok.ravno(),gettext("Номер документа")); if(data->poi.pri_ras == 1) { data->zagolov_poi.ps_plus(gettext("Приход/расход")); data->zagolov_poi.plus(": +"); } if(data->poi.pri_ras == 2) { data->zagolov_poi.ps_plus(gettext("Приход/расход")); data->zagolov_poi.plus(": -"); } gtk_label_set_text(GTK_LABEL(data->label_poisk),data->zagolov_poi.ravno_toutf()); gtk_widget_show(data->label_poisk); } else { gtk_widget_hide(data->label_poisk); gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна } gtk_widget_show(data->label_kolstr); }
int gui_calls_manager_init(SphoneManager *manager) { g_calls_manager.manager=manager; g_calls_manager.main_window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(g_calls_manager.main_window),"Active Calls"); gtk_window_set_deletable(GTK_WINDOW(g_calls_manager.main_window),FALSE); gtk_window_set_default_size(GTK_WINDOW(g_calls_manager.main_window),400,220); GtkWidget *v1=gtk_vbox_new(FALSE,0); GtkWidget *s = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (s), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); g_calls_manager.dials_view = gtk_tree_view_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_calls_manager.dials_view),FALSE); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("Photo", renderer, "pixbuf", GUI_CALLS_COLUMN_PHOTO, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", GUI_CALLS_COLUMN_DESC, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", GUI_CALLS_COLUMN_STATUS, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column); g_calls_manager.dials_store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, SPHONE_TYPE_CALL, G_TYPE_STRING, GDK_TYPE_PIXBUF); gtk_tree_view_set_model(GTK_TREE_VIEW(g_calls_manager.dials_view), GTK_TREE_MODEL(g_calls_manager.dials_store)); GtkWidget *h1=gtk_hbox_new(FALSE, 0); GtkWidget *h2=gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(s), g_calls_manager.dials_view); gtk_container_add(GTK_CONTAINER(v1), s); gtk_box_pack_start(GTK_BOX(v1), h1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(v1), h2, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(g_calls_manager.main_window), v1); gtk_widget_show_all(v1); g_calls_manager.answer_button=gtk_button_new_with_label("\nAnswer\n"); g_calls_manager.answer_waiting_button=gtk_button_new_with_label("\nAnswer\n"); g_calls_manager.activate_button=gtk_button_new_with_label("\nActivate\n"); g_calls_manager.hangup_button=gtk_button_new_with_label("\nHangup\n"); g_calls_manager.mute_button=gtk_button_new_with_label("\nMute ringing\n"); g_calls_manager.speaker_button=gtk_button_new_with_label("\nSpeaker\n"); g_calls_manager.handset_button=gtk_button_new_with_label("\nHandset\n"); gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.activate_button); gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_button); gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_waiting_button); gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.hangup_button); gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.mute_button); gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.speaker_button); gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.handset_button); g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"cursor-changed", G_CALLBACK(gui_calls_select_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"row-activated", G_CALLBACK(gui_calls_double_click_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.activate_button),"clicked", G_CALLBACK(gui_calls_activate_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.answer_button),"clicked", G_CALLBACK(gui_calls_answer_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.answer_waiting_button),"clicked", G_CALLBACK(gui_calls_answer_waiting_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.hangup_button),"clicked", G_CALLBACK(gui_calls_hangup_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.mute_button),"clicked", G_CALLBACK(gui_calls_mute_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.speaker_button),"clicked", G_CALLBACK(gui_calls_speaker_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.handset_button),"clicked", G_CALLBACK(gui_calls_handset_callback),NULL); g_signal_connect(G_OBJECT(g_calls_manager.main_window),"delete-event", G_CALLBACK(return_true),NULL); g_signal_connect(G_OBJECT(manager),"call_added", G_CALLBACK(gui_calls_new_call_callback),NULL); return 0; }
void l_uosamort_create_list (class l_uosamort_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("uosamort_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(l_uosamort_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_uosamort_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_INT); sprintf(strsql,"select * from Uosamor where innom=%d and god >= %d \ order by god,mes asc",data->innom,startgoduos); data->zapros.new_plus(strsql); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } iceb_u_str ss[NUM_COLUMNS]; data->kolzap=0; short mes=0,god=0; while(cur.read_cursor(&row) != 0) { // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); mes=atoi(row[1]); god=atoi(row[2]); sprintf(strsql,"%02d.%d",mes,god); if(iceb_u_SRAV(strsql,data->data_tv.ravno(),0) == 0) data->snanomer=data->kolzap; //ДАТА ss[COL_DATA].new_plus(strsql); //подразделение ss[COL_PODR].new_plus(iceb_u_toutf(row[3])); //ШИФР затрат ss[COL_HZT].new_plus(iceb_u_toutf(row[4])); //Шифр нормы аморт-отчислений ss[COL_HNA].new_plus(iceb_u_toutf(row[5])); //Сумма ss[COL_SUMA].new_plus(atof(row[6])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[8]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[7],0,data->window)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_DATA,ss[COL_DATA].ravno(), COL_SUMA,ss[COL_SUMA].ravno(), COL_PODR,ss[COL_PODR].ravno(), COL_HZT,ss[COL_HZT].ravno(), COL_HNA,ss[COL_HNA].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } data->data_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_uosamort_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); zagolov.new_plus(gettext("Амортизационные отчисления налогового учёта")); zagolov.ps_plus(gettext("Инвентарный номер")); zagolov.plus(":"); zagolov.plus(data->innom); zagolov.plus("/"); zagolov.plus(data->naim.ravno()); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.ps_plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); l_uosamort_bsiz(data); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
/* * Call UpdateMostList to update the movelist in the GTK hint window. * For example, after new evaluations, rollouts or toggle of MWC/Equity. * */ extern void MoveListUpdate(const hintdata * phd) { unsigned int i, j, colNum; char sz[32]; cubeinfo ci; movelist *pml = phd->pml; int col = phd->fDetails ? 8 : 2; int showWLTree = showMoveListDetail && !phd->fDetails; int offset = (phd->fDetails) ? 0 : MIN_COLUMN_COUNT - DETAIL_COLUMN_COUNT; GtkTreeIter iter; GtkListStore *store; store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(phd->pwMoves))); gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter); if (!psHighlight) { /* Get highlight style first time in */ GtkStyle *psTemp; GtkStyle *psMoves = gtk_widget_get_style(phd->pwMoves); GetStyleFromRCFile(&psHighlight, "move-done", psMoves); /* Use correct background colour when selected */ memcpy(&psHighlight->bg[GTK_STATE_SELECTED], &psMoves->bg[GTK_STATE_SELECTED], sizeof(GdkColor)); /* Also get colour to use for w/l stats in detail view */ GetStyleFromRCFile(&psTemp, "move-winlossfg", psMoves); memcpy(&wlCol, &psTemp->fg[GTK_STATE_NORMAL], sizeof(GdkColor)); g_object_unref(psTemp); } /* This function should only be called when the game state matches * the move list. */ g_assert(ms.fMove == 0 || ms.fMove == 1); GetMatchStateCubeInfo(&ci, &ms); rBest = pml->amMoves[0].rScore; if (!showWLTree) gtk_tree_view_column_set_title(gtk_tree_view_get_column(GTK_TREE_VIEW(phd->pwMoves), col), (fOutputMWC && ms.nMatchTo) ? _("MWC") : _("Equity")); for (i = 0; i < pml->cMoves; i++) { float *ar = pml->amMoves[i].arEvalMove; int rankKnown; char *highlight_sz; if (showWLTree) gtk_list_store_set(store, &iter, 0, pml->amMoves + i, -1); else gtk_list_store_set(store, &iter, ML_COL_DATA + offset, pml->amMoves + i, -1); rankKnown = 1; if (i && i == pml->cMoves - 1 && phd->piHighlight && i == *phd->piHighlight) /* The move made is the last on the list. Some moves might * have been deleted to fit this one in */ { /* Lets count how many moves are possible to see if this is the last move */ movelist ml; int dice[2]; memcpy(dice, ms.anDice, sizeof(dice)); if (!dice[0]) { /* If the dice have got lost, try to find them */ moverecord *pmr = (moverecord *) plLastMove->plNext->p; if (pmr) { dice[0] = pmr->anDice[0]; dice[1] = pmr->anDice[1]; } } GenerateMoves(&ml, msBoard(), dice[0], dice[1], FALSE); if (i < ml.cMoves - 1) rankKnown = 0; } highlight_sz = (phd->piHighlight && *phd->piHighlight == i) ? "*" : ""; if (rankKnown) sprintf(sz, "%s%s%d", pml->amMoves[i].cmark ? "+" : "", highlight_sz, i + 1); else sprintf(sz, "%s%s??", pml->amMoves[i].cmark ? "+" : "", highlight_sz); if (showWLTree) { gtk_list_store_set(store, &iter, 1, rankKnown ? (int) i + 1 : -1, -1); goto skipoldcode; } else gtk_list_store_set(store, &iter, ML_COL_RANK, sz, -1); FormatEval(sz, &pml->amMoves[i].esMove); gtk_list_store_set(store, &iter, ML_COL_TYPE, sz, -1); /* gwc */ if (phd->fDetails) { colNum = ML_COL_WIN; for (j = 0; j < 5; j++) { if (j == 3) { gtk_list_store_set(store, &iter, colNum, OutputPercent(1.0f - ar[OUTPUT_WIN]), -1); colNum++; } gtk_list_store_set(store, &iter, colNum, OutputPercent(ar[j]), -1); colNum++; } } /* cubeless equity */ gtk_list_store_set(store, &iter, ML_COL_EQUITY + offset, OutputEquity(pml->amMoves[i].rScore, &ci, TRUE), -1); if (i != 0) { gtk_list_store_set(store, &iter, ML_COL_DIFF + offset, OutputEquityDiff(pml->amMoves[i].rScore, rBest, &ci), -1); } gtk_list_store_set(store, &iter, ML_COL_MOVE + offset, FormatMove(sz, msBoard(), pml->amMoves[i].anMove), -1); /* highlight row */ if (phd->piHighlight && *phd->piHighlight == i) { char buf[20]; sprintf(buf, "#%02x%02x%02x", psHighlight->fg[GTK_STATE_SELECTED].red / 256, psHighlight->fg[GTK_STATE_SELECTED].green / 256, psHighlight->fg[GTK_STATE_SELECTED].blue / 256); gtk_list_store_set(store, &iter, ML_COL_FGCOL + offset, buf, -1); } else gtk_list_store_set(store, &iter, ML_COL_FGCOL + offset, NULL, -1); skipoldcode: /* Messy as 3 copies of code at moment... */ gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter); } }
static void update_module_info_cb(GtkWidget *tree, GtkWidget *parent) { GtkLabel *label; GtkTreeModel *store; GtkTreeSelection *selection; const GwyModuleInfo *mod_info; GtkTreeIter iter; GSList *l; gchar *s, *name; gsize n; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); g_return_if_fail(selection); if (!gtk_tree_selection_get_selected(selection, &store, &iter)) return; gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, MODULE_NAME, &name, -1); mod_info = gwy_module_lookup(name); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "name-version")); s = g_strconcat(mod_info->name, "-", mod_info->version, NULL); gtk_label_set_text(label, s); g_free(s); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "file")); gtk_label_set_text(label, gwy_module_get_filename(name)); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "author")); gtk_label_set_text(label, mod_info->author); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "copy")); gtk_label_set_text(label, mod_info->copyright); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "date")); gtk_label_set_text(label, mod_info->date); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "desc")); gtk_label_set_text(label, _(mod_info->blurb)); label = GTK_LABEL(g_object_get_data(G_OBJECT(parent), "funcs")); n = 0; for (l = gwy_module_get_functions(name); l; l = g_slist_next(l)) n += strlen((gchar*)l->data) + 1; if (!n) gtk_label_set_text(label, ""); else { gchar *p; p = s = g_new(gchar, n); for (l = gwy_module_get_functions(name); l; l = g_slist_next(l)) { p = g_stpcpy(p, (gchar*)l->data); *(p++) = '\n'; } *(--p) = '\0'; gtk_label_set_text(label, s); g_free(s); } g_free(name); }
extern gint MoveListClearSelection(GtkWidget * UNUSED(pw), GdkEventSelection * UNUSED(pes), hintdata * phd) { gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(phd->pwMoves))); return TRUE; }
void ctree_init(void) { GtkTreeView *view = GTK_TREE_VIEW(gfm_widget.tree); GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; gint i; tree = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_INT); model = GTK_TREE_MODEL(tree); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(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, _("Name")); 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", COLUMN_ICON, 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", COLUMN_NAME, "font", COLUMN_FONT, "editable", COLUMN_EDIT, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Attr"), renderer, "pixbuf", COLUMN_ATTR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); for (i = 0; i < CTREE_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, allow_selection, NULL, NULL); ctree_set_basetree(); }
static void home_window_construct (GenesisController *controller) { GtkWidget *window; GtkWidget *hbox, *vbox; GtkWidget *app_treeview, *cat_treeview; GtkWidget *scrolledwindow; GtkTreeModel *app_model, *cat_model; GtkTreeSelection *app_selection, *cat_selection; GtkWidget *textview, *button; GenesisAppEntry *entry = NULL; guint n = 0; GList *cat_list; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Genesis Face"); g_signal_connect (G_OBJECT (window), "delete-event", (GCallback) gtk_main_quit, NULL); hbox = gtk_hbox_new (FALSE,0); gtk_container_add (GTK_CONTAINER (window), hbox); vbox = gtk_vbox_new (FALSE,0); gtk_box_pack_end (GTK_BOX(hbox), vbox, FALSE, FALSE, 0); textview = gtk_text_view_new (); gtk_box_pack_start (GTK_BOX(vbox), textview, FALSE, FALSE, 0); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0); app_treeview = gtk_tree_view_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (app_treeview), -1, "Applications", gtk_cell_renderer_text_new(), "text", 0, NULL); app_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (app_treeview)); gtk_tree_selection_set_mode (app_selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (app_selection), "changed", G_CALLBACK (app_selection_changed_callback), textview); gtk_container_add (GTK_CONTAINER (scrolledwindow), app_treeview); app_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_view_set_model (GTK_TREE_VIEW(app_treeview), app_model); do { entry = genesis_controller_get_nth_entry (controller, n++); if (entry) { gchar *entry_name = genesis_app_entry_get_name (entry); tree_view_append_entry (app_model, entry_name); } }while (entry); cat_list = genesis_controller_get_categories (controller); if (!cat_list) g_print ("failed to get categories list.\n"); else { GList *tmp; scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0); cat_treeview = gtk_tree_view_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (cat_treeview), -1, "Categories", gtk_cell_renderer_text_new(), "text", 0, NULL); cat_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (cat_treeview)); gtk_tree_selection_set_mode (cat_selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (cat_selection), "changed", G_CALLBACK (cat_selection_changed_callback), app_treeview); gtk_container_add (GTK_CONTAINER (scrolledwindow), cat_treeview); cat_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_view_set_model (GTK_TREE_VIEW(cat_treeview), cat_model); tmp = cat_list; while (tmp) { GenesisCategory *category = tmp->data; tree_view_append_entry (cat_model, category->name); tmp = tmp->next; } g_list_free(cat_list); } button = gtk_button_new_with_label ("Start"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (start_button_clicked_callback), app_treeview); gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0); gtk_widget_show_all (window); }