static void dialog_kaplan_meier_tool_setup_treeview (KaplanMeierToolState *state) { guint i; GtkCellRenderer *renderer; GtkWidget *scrolled = glade_xml_get_widget (state->base.gui, "groups-scrolled"); GtkTreeSelection *selection; state->groups_treeview = GTK_TREE_VIEW (glade_xml_get_widget (state->base.gui, "groups-tree")); state->groups_list = gtk_list_store_new (GROUP_COLUMNS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_OBJECT, G_TYPE_OBJECT); state->groups_treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->groups_list))); selection = gtk_tree_view_get_selection (state->groups_treeview); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); for (i = 0; i<2; i++) dialog_kaplan_meier_tool_treeview_add_item (state, i); g_signal_connect (selection, "changed", G_CALLBACK (cb_selection_changed), state); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL); gtk_tree_view_insert_column_with_attributes (state->groups_treeview, -1, _("Group"), renderer, "text", GROUP_NAME, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cb_group_name_edited), state); renderer = gtk_cell_renderer_spin_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, "xalign", 1.0, "digits", 0, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cb_change_from), state); gtk_tree_view_insert_column_with_attributes (state->groups_treeview, -1, _("From"), renderer, "text", GROUP_FROM, "adjustment", GROUP_ADJUSTMENT_FROM, NULL); renderer = gtk_cell_renderer_spin_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, "xalign", 1.0, "digits", 0, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cb_change_to), state); gtk_tree_view_insert_column_with_attributes (state->groups_treeview, -1, _("To"), renderer, "text", GROUP_TO, "adjustment", GROUP_ADJUSTMENT_TO, NULL); gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->groups_treeview)); cb_selection_changed (selection, state); }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *hbox, *page_selector, *area_hbox; GtkWidget *button; GtkWidget *swindow, *textview, *treeview; GtkTreeSelection *selection; GtkWidget *frame, *alignment, *table; GtkWidget *hpaned; GtkCellRenderer *renderer; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x1, TRUE, TRUE, 0); gtk_widget_show (demo->area_x1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y1, TRUE, TRUE, 0); gtk_widget_show (demo->area_y1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x2, TRUE, TRUE, 0); gtk_widget_show (demo->area_x2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y2, TRUE, TRUE, 0); gtk_widget_show (demo->area_y2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); pgd_text_area_selector_setup (demo); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->treeview = treeview; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X1_COLUMN, "X1", renderer, "text", TEXT_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y1_COLUMN, "Y1", renderer, "text", TEXT_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X2_COLUMN, "X2", renderer, "text", TEXT_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y2_COLUMN, "Y2", renderer, "text", TEXT_Y2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_OFFSET_COLUMN, "Offset", renderer, "text", TEXT_OFFSET_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (selection, "changed", G_CALLBACK (pgd_text_selection_changed), (gpointer) demo); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Text attributes */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Text Attributes</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); demo->font_name = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Name:</b>", demo->font_name, &row); demo->font_size = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Size:</b>", demo->font_size, &row); demo->is_underlined = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Underlined:</b>", demo->is_underlined, &row); demo->text_color = gtk_image_new (); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Color:</b>", demo->text_color, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 12); gtk_widget_show (frame); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); g_signal_connect (textview, "query-tooltip", G_CALLBACK (pgd_text_view_query_tooltip), demo); g_signal_connect (demo->buffer, "notify::has-selection", G_CALLBACK (pgd_text_buffer_selection_changed), textview); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
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); }
static void moko_history_load_entries (MokoHistory *history) { MokoHistoryPrivate *priv; GtkListStore *store; GtkTreeModel *sorted; GtkTreeModel *filtered; GtkCellRenderer *renderer; MokoJournalEntry *entry; gint i, j, n_entries; GList *entries = NULL, *e; g_return_if_fail (MOKO_IS_HISTORY (history)); priv = history->priv; /* Create renderer and column */ renderer = jana_gtk_cell_renderer_note_new (); g_object_set (G_OBJECT (renderer), "show_created", FALSE, "show_recipient", FALSE, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview), 0, NULL, renderer, "author", DISPLAY_TEXT_COLUMN, "body", CALL_DETAILS_COLUMN, "icon", ICON_NAME_COLUMN, NULL); g_signal_connect (priv->treeview, "size-allocate", G_CALLBACK (jana_gtk_utils_treeview_resize), renderer); /* Set up the list store */ store = gtk_list_store_new (7, G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); priv->main_model = GTK_TREE_MODEL (store); sorted = gtk_tree_model_sort_new_with_model (priv->main_model); priv->sort_model = sorted; gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sorted), DSTART_COLUMN, GTK_SORT_DESCENDING); /* Set up the filtered column */ filtered = gtk_tree_model_filter_new (sorted, NULL); priv->filter_model = filtered; gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered), (GtkTreeModelFilterVisibleFunc) moko_history_filter_visible_func, history, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), filtered); g_signal_connect (priv->journal, "entry_added", G_CALLBACK (on_entry_added_cb), (gpointer)history); n_entries = moko_journal_get_nb_entries (priv->journal); if (n_entries < 1) { g_debug ("The Journal is empty"); return; } i = j = 0; for (i = 0; i < n_entries; i++) { moko_journal_get_entry_at (priv->journal, i, &entry); /* We are not interested in anything other than voice entries */ if (moko_journal_entry_get_entry_type (entry) != VOICE_JOURNAL_ENTRY) continue; entries = g_list_insert_sorted (entries, (gpointer)entry, (GCompareFunc)sort_by_date); } for (e = entries; e != NULL; e = e->next) { if (history_add_entry (store, e->data)) j++; } }
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_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_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_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_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_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); }
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; }
/*************************** * * * Encodings dialog window * * * **************************/ void gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data) { GtkBuilder *builder; GtkWidget *dialog; GtkListStore *list_store; GtkTreeStore *tree_store; GtkTreeIter iter, parent, *parent_ptr; GList *encodings_bak, *enc_iter; const gchar *encoding; system_encoding_type *system_enc; gpointer enc_ptr; gint i, j; builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "Encodings Dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Encodings Dialog")); data->encodings_dialog = dialog; gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant)); data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry")); /* set up selected encodings list */ data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view")); list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next) { encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding, ENC_COL_QUARK, enc_iter->data, -1); } gtk_tree_view_insert_column_with_attributes ( data->selected_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->selected_encs_view, GTK_TREE_MODEL (list_store)); g_object_unref (list_store); /* set up system encodings list */ data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (i = 0, system_enc = system_encodings; i < n_system_encodings; i++, system_enc++) { if (i == 0) { /* first system encoding */ parent_ptr = NULL; } else { parent_ptr = &iter; for (j = 0; j < system_enc->parent; j++) if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store), &parent, &iter)) { /* go up one level */ iter = parent; } else { /* no parent to toplevel element */ parent_ptr = NULL; } } if (system_enc->encoding) enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding)); else enc_ptr = NULL; gtk_tree_store_append (tree_store, &iter, parent_ptr); gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING, gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1); } gtk_tree_view_insert_column_with_attributes ( data->available_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->available_encs_view, GTK_TREE_MODEL (tree_store)); g_object_unref (tree_store); /* run the dialog */ encodings_bak = g_list_copy (data->encodings); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { g_list_free (encodings_bak); if (!g_list_find (data->encodings, GUINT_TO_POINTER (data->default_encoding))) { /* choose top level encoding then */ data->default_encoding = GPOINTER_TO_UINT (data->encodings->data); } /* update whole page */ gxi_check_file (data); gxi_update_default_enc_combo (data); gxi_update_string_box (data); gxi_update_conversion_forward (data); } else { g_list_free (data->encodings); data->encodings = encodings_bak; } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy (dialog); data->encodings_dialog = NULL; }
static void plugin_stats_construct(GtkWidget * container) { gchar *path = gmpc_get_full_glade_path("preferences-plugins.ui"); plugin_stat_xml = gtk_builder_new(); gtk_builder_add_from_file(plugin_stat_xml, path, NULL); q_free(path); if (plugin_stat_xml) { GtkWidget *tree = (GtkWidget *) gtk_builder_get_object(plugin_stat_xml, "plugin_stats_tree"); GtkListStore *store = NULL; GtkTreeIter iter; GtkCellRenderer *renderer = NULL; int i = 0; GtkWidget *vbox = (GtkWidget *) gtk_builder_get_object(plugin_stat_xml, "plugin_stats_vbox"); /** * new */ store = gtk_list_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_toggle_new(); g_object_set_data(G_OBJECT(renderer), "editable", GINT_TO_POINTER(1)); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, _("Enabled"), renderer, "active", 0, NULL); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(pref_plugin_enabled), store); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, _("Name"), renderer, "text", 1, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, _("Function"), renderer, "text", 2, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, _("Version"), renderer, "text", 4, NULL); for (i = 0; i < num_plugins; i++) { if (!gmpc_plugin_is_internal(plugins[i])) { const gchar *translation_domain = gmpc_plugin_get_translation_domain(plugins[i]); const int *ver = gmpc_plugin_get_version(plugins[i]); gchar *version = (ver) ? g_strdup_printf("%i.%i.%i", ver[0], ver[1], ver[2]) : g_strdup("n/a"); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, TRUE, #if defined(ENABLE_NLS) && GLIB_CHECK_VERSION(2,18,0) 1, g_dgettext(translation_domain, gmpc_plugin_get_name(plugins[i])), #else 1, gmpc_plugin_get_name(plugins[i]), #endif 3, (plugins[i]), 4, version, -1); g_free(version); if (gmpc_plugin_get_enabled(plugins[i])) { gtk_list_store_set(store, &iter, 0, TRUE, -1); } else gtk_list_store_set(store, &iter, 0, FALSE, -1); switch (gmpc_plugin_get_type(plugins[i])) { case GMPC_PLUGIN_DUMMY: gtk_list_store_set(store, &iter, 2, _("Dummy"), -1); break; case GMPC_PLUGIN_PL_BROWSER: gtk_list_store_set(store, &iter, 2, _("Browser Extension"), -1); break; case GMPC_PLUGIN_META_DATA: gtk_list_store_set(store, &iter, 2, _("Metadata Provider"), -1); break; case GMPC_PLUGIN_PL_BROWSER | GMPC_PLUGIN_META_DATA: gtk_list_store_set(store, &iter, 2, _("Metadata Provider and Browser Extension"), -1); break; case GMPC_PLUGIN_NO_GUI: gtk_list_store_set(store, &iter, 2, _("Misc."), -1); break; case GMPC_INTERNALL: case GMPC_DEPRECATED: default: gtk_list_store_set(store, &iter, 2, _("Unknown"), -1); break; } } } gtk_container_add(GTK_CONTAINER(container), vbox); } }
void ephy_permissions_dialog_add_tab (EphyPermissionsDialog *dialog, const char *type, const char *title) { EphyPermissionsDialogPrivate *priv = dialog->priv; GtkWidget *hbox, *view, *vbuttonbox, *button; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeView *treeview; GtkTreeViewColumn *column; GtkTreeSelection *selection; DialogTab *tab; tab = g_new0 (DialogTab, 1); tab->dialog = dialog; tab->type = g_strdup (type); tab->qtype = g_quark_from_string (type); tab->filled = FALSE; priv->tabs = g_list_prepend (priv->tabs, tab); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); g_object_set_data (G_OBJECT (hbox), TAB_DATA_KEY, tab); view = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_NEVER /* FIXME? */, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), view, TRUE, TRUE, 0); tab->store = store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); tab->model = GTK_TREE_MODEL (store); tab->treeview = treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (tab->model)); g_object_unref (store); g_signal_connect (treeview, "key-press-event", G_CALLBACK (treeview_key_press_event_cb), tab); gtk_tree_view_set_headers_visible (treeview, TRUE); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (treeview, COL_HOST, _("Domain"), renderer, "text", COL_HOST, NULL); column = gtk_tree_view_get_column (treeview, COL_HOST); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sort_column_id (column, COL_HOST); gtk_tree_view_insert_column_with_attributes (treeview, COL_PERM, _("State"), renderer, "text", COL_PERM, NULL); column = gtk_tree_view_get_column (treeview, COL_PERM); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sort_column_id (column, COL_PERM); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (treeview)); tab->selection = selection = gtk_tree_view_get_selection (treeview); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); g_signal_connect (selection, "changed", G_CALLBACK (treeview_selection_changed_cb), tab); /* Button box */ vbuttonbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (hbox), vbuttonbox, FALSE, FALSE, 0); /* Remove button */ tab->remove_button = button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); g_signal_connect (button, "clicked", G_CALLBACK (remove_button_clicked_cb), tab); gtk_box_pack_start (GTK_BOX (vbuttonbox), button, FALSE, FALSE, 0); gtk_size_group_add_widget (priv->buttons_size_group, button); gtk_widget_show_all (hbox); /* And finally insert it in the notebook */ gtk_notebook_append_page (priv->notebook, hbox, gtk_label_new (title)); }
static void log_window_find_setup (EmpathyLogWindow *window) { GtkTreeView *view; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeSortable *sortable; GtkTreeViewColumn *column; GtkListStore *store; GtkCellRenderer *cell; gint offset; view = GTK_TREE_VIEW (window->treeview_find); selection = gtk_tree_view_get_selection (view); /* New store */ store = gtk_list_store_new (COL_FIND_COUNT, G_TYPE_STRING, /* account icon name */ G_TYPE_STRING, /* account name */ TP_TYPE_ACCOUNT, /* account */ G_TYPE_STRING, /* chat name */ G_TYPE_STRING, /* chat id */ G_TYPE_BOOLEAN, /* is chatroom */ G_TYPE_STRING, /* date */ G_TYPE_STRING); /* date_readable */ model = GTK_TREE_MODEL (store); sortable = GTK_TREE_SORTABLE (store); gtk_tree_view_set_model (view, model); /* New column */ column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "icon-name", COL_FIND_ACCOUNT_ICON); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_FIND_ACCOUNT_NAME); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_append_column (view, column); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); cell = gtk_cell_renderer_text_new (); offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"), cell, "text", COL_FIND_CHAT_NAME, NULL); column = gtk_tree_view_get_column (view, offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); cell = gtk_cell_renderer_text_new (); offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"), cell, "text", COL_FIND_DATE_READABLE, NULL); column = gtk_tree_view_get_column (view, offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); /* Set up treeview properties */ gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gtk_tree_sortable_set_sort_column_id (sortable, COL_FIND_DATE, GTK_SORT_ASCENDING); /* Set up signals */ g_signal_connect (selection, "changed", G_CALLBACK (log_window_find_changed_cb), window); g_object_unref (store); }
static void finish_setup (CEPageIP4 *self, gpointer unused, GError *error, gpointer user_data) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeSelection *selection; gint offset; GtkTreeViewColumn *column; GtkCellRenderer *renderer; if (error) return; populate_ui (self); /* 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), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_ADDRESS] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Address"), renderer, "text", COL_ADDRESS, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), 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); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_ADDRESS), NULL); /* Prefix/netmask column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_PREFIX] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Netmask"), renderer, "text", COL_PREFIX, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), 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); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_PREFIX), NULL); /* Gateway column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self); g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_GATEWAY)); g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), self); g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), self); priv->addr_cells[COL_GATEWAY] = GTK_CELL_RENDERER (renderer); offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list, -1, _("Gateway"), renderer, "text", COL_GATEWAY, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), 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); gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func, GUINT_TO_POINTER (COL_GATEWAY), NULL); g_signal_connect (priv->addr_list, "button-press-event", G_CALLBACK (tree_view_button_pressed_cb), self); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), TRUE); gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), FALSE); g_signal_connect (priv->addr_add, "clicked", G_CALLBACK (addr_add_clicked), self); g_signal_connect (priv->addr_delete, "clicked", G_CALLBACK (addr_delete_clicked), priv->addr_list); selection = gtk_tree_view_get_selection (priv->addr_list); g_signal_connect (selection, "changed", G_CALLBACK (list_selection_changed), priv->addr_delete); g_signal_connect_swapped (priv->dns_servers, "changed", G_CALLBACK (ce_page_changed), self); g_signal_connect (priv->dns_servers, "insert-text", G_CALLBACK (dns_servers_filter_cb), self); g_signal_connect_swapped (priv->dns_searches, "changed", G_CALLBACK (ce_page_changed), self); method_changed (priv->method, self); g_signal_connect (priv->method, "changed", G_CALLBACK (method_changed), self); g_signal_connect_swapped (priv->dhcp_client_id, "changed", G_CALLBACK (ce_page_changed), self); g_signal_connect_swapped (priv->ip4_required, "toggled", G_CALLBACK (ce_page_changed), self); g_signal_connect (priv->routes_button, "clicked", G_CALLBACK (routes_button_clicked_cb), self); }
static void add_tree_view (CajaColumnChooser *chooser) { GtkWidget *scrolled; GtkWidget *view; GtkListStore *store; GtkCellRenderer *cell; GtkTreeSelection *selection; view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (store)); g_object_unref (store); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_connect (selection, "changed", G_CALLBACK (selection_changed_callback), chooser); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (visible_toggled_callback), chooser); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, cell, "active", COLUMN_VISIBLE, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, cell, "text", COLUMN_LABEL, NULL); chooser->details->view = GTK_TREE_VIEW (view); chooser->details->store = store; gtk_widget_show (view); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (GTK_WIDGET (scrolled)); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_box_pack_start (GTK_BOX (chooser), scrolled, TRUE, TRUE, 0); }
/*! * Fill the GUI tree with the styles as defined in the XP tree. */ void AP_UnixDialog_Stylist::_fillTree(void) { Stylist_tree * pStyleTree = getStyleTree(); if(pStyleTree == NULL) { updateDialog(); pStyleTree = getStyleTree(); } if(pStyleTree->getNumRows() == 0) { updateDialog(); pStyleTree = getStyleTree(); } UT_DEBUGMSG(("Number of rows of styles in document %d \n",pStyleTree->getNumRows())); if(m_wRenderer) { // g_object_unref (G_OBJECT (m_wRenderer)); gtk_widget_destroy (m_wStyleList); } GtkTreeIter iter; GtkTreeIter child_iter; GtkTreeSelection *sel; UT_sint32 row,col, page; m_wModel = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); page = 0; UT_UTF8String sTmp(""); for(row= 0; row < pStyleTree->getNumRows();row++) { gtk_tree_store_append (m_wModel, &iter, NULL); if(!pStyleTree->getNameOfRow(sTmp,row)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); break; } if(pStyleTree->getNumCols(row) > 0) { xxx_UT_DEBUGMSG(("Adding Heading %s at row %d \n",sTmp.utf8_str(),row)); gtk_tree_store_set (m_wModel, &iter, 0, sTmp.utf8_str(), 1, row,2,0, -1); for(col =0 ; col < pStyleTree->getNumCols(row); col++) { gtk_tree_store_append (m_wModel, &child_iter, &iter); if(!pStyleTree->getStyleAtRowCol(sTmp,row,col)) { UT_ASSERT(UT_SHOULD_NOT_HAPPEN); break; } gtk_tree_store_set (m_wModel, &child_iter, 0, sTmp.utf8_str(), 1, row,2,col+1, -1); xxx_UT_DEBUGMSG(("Adding style %s at row %d col %d \n",sTmp.utf8_str(),row,col+1)); page++; } } else { xxx_UT_DEBUGMSG(("Adding style %s at row %d \n",sTmp.utf8_str(),row)); gtk_tree_store_set (m_wModel, &iter, 0, sTmp.utf8_str(), 1,row,2,0,-1); page++; } } // create a new treeview m_wStyleList = gtk_tree_view_new_with_model (GTK_TREE_MODEL (m_wModel)); g_object_unref (G_OBJECT (m_wModel)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (m_wStyleList), true); // get the current selection sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_wStyleList)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function (sel, tree_select_filter, NULL, NULL); const XAP_StringSet * pSS = m_pApp->getStringSet (); m_wRenderer = gtk_cell_renderer_text_new (); UT_UTF8String s; pSS->getValueUTF8(AP_STRING_ID_DLG_Stylist_Styles,s); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (m_wStyleList), -1, s.utf8_str(), m_wRenderer, "text", 0, NULL); gtk_tree_view_collapse_all (GTK_TREE_VIEW (m_wStyleList)); gtk_container_add (GTK_CONTAINER (m_wStyleListContainer), m_wStyleList); g_signal_connect_after(G_OBJECT(m_wStyleList), "cursor-changed", G_CALLBACK(s_types_clicked), static_cast<gpointer>(this)); g_signal_connect_after(G_OBJECT(m_wStyleList), "row-activated", G_CALLBACK(s_types_dblclicked), static_cast<gpointer>(this)); gtk_widget_show_all(m_wStyleList); setStyleTreeChanged(false); }
static void tree_gui_init_treeview(tree_gui_t *gui) { //GtkTooltips *tooltips; GtkTreeViewColumn *column; GtkCellRenderer *renderer; /* Get tooltips engine */ //tooltips = gtk_object_get_data(GTK_OBJECT(gui->window), "tooltips"); /* Create test tree */ gui->tree_model = gtk_tree_store_new(TREE_GUI_NCOLS, /* TREE_GUI_COL_TYPE_PIXBUF */ GDK_TYPE_PIXBUF, /* TREE_GUI_COL_NAME */ G_TYPE_STRING, /* TREE_GUI_COL_BRKPT_PIXBUF */ GDK_TYPE_PIXBUF, /* TREE_GUI_COL_BRKPT */ G_TYPE_INT, /* TREE_GUI_COL_FLAGS_PIXBUF */ GDK_TYPE_PIXBUF, /* TREE_GUI_COL_SKIP */ G_TYPE_INT, /* TREE_GUI_COL_VERDICT_PIXBUF */ GDK_TYPE_PIXBUF, /* TREE_GUI_COL_CRITICITY */ G_TYPE_STRING, /* TREE_GUI_COL_CRITICITY_COLOR */ G_TYPE_STRING, /* TREE_GUI_COL_BACKGROUND */ GDK_TYPE_COLOR, /* TREE_GUI_COL_STYLE */ PANGO_TYPE_STYLE, /* TREE_GUI_COL_KEY */ G_TYPE_ULONG, /* TREE_GUI_COL_OBJECT */ G_TYPE_POINTER); gui->tree_view = GTK_TREE_VIEW(lookup_widget(gui->window, "tree_view")); gtk_tree_view_set_model(gui->tree_view, GTK_TREE_MODEL(gui->tree_model)); /* Setup tree selection handler */ gui->tree_selection = gtk_tree_view_get_selection(gui->tree_view); gtk_tree_selection_set_mode(gui->tree_selection, GTK_SELECTION_SINGLE); gtk_tree_selection_set_select_function(gui->tree_selection, (GtkTreeSelectionFunc) tree_gui_select, gui, NULL); /* Set up row activation handler */ gtk_signal_connect(GTK_OBJECT(gui->tree_view), "row-activated", GTK_SIGNAL_FUNC(tree_gui_row_activated), gui); /* Column #0: breakpoint flag */ renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Brk", renderer, "pixbuf", TREE_GUI_COL_BRKPT_PIXBUF, "cell-background-gdk", TREE_GUI_COL_BACKGROUND, NULL); /* Setup breakpoints clear button */ column = gtk_tree_view_get_column(gui->tree_view, 0); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_clickable(column, TRUE); // TODO: gtk_tooltips_set_tip (tooltips, w, "Clear all breakpoints", NULL); gtk_signal_connect_object(GTK_OBJECT(column), "clicked", GTK_SIGNAL_FUNC(tree_gui_breakpoint_clear_clicked), gui); /* Column #1: Node pix and name */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Test Tree"); gtk_tree_view_column_set_expand(column, TRUE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_TYPE_PIXBUF); gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND); renderer = gtk_cell_renderer_text_new(); //gtk_object_set(GTK_OBJECT(renderer), "family", "Monospace", NULL); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_NAME); gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND); gtk_tree_view_column_add_attribute(column, renderer, "style", TREE_GUI_COL_STYLE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column(gui->tree_view, column); gtk_tree_view_set_expander_column(gui->tree_view, column); /* Setup selection clear button */ gtk_tree_view_column_set_clickable(column, TRUE); // TODO: gtk_tooltips_set_tip (tooltips, w, "Clear selection", NULL); gtk_signal_connect_object(GTK_OBJECT(column), "clicked", GTK_SIGNAL_FUNC(tree_gui_unselect), gui); /* Column #2: runtime flag */ renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(gui->tree_view, -1, "Flg", renderer, "pixbuf", TREE_GUI_COL_FLAGS_PIXBUF, "cell-background-gdk", TREE_GUI_COL_BACKGROUND, NULL); /* Column #3: verdict and criticity */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Verdict"); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", TREE_GUI_COL_VERDICT_PIXBUF); gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND); renderer = gtk_cell_renderer_text_new(); gtk_object_set(GTK_OBJECT(renderer), "scale", 0.6, NULL); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", TREE_GUI_COL_CRITICITY); gtk_tree_view_column_add_attribute(column, renderer, "foreground", TREE_GUI_COL_CRITICITY_COLOR); gtk_tree_view_column_add_attribute(column, renderer, "cell-background-gdk", TREE_GUI_COL_BACKGROUND); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(gui->tree_view, column); }
GtkWidget * pgd_forms_create_widget (PopplerDocument *document) { PgdFormsDemo *demo; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; gchar *str; gint n_pages; demo = g_new0 (PgdFormsDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_forms_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Forms Fields"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_forms_get_form_fields), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No form fields found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_hpaned_new (); demo->field_view = pgd_form_field_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 0, "Form Field Type", renderer, "text", FORMS_FIELD_TYPE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 1, "Form Field Id", renderer, "text", FORMS_ID_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 2, "Read Only", renderer, "active", FORMS_READ_ONLY_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 3, "X1", renderer, "text", FORMS_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 4, "Y1", renderer, "text", FORMS_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 5, "X2", renderer, "text", FORMS_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 6, "Y2", renderer, "text", FORMS_Y2_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_forms_selection_changed), (gpointer)demo); 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), demo->field_view); gtk_widget_show (demo->field_view); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_forms_free, demo); return vbox; }
/* Main UI */ GtkWidget * pgd_annots_create_widget (PopplerDocument *document) { PgdAnnotsDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *button; GtkWidget *hbox, *page_selector; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkListStore *model; GtkTreeIter iter; gchar *str; gint n_pages; gint i; demo = g_new0 (PgdAnnotsDemo, 1); demo->doc = g_object_ref (document); demo->cursor = GDK_LAST_CURSOR; demo->mode = MODE_NORMAL; n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_annots_page_selector_value_changed), (gpointer) demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); demo->remove_button = gtk_button_new_with_mnemonic ("_Remove"); gtk_widget_set_sensitive (demo->remove_button, FALSE); g_signal_connect (G_OBJECT (demo->remove_button), "clicked", G_CALLBACK (pgd_annots_remove_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), demo->remove_button, FALSE, FALSE, 6); gtk_widget_show (demo->remove_button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_mnemonic ("_Add"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_annots_start_add_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); model = gtk_list_store_new(SELECTED_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < G_N_ELEMENTS (supported_annots); i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, SELECTED_TYPE_COLUMN, supported_annots[i].type, SELECTED_LABEL_COLUMN, supported_annots[i].label, -1); } demo->type_selector = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (demo->type_selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (demo->type_selector), renderer, "text", SELECTED_LABEL_COLUMN, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (demo->type_selector), 0); gtk_box_pack_end (GTK_BOX (hbox), demo->type_selector, FALSE, FALSE, 0); gtk_widget_show (demo->type_selector); button = gtk_color_button_new (); demo->annot_color.red = 65535; demo->annot_color.alpha = 1.0; #if GTK_CHECK_VERSION(3,4,0) gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_color); #else gtk_color_button_set_rgba (GTK_COLOR_BUTTON (button), &demo->annot_color); #endif g_signal_connect (button, "notify::color", G_CALLBACK (pgd_annot_color_changed), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_widget_show (button); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No annotations found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); demo->annot_view = pgd_annot_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->tree_view = treeview; column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Type"); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", ANNOTS_COLOR_COLUMN); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", ANNOTS_TYPE_COLUMN); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_invisible_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_INVISIBLE_COLUMN, "Invisible", renderer, "active", ANNOTS_FLAG_INVISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_hidden_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_HIDDEN_COLUMN, "Hidden", renderer, "active", ANNOTS_FLAG_HIDDEN_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_print_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_PRINT_COLUMN, "Print", renderer, "active", ANNOTS_FLAG_PRINT_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_annots_selection_changed), (gpointer) demo); /* Annotation's list */ gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Annotation Properties */ swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (swindow), demo->annot_view); gtk_widget_show (demo->annot_view); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 6); gtk_widget_show (swindow); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); /* Demo Area (Render) */ demo->darea = gtk_drawing_area_new (); g_signal_connect (demo->darea, "draw", G_CALLBACK (pgd_annots_view_drawing_area_draw), demo); g_signal_connect (demo->darea, "realize", G_CALLBACK (pgd_annots_drawing_area_realize), (gpointer)demo); g_signal_connect (demo->darea, "button_press_event", G_CALLBACK (pgd_annots_drawing_area_button_press), (gpointer)demo); g_signal_connect (demo->darea, "motion_notify_event", G_CALLBACK (pgd_annots_drawing_area_motion_notify), (gpointer)demo); g_signal_connect (demo->darea, "button_release_event", G_CALLBACK (pgd_annots_drawing_area_button_release), (gpointer)demo); swindow = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_annots_free, demo); pgd_annots_viewer_queue_redraw (demo); pgd_annots_get_annots (demo); demo->main_box = vbox; return vbox; }
static void cv_tree_init (chanview *cv) { GtkWidget *view, *win; GtkCellRenderer *renderer; static const GtkTargetEntry dnd_src_target[] = { {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_dest_target[] = { {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; win = gtk_scrolled_window_new (0, 0); /*gtk_container_set_border_width (GTK_CONTAINER (win), 1);*/ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (win), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (cv->box), win); gtk_widget_show (win); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (cv->store)); gtk_widget_set_name (view, "xchat-tree"); if (cv->style) gtk_widget_set_style (view, cv->style); /*gtk_widget_modify_base (view, GTK_STATE_NORMAL, &colors[COL_BG]);*/ GTK_WIDGET_UNSET_FLAGS (view, GTK_CAN_FOCUS); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); #if GTK_CHECK_VERSION(2,10,0) if (!(prefs.gui_tweaks & 8)) gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (view), TRUE); #endif gtk_container_add (GTK_CONTAINER (win), view); /* icon column */ if (cv->use_icons) { renderer = gtk_cell_renderer_pixbuf_new (); if (prefs.gui_tweaks & 32) g_object_set (G_OBJECT (renderer), "ypad", 0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, renderer, "pixbuf", COL_PIXBUF, NULL); } /* main column */ renderer = gtk_cell_renderer_text_new (); if (prefs.gui_tweaks & 32) g_object_set (G_OBJECT (renderer), "ypad", 0, NULL); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, renderer, "text", COL_NAME, "attributes", COL_ATTR, NULL); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))), "changed", G_CALLBACK (cv_tree_sel_cb), cv); g_signal_connect (G_OBJECT (view), "button-press-event", G_CALLBACK (cv_tree_click_cb), cv); g_signal_connect (G_OBJECT (view), "row-activated", G_CALLBACK (cv_tree_activated_cb), NULL); gtk_drag_dest_set (view, GTK_DEST_DEFAULT_ALL, dnd_dest_target, 1, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK); gtk_drag_source_set (view, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_COPY); #ifndef WIN32 g_signal_connect (G_OBJECT (view), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); #endif ((treeview *)cv)->tree = GTK_TREE_VIEW (view); ((treeview *)cv)->scrollw = win; gtk_widget_show (view); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *box; GtkWidget *drawing_area; GtkWidget *button; GtkWidget *label; GtkWidget *tooltip_window; GtkWidget *tooltip_button; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkWidget *text_view; GtkTextBuffer *buffer; GtkTextIter iter; GtkTextTag *tag; gchar *text, *markup; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Tooltips test"); gtk_container_set_border_width (GTK_CONTAINER (window), 10); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_container_add (GTK_CONTAINER (window), box); /* A check button using the tooltip-markup property */ button = gtk_check_button_new_with_label ("This one uses the tooltip-markup property"); gtk_widget_set_tooltip_text (button, "Hello, I am a static tooltip."); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); text = gtk_widget_get_tooltip_text (button); markup = gtk_widget_get_tooltip_markup (button); g_assert (g_str_equal ("Hello, I am a static tooltip.", text)); g_assert (g_str_equal ("Hello, I am a static tooltip.", markup)); g_free (text); g_free (markup); /* A check button using the query-tooltip signal */ button = gtk_check_button_new_with_label ("I use the query-tooltip signal"); g_object_set (button, "has-tooltip", TRUE, NULL); g_signal_connect (button, "query-tooltip", G_CALLBACK (query_tooltip_cb), NULL); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); /* A label */ button = gtk_label_new ("I am just a label"); gtk_label_set_selectable (GTK_LABEL (button), FALSE); gtk_widget_set_tooltip_text (button, "Label & and tooltip"); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); text = gtk_widget_get_tooltip_text (button); markup = gtk_widget_get_tooltip_markup (button); g_assert (g_str_equal ("Label & and tooltip", text)); g_assert (g_str_equal ("Label & and tooltip", markup)); g_free (text); g_free (markup); /* A selectable label */ button = gtk_label_new ("I am a selectable label"); gtk_label_set_selectable (GTK_LABEL (button), TRUE); gtk_widget_set_tooltip_markup (button, "<b>Another</b> Label tooltip"); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); text = gtk_widget_get_tooltip_text (button); markup = gtk_widget_get_tooltip_markup (button); g_assert (g_str_equal ("Another Label tooltip", text)); g_assert (g_str_equal ("<b>Another</b> Label tooltip", markup)); g_free (text); g_free (markup); /* Another one, with a custom tooltip window */ button = gtk_check_button_new_with_label ("This one has a custom tooltip window!"); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); tooltip_window = gtk_window_new (GTK_WINDOW_POPUP); tooltip_button = gtk_label_new ("blaat!"); gtk_container_add (GTK_CONTAINER (tooltip_window), tooltip_button); gtk_widget_show (tooltip_button); gtk_widget_set_tooltip_window (button, GTK_WINDOW (tooltip_window)); g_signal_connect (button, "query-tooltip", G_CALLBACK (query_tooltip_custom_cb), NULL); g_object_set (button, "has-tooltip", TRUE, NULL); /* An insensitive button */ button = gtk_button_new_with_label ("This one is insensitive"); gtk_widget_set_sensitive (button, FALSE); g_object_set (button, "tooltip-text", "Insensitive!", NULL); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); /* Testcases from Kris without a tree view don't exist. */ tree_view = gtk_tree_view_new_with_model (create_model ()); gtk_widget_set_size_request (tree_view, 200, 240); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), 0, "Test", gtk_cell_renderer_text_new (), "text", 0, NULL); g_object_set (tree_view, "has-tooltip", TRUE, NULL); g_signal_connect (tree_view, "query-tooltip", G_CALLBACK (query_tooltip_tree_view_cb), NULL); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), "changed", G_CALLBACK (selection_changed_cb), tree_view); /* Set a tooltip on the column */ column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0); gtk_tree_view_column_set_clickable (column, TRUE); g_object_set (gtk_tree_view_column_get_button (column), "tooltip-text", "Header", NULL); gtk_box_pack_start (GTK_BOX (box), tree_view, FALSE, FALSE, 2); /* And a text view for Matthias */ buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_get_end_iter (buffer, &iter); gtk_text_buffer_insert (buffer, &iter, "Hello, the text ", -1); tag = gtk_text_buffer_create_tag (buffer, "bold", NULL); g_object_set (tag, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_get_end_iter (buffer, &iter); gtk_text_buffer_insert_with_tags (buffer, &iter, "in bold", -1, tag, NULL); gtk_text_buffer_get_end_iter (buffer, &iter); gtk_text_buffer_insert (buffer, &iter, " has a tooltip!", -1); text_view = gtk_text_view_new_with_buffer (buffer); gtk_widget_set_size_request (text_view, 200, 50); g_object_set (text_view, "has-tooltip", TRUE, NULL); g_signal_connect (text_view, "query-tooltip", G_CALLBACK (query_tooltip_text_view_cb), tag); gtk_box_pack_start (GTK_BOX (box), text_view, FALSE, FALSE, 2); /* Drawing area */ drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (drawing_area, 320, 240); g_object_set (drawing_area, "has-tooltip", TRUE, NULL); g_signal_connect (drawing_area, "draw", G_CALLBACK (drawing_area_draw), NULL); g_signal_connect (drawing_area, "query-tooltip", G_CALLBACK (query_tooltip_drawing_area_cb), NULL); gtk_box_pack_start (GTK_BOX (box), drawing_area, FALSE, FALSE, 2); button = gtk_label_new ("Custom tooltip I"); label = gtk_label_new ("See, custom"); g_object_ref_sink (label); g_object_set (button, "has-tooltip", TRUE, NULL); g_signal_connect (button, "query-tooltip", G_CALLBACK (query_tooltip_label_cb), label); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2); button = gtk_label_new ("Custom tooltip II"); label = gtk_label_new ("See, custom, too"); g_object_ref_sink (label); g_object_set (button, "has-tooltip", TRUE, NULL); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2); g_signal_connect (button, "query-tooltip", G_CALLBACK (query_tooltip_label_cb), label); /* Done! */ gtk_widget_show_all (window); gtk_main (); return 0; }
void browser_dialog_open (const gchar *plug_in_binary) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *paned; GtkWidget *scrolled; GtkWidget *button; GtkToolItem *item; GtkAction *action; DialogData data = { 720, 560, 240, TRUE, 1.0 }; gimp_ui_init (plug_in_binary, TRUE); gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data); /* the dialog window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser")); gtk_window_set_role (GTK_WINDOW (window), plug_in_binary); gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); window_set_icons (window); vbox = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); ui_manager = ui_manager_new (window); toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show (toolbar); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/forward"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_next = GTK_WIDGET (item); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/back"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_prev = GTK_WIDGET (item); item = GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/space")); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_tool_item_set_expand (item, TRUE); button = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/website"); /* the horizontal paned */ paned = gtk_hpaned_new (); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); gtk_widget_show (paned); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled); gtk_paned_set_position (GTK_PANED (paned), data.paned_position); sidebar = scrolled; if (data.show_index) gtk_widget_show (sidebar); tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_container_add (GTK_CONTAINER (scrolled), tree_view); gtk_widget_show (tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, NULL, gtk_cell_renderer_text_new (), "text", 1, NULL); g_signal_connect (tree_view, "row-activated", G_CALLBACK (row_activated), NULL); /* HTML view */ main_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (main_vbox); gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled, 300, 200); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show (scrolled); view = webkit_web_view_new (); webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view), TRUE); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_widget_show (view); g_signal_connect (view, "realize", G_CALLBACK (view_realize), NULL); g_signal_connect (view, "unrealize", G_CALLBACK (view_unrealize), NULL); g_signal_connect (view, "popup-menu", G_CALLBACK (view_popup_menu), NULL); g_signal_connect (view, "button-press-event", G_CALLBACK (view_button_press), NULL); g_signal_connect (view, "key-press-event", G_CALLBACK (view_key_press), NULL); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom); g_signal_connect (view, "title-changed", G_CALLBACK (title_changed), window); g_signal_connect (view, "load-started", G_CALLBACK (load_started), NULL); g_signal_connect (view, "load-finished", G_CALLBACK (load_finished), NULL); gtk_widget_grab_focus (view); g_signal_connect (window, "unmap", G_CALLBACK (dialog_unmap), paned); update_actions (); /* Searchbar */ searchbar = build_searchbar (); gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0); }
void bmd_add_columns (GtkTreeView *treeview, GtkTreeModel *items_model, GtkTreeModel *numbers_model) { GtkCellRenderer *renderer; // added for sorting GtkTreeViewColumn *column; /* number column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_NUMBER)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Number", renderer, "text", COLUMN_ITEM_NUMBER, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0); gtk_tree_view_column_set_sort_column_id (column, 0); /* title column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_TITLE)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Title", renderer, "text", COLUMN_ITEM_TITLE, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1); gtk_tree_view_column_set_sort_column_id (column, 1); /* author column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_AUTHOR)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Author", renderer, "text", COLUMN_ITEM_AUTHOR, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 2); gtk_tree_view_column_set_sort_column_id (column, 2); /* pages column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (bmd_cell_edited), items_model); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_PAGES)); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Pages", renderer, "text", COLUMN_ITEM_PAGES, NULL); // added for sorting column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 3); gtk_tree_view_column_set_sort_column_id (column, 3); }
void ghid_netlist_window_create (GHidPort * out) { GtkWidget *vbox, *hbox, *button, *label, *sep; GtkTreeView *treeview; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; if (netlist_window) return; netlist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (G_OBJECT (netlist_window), "destroy", G_CALLBACK (netlist_destroy_cb), out); gtk_window_set_title (GTK_WINDOW (netlist_window), _("PCB Netlist")); gtk_window_set_wmclass (GTK_WINDOW (netlist_window), "PCB_Netlist", "PCB"); g_signal_connect (G_OBJECT (netlist_window), "configure_event", G_CALLBACK (netlist_window_configure_event_cb), NULL); gtk_window_set_default_size (GTK_WINDOW (netlist_window), -1, ghidgui->netlist_window_height); gtk_container_set_border_width (GTK_CONTAINER (netlist_window), 2); vbox = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (netlist_window), vbox); hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 4); model = net_model_create (); treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model (model)); net_model = model; net_treeview = treeview; gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (net_model), NET_NAME_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_rules_hint (treeview, FALSE); g_object_set (treeview, "enable-tree-lines", TRUE, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (treeview, -1, _(" "), renderer, "text", NET_ENABLED_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Net Name"), renderer, "text", NET_NAME_COLUMN, NULL); gtk_tree_view_insert_column (treeview, column, -1); gtk_tree_view_set_expander_column (treeview, column); /* TODO: dont expand all, but record expanded states when window is | destroyed and restore state here. */ gtk_tree_view_expand_all (treeview); ghid_scrolled_selection (treeview, hbox, GTK_SELECTION_SINGLE, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, net_selection_changed_cb, NULL); /* Connect to the double click event. */ g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (net_selection_double_click_cb), NULL); /* Create the elements treeview and wait for a callback to populate it. */ treeview = GTK_TREE_VIEW (gtk_tree_view_new ()); node_treeview = treeview; gtk_tree_view_set_rules_hint (treeview, FALSE); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (treeview, -1, _("Nodes"), renderer, "text", NODE_NAME_COLUMN, NULL); ghid_scrolled_selection (treeview, hbox, GTK_SELECTION_SINGLE, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, node_selection_changed_cb, NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (_("Operations on selected 'Net Name':")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 4); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4); button = gtk_button_new_with_label (_("Select")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (netlist_select_cb), GINT_TO_POINTER (1)); button = gtk_button_new_with_label (_("Unselect")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (netlist_select_cb), GINT_TO_POINTER (0)); button = gtk_button_new_with_label (_("Find")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (netlist_find_cb), GINT_TO_POINTER (0)); button = gtk_button_new_with_label (_("Rip Up")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (netlist_rip_up_cb), GINT_TO_POINTER (0)); ghid_check_button_connected (vbox, &disable_all_button, FALSE, TRUE, FALSE, FALSE, 0, netlist_disable_all_cb, NULL, _("Disable all nets for adding rats")); sep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 3); hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (netlist_close_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_realize (netlist_window); if (Settings.AutoPlace) gtk_window_move (GTK_WINDOW (netlist_window), 10, 10); }
GtkWidget *hview_get_event_window(HviewWidgetsT *w) { GtkWidget *window; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeStore *model; window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(GTK_WIDGET(window), HVIEW_LOG_WINDOW_WIDTH, HVIEW_LOG_WINDOW_HEIGHT); model = gtk_tree_store_new(VOH_EVENT_LIST_NUM_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); w->event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_object_unref(model); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_TIME, HVIEW_EVENT_TIME_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_TIME, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_TIME); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_NAME, HVIEW_EVENT_LIST_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_NAME, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_NAME); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_SOURCE, HVIEW_EVENT_SOURCE_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_SOURCE, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_SOURCE); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_SEVER, HVIEW_EVENT_SEVERITY_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_SEVER, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_SEVER); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_TYPE, HVIEW_EVENT_TYPE_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_TYPE, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_TYPE); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW( w->event_view), VOH_EVENT_LIST_COLUMN_DOMAIN, HVIEW_EVENT_DOMAIN_TITLE, renderer, "text", VOH_EVENT_LIST_COLUMN_DOMAIN, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(w->event_view), VOH_EVENT_LIST_COLUMN_DOMAIN); // gtk_tree_view_column_set_cell_data_func(col, renderer, // hview_event_cell_func, // NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window), w->event_view); return window; }
bool sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { return false; } girara_tree_node_t* document_index = NULL; GtkWidget* treeview = NULL; GtkTreeModel* model = NULL; GtkCellRenderer* renderer = NULL; GtkCellRenderer* renderer2 = NULL; if (zathura->ui.index == NULL) { /* create new index widget */ zathura->ui.index = gtk_scrolled_window_new(NULL, NULL); if (zathura->ui.index == NULL) { goto error_ret; } gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* create index */ document_index = zathura_document_index_generate(zathura->document, NULL); if (document_index == NULL) { girara_notify(session, GIRARA_WARNING, _("This document does not contain any index")); goto error_free; } model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); if (model == NULL) { goto error_free; } treeview = gtk_tree_view_new_with_model(model); if (treeview == NULL) { goto error_free; } g_object_unref(model); renderer = gtk_cell_renderer_text_new(); if (renderer == NULL) { goto error_free; } renderer2 = gtk_cell_renderer_text_new(); if (renderer2 == NULL) { goto error_free; } document_index_build(model, NULL, document_index); girara_node_free(document_index); /* setup widget */ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); 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); gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f); gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura); gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview); gtk_widget_show(treeview); } if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) { girara_set_view(session, zathura->ui.page_widget_alignment); gtk_widget_hide(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.normal); /* refresh view */ refresh_view(zathura); } else { /* save current position to the jumplist */ zathura_jumplist_add(zathura); girara_set_view(session, zathura->ui.index); gtk_widget_show(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.index); } return false; error_free: if (zathura->ui.index != NULL) { g_object_ref_sink(zathura->ui.index); zathura->ui.index = NULL; } if (document_index != NULL) { girara_node_free(document_index); } error_ret: return false; }
GtkWidget *hview_get_resource_window(HviewWidgetsT *w, gint page) { GtkWidget *window; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeSelection *selection; GtkWidget *view; window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(GTK_WIDGET(window), HVIEW_TREE_WINDOW_WIDTH, HVIEW_TREE_WINDOW_HEIGHT); w->tab_views[page].resource_view = view = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), VOH_LIST_COLUMN_NAME, HVIEW_RESOURCE_COLUMN_TITLE, renderer, "text", VOH_LIST_COLUMN_NAME, NULL); col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), VOH_LIST_COLUMN_NAME); gtk_tree_view_column_set_cell_data_func(col, renderer, hview_tree_cell_func, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), VOH_LIST_COLUMN_ICON, NULL, renderer, "pixbuf", VOH_LIST_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), VOH_LIST_COLUMN_VALUE, NULL, renderer, "text", VOH_LIST_COLUMN_VALUE, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(hview_tree_row_selected_call), (gpointer) w); g_signal_connect(G_OBJECT(view), "button-press-event", G_CALLBACK(hview_butpress_rlist_call), (gpointer) w); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window), view); return window; }
static void import_widget_set_up_account_list (EmpathyImportWidget *self) { EmpathyImportWidgetPriv *priv = GET_PRIV (self); GtkListStore *store; GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; priv->accounts = empathy_import_accounts_load (priv->app_id); store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (store)); g_object_unref (store); view = GTK_TREE_VIEW (priv->treeview); gtk_tree_view_set_headers_visible (view, TRUE); /* Import column */ cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (view, -1, /* Translators: this is the header of a treeview column */ _("Import"), cell, "active", COL_IMPORT, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (import_widget_cell_toggled_cb), self); /* Protocol column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Protocol")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL); /* Account column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME); if (priv->app_id == EMPATHY_IMPORT_APPLICATION_ALL) { /* Source column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Source")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE); } import_widget_add_accounts_to_model (self); }
/************************************************************************** Build widgets **************************************************************************/ static void modinst_setup_widgets(GtkWidget *toplevel) { GtkWidget *mbox, *Ubox; GtkWidget *install_button, *install_label; GtkWidget *URL_label; GtkCellRenderer *renderer; GtkTreeSelection *selection; const char *errmsg; mbox = gtk_vbox_new(FALSE, 4); main_list = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(main_list), ML_COL_NAME, _("Name"), renderer, "text", 0, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(main_list), ML_COL_VER, _("Version"), renderer, "text", 1, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(main_list), ML_COL_TYPE, _("Type"), renderer, "text", 2, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(main_list), ML_COL_URL, _("URL"), renderer, "text", 3, NULL); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(main_list)); g_signal_connect(selection, "changed", G_CALLBACK(select_from_list), NULL); install_button = gtk_button_new(); install_label = gtk_label_new(_("Install modpack")); gtk_label_set_mnemonic_widget(GTK_LABEL(install_label), install_button); g_object_set_data(G_OBJECT(install_button), "label", install_label); gtk_container_add(GTK_CONTAINER(install_button), install_label); Ubox = gtk_hbox_new(FALSE, 4); URL_label = gtk_label_new_with_mnemonic(_("Modpack URL")); URL_input = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(URL_input), strlen(EXAMPLE_URL)); gtk_entry_set_text(GTK_ENTRY(URL_input), DEFAULT_URL_START); g_signal_connect(URL_input, "activate", G_CALLBACK(URL_return), NULL); g_signal_connect(install_button, "clicked", G_CALLBACK(install_clicked), URL_input); gtk_box_pack_start(GTK_BOX(Ubox), URL_label, TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(Ubox), URL_input, TRUE, TRUE, 0); progressbar = gtk_progress_bar_new(); statusbar = gtk_label_new(_("Select modpack to install")); gtk_box_pack_start(GTK_BOX(mbox), main_list, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(mbox), Ubox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(mbox), install_button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(mbox), progressbar, TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(mbox), statusbar, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(toplevel), mbox); main_store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); errmsg = download_modpack_list(MODPACK_LIST_URL, setup_modpack_list, msg_callback); gtk_tree_view_set_model(GTK_TREE_VIEW(main_list), GTK_TREE_MODEL(main_store)); g_object_unref(main_store); if (errmsg != NULL) { gtk_label_set_text(GTK_LABEL(statusbar), errmsg); } }
static void mc_preferences_setup_dialog (GtkBuilder *builder, MCData *mc) { MCPrefsDialog *dialog; GtkCellRenderer *renderer; MateConfClient *client; GdkColor color; dialog = &mc->prefs_dialog; g_signal_connect (dialog->dialog, "response", G_CALLBACK (preferences_response), mc); gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_CLOSE); gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 400, -1); dialog->auto_complete_history_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "auto_complete_history_toggle")); dialog->size_spinner = GTK_WIDGET (gtk_builder_get_object (builder, "size_spinner")); dialog->use_default_theme_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "default_theme_toggle")); dialog->fg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_picker")); dialog->bg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_picker")); dialog->macros_tree = GTK_WIDGET (gtk_builder_get_object (builder, "macros_tree")); dialog->delete_button = GTK_WIDGET (gtk_builder_get_object (builder, "delete_button")); dialog->add_button = GTK_WIDGET (gtk_builder_get_object (builder, "add_button")); /* History based autocompletion */ g_signal_connect (dialog->auto_complete_history_toggle, "toggled", G_CALLBACK (auto_complete_history_toggled), mc); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->auto_complete_history_toggle), mc->preferences.auto_complete_history); if ( ! mc_key_writable (mc, "autocomplete_history")) hard_set_sensitive (dialog->auto_complete_history_toggle, FALSE); /* Width */ gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spinner), mc->preferences.normal_size_x); g_signal_connect (dialog->size_spinner, "value_changed", G_CALLBACK (size_value_changed), mc); if ( ! mc_key_writable (mc, "normal_size_x")) { hard_set_sensitive (dialog->size_spinner, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_label")), FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_post_label")), FALSE); } /* Use default theme */ g_signal_connect (dialog->use_default_theme_toggle, "toggled", G_CALLBACK (use_default_theme_toggled), mc); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->use_default_theme_toggle), mc->preferences.show_default_theme); if ( ! mc_key_writable (mc, "show_default_theme")) hard_set_sensitive (dialog->use_default_theme_toggle, FALSE); /* Foreground color */ g_signal_connect (dialog->fg_color_picker, "color_set", G_CALLBACK (foreground_color_set), mc); color.red = mc->preferences.cmd_line_color_fg_r; color.green = mc->preferences.cmd_line_color_fg_g; color.blue = mc->preferences.cmd_line_color_fg_b; gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->fg_color_picker), &color); soft_set_sensitive (dialog->fg_color_picker, !mc->preferences.show_default_theme); if ( ! mc_key_writable (mc, "cmd_line_color_fg_r") || ! mc_key_writable (mc, "cmd_line_color_fg_g") || ! mc_key_writable (mc, "cmd_line_color_fg_b")) { hard_set_sensitive (dialog->fg_color_picker, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_label")), FALSE); } /* Background color */ g_signal_connect (dialog->bg_color_picker, "color_set", G_CALLBACK (background_color_set), mc); color.red = mc->preferences.cmd_line_color_bg_r; color.green = mc->preferences.cmd_line_color_bg_g; color.blue = mc->preferences.cmd_line_color_bg_b; gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->bg_color_picker), &color); soft_set_sensitive (dialog->bg_color_picker, !mc->preferences.show_default_theme); if ( ! mc_key_writable (mc, "cmd_line_color_bg_r") || ! mc_key_writable (mc, "cmd_line_color_bg_g") || ! mc_key_writable (mc, "cmd_line_color_bg_b")) { hard_set_sensitive (dialog->bg_color_picker, FALSE); hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_label")), FALSE); } /* Macros Delete and Add buttons */ g_signal_connect (dialog->delete_button, "clicked", G_CALLBACK (macro_delete), mc); g_signal_connect (dialog->add_button, "clicked", G_CALLBACK (macro_add), mc); client = mateconf_client_get_default (); if ( ! mateconf_client_key_is_writable (client, "/apps/mini-commander/macro_patterns", NULL) || ! mateconf_client_key_is_writable (client, "/apps/mini-commander/macro_commands", NULL)) { hard_set_sensitive (dialog->add_button, FALSE); hard_set_sensitive (dialog->delete_button, FALSE); hard_set_sensitive (dialog->macros_tree, FALSE); } /* Macros tree view */ dialog->macros_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->macros_tree), GTK_TREE_MODEL (dialog->macros_store)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_PATTERN)); g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->macros_tree), -1, _("Pattern"), renderer, "text", COLUMN_PATTERN, NULL); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_COMMAND)); g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (dialog->macros_tree), -1, _("Command"), renderer, "text", COLUMN_COMMAND, NULL); show_macros_list (mc); }
GtkWidget *pref_start_filter() { GtkWidget *button; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *scroll; GtkCellRenderer *renderer; LOG(LOG_DEBUG, "IN : pref_start_dictgroup()"); // Left half vbox = gtk_vbox_new(FALSE,0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 2); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(vbox) , frame,TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (frame), scroll); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(filter_view), TRUE); gtk_tree_view_expand_all(GTK_TREE_VIEW(filter_view)); gtk_container_add (GTK_CONTAINER (scroll), filter_view); renderer = gtk_cell_renderer_text_new(); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(cell_edited), NULL); g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_EXT_COLUMN); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view), -1, _("Extension"), renderer, "text", FILTER_EXT_COLUMN, "editable", FILTER_EDITABLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new(); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(cell_edited), NULL); g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_FILTER_COMMAND_COLUMN); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view), -1, _("Filter Command"), renderer, "text", FILTER_FILTER_COMMAND_COLUMN, "editable", FILTER_EDITABLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new(); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(cell_edited), NULL); g_object_set_data(G_OBJECT(renderer), "column", (gint *)FILTER_OPEN_COMMAND_COLUMN); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(filter_view), -1, _("Open Command"), renderer, "text", FILTER_OPEN_COMMAND_COLUMN, "editable", FILTER_EDITABLE_COLUMN, NULL); // Enable resizing all column { gint i; GtkTreeViewColumn *column; for(i=0;;i++){ column = gtk_tree_view_get_column(GTK_TREE_VIEW(filter_view), i); if(column == NULL) break; gtk_tree_view_column_set_resizable(column, TRUE); } } hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox,FALSE, FALSE, 2); button = gtk_button_new_with_label(_("Add")); gtk_box_pack_start(GTK_BOX(hbox), button,FALSE,FALSE, 2); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(add_filter), (gpointer)button); button = gtk_button_new_with_label(_("Remove")); gtk_box_pack_start(GTK_BOX(hbox), button,FALSE,FALSE, 2); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(remove_filter), (gpointer)button); LOG(LOG_DEBUG, "OUT : pref_start_dictgroup()"); return(vbox); }
static void import_dialog_set_up_account_list (EmpathyImportDialog *dialog) { GtkListStore *store; GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview), GTK_TREE_MODEL (store)); g_object_unref (store); view = GTK_TREE_VIEW (dialog->treeview); gtk_tree_view_set_headers_visible (view, TRUE); /* Import column */ cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (view, -1, _("Import"), cell, "active", COL_IMPORT, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (import_dialog_cell_toggled_cb), dialog); /* Protocol column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Protocol")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL); /* Account column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Account")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME); /* Source column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Source")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (view, column); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE); import_dialog_add_accounts_to_model (dialog); }
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); }