static void feed_list_view_reduce_mode_changed (void) { if (flv->feedlist_reduced_unread) { gtk_tree_view_set_reorderable (flv->treeview, FALSE); gtk_tree_view_set_model (flv->treeview, GTK_TREE_MODEL (flv->filter)); gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (flv->filter)); } else { gtk_tree_view_set_reorderable (flv->treeview, TRUE); gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (flv->filter)); gtk_tree_view_set_model (flv->treeview, GTK_TREE_MODEL (flv->feedstore)); feedlist_foreach (feed_list_view_restore_folder_expansion); } }
static void create_treeview(GtkWidget *treeview, GtkWidget *treeview_sw, char *col_names[], int col_names_count) { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE); /* fixed with and height improve performance */ gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW (treeview), FALSE); gtk_container_add (GTK_CONTAINER (treeview_sw), treeview); /* add columns to the tree view */ GtkCellRenderer *renderer; GtkTreeViewColumn *col; /* hack! minimal screen width - scroll bar width - separators and borders */ int width = 430 / col_names_count; int i; for (i=0; i<col_names_count; i++) { renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (col_names[i], renderer, "text", i, NULL); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_column_set_clickable(col, FALSE); gtk_tree_view_column_set_cell_data_func (col, renderer, svinfo_treeview_func_text, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), col); } }
static GtkWidget * create_batchinfo_treeview() { batchinfo_treeview = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchinfo_treeview), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW (batchinfo_treeview), FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchinfo_treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE); batchinfo_treeview_sw = new_scrolled_window (NULL); gtk_container_add (GTK_CONTAINER (batchinfo_treeview_sw), batchinfo_treeview); /* add columns to the tree view */ GtkCellRenderer *renderer; GtkTreeViewColumn *col; int i; for (i=0; i<COL_BINFO_COUNT; i++) { renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (batchinfo_col_names[i], renderer, "text", i, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchinfo_treeview), col); } batchinfo_store = gtk_list_store_new (COL_BINFO_COUNT, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(batchinfo_treeview), GTK_TREE_MODEL(batchinfo_store)); return batchinfo_treeview_sw; }
static void setup_treeview () { GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gtk_tree_view_set_headers_visible (editor->treeview, FALSE); editor->store = GTK_TREE_STORE (bookmark_tree_store_new()); gtk_tree_view_set_model (editor->treeview, GTK_TREE_MODEL (editor->store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_append_column (editor->treeview, column); add_bookmarks (); selection = gtk_tree_view_get_selection (editor->treeview); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (selection_changed_cb), editor); editor->selection = selection; g_signal_connect (editor->store, "row_deleted", G_CALLBACK (on_row_deleted_cb), NULL); gtk_tree_view_set_reorderable (editor->treeview, TRUE); }
G_MODULE_EXPORT void setup_rtt_treeview(GtkWidget *treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *parent = gtk_widget_get_parent(treeview); GtkStyle * style = NULL; style = gtk_widget_get_style(parent); renderer = gtk_cell_renderer_text_new(); /*gtk_cell_renderer_set_fixed_size(GTK_CELL_RENDERER(renderer),-1, 1);*/ g_object_set(renderer, "background-gdk", &style->bg[GTK_STATE_NORMAL], NULL); column = gtk_tree_view_column_new_with_attributes("",renderer, "text", COL_RTT_INT_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new(); /*gtk_cell_renderer_set_fixed_size(GTK_CELL_RENDERER(renderer),65, 1);*/ g_object_set(renderer, "background-gdk", &style->bg[GTK_STATE_NORMAL], NULL); column = gtk_tree_view_column_new_with_attributes("",renderer, "markup", COL_RTT_DATA, NULL); g_object_set(column, "alignment", 1.0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), TRUE); }
static GObject * radare_gui_list_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { GObject * obj; RadareGUIListClass * klass; GObjectClass * parent_class; RadareGUIList * self; klass = RADARE_GUI_LIST_CLASS (g_type_class_peek (RADARE_GUI_TYPE_LIST)); parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass)); obj = parent_class->constructor (type, n_construct_properties, construct_properties); self = RADARE_GUI_LIST (obj); { GtkScrolledWindow* _tmp0; GtkTreeView* _tmp1; GtkListStore* _tmp2; _tmp0 = NULL; #line 44 "list.vala" radare_gui_list_set_widget (self, (_tmp0 = g_object_ref_sink (((GtkScrolledWindow*) (gtk_scrolled_window_new (NULL, NULL)))))); (_tmp0 == NULL ? NULL : (_tmp0 = (g_object_unref (_tmp0), NULL))); #line 45 "list.vala" gtk_scrolled_window_set_policy (self->priv->_widget, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); _tmp1 = NULL; #line 47 "list.vala" self->priv->tv = (_tmp1 = g_object_ref_sink (((GtkTreeView*) (gtk_tree_view_new ()))), (self->priv->tv == NULL ? NULL : (self->priv->tv = (g_object_unref (self->priv->tv), NULL))), _tmp1); #line 48 "list.vala" gtk_tree_view_set_reorderable (self->priv->tv, TRUE); #line 49 "list.vala" gtk_tree_view_set_rules_hint (self->priv->tv, TRUE); _tmp2 = NULL; #line 50 "list.vala" gtk_tree_view_set_model (self->priv->tv, ((GtkTreeModel*) (self->priv->ls = (_tmp2 = gtk_list_store_new (1, G_TYPE_STRING, NULL), (self->priv->ls == NULL ? NULL : (self->priv->ls = (g_object_unref (self->priv->ls), NULL))), _tmp2)))); #line 52 "list.vala" gtk_container_add (((GtkContainer*) (self->priv->_widget)), ((GtkWidget*) (self->priv->tv))); } return obj; }
static void playlist_widget_init(PlaylistWidget *wgt) { wgt->indicator_renderer = gtk_cell_renderer_text_new(); wgt->title_renderer = gtk_cell_renderer_text_new(); wgt->list_store = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); wgt->tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(wgt->list_store)); wgt->indicator_column = gtk_tree_view_column_new_with_attributes ( "\xe2\x80\xa2", /* UTF-8 bullet */ wgt->indicator_renderer, "text", 0, NULL ); wgt->title_column = gtk_tree_view_column_new_with_attributes (_("Playlist"), wgt->title_renderer, "text", 1, NULL); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(wgt->tree_view), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(wgt->tree_view), wgt->indicator_column); gtk_tree_view_append_column (GTK_TREE_VIEW(wgt->tree_view), wgt->title_column); gtk_container_add(GTK_CONTAINER(wgt), wgt->tree_view); }
void button_refresh_clicked(GtkWidget *widget, gpointer data) { GtkListStore *store = gui_model_fill_data (); gtk_tree_view_set_model (gui_get_gtk_tree_viewer(),(GtkTreeModel*)store); //viewer "sortierbar" machen gtk_tree_view_set_reorderable (gui_get_gtk_tree_viewer(),TRUE); }
static GtkWidget * editlist_treeview_new (GtkWidget *box, char *title1, char *title2) { GtkWidget *scroll; GtkListStore *store; GtkTreeViewColumn *col; GtkWidget *view; GtkCellRenderer *render; scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); g_return_val_if_fail (store != NULL, NULL); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE); g_signal_connect (G_OBJECT (view), "key_press_event", G_CALLBACK (editlist_keypress), NULL); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (editlist_edited), GINT_TO_POINTER(NAME_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), NAME_COLUMN, title1, render, "text", NAME_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (editlist_edited), GINT_TO_POINTER(CMD_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), CMD_COLUMN, title2, render, "text", CMD_COLUMN, NULL); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), NAME_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_set_min_width (col, 100); gtk_container_add (GTK_CONTAINER (scroll), view); gtk_container_add (GTK_CONTAINER (box), scroll); gtk_widget_show_all (box); return view; }
void fill_qck_launcher_dlg() { GtkTreeModel *treemodel; GList *i; GtkTreeIter iter; GdkPixbuf *pixbuf; GtkTreeViewColumn *column; GtkCellRenderer *render; t_launcher *launcher; _icon_window = create_icon_window(); treemodel = GTK_TREE_MODEL(gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); gtk_tree_view_set_model(GTK_TREE_VIEW(_dlg->treeview1), treemodel); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (_dlg->treeview1), FALSE);//==>besoin de gérer le reorder gtk_spin_button_set_value(GTK_SPIN_BUTTON(_dlg->spin1), (gdouble)_quicklauncher->nb_lines); render = gtk_cell_renderer_pixbuf_new(); //render = gtk_cell_renderer_combo_new(); //configure_combo(render); if I one day can use combo with pixbuf... g_object_set (G_OBJECT(render), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,"sensitive", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes(_("icone"), render, "pixbuf", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(_dlg->treeview1), column); render = gtk_cell_renderer_text_new(); g_object_set (G_OBJECT(render),"editable", TRUE, NULL); g_signal_connect(render, "edited", G_CALLBACK (cmd_changed), NULL); column = gtk_tree_view_column_new_with_attributes(_("commande"), render, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(_dlg->treeview1), column); //load current config for( i = g_list_last(_quicklauncher->launchers); i != NULL; i = g_list_previous(i) ) { launcher = i->data; gtk_list_store_insert(GTK_LIST_STORE(treemodel), &iter, 0); pixbuf = _create_pixbuf(launcher->icon_id, launcher->icon_name, 16); gtk_list_store_set(GTK_LIST_STORE(treemodel), &iter, 0, pixbuf, 1, launcher->command, 2, (gpointer)launcher, -1); UNREF(pixbuf); } g_signal_connect(_dlg->treeview1, "row-activated", G_CALLBACK(show_icon_window), NULL); g_signal_connect((gpointer)_dlg->spin1, "value-changed", G_CALLBACK (on_spin_value_changed), NULL); g_signal_connect ((gpointer) _dlg->btn_new, "clicked", G_CALLBACK (on_btn_new_clicked), NULL); g_signal_connect ((gpointer) _dlg->btn_remove, "clicked", G_CALLBACK (on_btn_remove_clicked), NULL); g_signal_connect ((gpointer) _dlg->btn_up, "clicked", G_CALLBACK (on_btn_up_clicked), NULL); g_signal_connect ((gpointer) _dlg->btn_down, "clicked", G_CALLBACK (on_btn_down_clicked), NULL); }
static void gal_define_views_dialog_init (GalDefineViewsDialog *dialog) { GladeXML *gui; GtkWidget *widget; gchar *filename = g_build_filename (EVOLUTION_GLADEDIR, "gal-define-views.glade", NULL); dialog->collection = NULL; gui = glade_xml_new (filename, NULL, GETTEXT_PACKAGE); g_free (filename); dialog->gui = gui; widget = glade_xml_get_widget(gui, "table-top"); if (!widget) { return; } g_object_ref (widget); gtk_container_remove (GTK_CONTAINER (widget->parent), widget); gtk_window_set_default_size (GTK_WINDOW (dialog), 360, 270); gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); gtk_container_set_border_width (GTK_CONTAINER (widget), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), widget, TRUE, TRUE, 0); g_object_unref(widget); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); dialog->treeview = GTK_TREE_VIEW (glade_xml_get_widget (dialog->gui, "treeview1")); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->treeview), FALSE); gtk_tree_view_set_headers_visible (dialog->treeview, TRUE); gtk_window_set_policy (GTK_WINDOW (dialog), FALSE, TRUE, FALSE); gdvd_connect_signal(dialog, "button-new", "clicked", G_CALLBACK(gdvd_button_new_callback)); gdvd_connect_signal(dialog, "button-modify", "clicked", G_CALLBACK(gdvd_button_modify_callback)); gdvd_connect_signal(dialog, "button-delete", "clicked", G_CALLBACK(gdvd_button_delete_callback)); #if 0 gdvd_connect_signal(dialog, "button-copy", "clicked", G_CALLBACK(gdvd_button_copy_callback)); #endif gdvd_connect_signal(dialog, "treeview1", "cursor-changed", G_CALLBACK(gdvd_cursor_changed_callback)); g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), NULL); gtk_widget_show (GTK_WIDGET (dialog)); }
void xkb_layouts_prepare_selected_tree (GtkBuilder * dialog) { GtkListStore *list_store; GtkWidget *tree_view = WID ("xkb_layouts_selected"); GtkTreeSelection *selection; GtkTreeViewColumn *desc_column; list_store = gtk_list_store_new (SEL_LAYOUT_N_COLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); text_renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ()); desc_column = gtk_tree_view_column_new_with_attributes (_("Layout"), text_renderer, "text", SEL_LAYOUT_TREE_COL_DESCRIPTION, "sensitive", SEL_LAYOUT_TREE_COL_ENABLED, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store)); gtk_tree_view_column_set_sizing (desc_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (desc_column, TRUE); gtk_tree_view_column_set_expand (desc_column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), desc_column); g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (xkb_layouts_enable_disable_buttons), dialog); max_selected_layouts = xkl_engine_get_max_num_groups (engine); /* Setting up DnD */ gtk_tree_view_set_reorderable (GTK_TREE_VIEW (tree_view), TRUE); g_signal_connect (G_OBJECT (tree_view), "drag-end", G_CALLBACK (xkb_layouts_drag_end), dialog); }
static GtkWidget * create_batchlist_treeview() { batchlist_treeview = gtk_tree_view_new (); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(batchlist_treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchlist_treeview), TRUE); GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchlist_treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE); /* For touch screen, better to use "cursor-changed", instead of "row-activated" */ g_signal_connect (G_OBJECT(batchlist_treeview), "cursor-changed", G_CALLBACK (batchlist_treeview_row_selected), NULL); batchlist_treeview_sw = new_scrolled_window (NULL); gtk_container_add (GTK_CONTAINER (batchlist_treeview_sw), batchlist_treeview); /* add columns to the tree view */ GtkCellRenderer *cell; GtkTreeViewColumn *col; int i; for (i=COL_BL_LEVELS; i<=COL_BL_FAILED_PERCENT; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[i], cell, "text", i, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); } /* cancel column */ cell = clickable_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new_with_attributes("", cell, "pixbuf", COL_BL_CANCEL, NULL); g_signal_connect (G_OBJECT (cell), "clicked", G_CALLBACK (cancel_batch_button_clicked), NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); gtk_tree_view_column_set_fixed_width(col, 16); cell = gtk_cell_renderer_progress_new(); col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[COL_BL_DONE_PERCENT], cell, "value", COL_BL_DONE_PERCENT, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); batchlist_store = gtk_list_store_new (COL_BL_COUNT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_POINTER); gtk_tree_view_set_model(GTK_TREE_VIEW(batchlist_treeview), GTK_TREE_MODEL(batchlist_store)); return batchlist_treeview_sw; }
static void set_features (EmpathyPersonaView *self, EmpathyPersonaViewFeatureFlags features) { EmpathyPersonaViewPriv *priv = GET_PRIV (self); priv->features = features; /* Setting reorderable is a hack that gets us row previews as drag icons for free. We override all the drag handlers. It's tricky to get the position of the drag icon right in drag_begin. GtkTreeView has special voodoo for it, so we let it do the voodoo that he do (but only if dragging is enabled). */ gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self), (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG)); /* Update DnD source/dest */ if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG) { gtk_drag_source_set (GTK_WIDGET (self), GDK_BUTTON1_MASK, drag_types_source, G_N_ELEMENTS (drag_types_source), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { gtk_drag_source_unset (GTK_WIDGET (self)); } if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DROP) { gtk_drag_dest_set (GTK_WIDGET (self), GTK_DEST_DEFAULT_ALL, drag_types_dest, G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { gtk_drag_dest_unset (GTK_WIDGET (self)); } g_object_notify (G_OBJECT (self), "features"); }
static void playlist_widget_init(PlaylistWidget *wgt) { wgt->indicator_renderer = gtk_cell_renderer_text_new(); wgt->title_renderer = gtk_cell_renderer_text_new(); wgt->list_store = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); wgt->tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(wgt->list_store)); wgt->indicator_column = gtk_tree_view_column_new_with_attributes ( "\xe2\x80\xa2", /* UTF-8 bullet */ wgt->indicator_renderer, "text", 0, NULL ); wgt->title_column = gtk_tree_view_column_new_with_attributes (_("Playlist"), wgt->title_renderer, "text", 1, NULL); g_signal_connect( wgt->tree_view, "button-press-event", G_CALLBACK(mouse_press_handler), NULL ); gtk_widget_set_can_focus(GTK_WIDGET(wgt->tree_view), FALSE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(wgt->tree_view), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(wgt->tree_view), wgt->indicator_column); gtk_tree_view_append_column (GTK_TREE_VIEW(wgt->tree_view), wgt->title_column); gtk_container_add(GTK_CONTAINER(wgt), wgt->tree_view); }
static GtkWidget *prefs_custom_header_list_view_create(void) { GtkTreeView *list_view; GtkTreeSelection *selector; GtkTreeModel *model; model = GTK_TREE_MODEL(prefs_custom_header_create_data_store()); list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model)); g_object_unref(model); gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere); gtk_tree_view_set_reorderable(list_view, TRUE); selector = gtk_tree_view_get_selection(list_view); gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selector, prefs_custom_header_selected, NULL, NULL); /* create the columns */ prefs_custom_header_create_list_view_columns(GTK_WIDGET(list_view)); return GTK_WIDGET(list_view); }
static GtkWidget * _preferences_window_applets_view(GtkListStore * store, gboolean reorderable) { GtkWidget * view; GtkTreeSelection * treesel; GtkCellRenderer * renderer; GtkTreeViewColumn * column; view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(view), reorderable); treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(treesel, GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); return view; }
static void search_list_tree_view_init(void) { GtkTreeView *tv; tv = GTK_TREE_VIEW(gui_main_window_lookup("tree_view_search")); tree_view_search = tv; gtk_tree_view_set_reorderable(tv, TRUE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_MULTIPLE); gtk_tree_view_set_model(tv, create_searches_model()); add_list_columns(tv); widget_add_popup_menu(GTK_WIDGET(tv), search_gui_get_search_list_popup_menu); gui_signal_connect(tv, "button-release-event", on_search_list_button_release_event, NULL); gui_signal_connect(tv, "key-release-event", on_search_list_key_release_event, NULL); gui_signal_connect_after(gtk_tree_view_get_model(tv), "row-deleted", on_search_list_row_deleted, NULL); }
static GtkWidget* do_todos (MaintainrProjectbox *item) { GtkListStore *model; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeSelection *selection; model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT); item->priv->todos = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_widget_set_tooltip_text (item->priv->todos, "Press '+' to add an item, '-' to remove the selected one"); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (item->priv->todos), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (item->priv->todos), TRUE); renderer = gtk_cell_renderer_toggle_new (); gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE); g_object_set (G_OBJECT (renderer), "yalign", 0, NULL); col = gtk_tree_view_column_new_with_attributes ("Check", renderer, "active", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col); g_signal_connect (renderer, "toggled", G_CALLBACK (todo_check_changed), item); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "wrap-mode", PANGO_WRAP_WORD, "yalign", 0, NULL); g_object_set (G_OBJECT (renderer), "editable", TRUE, "wrap-width", 200, NULL); col = gtk_tree_view_column_new_with_attributes ("String", renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->todos), col); g_signal_connect (renderer, "edited", G_CALLBACK (todo_string_changed), item); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item->priv->todos)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (item->priv->todos, "realize", G_CALLBACK (activate_focus_management), NULL); g_signal_connect (item->priv->todos, "focus-out-event", G_CALLBACK (unselect_all_todos), NULL); g_signal_connect (item->priv->todos, "key-press-event", G_CALLBACK (edit_todo_shortcuts), item); return item->priv->todos; }
static void add_tree_view (NautilusColumnChooser *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, G_TYPE_BOOLEAN); 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); g_signal_connect (view, "row-activated", G_CALLBACK (view_row_activated_callback), chooser); 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, "sensitive", COLUMN_SENSITIVE, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, cell, "text", COLUMN_LABEL, "sensitive", COLUMN_SENSITIVE, 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); }
/** * dialog_init: * @state: * * Create the dialog (guru). * **/ static gboolean dialog_init (SolverState *state) { GtkGrid *grid; GnmSolverParameters *param; GtkCellRenderer *renderer; GtkListStore *store; GtkTreeViewColumn *column; GSList *cl; GnmCell *target_cell; GnmValue const *input; int i; param = state->sheet->solver_parameters; state->gui = gnm_gtk_builder_load ("solver.ui", NULL, GO_CMD_CONTEXT (state->wbcg)); if (state->gui == NULL) return TRUE; state->dialog = go_gtk_builder_get_widget (state->gui, "Solver"); if (state->dialog == NULL) return TRUE; state->notebook = go_gtk_builder_get_widget (state->gui, "solver_notebook"); /* buttons */ state->solve_button = go_gtk_builder_get_widget (state->gui, "solvebutton"); g_signal_connect (G_OBJECT (state->solve_button), "clicked", G_CALLBACK (cb_dialog_solve_clicked), state); state->close_button = go_gtk_builder_get_widget (state->gui, "closebutton"); g_signal_connect (G_OBJECT (state->close_button), "clicked", G_CALLBACK (cb_dialog_close_clicked), state); state->help_button = go_gtk_builder_get_widget (state->gui, "helpbutton"); gnm_init_help_button (state->help_button, GNUMERIC_HELP_LINK_SOLVER); state->add_button = go_gtk_builder_get_widget (state->gui, "addbutton"); gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0.5, .5); g_signal_connect_swapped (G_OBJECT (state->add_button), "clicked", G_CALLBACK (cb_dialog_add_clicked), state); state->change_button = go_gtk_builder_get_widget (state->gui, "changebutton"); g_signal_connect (G_OBJECT (state->change_button), "clicked", G_CALLBACK (cb_dialog_change_clicked), state); state->delete_button = go_gtk_builder_get_widget (state->gui, "deletebutton"); gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0.5, .5); g_signal_connect (G_OBJECT (state->delete_button), "clicked", G_CALLBACK (cb_dialog_delete_clicked), state); state->stop_button = go_gtk_builder_get_widget (state->gui, "stopbutton"); g_signal_connect_swapped (G_OBJECT (state->stop_button), "clicked", G_CALLBACK (cb_stop_solver), state); /* target_entry */ grid = GTK_GRID (go_gtk_builder_get_widget (state->gui, "parameter-grid")); state->target_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->target_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF | GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->target_entry), TRUE); gtk_grid_attach (grid, GTK_WIDGET (state->target_entry), 1, 0, 2, 1); gnm_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (state->target_entry)); gtk_widget_show (GTK_WIDGET (state->target_entry)); g_signal_connect_after (G_OBJECT (state->target_entry), "changed", G_CALLBACK (dialog_set_main_button_sensitivity), state); /* change_cell_entry */ state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->change_cell_entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF | GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->change_cell_entry), TRUE); gtk_grid_attach (grid, GTK_WIDGET (state->change_cell_entry), 1, 2, 2, 1); gnm_editable_enters (GTK_WINDOW (state->dialog), GTK_WIDGET (state->change_cell_entry)); gtk_widget_show (GTK_WIDGET (state->change_cell_entry)); g_signal_connect_after (G_OBJECT (state->change_cell_entry), "changed", G_CALLBACK (dialog_set_main_button_sensitivity), state); /* Algorithm */ state->algorithm_combo = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "algorithm_combo")); renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, "text", 0, NULL); fill_algorithm_combo (state, param->options.model_type); for (i = 0; model_type_group[i]; i++) { const char *bname = model_type_group[i]; GtkWidget *w = go_gtk_builder_get_widget(state->gui, bname); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), param->options.model_type == (GnmSolverModelType)i); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (cb_dialog_model_type_clicked), state); } /* Options */ state->max_iter_entry = go_gtk_builder_get_widget (state->gui, "max_iter_entry"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_iter_entry), param->options.max_iter); state->max_time_entry = go_gtk_builder_get_widget (state->gui, "max_time_entry"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_time_entry), param->options.max_time_sec); state->gradient_order_entry = go_gtk_builder_get_widget (state->gui, "gradient_order_entry"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->gradient_order_entry), param->options.gradient_order); /* lhs_entry */ grid = GTK_GRID (go_gtk_builder_get_widget (state->gui, "constraints-grid")); state->lhs.entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->lhs.entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF | GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->lhs.entry), TRUE); gtk_grid_attach (grid, GTK_WIDGET (state->lhs.entry), 0, 4, 1, 1); state->lhs.label = go_gtk_builder_get_widget (state->gui, "lhs_label"); gtk_label_set_mnemonic_widget (GTK_LABEL (state->lhs.label), GTK_WIDGET (state->lhs.entry)); gtk_widget_show (GTK_WIDGET (state->lhs.entry)); g_signal_connect_after (G_OBJECT (state->lhs.entry), "changed", G_CALLBACK (dialog_set_sec_button_sensitivity), state); g_signal_connect_swapped ( gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->lhs.entry)), "activate", G_CALLBACK (cb_dialog_add_clicked), state); /* rhs_entry */ state->rhs.entry = gnm_expr_entry_new (state->wbcg, TRUE); gnm_expr_entry_set_flags (state->rhs.entry, GNM_EE_SINGLE_RANGE | GNM_EE_FORCE_ABS_REF | GNM_EE_SHEET_OPTIONAL | GNM_EE_CONSTANT_ALLOWED, GNM_EE_MASK); gtk_widget_set_hexpand (GTK_WIDGET (state->rhs.entry), TRUE); gtk_grid_attach (grid, GTK_WIDGET (state->rhs.entry), 2, 4, 1, 1); gtk_widget_show (GTK_WIDGET (state->rhs.entry)); state->rhs.label = go_gtk_builder_get_widget (state->gui, "rhs_label"); gtk_label_set_mnemonic_widget ( GTK_LABEL (state->rhs.label), GTK_WIDGET (state->rhs.entry)); g_signal_connect_after (G_OBJECT (state->rhs.entry), "changed", G_CALLBACK (dialog_set_sec_button_sensitivity), state); g_signal_connect_swapped ( gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->rhs.entry)), "activate", G_CALLBACK (cb_dialog_add_clicked), state); /* type_menu */ state->type_combo = GTK_COMBO_BOX (go_gtk_builder_get_widget (state->gui, "type_menu")); gtk_combo_box_set_active (state->type_combo, 0); g_signal_connect (state->type_combo, "changed", G_CALLBACK (dialog_set_sec_button_sensitivity), state); /* constraint_list */ state->constraint_list = GTK_TREE_VIEW (go_gtk_builder_get_widget (state->gui, "constraint_list")); state->constr = NULL; g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (state->constraint_list)), "changed", G_CALLBACK (constraint_select_click), state); gtk_tree_view_set_reorderable (state->constraint_list, TRUE); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (state->constraint_list, GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ( _("Subject to the Constraints:"), renderer, "text", 0, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (state->constraint_list, column); { GtkWidget *w = GTK_WIDGET (state->constraint_list); int width, height, vsep; PangoLayout *layout = gtk_widget_create_pango_layout (w, "Mg19"); gtk_widget_style_get (w, "vertical_separator", &vsep, NULL); pango_layout_get_pixel_size (layout, &width, &height); gtk_widget_set_size_request (w, -1, (2 * height + vsep) * (4 + 1)); g_object_unref (layout); } /* Loading the old solver specs... from param */ for (cl = param->constraints; cl; cl = cl->next) { GnmSolverConstraint const *c = cl->data; GtkTreeIter iter; char *str; gtk_list_store_append (store, &iter); str = gnm_solver_constraint_as_str (c, state->sheet); gtk_list_store_set (store, &iter, 0, str, 1, c, -1); g_free (str); } g_object_unref (store); INIT_BOOL_ENTRY ("autoscale_button", options.automatic_scaling); INIT_BOOL_ENTRY ("non_neg_button", options.assume_non_negative); INIT_BOOL_ENTRY ("all_int_button", options.assume_discrete); INIT_BOOL_ENTRY ("program", options.program_report); INIT_BOOL_ENTRY ("sensitivity", options.sensitivity_report); input = gnm_solver_param_get_input (param); if (input != NULL) gnm_expr_entry_load_from_text (state->change_cell_entry, value_peek_string (input)); target_cell = gnm_solver_param_get_target_cell (param); if (target_cell) gnm_expr_entry_load_from_text (state->target_entry, cell_name (target_cell)); else { SheetView *sv = wb_control_cur_sheet_view (GNM_WBC (state->wbcg)); if (sv) { GnmRange first = {sv->edit_pos, sv->edit_pos}; gnm_expr_entry_load_from_range (state->target_entry, state->sheet, &first); } } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( go_gtk_builder_get_widget(state->gui, "max_button")), param->problem_type == GNM_SOLVER_MAXIMIZE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( go_gtk_builder_get_widget(state->gui, "min_button")), param->problem_type == GNM_SOLVER_MINIMIZE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( go_gtk_builder_get_widget(state->gui, "no_scenario")), ! param->options.add_scenario); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( go_gtk_builder_get_widget(state->gui, "optimal_scenario")), param->options.add_scenario); state->scenario_name_entry = go_gtk_builder_get_widget (state->gui, "scenario_name_entry"); gtk_entry_set_text (GTK_ENTRY (state->scenario_name_entry), param->options.scenario_name); state->run.status_widget = go_gtk_builder_get_widget (state->gui, "solver_status_label"); state->run.problem_status_widget = go_gtk_builder_get_widget (state->gui, "problem_status_label"); state->run.objective_value_widget = go_gtk_builder_get_widget (state->gui, "objective_value_label"); state->run.timer_widget = go_gtk_builder_get_widget (state->gui, "elapsed_time_label"); state->run.spinner = go_gtk_builder_get_widget (state->gui, "run_spinner"); /* Done */ gnm_expr_entry_grab_focus (state->target_entry, FALSE); wbcg_set_entry (state->wbcg, state->target_entry); dialog_set_main_button_sensitivity (NULL, state); dialog_set_sec_button_sensitivity (NULL, state); /* dialog */ wbc_gtk_attach_guru (state->wbcg, state->dialog); g_signal_connect_swapped (G_OBJECT (state->dialog), "destroy", G_CALLBACK (cb_dialog_solver_destroy), state); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify)unref_state); return FALSE; }
void create_romBrowser() { GtkWidget* menu; GtkWidget* submenu; GtkWidget* item; australia = gdk_pixbuf_new_from_file(get_iconpath("australia.png"), NULL); europe = gdk_pixbuf_new_from_file(get_iconpath("europe.png"), NULL); france = gdk_pixbuf_new_from_file(get_iconpath("france.png"), NULL); germany = gdk_pixbuf_new_from_file(get_iconpath("germany.png"), NULL); italy = gdk_pixbuf_new_from_file(get_iconpath("italy.png"), NULL); japan = gdk_pixbuf_new_from_file(get_iconpath("japan.png"), NULL); spain = gdk_pixbuf_new_from_file(get_iconpath("spain.png"), NULL); usa = gdk_pixbuf_new_from_file(get_iconpath("usa.png"), NULL); japanusa = gdk_pixbuf_new_from_file(get_iconpath("japanusa.png"), NULL); n64cart = gdk_pixbuf_new_from_file(get_iconpath("16x16/mupen64cart.png"), NULL); /* Setup rombrowser column names. g_MainWindow.column_names[column][0] is the translated column header. g_MainWindow.column_names[column][1] toggles visability in the config system. */ snprintf(g_MainWindow.column_names[0][0], 128, tr("Country")); snprintf(g_MainWindow.column_names[0][1], 128, "ColumnCountryVisible"); snprintf(g_MainWindow.column_names[1][0], 128, tr("Good Name")); snprintf(g_MainWindow.column_names[1][1], 128, "ColumnGoodNameVisible"); snprintf(g_MainWindow.column_names[2][0], 128, tr("Status")); snprintf(g_MainWindow.column_names[2][1], 128, "ColumnStatusVisible"); snprintf(g_MainWindow.column_names[3][0], 128, tr("User Comments")); snprintf(g_MainWindow.column_names[3][1], 128, "ColumnUserCommentsVisible"); snprintf(g_MainWindow.column_names[4][0], 128, tr("File Name")); snprintf(g_MainWindow.column_names[4][1], 128, "ColumnFileNameVisible"); snprintf(g_MainWindow.column_names[5][0], 128, tr("MD5 Hash")); snprintf(g_MainWindow.column_names[5][1], 128, "ColumnMD5HashVisible"); snprintf(g_MainWindow.column_names[6][0], 128, tr("CRC1")); snprintf(g_MainWindow.column_names[6][1], 128, "ColumnCRC1Visible"); snprintf(g_MainWindow.column_names[7][0], 128, tr("CRC2")); snprintf(g_MainWindow.column_names[7][1], 128, "ColumnCRC2Visible"); snprintf(g_MainWindow.column_names[8][0], 128, tr("Internal Name")); snprintf(g_MainWindow.column_names[8][1], 128, "ColumnInternalNameVisible"); snprintf(g_MainWindow.column_names[9][0], 128, tr("Save Types")); snprintf(g_MainWindow.column_names[9][1], 128, "ColumnSaveTypeVisible"); snprintf(g_MainWindow.column_names[10][0], 128, tr("Players")); snprintf(g_MainWindow.column_names[10][1], 128, "ColumnPlayersVisible"); snprintf(g_MainWindow.column_names[11][0], 128, tr("Size")); snprintf(g_MainWindow.column_names[11][1], 128, "ColumnSizeVisible"); snprintf(g_MainWindow.column_names[12][0], 128, tr("Compression")); snprintf(g_MainWindow.column_names[12][1], 128, "ColumnCompressionVisible"); snprintf(g_MainWindow.column_names[13][0], 128, tr("Image Type")); snprintf(g_MainWindow.column_names[13][1], 128, "ColumnImageTypeVisible"); snprintf(g_MainWindow.column_names[14][0], 128, tr("CIC Chip")); snprintf(g_MainWindow.column_names[14][1], 128, "ColumnCICChipVisible"); snprintf(g_MainWindow.column_names[15][0], 128, tr("Rumble")); snprintf(g_MainWindow.column_names[15][1], 128, "ColumnRumbleVisible"); /* Setup rombrowser tree views. */ g_MainWindow.romFullList = gtk_tree_view_new(); g_MainWindow.romDisplay = gtk_tree_view_new(); /* Multiple selections needed due to the way we clear the TreeViews. */ GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romFullList)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romDisplay)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* Initialize TreeViews - i.e. setup column info. models */ setup_view(g_MainWindow.romFullList); setup_view(g_MainWindow.romDisplay); g_MainWindow.romScrolledWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_MainWindow.romScrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* Add the Display TreeView into our scrolled window. */ gtk_container_add(GTK_CONTAINER(g_MainWindow.romScrolledWindow), g_MainWindow.romDisplay); gtk_container_add(GTK_CONTAINER(g_MainWindow.toplevelVBox), g_MainWindow.romScrolledWindow); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(g_MainWindow.romDisplay), FALSE); /* Open on double click. */ g_signal_connect(g_MainWindow.romDisplay, "row-activated", G_CALLBACK(callback_play_rom), NULL); /* Setup right-click menu. */ menu = gtk_menu_new(); g_MainWindow.playRomItem = gtk_image_menu_item_new_with_label(tr("Play Rom")); g_MainWindow.playRombrowserImage = gtk_image_new(); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.playRomItem), g_MainWindow.playRombrowserImage); g_signal_connect(g_MainWindow.playRomItem, "activate", G_CALLBACK(callback_play_rom), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.playRomItem); g_MainWindow.romPropertiesItem = gtk_image_menu_item_new_with_label(tr("Rom Properties")); g_MainWindow.propertiesRombrowserImage = gtk_image_new(); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.romPropertiesItem), g_MainWindow.propertiesRombrowserImage); g_signal_connect(g_MainWindow.romPropertiesItem, "activate", G_CALLBACK(callback_rom_properties), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.romPropertiesItem); gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); item = gtk_image_menu_item_new_with_label(tr("Refresh")); g_MainWindow.refreshRombrowserImage = gtk_image_new(); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), g_MainWindow.refreshRombrowserImage); g_signal_connect(item, "activate", G_CALLBACK(callback_call_rcs), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(tr("Configure Rombrowser")); g_signal_connect(item, "activate", G_CALLBACK(callback_configure_rombrowser), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); submenu = gtk_image_menu_item_new_with_label(tr("Configure Columns")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu), g_MainWindow.romHeaderMenu); gtk_menu_shell_append(GTK_MENU_SHELL(menu), submenu); gtk_widget_show_all(menu); g_signal_connect(g_MainWindow.romDisplay, "button-press-event", G_CALLBACK(callback_rombrowser_context), (gpointer)menu); }
static void codecs_box_init (CodecsBox *self) { GtkWidget *image = NULL; GtkWidget *scroll_window = NULL; GtkWidget *button = NULL; GtkWidget *buttons_vbox = NULL; GtkWidget *alignment = NULL; GtkListStore *list_store = NULL; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CODECS_BOX_TYPE, CodecsBoxPrivate); self->priv->type = Ekiga::Call::Audio; self->priv->audio_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (AUDIO_CODECS_SCHEMA)); self->priv->video_settings = boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (VIDEO_CODECS_SCHEMA)); self->priv->codecs_list = gtk_tree_view_new (); gtk_box_set_spacing (GTK_BOX (self), 6); gtk_box_set_homogeneous (GTK_BOX (self), FALSE); list_store = gtk_list_store_new (COLUMN_CODEC_NUMBER, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->codecs_list), TRUE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->codecs_list), TRUE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->codecs_list),0); gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->codecs_list), GTK_TREE_MODEL (list_store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->codecs_list), FALSE); /* Set all Colums */ renderer = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "active", COLUMN_CODEC_ACTIVE, NULL); gtk_tree_view_column_add_attribute (column, renderer, "activatable", COLUMN_CODEC_SELECTABLE); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 25); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); g_signal_connect (renderer, "toggled", G_CALLBACK (codec_toggled_cb), (gpointer) self); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); g_object_set (G_OBJECT (renderer), "weight", PANGO_WEIGHT_BOLD, NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_CLOCKRATE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", COLUMN_CODEC_PROTOCOLS, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->codecs_list), column); scroll_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll_window), GTK_SHADOW_IN); gtk_widget_set_size_request (scroll_window, -1, 130); gtk_container_add (GTK_CONTAINER (scroll_window), GTK_WIDGET (self->priv->codecs_list)); gtk_box_pack_start (GTK_BOX (self), scroll_window, TRUE, TRUE, 0); /* The buttons */ alignment = gtk_alignment_new (1, 0.5, 0, 0); buttons_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (alignment), buttons_vbox); image = gtk_image_new_from_icon_name ("go-up", GTK_ICON_SIZE_MENU); button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_set_tooltip_text (button, _("Move selected codec priority upwards")); gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (button), "operation", (gpointer) "up"); g_signal_connect (button, "clicked", G_CALLBACK (codec_moved_cb), (gpointer) self); image = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_MENU); button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_set_tooltip_text (button, _("Move selected codec priority downwards")); gtk_box_pack_start (GTK_BOX (buttons_vbox), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (button), "operation", (gpointer) "down"); g_signal_connect (button, "clicked", G_CALLBACK (codec_moved_cb), (gpointer) self); gtk_box_pack_start (GTK_BOX (self), alignment, FALSE, FALSE, 0); gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE); gtk_widget_show_all (GTK_WIDGET (self)); }
GtkWidget * scratch_tab_create() { GtkWidget *vbox = gtk_vbox_new(FALSE, 5); /* file list treeview */ filelist_treeview = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (filelist_treeview), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW (filelist_treeview), FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(filelist_treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT(filelist_treeview), "cursor-changed", G_CALLBACK (filelist_treeview_row_selected), NULL); filelist_treeview_sw = new_scrolled_window (NULL); gtk_container_add (GTK_CONTAINER (filelist_treeview_sw), filelist_treeview); /* add columns to the tree view */ GtkCellRenderer *renderer; GtkTreeViewColumn *col; int i; int col_count = sizeof (filelist_treeview_col_names) / sizeof (char *); for (i=0; i<col_count; i++) { renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (filelist_treeview_col_names[i], renderer, "text", i, NULL); if (i == 0) { gtk_tree_view_column_set_clickable(col, TRUE); gtk_tree_view_column_set_sort_order(col, GTK_SORT_DESCENDING); gtk_tree_view_column_set_sort_column_id(col, 0); gtk_tree_view_column_set_sort_indicator(col, TRUE); } else { gtk_tree_view_column_set_clickable(col, FALSE); } gtk_tree_view_append_column (GTK_TREE_VIEW(filelist_treeview), col); } filelist_store = gtk_list_store_new (col_count, G_TYPE_STRING, G_TYPE_STRING); GtkTreeSortable *sortable = GTK_TREE_SORTABLE(filelist_store); gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_DESCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(filelist_treeview), GTK_TREE_MODEL(filelist_store)); GtkWidget *hbox = gtk_hbox_new(TRUE, 5); GtkWidget *scratch_button = gtk_button_new_with_label("Scratch on map"); g_signal_connect (G_OBJECT (scratch_button), "clicked", G_CALLBACK (scratch_button_clicked), NULL); view_button = gtk_button_new_with_label("View"); g_signal_connect (G_OBJECT(view_button), "clicked", G_CALLBACK (view_button_clicked), NULL); delete_button = gtk_button_new_with_label("Delete"); g_signal_connect (G_OBJECT(delete_button), "clicked", G_CALLBACK (delete_button_clicked), NULL); gtk_container_add(GTK_CONTAINER(hbox), view_button); gtk_container_add(GTK_CONTAINER(hbox), delete_button); gtk_container_add(GTK_CONTAINER(hbox), scratch_button); gtk_box_pack_start(GTK_BOX(vbox), filelist_treeview_sw, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); /* populate files into filelist treeview */ GtkTreeIter iter; struct dirent *ep; char buf[256]; char *file_path = NULL; int len, ext_len = strlen(SCREENSHOT_FILE_EXT); char *fname; struct stat st; DIR *dp = opendir (g_context.screenshot_dir); if (dp == NULL) { if (stat(buf, &st) == 0) warn_dialog("unable to list screenshot files"); } else { while ((ep = readdir (dp))) { fname = ep->d_name; len = strlen(fname); if (ep->d_type == DT_REG && len > ext_len && (strncmp(&fname[len-ext_len], SCREENSHOT_FILE_EXT, ext_len) == 0)) { gtk_list_store_prepend (filelist_store, &iter); file_path = get_full_path(buf, sizeof(buf), fname); add_file_to_list(&iter, file_path, fname); } } closedir (dp); } notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE); GtkWidget *label; label = gtk_label_new("screen shot list"); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label); GtkWidget *image_box = gtk_vbox_new(FALSE, 0); screenshot_label = gtk_label_new(""); screenshot_image = gtk_image_new(); gtk_box_pack_start(GTK_BOX(image_box), screenshot_label, FALSE, FALSE, 0); GtkWidget *sw = new_scrolled_window (screenshot_image); /* stretch */ gtk_box_pack_start(GTK_BOX(image_box), sw, TRUE, TRUE, 0); label = gtk_label_new("view screen shot"); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), image_box, label); return notebook; }
void app_new(int argc, char *argv[], const char *geometry_string) { GtkWidget *vbox; GtkWidget *widget; GtkWidget *vpane; GtkWidget *separator; GtkLabel *filler; GtkHBox *labels; GtkVBox *status_vbox; GtkStatusbar *grip; app_window = gnome_app_new(GTT_APP_NAME, GTT_APP_TITLE " " VERSION); gtk_window_set_wmclass(GTK_WINDOW(app_window), GTT_APP_NAME, GTT_APP_PROPER_NAME); /* 485 x 272 seems to be a good size to default to */ gtk_window_set_default_size(GTK_WINDOW(app_window), 485, 272); gtk_window_set_resizable (GTK_WINDOW(app_window), TRUE); /* build menus */ menus_create(GNOME_APP(app_window)); /* build toolbar */ widget = build_toolbar(); gtk_widget_show(widget); gnome_app_set_toolbar(GNOME_APP(app_window), GTK_TOOLBAR(widget)); /* container holds status bar, main ctree widget */ vbox = gtk_vbox_new(FALSE, 0); /* build statusbar */ status_vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0)); gtk_widget_show(GTK_WIDGET(status_vbox)); labels = GTK_HBOX(gtk_hbox_new(FALSE, 0)); gtk_widget_show(GTK_WIDGET(labels)); status_bar = gtk_hbox_new(FALSE, 0); gtk_widget_show(status_bar); separator = gtk_hseparator_new(); gtk_widget_show(separator); gtk_box_pack_start(GTK_BOX(status_vbox), separator, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(status_vbox), GTK_WIDGET (labels), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET (status_vbox), TRUE, TRUE, 0); grip = GTK_STATUSBAR(gtk_statusbar_new()); gtk_statusbar_set_has_resize_grip(grip, TRUE); gtk_widget_show(GTK_WIDGET(grip)); gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET(grip), FALSE, FALSE, 0); /* put elapsed time into statusbar */ status_day_time = GTK_LABEL(gtk_label_new(_("00:00"))); gtk_widget_show(GTK_WIDGET(status_day_time)); gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_day_time), FALSE, TRUE, 0); /* put project name into statusbar */ status_project = GTK_LABEL(gtk_label_new( _("Timer is not running"))); gtk_widget_show(GTK_WIDGET(status_project)); gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_project), FALSE, TRUE, 10); filler = GTK_LABEL(gtk_label_new("")); gtk_widget_show(GTK_WIDGET(filler)); gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(filler), TRUE, TRUE, 1); /* put timer icon into statusbar */ status_timer = gtk_image_new_from_stock (GNOME_STOCK_TIMER, GTK_ICON_SIZE_MENU); gtk_widget_show(status_timer); gtk_box_pack_end(GTK_BOX(status_bar), GTK_WIDGET(status_timer), FALSE, FALSE, 1); /* create the main columned tree for showing projects */ projects_tree = gtt_projects_tree_new (); g_signal_connect (projects_tree, "columns-setup-done", G_CALLBACK (projects_tree_columns_setup_done), NULL); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (projects_tree), TRUE); g_signal_connect (projects_tree, "row-activated", G_CALLBACK (projects_tree_row_activated), NULL); /* create the notes area */ global_na = notes_area_new(); vpane = notes_area_get_widget (global_na); /* Need to reparent, to get rid of glade parent-window hack. * But gtk_widget_reparent (vpane); causes a "Gtk-CRITICAL" * to occur. So we need a fancier move. */ gtk_widget_ref (vpane); gtk_container_remove(GTK_CONTAINER(vpane->parent), vpane); gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 0); gtk_widget_unref (vpane); gtk_box_pack_end(GTK_BOX(vbox), status_bar, FALSE, FALSE, 2); notes_area_add_projects_tree (global_na, projects_tree); /* we are done building it, make it visible */ gtk_widget_show(vbox); gnome_app_set_contents(GNOME_APP(app_window), vbox); gtt_status_icon_create(); if (!geometry_string) return; if (gtk_window_parse_geometry(GTK_WINDOW(app_window),geometry_string)) { geom_size_override=TRUE; } else { gnome_app_error(GNOME_APP(app_window), _("Couldn't understand geometry (position and size)\n" " specified on command line")); } }
/* Shows the preferences dialog on the given tab */ void show_preferences(gint tab) { if(gtk_grab_get_current()) { /* A window is already open, so we present it to the user */ GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current()); gtk_window_present((GtkWindow*)toplevel); return; } /* Declare some variables */ GtkWidget *frame, *label, *alignment, *hbox, *vbox; GtkObject *adjustment, *adjustment_small, *adjustment_statics; GtkTreeViewColumn *tree_column; /* Create the dialog */ GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL, (GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL)); gtk_window_set_resizable((GtkWindow*)dialog, FALSE); /* Create notebook */ GtkWidget* notebook = gtk_notebook_new(); #if GTK_CHECK_VERSION (2,14,0) gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2); #else gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2); #endif /* Build the settings page */ GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings"))); GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_settings, vbox_settings); /* Build the clipboards frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)")); g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0); primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)")); g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0); synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards")); gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0); paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item")); g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the miscellaneous frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu")); gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0); save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs")); gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0); hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only")); gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0); confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history")); gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0); use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu")); gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0); /* Build the history page */ GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History"))); GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_history, vbox_history); /* Build the history frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); save_check = gtk_check_button_new_with_mnemonic(_("Save _history")); gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions")); gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in history:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0); history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0); items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0); statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu")); g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL); gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Static items in menu:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0); statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the items frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line")); gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0); reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order")); gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Character length of items:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0); charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0); gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID); gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_new_text(); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); /* Build the omitting frame frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Omit items in the:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0); ellipsize_combo = gtk_combo_box_new_text(); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle")); gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End")); gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0); gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */ /* Build the actions page */ GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions"))); GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_actions, vbox_actions); /* Build the actions label */ label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0); /* Build the actions treeview */ GtkWidget* scrolled_window = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE); actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list); GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new(); g_object_set(name_renderer, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new(); g_object_set(command_renderer, "editable", TRUE, NULL); g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1); tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL); gtk_tree_view_column_set_expand(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column); gtk_container_add((GtkContainer*)scrolled_window, treeview); gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview); gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START); GtkWidget* add_button = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0); GtkWidget* remove_button = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL); gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0); GtkWidget* up_button = gtk_button_new(); gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL); gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0); GtkWidget* down_button = gtk_button_new(); gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL); gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0); /* Build the exclude page */ GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude"))); GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6); gtk_container_add((GtkContainer*)page_exclude, vbox_exclude); /* Build the exclude label */ label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc).")); gtk_label_set_line_wrap((GtkLabel*)label, TRUE); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0); /* Build the exclude treeview */ GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new( (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0), (GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0)); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT); GtkWidget* treeview_exclude = gtk_tree_view_new(); gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE); gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE); exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1); gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list); GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new(); g_object_set(name_renderer_exclude, "editable", TRUE, NULL); g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0); tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL); gtk_tree_view_column_set_resizable(tree_column, TRUE); gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column); gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude); gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0); /* Edit selection and connect treeview related signals */ exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude); gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE); g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL); /* Build the buttons */ GtkWidget* hbbox_exclude = gtk_hbutton_box_new(); gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6); gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START); GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add...")); gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0); GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove")); gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU)); g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL); gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0); /* Build the hotkeys page */ GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6); gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys"))); GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12); gtk_container_add((GtkContainer*)page_extras, vbox_extras); /* Build the hotkeys frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE); label = gtk_label_new(NULL); gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>")); gtk_frame_set_label_widget((GtkFrame*)frame, label); alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0); gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0); gtk_container_add((GtkContainer*)frame, alignment); vbox = gtk_vbox_new(FALSE, 2); gtk_container_add((GtkContainer*)alignment, vbox); /* History key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("History hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); history_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0); /* Actions key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Actions hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); actions_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0); /* Menu key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Menu hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); menu_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0); /* Search key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Manage hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); search_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0); /* Offline mode key combination */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Offline mode hotkey:")); gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50); gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0); offline_key_entry = gtk_entry_new(); gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10); gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0); gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0); /* Make widgets reflect current preferences */ gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy); gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary); gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize); gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste); gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes); gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris); gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu); gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history); gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit); gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu); gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show); gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items); gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only); gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear); gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line); gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history); gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length); gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1); gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key); gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key); gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key); gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key); gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key); /* Read actions */ read_actions(); read_excludes(); /* Run the dialog */ gtk_widget_show_all(dialog); #ifdef HAVE_APPINDICATOR gtk_widget_hide(use_rmb_menu_check); #endif gtk_notebook_set_current_page((GtkNotebook*)notebook, tab); if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT) { /* If the user disabled history saving, we ask him if he wants to delete the history file */ if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check)) check_saved_hist_file(); /* Apply and save preferences */ apply_preferences(); save_preferences(); save_actions(); save_excludes(); } gtk_widget_destroy(dialog); }
TextReplacementDialog::TextReplacementDialog(int dummy) { // Get configurations. extern Settings *settings; // Shortcuts. Shortcuts shortcuts(0); textreplacementdialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(textreplacementdialog), _("Text Replacement")); gtk_window_set_position(GTK_WINDOW(textreplacementdialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal(GTK_WINDOW(textreplacementdialog), TRUE); gtk_window_set_type_hint(GTK_WINDOW(textreplacementdialog), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(textreplacementdialog)); gtk_widget_show(dialog_vbox1); vbox1 = gtk_vbox_new(FALSE, 2); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0); checkbutton1 = gtk_check_button_new_with_mnemonic(_("Replace text when printing and exporting")); gtk_widget_show(checkbutton1); gtk_box_pack_start(GTK_BOX(vbox1), checkbutton1, FALSE, FALSE, 0); shortcuts.button(checkbutton1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton1), settings->genconfig.text_replacement_get()); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_SHADOW_IN); treeview1 = gtk_tree_view_new(); gtk_widget_show(treeview1); gtk_container_add(GTK_CONTAINER(scrolledwindow1), treeview1); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview1), TRUE); dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(textreplacementdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(textreplacementdialog, NULL, &shortcuts, "menu-preferences/text-replacement"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(textreplacementdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); shortcuts.stockbutton(cancelbutton1); okbutton1 = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(textreplacementdialog), okbutton1, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true); shortcuts.stockbutton(okbutton1); shortcuts.process(); g_signal_connect((gpointer) checkbutton1, "toggled", G_CALLBACK(on_checkbutton1_toggled), gpointer(this)); g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this)); gtk_widget_grab_focus(okbutton1); gtk_widget_grab_default(okbutton1); // Toggle button. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton1), settings->genconfig.text_replacement_get()); // Storage, renderer, column and selection. model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(model)); g_object_unref(model); GtkCellRenderer *renderer1 = gtk_cell_renderer_text_new(); g_signal_connect(renderer1, "edited", G_CALLBACK(cell_text_edited), gpointer(this)); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview1), -1, "Texts", renderer1, "text", COLUMN_ORIGINALS, "editable", COLUMN_EDITABLE1, NULL); GtkCellRenderer *renderer2 = gtk_cell_renderer_text_new(); g_signal_connect(renderer2, "edited", G_CALLBACK(cell_replacement_edited), gpointer(this)); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview1), -1, "Replacements", renderer2, "text", COLUMN_REPLACEMENTS, "editable", COLUMN_EDITABLE2, NULL); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)), GTK_SELECTION_SINGLE); // Load texts and replacements - these get initialized to defaults if there were none. vector < ustring > originals; vector < ustring > replacements; text_replacement_get_words(originals, replacements); GtkTreeIter iter; for (unsigned int i = 0; i < originals.size(); i++) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, COLUMN_ORIGINALS, originals[i].c_str(), COLUMN_EDITABLE1, 1, COLUMN_REPLACEMENTS, replacements[i].c_str(), COLUMN_EDITABLE2, 1, -1); } gui(); new DialogAutoScaler (textreplacementdialog, G_MAXINT); }
static GtkWidget * key_dialog_treeview_new (GtkWidget *box) { GtkWidget *scroll; GtkListStore *store, *combostore; GtkTreeViewColumn *col; GtkWidget *view; GtkCellRenderer *render; int i; scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); g_return_val_if_fail (store != NULL, NULL); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE); g_signal_connect (G_OBJECT (view), "key-press-event", G_CALLBACK (key_dialog_keypress), NULL); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))), "changed", G_CALLBACK (key_dialog_selection_changed), NULL); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); render = gtk_cell_renderer_accel_new (); g_object_set (render, "editable", TRUE, #ifndef WIN32 "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER, #endif NULL); g_signal_connect (G_OBJECT (render), "accel-edited", G_CALLBACK (key_dialog_set_key), NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN, "Key", render, "text", KEY_COLUMN, NULL); render = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), ACCEL_COLUMN, "Accel", render, "text", ACCEL_COLUMN, NULL); combostore = gtk_list_store_new (1, G_TYPE_STRING); for (i = 0; i <= KEY_MAX_ACTIONS; i++) { GtkTreeIter iter; if (key_actions[i].name[0]) { gtk_list_store_append (combostore, &iter); gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1); } } render = gtk_cell_renderer_combo_new (); g_object_set (G_OBJECT (render), "model", combostore, "has-entry", FALSE, "editable", TRUE, "text-column", 0, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN)); g_signal_connect (G_OBJECT (render), "changed", G_CALLBACK (key_dialog_combo_changed), combostore); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN, "Action", render, "text", ACTION_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D1_COLUMN, "Data1", render, "text", D1_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D2_COLUMN, "Data2", render, "text", D2_COLUMN, NULL); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN); gtk_tree_view_column_set_fixed_width (col, 200); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN); gtk_tree_view_column_set_visible (col, FALSE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN); gtk_tree_view_column_set_fixed_width (col, 160); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); gtk_container_add (GTK_CONTAINER (scroll), view); gtk_container_add (GTK_CONTAINER (box), scroll); return view; }
static void pluma_documents_panel_init (PlumaDocumentsPanel *panel) { GtkWidget *sw; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; panel->priv = PLUMA_DOCUMENTS_PANEL_GET_PRIVATE (panel); panel->priv->adding_tab = FALSE; panel->priv->is_reodering = FALSE; gtk_orientable_set_orientation (GTK_ORIENTABLE (panel), GTK_ORIENTATION_VERTICAL); /* Create the scrolled window */ sw = gtk_scrolled_window_new (NULL, NULL); g_return_if_fail (sw != NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0); /* Create the empty model */ panel->priv->model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); /* Create the treeview */ panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model); g_object_unref (G_OBJECT (panel->priv->model)); gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), TRUE); g_object_set (panel->priv->treeview, "has-tooltip", TRUE, NULL); gtk_widget_show (panel->priv->treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Documents")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview), column); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (panel->priv->treeview, "cursor_changed", G_CALLBACK (treeview_cursor_changed), panel); g_signal_connect (panel->priv->treeview, "button-press-event", G_CALLBACK (panel_button_press_event), panel); g_signal_connect (panel->priv->treeview, "popup-menu", G_CALLBACK (panel_popup_menu), panel); g_signal_connect (panel->priv->treeview, "query-tooltip", G_CALLBACK (treeview_query_tooltip), NULL); g_signal_connect (panel->priv->model, "row-inserted", G_CALLBACK (treeview_row_inserted), panel); }
static TBEditorWidget *tb_editor_create_dialog(MarlinViewWindow *mvw) { GtkWidget *dialog, *vbox, *hbox, *vbox_buttons, *button_add, *button_remove; GtkWidget *swin_available, *swin_used, *tree_available, *tree_used, *label; GtkCellRenderer *text_renderer, *icon_renderer; GtkTreeViewColumn *column; TBEditorWidget *tbw = g_new(TBEditorWidget, 1); dialog = gtk_dialog_new_with_buttons(_("Customize Toolbar"), GTK_WINDOW (mvw), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 300); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); tbw->store_available = gtk_list_store_new(TB_EDITOR_COLS_MAX, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); tbw->store_used = gtk_list_store_new(TB_EDITOR_COLS_MAX, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); label = gtk_label_new(_("Select items to be displayed on the toolbar. Items can be reordered by drag and drop.")); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); tree_available = gtk_tree_view_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(tree_available), GTK_TREE_MODEL(tbw->store_available)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_available), TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tbw->store_available), TB_EDITOR_COL_LABEL, GTK_SORT_ASCENDING); icon_renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column); text_renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Available Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column); swin_available = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_available), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_available), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(swin_available), tree_available); tree_used = gtk_tree_view_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(tree_used), GTK_TREE_MODEL(tbw->store_used)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_used), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree_used), TRUE); icon_renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column); text_renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Displayed Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column); swin_used = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_used), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_used), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(swin_used), tree_used); /* drag'n'drop */ gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_available), GDK_BUTTON1_MASK, tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_available), tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); g_signal_connect(tree_available, "drag-data-get", G_CALLBACK(tb_editor_drag_data_get_cb), tbw); g_signal_connect(tree_available, "drag-data-received", G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw); g_signal_connect(tree_available, "drag-motion", G_CALLBACK(tb_editor_drag_motion_cb), tbw); gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_used), GDK_BUTTON1_MASK, tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_used), tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); g_signal_connect(tree_used, "drag-data-get", G_CALLBACK(tb_editor_drag_data_get_cb), tbw); g_signal_connect(tree_used, "drag-data-received", G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw); g_signal_connect(tree_used, "drag-motion", G_CALLBACK(tb_editor_drag_motion_cb), tbw); button_add = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(button_add), gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); button_remove = gtk_button_new(); g_signal_connect(button_add, "clicked", G_CALLBACK(tb_editor_btn_add_clicked_cb), tbw); gtk_button_set_image(GTK_BUTTON(button_remove), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); g_signal_connect(button_remove, "clicked", G_CALLBACK(tb_editor_btn_remove_clicked_cb), tbw); vbox_buttons = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); /* FIXME this is a little hack'ish, any better ideas? */ gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), button_add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), button_remove, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(hbox), swin_available, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox_buttons, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), swin_used, TRUE, TRUE, 0); g_object_set (label, "margin", 5, NULL); g_object_set (hbox, "margin", 5, NULL); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_widget_show_all(vbox); g_object_unref(tbw->store_available); g_object_unref(tbw->store_used); tbw->dialog = dialog; tbw->tree_available = GTK_TREE_VIEW(tree_available); tbw->tree_used = GTK_TREE_VIEW(tree_used); tbw->last_drag_path = NULL; return tbw; }