/*! * Set up the dialog. */ GtkWidget * AP_UnixDialog_Spell::_constructWindow (void) { // load the dialog from the UI file #if GTK_CHECK_VERSION(3,0,0) GtkBuilder* builder = newDialogBuilder("ap_UnixDialog_Spell.ui"); #else GtkBuilder* builder = newDialogBuilder("ap_UnixDialog_Spell-2.ui"); #endif m_wDialog = GTK_WIDGET(gtk_builder_get_object(builder, "ap_UnixDialog_Spell")); const XAP_StringSet * pSS = m_pApp->getStringSet(); std::string s; pSS->getValueUTF8(AP_STRING_ID_DLG_Spell_SpellTitle,s); gtk_window_set_title (GTK_WINDOW( m_wDialog), s.c_str()); localizeLabelUnderline(GTK_WIDGET(gtk_builder_get_object(builder, "lbNotInDict")), pSS, AP_STRING_ID_DLG_Spell_UnknownWord); localizeLabelUnderline(GTK_WIDGET(gtk_builder_get_object(builder, "lbChangeTo")), pSS, AP_STRING_ID_DLG_Spell_ChangeTo); m_txWrong = GTK_WIDGET(gtk_builder_get_object(builder, "txWrong")); m_eChange = GTK_WIDGET(gtk_builder_get_object(builder, "eChange")); m_lvSuggestions = GTK_WIDGET(gtk_builder_get_object(builder, "tvSuggestions")); // localise localizeButtonUnderline (GTK_WIDGET(gtk_builder_get_object(builder, "btIgnore")), pSS, AP_STRING_ID_DLG_Spell_Ignore); localizeButtonUnderline (GTK_WIDGET(gtk_builder_get_object(builder, "btIgnoreAll")), pSS, AP_STRING_ID_DLG_Spell_IgnoreAll); localizeButtonUnderline (GTK_WIDGET(gtk_builder_get_object(builder, "btChange")), pSS, AP_STRING_ID_DLG_Spell_Change); localizeButtonUnderline (GTK_WIDGET(gtk_builder_get_object(builder, "btChangeAll")), pSS, AP_STRING_ID_DLG_Spell_ChangeAll); // attach signals g_signal_connect (GTK_WIDGET(gtk_builder_get_object(builder, "btAdd")), "clicked", G_CALLBACK (AP_UnixDialog_Spell__onAddClicked), (gpointer)this); g_signal_connect (GTK_WIDGET(gtk_builder_get_object(builder, "btIgnore")), "clicked", G_CALLBACK (AP_UnixDialog_Spell__onIgnoreClicked), (gpointer)this); g_signal_connect (GTK_WIDGET(gtk_builder_get_object(builder, "btIgnoreAll")), "clicked", G_CALLBACK (AP_UnixDialog_Spell__onIgnoreAllClicked), (gpointer)this); g_signal_connect (GTK_WIDGET(gtk_builder_get_object(builder, "btChange")), "clicked", G_CALLBACK (AP_UnixDialog_Spell__onChangeClicked), (gpointer)this); g_signal_connect (GTK_WIDGET(gtk_builder_get_object(builder, "btChangeAll")), "clicked", G_CALLBACK (AP_UnixDialog_Spell__onChangeAllClicked), (gpointer)this); g_signal_connect (GTK_TREE_VIEW (m_lvSuggestions), "row-activated", G_CALLBACK (AP_UnixDialog_Spell__onSuggestionDblClicked), (gpointer)this); m_replaceHandlerID = g_signal_connect (G_OBJECT(m_eChange), "changed", G_CALLBACK (AP_UnixDialog_Spell__onSuggestionChanged), (gpointer)this); // highlight our misspelled word in red m_highlight.red = 0xffff; m_highlight.green = 0x0000; m_highlight.blue = 0x0000; // Liststore and -view GtkListStore *store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_UINT); gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), GTK_TREE_MODEL (store)); g_object_unref (G_OBJECT (store)); // Column Suggestion GtkCellRenderer *renderer = NULL; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (m_lvSuggestions), -1, "Name", renderer, "text", COLUMN_SUGGESTION, NULL); GtkTreeViewColumn *column = gtk_tree_view_get_column (GTK_TREE_VIEW (m_lvSuggestions), 0); gtk_tree_view_column_set_sort_column_id (column, COLUMN_SUGGESTION); m_listHandlerID = g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)), "changed", G_CALLBACK (AP_UnixDialog_Spell__onSuggestionSelected), (gpointer)this); gtk_widget_show_all (m_wDialog); g_object_unref(G_OBJECT(builder)); return m_wDialog; }
/*--------------------------------СОЗДАНИЕ КОЛОНОК В ДЕРЕВЕ----------------------------------*/ void Amt::ViewSillsImpl::addColumns(GtkTreeView *_view){ GtkTreeViewColumn *col; gint col_offset; GtkCellRenderer *renderer; GtkTreeModel *model = gtk_tree_view_get_model (_view ); /*Столбец название*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.0, NULL); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, " ", renderer, "text", riku::LIMIT_NAME, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Отказ(Макс)*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MAX_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Отказ(макс)", renderer, "text", riku::LIMIT_MAX_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Отказ(Мин)*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MIN_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Отказ(мин)", renderer, "text", riku::LIMIT_MIN_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Предотказ(Макс)*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MAX_PRE_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Предотказ(макс)", renderer, "text", riku::LIMIT_MAX_PRE_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Предотказ(Мин)*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MIN_PRE_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Предотказ(мин)", renderer, "text", riku::LIMIT_MIN_PRE_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Выключен*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_OFF)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Выключен", renderer, "text", riku::LIMIT_OFF, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Отказ по изоляции*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_ISOL_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Отказ по Изоляц.", renderer, "text", riku::LIMIT_ISOL_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*ПредОтказ по изоляции*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_ISOL_PRE_FAULT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Пред.Отказ по Изол.", renderer, "text", riku::LIMIT_ISOL_PRE_FAULT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 150); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Комментарии*/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.0, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_COMMENT)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Коментарии", renderer, "text", riku::LIMIT_COMMENT, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Максимум по Y/ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MAX_Y)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Максимум по Y", renderer, "text", riku::LIMIT_MAX_Y, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Минимум по Y / renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_MIN_Y)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Минимум по Y", renderer, "text", riku::LIMIT_MIN_Y, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); /*Шаг по Y / renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_editedSt), this); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (riku::LIMIT_STEP_Y)); col_offset = gtk_tree_view_insert_column_with_attributes (_view, -1, "Шаг по Y", renderer, "text", riku::LIMIT_STEP_Y, NULL); col = gtk_tree_view_get_column (_view, col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 140); gtk_tree_view_column_set_alignment (GTK_TREE_VIEW_COLUMN (col), 0.5); */ }
void init_right_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree2_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gint i; gtk_tree_view_set_model(view, model2); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COL_PIXBUF, "visible", COL_PIXVIS, NULL); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); /*g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(renderer_toggled), NULL); */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COL_NAME, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "N", renderer, "text", COL_NO, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "M", renderer, "text", COL_MOD, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Y", renderer, "text", COL_YES, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Value"), renderer, "text", COL_VALUE, "editable", COL_EDIT, "foreground-gdk", COL_COLOR, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); column = gtk_tree_view_get_column(view, COL_NAME); gtk_tree_view_column_set_visible(column, show_name); column = gtk_tree_view_get_column(view, COL_NO); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_MOD); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_YES); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_VALUE); gtk_tree_view_column_set_visible(column, show_value); if (resizeable) { for (i = 0; i < COL_VALUE; i++) { column = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(column, TRUE); } } sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); }
void clist_init(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeModel *model = GTK_TREE_MODEL(list); GtkCellRenderer *renderer; GtkTreeSelection *selection; gint i; list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER ); model = GTK_TREE_MODEL(list); 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); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "", renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COLUMN_NAME, 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); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"), renderer, "text", COLUMN_DATE, NULL); for (i = 0; i < CLIST_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); }
GtkWidget * pgd_layers_create_widget (PopplerDocument *document) { PgdLayersDemo *demo; GtkWidget *swindow; GtkWidget *treeview; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkWidget *hpaned, *viewer; demo = g_new0 (PgdLayersDemo, 1); demo->doc = g_object_ref (document); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); viewer = pgd_layers_create_viewer (demo); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = pgd_layers_create_model (document); treeview = gtk_tree_view_new_with_model (model); demo->treeview = treeview; g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 0, "Layer", renderer, "markup", LAYERS_TITLE_COLUMN, NULL); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_object_set (G_OBJECT (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)), "expand", TRUE, NULL); if (GTK_IS_TREE_STORE (model)) { renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 1, "Show/Hide", renderer, "active", LAYERS_VISIBILITY_COLUMN, "activatable", LAYERS_ENABLE_COLUMN, "visible", LAYERS_SHOWTOGGLE_COLUMN, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_layers_visibility_changed), (gpointer)demo); gtk_tree_view_column_set_clickable (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1), TRUE); } gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_NONE); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_paned_add1 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_add2 (GTK_PANED (hpaned), viewer); gtk_widget_show (viewer); gtk_paned_set_position (GTK_PANED (hpaned), 150); g_object_weak_ref (G_OBJECT (hpaned), (GWeakNotify)pgd_layers_free, (gpointer)demo); return hpaned; }
static void add_columns (GtkTreeView *treeview) { gint col_offset; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *model = gtk_tree_view_get_model (treeview); /* column for holiday names */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.0, NULL); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Holiday", renderer, "text", HOLIDAY_NAME_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* alex column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)ALEX_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Alex", renderer, "active", ALEX_COLUMN, "visible", VISIBLE_COLUMN, "activatable", WORLD_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* havoc column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)HAVOC_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Havoc", renderer, "active", HAVOC_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* tim column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)TIM_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Tim", renderer, "active", TIM_COLUMN, "visible", VISIBLE_COLUMN, "activatable", WORLD_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* owen column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)OWEN_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Owen", renderer, "active", OWEN_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* dave column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)DAVE_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Dave", renderer, "active", DAVE_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); }
static GtkTreeViewColumn * input_thumbnail_column (GtkWidget *widget, GdkEventMotion *event) { return gtk_tree_view_get_column (GTK_TREE_VIEW (widget), COL_INPUT_THUMBNAIL); }
static void set_columns_type (GtkTreeView *tree_view, ColumnsType type) { GtkTreeViewColumn *col; GtkCellRenderer *rend; GdkPixbuf *pixbuf; GtkWidget *image; GtkObject *adjustment; current_column_type = type; col = gtk_tree_view_get_column (tree_view, 0); while (col) { gtk_tree_view_remove_column (tree_view, col); col = gtk_tree_view_get_column (tree_view, 0); } gtk_tree_view_set_rules_hint (tree_view, FALSE); switch (type) { case COLUMNS_NONE: break; case COLUMNS_LOTS: /* with lots of columns we need to turn on rules */ gtk_tree_view_set_rules_hint (tree_view, TRUE); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 1", rend, "text", 1, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (col, "Column 2"); rend = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2); rend = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_add_attribute (col, rend, "text", 0); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); gtk_tree_view_set_expander_column (tree_view, col); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 3", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm); image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_widget_show (image); gtk_tree_view_column_set_widget (col, image); rend = gtk_cell_renderer_toggle_new (); /* you could also set this per-row by tying it to a column * in the model of course. */ g_object_set (rend, "radio", TRUE, NULL); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 4", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_spin_new (); adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100); g_object_set (rend, "editable", TRUE, NULL); g_object_set (rend, "adjustment", adjustment, NULL); g_signal_connect (rend, "edited", G_CALLBACK (edited_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 5", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #if 0 rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 6", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 7", rend, "text", 5, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 8", rend, "text", 6, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 9", rend, "text", 7, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 10", rend, "text", 8, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #endif /* FALL THRU */ case COLUMNS_ONE: rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 0", rend, "text", 0, NULL); setup_column (col); gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0); default: break; } }
static VALUE rg_get_column(VALUE self, VALUE num) { return GOBJ2RVAL(gtk_tree_view_get_column(_SELF(self), NUM2INT(num))); }
static void save_got_message(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *d) { struct _save_data *data = d; GtkDialog *dialog; GtkWidget *w, *tree; GtkTreeStore *model; GtkCellRenderer *renderer; /* not found, the mailer will show an error box for this */ if (msg == NULL) { free_data(data); return; } data->msg = msg; camel_object_ref(msg); dialog = (GtkDialog *)gtk_dialog_new_with_buttons(_("Save attachments"), NULL, /* target->parent? */ 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); w = gtk_file_chooser_button_new (_("Select save base name"), GTK_FILE_CHOOSER_ACTION_OPEN); data->entry = w; g_object_set(w, "filechooser_action", GTK_FILE_CHOOSER_ACTION_SAVE, NULL); gtk_widget_show(w); gtk_box_pack_start((GtkBox *)dialog->vbox, w, FALSE, TRUE, 6); g_signal_connect(GTK_FILE_CHOOSER_BUTTON (w), "selection-changed", G_CALLBACK(entry_changed), data); model = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); data->model = model; fill_model(msg, model); tree = gtk_tree_view_new_with_model((GtkTreeModel *)model); data->tree = tree; gtk_widget_show(tree); gtk_tree_view_expand_all((GtkTreeView *)tree); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1, _("MIME Type"), renderer, "text", 1, NULL); gtk_tree_view_set_expander_column((GtkTreeView *)tree, gtk_tree_view_get_column((GtkTreeView *)tree, 0)); renderer = gtk_cell_renderer_toggle_new(); g_object_set(renderer, "activatable", TRUE, NULL); g_signal_connect(renderer, "toggled", G_CALLBACK(toggle_changed), data); gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1, _("Save"), renderer, "active", 0, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1, _("Name"), renderer, "text", 2, NULL); w = g_object_new(gtk_frame_get_type(), "shadow_type", GTK_SHADOW_NONE, "label_widget", g_object_new(gtk_label_get_type(), "label", "<span weight=\"bold\">Attachments</span>", "use_markup", TRUE, "xalign", 0.0, NULL), "child", g_object_new(gtk_alignment_get_type(), "left_padding", 12, "top_padding", 6, "child", g_object_new(gtk_scrolled_window_get_type(), "hscrollbar_policy", GTK_POLICY_AUTOMATIC, "vscrollbar_policy", GTK_POLICY_AUTOMATIC, "shadow_type", GTK_SHADOW_IN, "child", tree, NULL), NULL), NULL); gtk_widget_show_all(w); gtk_box_pack_start((GtkBox *)dialog->vbox, w, TRUE, TRUE, 0); g_signal_connect(dialog, "response", G_CALLBACK(save_response), data); gtk_window_set_default_size((GtkWindow *)dialog, 500, 500); gtk_widget_show((GtkWidget *)dialog); }
void setup_tree_view(struct _properties *properties) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; char strike[200] = { 0 }; char call[200] = { 0 }; char put[200] = { 0 }; // delete previous column names if any... GtkTreeViewColumn *col; while((col = gtk_tree_view_get_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),0)) != NULL) { gtk_tree_view_remove_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),col); } if( option_algorithms[properties->modeltype].assetClass == FUTURES_CLASS ) { //g_print("tree Future detected\n"); if(properties->decimalorcalendar == CALENDAR ) { //g_print("tree CALENDAR future detect\n"); if( properties->spreads == 0 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); } else if( properties->spreads == 1 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (12, 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 ); } gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expiration", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Price", renderer, "text", X2, NULL); //(option_algorithms[properties->modeltype].price, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes // ("Decimal Time", renderer, "text", X4, NULL); ("Years to Expr", renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Ticker", renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( properties->spreads == 1 ) { renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expiration", renderer, "text", X6 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Price", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Years to Expr", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Ticker", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread Ticker", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } return; } if(properties->decimalorcalendar == DECIMALS ) { //g_print("DECIMALS future detect\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Value", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } } if( option_algorithms[properties->modeltype].assetClass == BOND_CLASS ) { g_print("Bonds detected\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } if( option_algorithms[properties->modeltype].assetClass == TERMSTRUCTURE_CLASS ) { g_print("Termstructure detected\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } if( properties->decimalorcalendar == DECIMALS ) { properties->GtkInfo.liststore1 = gtk_list_store_new (14, 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_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Delta", renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Delta", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Gamma", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Vega", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Theta", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Theta", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Rho", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Rho", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Elast", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Elast", renderer, "text", X14, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if(properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS6 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); char textDate[500] = { 0 }; snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS5 ) { properties->GtkInfo.liststore1 = gtk_list_store_new( 10, 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 ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref( properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); char textDate[400] = { 0 }; snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+3)],*(properties->days_to_expiration+3),(double)*(properties->expiration_year+3) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+4)],*(properties->days_to_expiration+4),(double)*(properties->expiration_year+4) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+5)],*(properties->days_to_expiration+5),(double)*(properties->expiration_year+5) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+6)],*(properties->days_to_expiration+6),(double)*(properties->expiration_year+6) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+7)],*(properties->days_to_expiration+7),(double)*(properties->expiration_year+7) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 0 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM )) { properties->GtkInfo.liststore1 = gtk_list_store_new( 17, 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_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref(properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Years to Expr", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Delta", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Delta", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Gamma", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Vega", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Theta", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Theta", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Rho", renderer, "text", X14, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Rho", renderer, "text", X15, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Legacy C", renderer, "text", X16, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Legacy P", renderer, "text", X17, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 1 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM )) { g_print("Spreads for Options\n"); properties->GtkInfo.liststore1 = gtk_list_store_new( 13, 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_STRING ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref(properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread C-C", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread P-P", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread C-P", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread P-C", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } } // void setup_tree_view(struct _properties *properties)
/** * empathy_irc_network_dialog_show: * @network: the #EmpathyIrcNetwork to configure * @parent: the parent of this dialog * * Display a dialog to configure a given #EmpathyIrcNetwork. * This function is a singleton so if a configuration dialog already * exists we use this one to edit the network. * * Returns: The displayed #GtkDialog */ GtkWidget * empathy_irc_network_dialog_show (EmpathyIrcNetwork *network, GtkWidget *parent) { static EmpathyIrcNetworkDialog *dialog = NULL; GtkBuilder *gui; GtkListStore *store; GtkCellRenderer *renderer; GtkAdjustment *adjustment; GtkTreeSelection *selection; GtkTreeViewColumn *column; gchar *filename; g_return_val_if_fail (network != NULL, NULL); if (dialog != NULL) { change_network (dialog, network); gtk_window_present (GTK_WINDOW (dialog->dialog)); return dialog->dialog; } dialog = g_slice_new0 (EmpathyIrcNetworkDialog); dialog->network = network; g_object_ref (dialog->network); filename = empathy_file_lookup ("empathy-account-widget-irc.ui", "libempathy-gtk"); gui = empathy_builder_get_file (filename, "irc_network_dialog", &dialog->dialog, "button_close", &dialog->button_close, "entry_network", &dialog->entry_network, "combobox_charset", &dialog->combobox_charset, "treeview_servers", &dialog->treeview_servers, "button_add", &dialog->button_add, "button_remove", &dialog->button_remove, "button_up", &dialog->button_up, "button_down", &dialog->button_down, NULL); g_free (filename); store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers), GTK_TREE_MODEL (store)); g_object_unref (store); /* address */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_address_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Server"), renderer, "text", COL_ADR, NULL); /* port */ adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16, 1, 10, 0); renderer = gtk_cell_renderer_spin_new (); g_object_set (renderer, "editable", TRUE, "adjustment", adjustment, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (irc_network_dialog_port_edited_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("Port"), renderer, "text", COL_PORT, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers), 1); gtk_tree_view_column_set_expand (column, TRUE); /* SSL */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "activatable", TRUE, NULL); g_signal_connect (renderer, "toggled", G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->treeview_servers), -1, _("SSL"), renderer, "active", COL_SSL, NULL); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (dialog->treeview_servers)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* charset */ totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset)); irc_network_dialog_setup (dialog); empathy_builder_connect (gui, dialog, "irc_network_dialog", "destroy", irc_network_dialog_destroy_cb, "button_close", "clicked", irc_network_dialog_close_clicked_cb, "entry_network", "focus-out-event", irc_network_dialog_network_focus_cb, "button_add", "clicked", irc_network_dialog_button_add_clicked_cb, "button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb, "button_up", "clicked", irc_network_dialog_button_up_clicked_cb, "button_down", "clicked", irc_network_dialog_button_down_clicked_cb, "combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb, NULL); g_object_unref (gui); g_object_add_weak_pointer (G_OBJECT (dialog->dialog), (gpointer) &dialog); g_signal_connect (selection, "changed", G_CALLBACK (irc_network_dialog_selection_changed_cb), dialog); gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent)); gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE); irc_network_dialog_network_update_buttons (dialog); gtk_widget_show_all (dialog->dialog); return dialog->dialog; }
static void _lib_modulelist_populate_callback(gpointer instance, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; if(!self || !(self->data)) return; GtkListStore *store; GtkTreeIter iter; GtkWidget *view = GTK_WIDGET(((dt_lib_modulelist_t *)self->data)->tree); GtkCellRenderer *pix_renderer, *fav_renderer, *text_renderer; GdkRGBA color; GtkStyleContext *context = gtk_widget_get_style_context(view); gboolean color_found = gtk_style_context_lookup_color (context, "selected_bg_color", &color); if(!color_found) { color.red = 1.0; color.green = 0.0; color.blue = 0.0; color.alpha = 1.0; } store = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_POINTER); gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store)); g_object_unref(store); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_MODULE, _lib_modulelist_gui_sort, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_MODULE, GTK_SORT_ASCENDING); pix_renderer = gtk_cell_renderer_pixbuf_new(); g_object_set(pix_renderer, "cell-background-rgba", &color, NULL); fav_renderer = gtk_cell_renderer_pixbuf_new(); cairo_surface_t *fav_cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ICON_SIZE, ICON_SIZE); cairo_t *fav_cr = cairo_create(fav_cst); cairo_set_source_rgb(fav_cr, 0.7, 0.7, 0.7); dtgtk_cairo_paint_modulegroup_favorites(fav_cr, 0, 0, ICON_SIZE, ICON_SIZE, 0); guchar *data = cairo_image_surface_get_data(fav_cst); dt_draw_cairo_to_gdk_pixbuf(data, ICON_SIZE, ICON_SIZE); ((dt_lib_modulelist_t *)self->data)->fav_pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE, 8, ICON_SIZE, ICON_SIZE, cairo_image_surface_get_stride(fav_cst), NULL, NULL); g_object_set(fav_renderer, "cell-background-rgba", &color, NULL); g_object_set(fav_renderer, "width", gdk_pixbuf_get_width(((dt_lib_modulelist_t *)self->data)->fav_pixbuf), NULL); text_renderer = gtk_cell_renderer_text_new(); g_object_set(text_renderer, "cell-background-rgba", &color, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), FALSE); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE); GtkTreeViewColumn *col; col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0); if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col); gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 0, "favorite", fav_renderer, favorite_renderer_function, NULL, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 1); if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col); gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 1, "image", pix_renderer, image_renderer_function, NULL, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 2); if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col); gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 2, "name", text_renderer, text_renderer_function, NULL, NULL); /* go thru list of iop modules and add them to the list */ GList *modules = g_list_last(darktable.iop); char datadir[PATH_MAX] = { 0 }; dt_loc_get_datadir(datadir, sizeof(datadir)); while(modules) { dt_iop_module_so_t *module = (dt_iop_module_so_t *)(modules->data); if(!dt_iop_so_is_hidden(module) && !(module->flags() & IOP_FLAGS_DEPRECATED)) { GdkPixbuf *pixbuf; char filename[PATH_MAX] = { 0 }; snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.svg", datadir, module->op); pixbuf = load_image(filename); if(pixbuf) goto end; snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.png", datadir, module->op); pixbuf = load_image(filename); if(pixbuf) goto end; snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.svg", datadir); pixbuf = load_image(filename); if(pixbuf) goto end; snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.png", datadir); pixbuf = load_image(filename); if(pixbuf) goto end; // wow, we could neither load the SVG nor the PNG files. something is f****d up. pixbuf = gdk_pixbuf_new_from_data(fallback_pixel, GDK_COLORSPACE_RGB, TRUE, 8, 1, 1, 4, NULL, NULL); end: gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, COL_IMAGE, pixbuf, COL_MODULE, module, -1); g_object_unref(pixbuf); } modules = g_list_previous(modules); } }
static void gwy_graph_data_update_ncurves(GwyGraphData *graph_data) { GwyGraphDataCurve *curve; GtkTreeView *treeview; GtkTreeViewColumn *column; GtkWidget *table, *label; guint i, ncolumns, ncurves = 0; ncolumns = graph_data->curves->len; gwy_debug("old ncurves: %d", ncolumns); /* Reconnect all signals just to be sure. * GraphModel is a bit cagey when changes in its curves are regarded */ for (i = 0; i < graph_data->curves->len; i++) { curve = &g_array_index(graph_data->curves, GwyGraphDataCurve, i); gwy_signal_handler_disconnect(curve->gcmodel, curve->changed_id); gwy_object_unref(curve->gcmodel); } g_array_set_size(graph_data->curves, 0); if (graph_data->graph_model) { GwyGraphDataCurve newcurve; ncurves = gwy_graph_model_get_n_curves(graph_data->graph_model); for (i = 0; i < ncurves; i++) { newcurve.gcmodel = gwy_graph_model_get_curve(graph_data->graph_model, i); g_object_ref(newcurve.gcmodel); newcurve.changed_id = g_signal_connect_swapped (newcurve.gcmodel, "data-changed", G_CALLBACK(gwy_graph_data_update_nrows), graph_data); g_array_append_val(graph_data->curves, newcurve); } } gwy_debug("ncurves: %d", ncurves); /* Update the number of columns. */ treeview = GTK_TREE_VIEW(graph_data); while (ncolumns > ncurves) { ncolumns--; gwy_debug("removing column %d", ncolumns); column = gtk_tree_view_get_column(treeview, ncolumns); gtk_tree_view_remove_column(treeview, column); } while (ncolumns < ncurves) { GtkRequisition req; GtkWidget *align; gwy_debug("adding column %d", ncolumns); column = gtk_tree_view_column_new(); g_object_set_qdata(G_OBJECT(column), quark_id, GINT_TO_POINTER(ncolumns)); gwy_graph_data_pack_renderer(graph_data, column, 0); gwy_graph_data_pack_renderer(graph_data, column, 1); table = gtk_table_new(2, 2, TRUE); label = gtk_label_new(NULL); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1); label = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label), COL_WIDTH); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); label = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label), COL_WIDTH); gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2); gtk_widget_show_all(table); gtk_tree_view_column_set_widget(column, table); gtk_widget_size_request(table, &req); g_object_set(column, "sizing", GTK_TREE_VIEW_COLUMN_FIXED, "fixed-width", req.width, NULL); gtk_tree_view_append_column(treeview, column); align = gtk_widget_get_parent(table); /* XXX: The alignment is Gtk+'s private widget. */ if (align && GTK_IS_ALIGNMENT(align)) { g_signal_connect(align, "notify::xscale", G_CALLBACK(fix_xscale), NULL); fix_xscale(align); } ncolumns++; } if (graph_data->graph_model) gwy_graph_data_update_headers(graph_data); if (graph_data->store) gwy_graph_data_update_nrows(graph_data); }
static GtkWidget * key_dialog_treeview_new (GtkWidget *box) { GtkWidget *scroll; GtkListStore *store, *combostore; GtkTreeViewColumn *col; GtkWidget *view; GtkCellRenderer *render; int i; scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); g_return_val_if_fail (store != NULL, NULL); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE); g_signal_connect (G_OBJECT (view), "key-press-event", G_CALLBACK (key_dialog_keypress), NULL); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))), "changed", G_CALLBACK (key_dialog_selection_changed), NULL); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); render = gtk_cell_renderer_accel_new (); g_object_set (render, "editable", TRUE, #ifndef WIN32 "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER, #endif NULL); g_signal_connect (G_OBJECT (render), "accel-edited", G_CALLBACK (key_dialog_set_key), NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN, "Key", render, "text", KEY_COLUMN, NULL); render = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), ACCEL_COLUMN, "Accel", render, "text", ACCEL_COLUMN, NULL); combostore = gtk_list_store_new (1, G_TYPE_STRING); for (i = 0; i <= KEY_MAX_ACTIONS; i++) { GtkTreeIter iter; if (key_actions[i].name[0]) { gtk_list_store_append (combostore, &iter); gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1); } } render = gtk_cell_renderer_combo_new (); g_object_set (G_OBJECT (render), "model", combostore, "has-entry", FALSE, "editable", TRUE, "text-column", 0, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN)); g_signal_connect (G_OBJECT (render), "changed", G_CALLBACK (key_dialog_combo_changed), combostore); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN, "Action", render, "text", ACTION_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D1_COLUMN, "Data1", render, "text", D1_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D2_COLUMN, "Data2", render, "text", D2_COLUMN, NULL); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN); gtk_tree_view_column_set_fixed_width (col, 200); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN); gtk_tree_view_column_set_visible (col, FALSE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN); gtk_tree_view_column_set_fixed_width (col, 160); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); gtk_container_add (GTK_CONTAINER (scroll), view); gtk_container_add (GTK_CONTAINER (box), scroll); return view; }
int fe_dcc_open_recv_win (int passive) { GtkWidget *radio, *table, *vbox, *bbox, *view, *exp, *detailbox; GtkListStore *store; GSList *group; if (dccfwin.window) { if (!passive) mg_bring_tofront (dccfwin.window); return TRUE; } dccfwin.window = mg_create_generic_tab ("Transfers", _(DISPLAY_NAME": Uploads and Downloads"), FALSE, TRUE, close_dcc_file_window, NULL, win_width, win_height, &vbox, 0); gtk_container_set_border_width (GTK_CONTAINER (dccfwin.window), 3); gtk_box_set_spacing (GTK_BOX (vbox), 3); store = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, 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, GDK_TYPE_COLOR); view = gtkutil_treeview_new (vbox, GTK_TREE_MODEL (store), NULL, -1); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); /* Up/Down Icon column */ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, gtk_cell_renderer_pixbuf_new (), "pixbuf", COL_TYPE, NULL); dcc_add_column (view, COL_STATUS, COL_COLOR, _("Status"), FALSE); dcc_add_column (view, COL_FILE, COL_COLOR, _("File"), FALSE); dcc_add_column (view, COL_SIZE, COL_COLOR, _("Size"), TRUE); dcc_add_column (view, COL_POS, COL_COLOR, _("Position"), TRUE); dcc_add_column (view, COL_PERC, COL_COLOR, "%", TRUE); dcc_add_column (view, COL_SPEED, COL_COLOR, "KB/s", TRUE); dcc_add_column (view, COL_ETA, COL_COLOR, _("ETA"), FALSE); dcc_add_column (view, COL_NICK, COL_COLOR, _("Nick"), FALSE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_FILE), TRUE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_NICK), TRUE); dccfwin.list = view; dccfwin.store = store; dccfwin.sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); view_mode = VIEW_BOTH; gtk_tree_selection_set_mode (dccfwin.sel, GTK_SELECTION_MULTIPLE); if (!prefs.hex_gui_tab_utils) g_signal_connect (G_OBJECT (dccfwin.window), "configure_event", G_CALLBACK (dcc_configure_cb), 0); g_signal_connect (G_OBJECT (dccfwin.sel), "changed", G_CALLBACK (dcc_row_cb), NULL); /* double click */ g_signal_connect (G_OBJECT (view), "row-activated", G_CALLBACK (dcc_dclick_cb), NULL); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 16); gtk_box_pack_start (GTK_BOX (vbox), table, 0, 0, 0); radio = gtk_radio_button_new_with_mnemonic (NULL, _("Both")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_BOTH)); gtk_table_attach (GTK_TABLE (table), radio, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Uploads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_UPLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Downloads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_DOWNLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); exp = gtk_expander_new (_("Details")); gtk_table_attach (GTK_TABLE (table), exp, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); detailbox = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (detailbox), 6); gtk_table_set_row_spacings (GTK_TABLE (detailbox), 2); gtk_container_set_border_width (GTK_CONTAINER (detailbox), 6); g_signal_connect (G_OBJECT (exp), "activate", G_CALLBACK (dcc_exp_cb), detailbox); gtk_table_attach (GTK_TABLE (table), detailbox, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); dccfwin.file_label = dcc_detail_label (_("File:"), detailbox, 0); dccfwin.address_label = dcc_detail_label (_("Address:"), detailbox, 1); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 2); dccfwin.abort_button = gtkutil_button (bbox, GTK_STOCK_CANCEL, 0, abort_clicked, 0, _("Abort")); dccfwin.accept_button = gtkutil_button (bbox, GTK_STOCK_APPLY, 0, accept_clicked, 0, _("Accept")); dccfwin.resume_button = gtkutil_button (bbox, GTK_STOCK_REFRESH, 0, resume_clicked, 0, _("Resume")); dccfwin.open_button = gtkutil_button (bbox, 0, 0, browse_dcc_folder, 0, _("Open Folder...")); gtk_widget_set_sensitive (dccfwin.accept_button, FALSE); gtk_widget_set_sensitive (dccfwin.resume_button, FALSE); gtk_widget_set_sensitive (dccfwin.abort_button, FALSE); dcc_fill_window (3); gtk_widget_show_all (dccfwin.window); gtk_widget_hide (detailbox); return FALSE; }
static void set_up (EmpathyGroupsWidget *self) { EmpathyGroupsWidgetPriv *priv; GtkWidget *label, *alignment; GtkBox *vbox, *hbox; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; guint col_offset; GtkScrolledWindow *scrolled_window; gchar *markup; priv = GET_PRIV (self); /* Set up ourself */ gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL); gtk_box_set_spacing (GTK_BOX (self), 6); /* Create our child widgets */ label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); markup = g_strdup_printf ("<b>%s</b>", _("Groups")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_box_pack_start (GTK_BOX (self), label, FALSE, FALSE, 0); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6)); label = gtk_label_new (_("Select the groups you want this contact to appear " "in. Note that you can select more than one group or no groups.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (vbox, label, FALSE, FALSE, 0); gtk_widget_show (label); hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12)); priv->add_group_entry = gtk_entry_new (); g_signal_connect (priv->add_group_entry, "changed", (GCallback) add_group_entry_changed_cb, self); g_signal_connect (priv->add_group_entry, "activate", (GCallback) add_group_entry_activate_cb, self); gtk_box_pack_start (hbox, priv->add_group_entry, TRUE, TRUE, 0); gtk_widget_show (priv->add_group_entry); priv->add_group_button = gtk_button_new_with_mnemonic (_("_Add Group")); gtk_widget_set_sensitive (priv->add_group_button, FALSE); gtk_widget_set_receives_default (priv->add_group_button, TRUE); g_signal_connect (priv->add_group_button, "clicked", (GCallback) add_group_button_clicked_cb, self); gtk_box_pack_start (hbox, priv->add_group_button, FALSE, FALSE, 0); gtk_widget_show (priv->add_group_button); gtk_box_pack_start (vbox, GTK_WIDGET (hbox), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (hbox)); scrolled_window = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL)); gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (scrolled_window, GTK_SHADOW_IN); gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100); priv->group_store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, /* name */ G_TYPE_BOOLEAN, /* enabled */ G_TYPE_BOOLEAN); /* editable */ tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model ( GTK_TREE_MODEL (priv->group_store))); gtk_tree_view_set_headers_visible (tree_view, FALSE); gtk_tree_view_set_enable_search (tree_view, FALSE); selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", (GCallback) cell_toggled_cb, self); column = gtk_tree_view_column_new_with_attributes ( C_("verb in a column header displaying group names", "Select"), renderer, "active", COL_ENABLED, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (column, 50); gtk_tree_view_append_column (tree_view, column); renderer = gtk_cell_renderer_text_new (); col_offset = gtk_tree_view_insert_column_with_attributes (tree_view, -1, _("Group"), renderer, "text", COL_NAME, /* "editable", COL_EDITABLE, */ NULL); column = gtk_tree_view_get_column (tree_view, col_offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_NAME); gtk_tree_view_column_set_resizable (column, FALSE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->group_store), COL_NAME, GTK_SORT_ASCENDING); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view)); gtk_widget_show (GTK_WIDGET (tree_view)); gtk_box_pack_start (vbox, GTK_WIDGET (scrolled_window), TRUE, TRUE, 0); gtk_widget_show (GTK_WIDGET (scrolled_window)); gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox)); gtk_widget_show (GTK_WIDGET (vbox)); gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0); gtk_widget_show (alignment); }
int main (int argc, char **argv) { int i; GtkWidget *window; GtkWidget *vbox; GtkWidget *combo_box; GtkWidget *sw; GtkWidget *tree_view; GtkWidget *button; gtk_init (&argc, &argv); /* Window and box */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 640, 480); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_add (GTK_CONTAINER (window), vbox); /* Option menu contents */ combo_box = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), NO_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), SINGLE_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), MULTI_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), LAST_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), BORDER_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), ALL_EXPAND); gtk_box_pack_start (GTK_BOX (vbox), combo_box, FALSE, FALSE); /* Scrolled window and tree view */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE); tree_view = gtk_tree_view_new_with_model (create_model ()); gtk_container_add (GTK_CONTAINER (sw), tree_view); for (i = 0; i < 5; i++) { GtkTreeViewColumn *column; gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), i, "Header", gtk_cell_renderer_text_new (), "text", i, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), i); gtk_tree_view_column_set_resizable (column, TRUE); } /* Toggle button for long content row */ button = gtk_toggle_button_new_with_label ("Toggle long content row"); g_signal_connect (button, "toggled", G_CALLBACK (toggle_long_content_row), tree_view); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE); /* Set up option menu callback and default item */ g_signal_connect (combo_box, "changed", G_CALLBACK (combo_box_changed), tree_view); gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); /* Done */ gtk_widget_show_all (window); gtk_main (); return 0; }
static PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; #if !GTK_CHECK_VERSION (3, 0, 0) GtkWidget *vbox; #endif GtkWidget *inner_vbox; GtkWidget *find_hbox; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; dialog = g_new0 (PanelAddtoDialog, 1); g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel), panel_addto_dialog_quark, dialog, (GDestroyNotify) panel_addto_dialog_free); dialog->panel_widget = panel_widget; g_signal_connect (dialog->panel_widget->toplevel->settings, "changed::" PANEL_TOPLEVEL_NAME_KEY, G_CALLBACK (panel_addto_name_notify), dialog); dialog->addto_dialog = gtk_dialog_new (); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_GO_BACK, PANEL_ADDTO_RESPONSE_BACK); dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_ADD, PANEL_ADDTO_RESPONSE_ADD); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog), PANEL_ADDTO_RESPONSE_ADD); gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog)); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); #else gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2); #endif g_signal_connect (G_OBJECT (dialog->addto_dialog), "response", G_CALLBACK (panel_addto_dialog_response), dialog); g_signal_connect (dialog->addto_dialog, "destroy", G_CALLBACK (panel_addto_dialog_destroy), dialog); #if !GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (dialog_vbox), vbox); #endif inner_vbox = gtk_vbox_new (FALSE, 6); #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); #else gtk_box_pack_start (GTK_BOX (vbox), inner_vbox, TRUE, TRUE, 0); #endif find_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0); dialog->label = gtk_label_new_with_mnemonic (""); gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5); gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE); gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label, FALSE, FALSE, 0); dialog->search_entry = gtk_entry_new (); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (panel_addto_search_entry_changed), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (panel_addto_search_entry_activated), dialog); gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label), dialog->search_entry); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0); dialog->tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "xpad", 4, "ypad", 4, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "markup", COLUMN_TEXT, NULL); //FIXME use the same search than the one for the search entry? gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_SEARCH); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view), panel_addto_separator_func, GINT_TO_POINTER (COLUMN_TEXT), NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_TEXT); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect (selection, "changed", G_CALLBACK (panel_addto_selection_changed), dialog); g_signal_connect (dialog->tree_view, "row-activated", G_CALLBACK (panel_addto_selection_activated), dialog); gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_show_all (dialog_vbox); #else gtk_widget_show_all (vbox); #endif panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel); panel_widget_register_open_dialog (panel_widget, dialog->addto_dialog); panel_addto_name_change (dialog, panel_toplevel_get_name (dialog->panel_widget->toplevel)); return dialog; }
static GtkTreeStore* ctree_create(GtkWidget *widget) { GtkTreeView *view = GTK_TREE_VIEW(widget); GtkTreeStore *store; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; gint i; store = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, -1 ); model = GTK_TREE_MODEL(store); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, TRUE); // col 1 renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Name", renderer, "text", COL_NAME, "font", COL_FONT, NULL); // col 2 column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, "Value"); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "visible", COL_BTNVIS, NULL); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(renderer_toggled), widget); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_VALUE, "editable", COL_EDIT, "font", COL_FONT, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), widget); // col 3 renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Address", renderer, "text", COL_ADDR, "font", COL_FONT, NULL); // col 4 renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Mask", renderer, "text", COL_MASK, "font", COL_FONT, 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_SINGLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); return store; }
int main(int argc, char *argv[]) { GtkWidget *main_window, *scroll; GtkWidget *treeview; GtkTreeViewColumn *column; GtkCellRenderer *name_renderer, *size_renderer; GtkTreeStore *store; GtkTreeIter categories[14]; GValue value = { 0, }; gint offset; uint32 res_counts[14]; uint32 res_sizes[14]; int i; Common::File in; uint32 index_pos; uint32 pos, len; gtk_init(&argc, &argv); if (argc != 2) { printf("Usage: %s filename\n", argv[0]); return EXIT_FAILURE; } in.open(argv[1], "rb"); if (!in.isOpen()) { printf("Couldn't open %s for reading\n", argv[1]); return EXIT_FAILURE; } /* Create the main window, scrollable in both directions */ main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer"); gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* Create the tree view */ for (i = 0; i < ARRAYSIZE(res_counts); i++) { res_counts[i] = 0; res_sizes[i] = 0; } store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); index_pos = in.readUint32LE(); in.seek(index_pos, SEEK_SET); for (;;) { GtkTreeIter iter; byte type; gchar *utf8_name; gchar name[34]; gchar *size; try { pos = in.readUint32LE(); len = in.readUint32LE(); } catch (...) { break; } size = make_size(len); index_pos = in.pos(); in.seek(pos, SEEK_SET); type = in.readByte(); in.readByte(); /* compType */ in.readUint32LE(); /* compSize */ in.readUint32LE(); /* decompSize */ in.read_noThrow(name, sizeof(name)); /* * We need to convert from Latin-1 to UTF-8. Otherwise the text * "CAFÉ" won't be displayed properly. */ utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); if (!res_counts[type]) { gtk_tree_store_append(store, &categories[type], NULL); gtk_tree_store_set(store, &categories[type], NAME_COLUMN, getType(type), SIZE_COLUMN, "", TYPE_COLUMN, -1, POSITION_COLUMN, -1, LENGTH_COLUMN, -1, -1); } res_counts[type]++; res_sizes[type] += len; gtk_tree_store_append(store, &iter, &categories[type]); gtk_tree_store_set(store, &iter, NAME_COLUMN, utf8_name, SIZE_COLUMN, size, TYPE_COLUMN, type, POSITION_COLUMN, pos, LENGTH_COLUMN, len); in.seek(index_pos, SEEK_SET); } in.close(); for (i = 0; i < ARRAYSIZE(res_counts); i++) { if (res_counts[i]) { gchar size[80]; sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]); gtk_tree_store_set(store, &categories[i], SIZE_COLUMN, size, -1); } } treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]); /* The view now holds a reference. We can get rid of our own. */ g_object_unref(G_OBJECT(store)); name_renderer = gtk_cell_renderer_text_new(); size_renderer = gtk_cell_renderer_text_new(); g_value_init(&value, G_TYPE_FLOAT); g_value_set_float(&value, 1.0); g_object_set_property(G_OBJECT(size_renderer), "xalign", &value); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Name", name_renderer, "text", NAME_COLUMN, NULL); offset = gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Size", size_renderer, "text", SIZE_COLUMN, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1); gtk_tree_view_column_set_alignment(column, 1.0); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview)); gtk_container_add(GTK_CONTAINER(main_window), scroll); gtk_widget_show_all(GTK_WIDGET(main_window)); gtk_main(); return EXIT_SUCCESS; }
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; }
void clist_refresh(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeSelection *selection; GtkTreeViewColumn *col; GtkTreeIter iter; GdkPixbuf *pix1, *pix2, *pix; GList *dirlist; gsize br, bw; gchar *utf8; int i; if(working_mode & MODE_CMD) return; // reparse folders tilp_local_selection_destroy(); tilp_dirlist_local(); selection = gtk_tree_view_get_selection(view); g_signal_handlers_block_by_func(G_OBJECT(selection), tree_selection_changed, NULL); gtk_list_store_clear(list); g_signal_handlers_unblock_by_func(G_OBJECT(selection), tree_selection_changed, NULL); // sort files for(i = 0; i < CLIST_NVCOLS; i++) { col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_sort_indicator(col, FALSE); } switch (options.local_sort) { case SORT_BY_NAME: tilp_file_sort_by_name(); col = gtk_tree_view_get_column(view, COLUMN_NAME); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_TYPE: tilp_file_sort_by_type(); col = gtk_tree_view_get_column(view, COLUMN_TYPE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_DATE: tilp_file_sort_by_date(); col = gtk_tree_view_get_column(view, COLUMN_DATE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; case SORT_BY_SIZE: tilp_file_sort_by_size(); col = gtk_tree_view_get_column(view, COLUMN_SIZE); gtk_tree_view_column_set_sort_indicator(col, TRUE); gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING); break; } pix2 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL); pix1 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU, NULL); for (dirlist = local.dirlist; dirlist != NULL; dirlist = dirlist->next) { FileEntry *fe = (FileEntry *) dirlist->data; gboolean b; CalcModel s = tifiles_file_get_model(fe->name); CalcModel t = options.calc_model; b = options.show_all || S_ISDIR(fe->attrib) || tifiles_file_is_tib(fe->name) || #if 0 tifiles_file_is_tigroup(fe->name) || #else tifiles_file_test(fe->name, TIFILE_TIGROUP, options.calc_model) || #endif tifiles_calc_are_compat(s, t); if(!b) continue; if (S_ISDIR(fe->attrib)) { pix = strcmp(fe->name, "..") ? pix2 : pix1; } else { char icon_name[2048]; strcpy(icon_name, tifiles_file_get_icon(fe->name)); if (!strcmp(icon_name, "")) strcpy(icon_name, "TIicon1"); strcat(icon_name, ".ico"); tilp_file_underscorize(icon_name); pix = create_pixbuf(icon_name); } // filenames are stored in the 'glib filename encoding' and GTK+ uses utf8 utf8 = g_filename_to_utf8(fe->name, -1, &br, &bw, NULL); gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, COLUMN_NAME, utf8, COLUMN_TYPE, tilp_file_get_type(fe), COLUMN_SIZE, tilp_file_get_size(fe), COLUMN_DATE, tilp_file_get_date(fe), COLUMN_DATA, (gpointer) fe, COLUMN_ICON, pix, -1); g_free(utf8); } g_object_unref(pix1); g_object_unref(pix2); }
/* * 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); } }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }
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 auth_methods_setup (GtkBuilder *builder, GHashTable *hash) { GtkWidget *widget; GtkListStore *store; GtkTreeIter iter; const char *value; gboolean allowed; gboolean use_mppe = FALSE; GtkCellRendererToggle *check_renderer; GtkCellRenderer *text_renderer; GtkTreeViewColumn *column; gint offset; gboolean mschap_state = TRUE; gboolean mschap2_state = TRUE; store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT, G_TYPE_BOOLEAN); /* Check for MPPE */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE); if (value && !strcmp (value, "yes")) use_mppe = TRUE; /* Or MPPE-128 */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_128); if (value && !strcmp (value, "yes")) use_mppe = TRUE; /* Or MPPE-40 */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_40); if (value && !strcmp (value, "yes")) use_mppe = TRUE; /* PAP */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_PAP); allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE; if (use_mppe) allowed = FALSE; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_NAME, _("PAP"), COL_VALUE, allowed, COL_TAG, TAG_PAP, COL_SENSITIVE, !use_mppe, -1); /* CHAP */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_CHAP); allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE; if (use_mppe) allowed = FALSE; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_NAME, _("CHAP"), COL_VALUE, allowed, COL_TAG, TAG_CHAP, COL_SENSITIVE, !use_mppe, -1); /* MSCHAP */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAP); allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE; mschap_state = allowed; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_NAME, _("MSCHAP"), COL_VALUE, allowed, COL_TAG, TAG_MSCHAP, COL_SENSITIVE, TRUE, -1); /* MSCHAPv2 */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAPV2); allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE; mschap2_state = allowed; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_NAME, _("MSCHAPv2"), COL_VALUE, allowed, COL_TAG, TAG_MSCHAPV2, COL_SENSITIVE, TRUE, -1); /* EAP */ value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_EAP); allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE; if (use_mppe) allowed = FALSE; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_NAME, _("EAP"), COL_VALUE, allowed, COL_TAG, TAG_EAP, COL_SENSITIVE, !use_mppe, -1); /* Set up the tree view */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_auth_methods")); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store)); check_renderer = GTK_CELL_RENDERER_TOGGLE (gtk_cell_renderer_toggle_new ()); g_signal_connect (check_renderer, "toggled", G_CALLBACK (check_toggled_cb), builder); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, "", GTK_CELL_RENDERER (check_renderer), "active", COL_VALUE, "sensitive", COL_SENSITIVE, "activatable", COL_SENSITIVE, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 30); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); text_renderer = gtk_cell_renderer_text_new (); offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget), -1, "", text_renderer, "text", COL_NAME, "sensitive", COL_SENSITIVE, 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); /* Make sure MPPE is non-sensitive if MSCHAP and MSCHAPv2 are disabled */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_use_mppe")); if (!mschap_state && !mschap2_state) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_widget_set_sensitive (widget, FALSE); } else gtk_widget_set_sensitive (widget, TRUE); }
static GtkWidget * ignore_treeview_new (GtkWidget *box) { GtkListStore *store; GtkWidget *view; GtkTreeViewColumn *col; GtkCellRenderer *render; int col_id; store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); g_return_val_if_fail (store != NULL, NULL); view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL, MASK_COLUMN, _("Mask"), CHAN_COLUMN, _("Channel"), PRIV_COLUMN, _("Private"), NOTICE_COLUMN, _("Notice"), CTCP_COLUMN, _("CTCP"), DCC_COLUMN, _("DCC"), INVITE_COLUMN, _("Invite"), UNIGNORE_COLUMN, _("Unignore"), -1); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), TRUE); /* attach to signals and customise columns */ for (col_id=0; (col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_id)); col_id++) { GList *list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); GList *tmp; for (tmp = list; tmp; tmp = tmp->next) { render = static_cast<GtkCellRenderer*>(tmp->data); if (col_id > 0) /* it's a toggle button column */ { g_signal_connect (render, "toggled", G_CALLBACK (option_toggled), GINT_TO_POINTER (col_id)); } else /* mask column */ { g_object_set (G_OBJECT (render), "editable", TRUE, NULL); g_signal_connect (render, "edited", G_CALLBACK (mask_edited), NULL); /* make this column sortable */ gtk_tree_view_column_set_sort_column_id (col, col_id); gtk_tree_view_column_set_min_width (col, 272); } /* centre titles */ gtk_tree_view_column_set_alignment (col, 0.5); } g_list_free (list); } gtk_widget_show (view); return view; }
static void create_unused_field_tree_view(GtkWidget *unused_field_tree_view) { /* GtkTreeModel *child_model = GTK_TREE_MODEL(user_data);*/ GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *child_model; int i; /* Construct empty list storage */ child_model = gtk_list_store_new(7, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); g_object_set_data(G_OBJECT(child_model), "selection_list", NULL); /* ソート用のモデルを作成してツリービューにセットする */ model = gtk_tree_model_sort_new_with_model(child_model); gtk_tree_view_set_model(GTK_TREE_VIEW(unused_field_tree_view), model); /* First raw */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(unused_field_tree_view), column); gtk_tree_view_column_set_title(column, "Index"); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_FIELD_INDEX, NULL); g_object_set(renderer, "width", (gint)60, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_clickable(column, TRUE); g_object_set_data(G_OBJECT(column), "unused_column_id", GINT_TO_POINTER(COLUMN_FIELD_INDEX)); g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(unused_column_clicked), unused_field_tree_view); /* Second row */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(unused_field_tree_view), column); gtk_tree_view_column_set_title(column, "Field name"); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_FIELD_NAME, NULL); g_object_set(renderer, "width", (gint)150, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_clickable(column, TRUE); g_object_set_data(G_OBJECT(column), "unused_column_id", GINT_TO_POINTER(COLUMN_FIELD_NAME)); g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(unused_column_clicked), unused_field_tree_view); /* 選択モード */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(unused_field_tree_view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* 1行毎に背景色を変更 */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(unused_field_tree_view), TRUE); /* ソート */ column = gtk_tree_view_get_column(GTK_TREE_VIEW(unused_field_tree_view), COLUMN_FIELD_INDEX); gtk_tree_view_column_set_sort_order(column, GTK_SORT_ASCENDING); gtk_tree_view_column_set_sort_indicator(column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), COLUMN_FIELD_INDEX, GTK_SORT_ASCENDING); /*init_model_data(unused_field_tree_view);*/ for(i=0;i<NUM_FIELD;i++){ if(all_fld_list[i]->iflag_use == 0) {append_model_data(i, child_model);}; } }
static void refresh_page(int page, int offset) { GtkNotebook *nb = GTK_NOTEBOOK(notebook); GtkWidget *tab; GtkWidget *label; G_CONST_RETURN gchar *text; uint32_t addr, len = DUMP_SIZE; GList *l, *elt; GtkWidget *list; GtkTreeView *view; GtkTreeModel *model; GtkListStore *store; gchar *str; gint i; // retrieve addr by tab name tab = gtk_notebook_get_nth_page(nb, page); label = gtk_notebook_get_tab_label(nb, tab); text = gtk_label_get_text(GTK_LABEL(label)); // get list pointer (we have 1 child) l = gtk_container_get_children(GTK_CONTAINER(nb)); elt = g_list_nth(l, page); list = GTK_WIDGET(elt->data); view = GTK_TREE_VIEW(list); model = gtk_tree_view_get_model(view); store = GTK_LIST_STORE(model); // get new address sscanf(text, "%x", &addr); len = DUMP_SIZE; addr += offset; addr &= 0xffffff; // refresh only if mem changed (speed-up) #ifndef FORCE_REFRESH if(!offset) { static uint8_t old_array[DUMP_SIZE] = { 0 }; gint diff = 0; // can't use memcmp due to banking for(i = 0; i < DUMP_SIZE; i++) { uint8_t old = old_array[i]; uint8_t mem = mem_rd_byte(addr + i); if(old != mem) { old = mem; diff = !0; } } if(!diff) return; } #endif // refresh tab str = g_strdup_printf("%06x", addr); gtk_label_set_text(GTK_LABEL(label), str); g_free(str); // and list clist_refresh(store, addr, len <= DUMP_SIZE ? len : DUMP_SIZE); // set column for(i = COL_0; i <= COL_F; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); str = g_strdup_printf("%X", (addr + i - 1) & 0xf); gtk_tree_view_column_set_title(col, str); g_free(str); } }