static pid_t attach_process_show (AttachProcess * ap, GtkWindow *parent) { GtkTreeView *view; GtkTreeStore *store; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkCheckButton *checkb_hide_paths; GtkCheckButton *checkb_hide_params; GtkCheckButton *checkb_process_tree; gint i, res; pid_t selected_pid = -1; g_return_val_if_fail (ap != NULL, -1); if (!ap->dialog) { GtkBuilder *bxml; bxml = anjuta_util_builder_new (GLADE_FILE, NULL); if (!bxml) return 0; anjuta_util_builder_get_objects (bxml, "attach_process_dialog", &ap->dialog, "attach_process_tv", &ap->treeview, "checkb_hide_paths", &checkb_hide_paths, "checkb_hide_params", &checkb_hide_params, "checkb_process_tree", &checkb_process_tree, NULL); g_object_unref (bxml); view = GTK_TREE_VIEW (ap->treeview); store = gtk_tree_store_new (COLUMNS_NB, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (view, GTK_TREE_MODEL (store)); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view), GTK_SELECTION_SINGLE); g_object_unref (G_OBJECT (store)); renderer = gtk_cell_renderer_text_new (); for (i = PID_COLUMN; i < COLUMNS_NB; i++) { GtkTreeViewColumn *column; column = gtk_tree_view_column_new_with_attributes (column_names[i], renderer, "text", i, NULL); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (view, column); if (i == COMMAND_COLUMN) gtk_tree_view_set_expander_column(view, column); } gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), PID_COLUMN, sort_pid, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), START_COLUMN, GTK_SORT_DESCENDING); ap->hide_paths = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_hide_paths)); ap->hide_params = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_hide_params)); ap->process_tree = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_process_tree)); attach_process_update (ap); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ap->treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_selection_changed), ap); g_signal_connect (G_OBJECT (ap->dialog), "delete_event", G_CALLBACK (on_delete_event), ap); g_signal_connect (checkb_hide_paths, "toggled", G_CALLBACK (on_toggle_hide_paths), ap); g_signal_connect (checkb_hide_params, "toggled", G_CALLBACK (on_toggle_hide_params), ap); g_signal_connect (checkb_process_tree, "toggled", G_CALLBACK (on_toggle_process_tree), ap); } gtk_window_set_transient_for (GTK_WINDOW (ap->dialog), GTK_WINDOW (parent)); /* gtk_widget_show (ap->dialog); */ res = gtk_dialog_run (GTK_DIALOG (ap->dialog)); while (res == GTK_RESPONSE_APPLY) { attach_process_update (ap); res = gtk_dialog_run (GTK_DIALOG (ap->dialog)); } if (res == GTK_RESPONSE_OK) { selected_pid = ap->pid; } attach_process_clear (ap, CLEAR_FINAL); return selected_pid; }
static GtkWidget * pidgin_get_mail_dialog(void) { if (mail_dialog == NULL) { GtkWidget *dialog = NULL; GtkWidget *label; GtkWidget *sw; GtkCellRenderer *rend; GtkTreeViewColumn *column; GtkWidget *button = NULL; GtkWidget *vbox = NULL; dialog = gtk_dialog_new_with_buttons(_("New Mail"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_window_set_role(GTK_WINDOW(dialog), "new_mail_detailed"); g_signal_connect(G_OBJECT(dialog), "focus-in-event", G_CALLBACK(mail_window_focus_cb), NULL); gtk_dialog_add_button(GTK_DIALOG(dialog), _("Open All Messages"), GTK_RESPONSE_ACCEPT); button = gtk_dialog_add_button(GTK_DIALOG(dialog), PIDGIN_STOCK_OPEN_MAIL, GTK_RESPONSE_YES); /* make "Open All Messages" the default response */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); /* Setup the dialog */ gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BOX_SPACE); gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BOX_SPACE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), PIDGIN_HIG_BORDER); /* Vertical box */ vbox = GTK_DIALOG(dialog)->vbox; /* Golden ratio it up! */ gtk_widget_set_size_request(dialog, 550, 400); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); mail_dialog = g_new0(PidginMailDialog, 1); mail_dialog->dialog = dialog; mail_dialog->open_button = button; mail_dialog->treemodel = gtk_tree_store_new(COLUMNS_PIDGIN_MAIL, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER); mail_dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mail_dialog->treemodel)); g_object_unref(G_OBJECT(mail_dialog->treemodel)); gtk_tree_view_set_search_column(GTK_TREE_VIEW(mail_dialog->treeview), PIDGIN_MAIL_TEXT); gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(mail_dialog->treeview), pidgin_tree_view_search_equal_func, NULL, NULL); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(email_response_cb), mail_dialog); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(mail_dialog->treeview))), "changed", G_CALLBACK(selection_changed_cb), mail_dialog); g_signal_connect(G_OBJECT(mail_dialog->treeview), "row-activated", G_CALLBACK(email_row_activated_cb), NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mail_dialog->treeview), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(mail_dialog->treeview), TRUE); gtk_container_add(GTK_CONTAINER(sw), mail_dialog->treeview); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_resizable(column, TRUE); rend = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "pixbuf", PIDGIN_MAIL_ICON, NULL); rend = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, rend, TRUE); gtk_tree_view_column_set_attributes(column, rend, "markup", PIDGIN_MAIL_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(mail_dialog->treeview), column); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<span weight=\"bold\" size=\"larger\">You have mail!</span>")); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); } return mail_dialog->dialog; }
static GtkTreeModel * gnac_ui_file_chooser_get_filters_model(void) { guint i; GSList *f; GtkFileFilter *filter; GtkTreeIter iter1, iter2, iter3; GtkTreeStore *store; /* To translators: translation of filters' name can be * found in /usr/share/mime */ const gchar *lossy_mime[][2] = { { "audio/mpeg" , _("MP3 audio") }, { "audio/mp4" , _("MPEG-4 audio") }, { "audio/x-musepack" , _("Musepack audio") }, { "audio/ogg" , _("Ogg Audio") }, { "audio/vnd.rn-realaudio", _("RealAudio document") }, { "audio/x-speex" , _("Speex audio") }, { "audio/x-ms-wma" , _("Windows Media audio") }, { NULL, NULL } }; const gchar *lossless_mime[][2] = { { "audio/x-ape" , _("Monkey's audio") }, { "audio/x-flac" , _("Flac audio") }, { "audio/x-wav" , _("WAV audio") }, { "audio/x-wavpack", _("WavPack audio") }, { NULL, NULL } }; const gchar *playlists_mime[][2] = { { "audio/x-ms-asx" , _("Microsoft ASX playlist") }, { "audio/x-mpegurl" , _("MP3 audio (streamed)") }, { "audio/x-scpls" , _("MP3 ShoutCast playlist") }, { "application/xspf+xml", _("XSPF playlist") }, { NULL, NULL } }; const gchar *video_mime[][2] = { { "video/3gpp" , _("3GPP multimedia file") }, { "video/x-ms-asf" , _("ASF video") }, { "video/x-msvideo" , _("AVI video") }, { "video/x-flv" , _("Flash video") }, { "video/x-matroska" , _("Matroska video") }, { "video/mpeg" , _("MPEG video") }, { "video/mp4" , _("MPEG-4 video") }, { "application/ogg" , _("Ogg multimedia file") }, { "video/ogg" , _("Ogg video") }, { "video/quicktime" , _("QuickTime video") }, { "application/vnd.rn-realmedia" , _("RealMedia document") }, { "application/x-shockwave-flash", _("Shockwave Flash file") }, { "video/x-ms-wmv" , _("Windows Media video") }, { NULL, NULL } }; filters = NULL; store = gtk_tree_store_new(1, G_TYPE_POINTER); /* All files */ filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, _("All files")); gtk_tree_store_append(store, &iter1, NULL); gtk_tree_store_set(store, &iter1, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Supported files */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Supported files")); i = 0; while (lossless_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]); i++; } i = 0; while (lossy_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]); i++; } i = 0; while (playlists_mime[i][0]) { gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]); i++; } i = 0; while (video_mime[i][0]) { gtk_file_filter_add_mime_type(filter, video_mime[i][0]); i++; } gtk_tree_store_append(store, &iter1, NULL); gtk_tree_store_set(store, &iter1, 0, filter, -1); filters = g_slist_prepend(filters, filter); default_file_filter = filter; /* Audio files */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Audio files")); i = 0; while (lossless_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]); i++; } i = 0; while (lossy_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]); i++; } i = 0; while (playlists_mime[i][0]) { gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]); i++; } gtk_tree_store_append(store, &iter1, NULL); gtk_tree_store_set(store, &iter1, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Lossy files */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Lossy files")); i = 0; while (lossy_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]); i++; } gtk_tree_store_append(store, &iter2, &iter1); gtk_tree_store_set(store, &iter2, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Individual lossy files */ i = 0; while (lossy_mime[i][0]) { filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, lossy_mime[i][0]); gtk_file_filter_set_name(filter, lossy_mime[i][1]); gtk_tree_store_append(store, &iter3, &iter2); gtk_tree_store_set(store, &iter3, 0, filter, -1); filters = g_slist_prepend(filters, filter); i++; } /* Lossless files */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Lossless files")); i = 0; while (lossless_mime[i][0]) { gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]); i++; } gtk_tree_store_append(store, &iter2, &iter1); gtk_tree_store_set(store, &iter2, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Individual lossless files */ i = 0; while (lossless_mime[i][0]) { filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, lossless_mime[i][0]); gtk_file_filter_set_name(filter, lossless_mime[i][1]); gtk_tree_store_append(store, &iter3, &iter2); gtk_tree_store_set(store, &iter3, 0, filter, -1); filters = g_slist_prepend(filters, filter); i++; } /* Playlists */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Playlists")); i = 0; while (playlists_mime[i][0]) { gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]); i++; } gtk_tree_store_append(store, &iter1, NULL); gtk_tree_store_set(store, &iter1, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Individual playlists */ i = 0; while (playlists_mime[i][0]) { filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, playlists_mime[i][0]); gtk_file_filter_set_name(filter, playlists_mime[i][1]); gtk_tree_store_append(store, &iter2, &iter1); gtk_tree_store_set(store, &iter2, 0, filter, -1); filters = g_slist_prepend(filters, filter); i++; } /* Video files */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Video files")); i = 0; while (video_mime[i][0]) { gtk_file_filter_add_mime_type(filter, video_mime[i][0]); i++; } gtk_tree_store_append(store, &iter1, NULL); gtk_tree_store_set(store, &iter1, 0, filter, -1); filters = g_slist_prepend(filters, filter); /* Individual video files */ i = 0; while (video_mime[i][0]) { filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, video_mime[i][0]); gtk_file_filter_set_name(filter, video_mime[i][1]); gtk_tree_store_append(store, &iter2, &iter1); gtk_tree_store_set(store, &iter2, 0, filter, -1); filters = g_slist_prepend(filters, filter); i++; } filters = g_slist_reverse(filters); for (f = filters; f; f = g_slist_next(f)) { g_object_ref(f->data); } return GTK_TREE_MODEL(store); }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *sw; GtkWidget *tv; GtkWidget *box; GtkWidget *combo_box; GtkTreeModel *model; gint i; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm); #if 0 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ()); #endif models[MODEL_LIST] = create_list_model (); models[MODEL_TREE] = create_tree_model (); model = create_list_model (); models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); model = create_tree_model (); models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT)); models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT)); models[MODEL_NULL] = NULL; run_automated_tests (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 430, 400); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); tv = gtk_tree_view_new_with_model (models[0]); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); /* Model menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < MODEL_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); g_signal_connect (combo_box, "changed", G_CALLBACK (model_selected), tv); /* Columns menu */ combo_box = gtk_combo_box_text_new (); gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER); for (i = 0; i < COLUMNS_LAST; i++) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]); gtk_container_add (GTK_CONTAINER (box), combo_box); set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS); gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS); g_signal_connect (combo_box, "changed", G_CALLBACK (columns_selected), tv); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (box), sw); gtk_container_add (GTK_CONTAINER (sw), tv); create_prop_editor (G_OBJECT (tv), GTK_TYPE_TREE_VIEW); create_prop_editor (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))), GTK_TYPE_TREE_SELECTION); gtk_widget_show_all (window); gtk_main (); return 0; }
static void pkg_window_init (PkgWindow *window) { PkgWindowPrivate *priv; GtkAccelGroup *accel_group; GtkWidget *vbox; GtkWidget *menu_bar; GtkWidget *perfkit_menu; GtkWidget *help_menu; GtkWidget *hpaned; GtkWidget *scroller; GtkTreeViewColumn *column; GtkCellRenderer *text; GtkCellRenderer *cpix; GtkTreeSelection *selection; ENTRY; priv = G_TYPE_INSTANCE_GET_PRIVATE(window, PKG_TYPE_WINDOW, PkgWindowPrivate); window->priv = priv; g_static_rw_lock_init(&priv->rw_lock); gtk_window_set_title(GTK_WINDOW(window), _("Perfkit")); gtk_window_set_default_size(GTK_WINDOW(window), 780, 550); accel_group = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); #define ADD_MENU(_n, _s) \ G_STMT_START { \ GtkWidget *_w; \ _w = gtk_menu_item_new_with_mnemonic((_s)); \ gtk_widget_show((_w)); \ gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), (_w)); \ _n = gtk_menu_new(); \ gtk_menu_item_set_submenu(GTK_MENU_ITEM(_w), _n); \ } G_STMT_END #define ADD_MENU_ITEM(_p, _s, _f) \ G_STMT_START { \ GtkWidget *_w; \ _w = gtk_menu_item_new_with_mnemonic(_s); \ gtk_widget_show((_w)); \ gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \ g_signal_connect(_w, "activate", G_CALLBACK(_f), \ window); \ } G_STMT_END #define ADD_MENU_ITEM_STOCK(_p, _s, _f) \ G_STMT_START { \ GtkWidget *_w = gtk_image_menu_item_new_from_stock( \ (_s), accel_group); \ gtk_widget_show((_w)); \ gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \ g_signal_connect(_w, "activate", G_CALLBACK(_f), \ window); \ } G_STMT_END #define ADD_SEPARATOR(_p) \ G_STMT_START { \ GtkWidget *_w = gtk_separator_menu_item_new(); \ gtk_widget_show((_w)); \ gtk_menu_shell_append(GTK_MENU_SHELL(_p), (_w)); \ } G_STMT_END ADD_MENU(perfkit_menu, _("_Perfkit")); ADD_MENU_ITEM(perfkit_menu, _("Connect to _Server"), gtk_false); ADD_SEPARATOR(perfkit_menu); ADD_MENU_ITEM_STOCK(perfkit_menu, GTK_STOCK_REFRESH, pkg_window_refresh_all); ADD_SEPARATOR(perfkit_menu); ADD_MENU_ITEM_STOCK(perfkit_menu, GTK_STOCK_QUIT, gtk_main_quit); ADD_MENU(help_menu, _("_Help")); ADD_MENU_ITEM_STOCK(help_menu, GTK_STOCK_ABOUT, gtk_false); hpaned = gtk_hpaned_new(); gtk_paned_set_position(GTK_PANED(hpaned), 275); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); scroller = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN); gtk_paned_add1(GTK_PANED(hpaned), scroller); gtk_widget_show(scroller); priv->model = gtk_tree_store_new(5, PK_TYPE_CONNECTION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); priv->treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(scroller), priv->treeview); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview), GTK_TREE_MODEL(priv->model)); gtk_tree_view_expand_all(GTK_TREE_VIEW(priv->treeview)); gtk_widget_show(priv->treeview); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview)); g_signal_connect(selection, "changed", G_CALLBACK(pkg_window_selection_changed), window); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Agents")); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview), column); cpix = gtk_cell_renderer_pixbuf_new(); g_object_set(cpix, "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL); gtk_tree_view_column_pack_start(column, cpix, FALSE); gtk_tree_view_column_set_cell_data_func(column, cpix, pkg_window_pixbuf_data_func, window, NULL); text = gtk_cell_renderer_text_new(); g_object_set(text, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start(column, text, TRUE); gtk_tree_view_column_set_cell_data_func(column, text, pkg_window_label_data_func, window, NULL); priv->container = gtk_alignment_new(0.5f, 0.5f, 1.0f, 1.0f); gtk_paned_add2(GTK_PANED(hpaned), priv->container); gtk_widget_show(priv->container); EXIT; }
void gmdb_sql_new_cb (GtkWidget *w, gpointer data) { GtkTargetEntry src; GtkWidget *mi, *but, *combobox; GladeXML *sqlwin_xml; /* load the interface */ sqlwin_xml = glade_xml_new(GMDB_GLADEDIR "gmdb-sql.glade", NULL, NULL); /* connect the signals in the interface */ glade_xml_signal_autoconnect(sqlwin_xml); sql_list = g_list_append(sql_list, sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "save_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_save_cb), sqlwin_xml); but = glade_xml_get_widget (sqlwin_xml, "save_button"); g_signal_connect (G_OBJECT (but), "clicked", G_CALLBACK (gmdb_sql_save_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "save_as_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_save_as_cb), sqlwin_xml); //but = glade_xml_get_widget (sqlwin_xml, "save_as_button"); //g_signal_connect (G_OBJECT (but), "clicked", // G_CALLBACK (gmdb_sql_save_as_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "results_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_results_cb), sqlwin_xml); but = glade_xml_get_widget (sqlwin_xml, "results_button"); g_signal_connect (G_OBJECT (but), "clicked", G_CALLBACK (gmdb_sql_results_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "open_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_open_cb), sqlwin_xml); but = glade_xml_get_widget (sqlwin_xml, "open_button"); g_signal_connect (G_OBJECT (but), "clicked", G_CALLBACK (gmdb_sql_open_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "paste_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_paste_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "cut_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_cut_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "copy_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_copy_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "close_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_close_cb), sqlwin_xml); but = glade_xml_get_widget (sqlwin_xml, "close_button"); g_signal_connect (G_OBJECT (but), "clicked", G_CALLBACK (gmdb_sql_close_cb), sqlwin_xml); mi = glade_xml_get_widget (sqlwin_xml, "execute_menu"); g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (gmdb_sql_execute_cb), sqlwin_xml); combobox = glade_xml_get_widget(sqlwin_xml, "sql_combo"); g_signal_connect (G_OBJECT(GTK_COMBO_BOX(combobox)), "changed", G_CALLBACK (gmdb_sql_select_hist_cb), sqlwin_xml); but = glade_xml_get_widget (sqlwin_xml, "execute_button"); g_signal_connect (G_OBJECT (but), "clicked", G_CALLBACK (gmdb_sql_execute_cb), sqlwin_xml); /* set up treeview, libglade only gives us the empty widget */ GtkWidget *tree = glade_xml_get_widget(sqlwin_xml, "sql_treeview"); GtkTreeStore *store = gtk_tree_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store)); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (tree), column); GtkTreeSelection *select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); //g_signal_connect (G_OBJECT (select), "changed", //G_CALLBACK (gmdb_sql_select_cb), sqlwin_xml); /* populate first level of tree */ gmdb_sql_tree_populate(mdb, sqlwin_xml); GtkWidget *textview = glade_xml_get_widget(sqlwin_xml, "sql_textview"); src.target = "table"; src.flags = 0; src.info = 1; gtk_drag_source_set( tree, GDK_BUTTON1_MASK, &src, 1, GDK_ACTION_COPY); gtk_drag_dest_set( textview, //GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT , // GTK_DEST_DEFAULT_DROP, &src, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_signal_connect( GTK_OBJECT(tree), "drag_data_get", GTK_SIGNAL_FUNC(gmdb_sql_dnd_dataget_cb), sqlwin_xml); gtk_signal_connect( GTK_OBJECT(textview), "drag_data_received", GTK_SIGNAL_FUNC(gmdb_sql_dnd_datareceived_cb), sqlwin_xml); //GValue value = {0, }; //but = glade_xml_get_widget(sqlwin_xml, "results_button"); //g_value_init(&value, G_TYPE_STRING); //g_value_set_static_string(&value, GMDB_ICONDIR "stock_export.png"); //g_object_set_property(G_OBJECT (but), "file" , &value); //g_value_unset (&value); gtk_widget_grab_focus(GTK_WIDGET(textview)); }
int main(int argc, char *argv[]) { GtkWidget *button; GtkWidget *box1; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "hart"); g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL); gtk_container_set_border_width(GTK_CONTAINER(window), 10); box1 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), box1); //Create tree model store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN); create_file_tree(".", NULL); //Sort the model for convenience sorted_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(sorted_model), FILE_COLUMN, GTK_SORT_ASCENDING); //Create the tree's view tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sorted_model)); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("File", renderer, "text", FILE_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes("Locked", renderer, "active", LOCKED_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); //Add ui callbacks for the tree GtkTreeSelection *select; select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(tree_selection_changed_cb), NULL); //Add tree to box gtk_box_pack_start(GTK_BOX(box1), tree, TRUE, TRUE, 0); //Create console output label GtkWidget* frame = gtk_frame_new("Console output"); GtkWidget* text_view = gtk_text_view_new(); GtkTextTagTable* text_tag_table = gtk_text_tag_table_new(); GtkTextBuffer* console_buffer = gtk_text_buffer_new(text_tag_table); gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), console_buffer); gchar* test_str = "blah\nwoiajheoih\nwoeihoiwha\nweoihewoih\nwoeihoi"; gtk_text_buffer_set_text(console_buffer, test_str, strlen(test_str)); gtk_container_add(GTK_CONTAINER(frame), text_view); gtk_box_pack_start(GTK_BOX(box1), frame, TRUE, TRUE, 0); //Create button w/ label GtkWidget* file_button = gtk_file_chooser_button_new("Select a folder", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_box_pack_start(GTK_BOX(box1), file_button, TRUE, TRUE, 0); g_signal_connect(file_button, "file-set", G_CALLBACK(file_button_callback), (gpointer)"file_button"); //Show all of the widgets gtk_widget_show(file_button); gtk_widget_show(tree); gtk_widget_show(frame); gtk_widget_show(text_view); gtk_widget_show(box1); gtk_widget_show(window); //Show window last so they all appear at once. gtk_main (); return 0; }
GtkTreeStore *pl_empty_tree_store(void) { GtkTreeStore *tree_store = gtk_tree_store_new(N_COLUMNS,G_TYPE_STRING,G_TYPE_INT,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_INT,G_TYPE_STRING); return tree_store; }
static void foldersel_create(void) { GtkWidget *vbox; GtkWidget *scrolledwin; GtkWidget *confirm_area; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; static GdkGeometry geometry; window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel"); gtk_window_set_title(GTK_WINDOW(window), _("Select folder")); gtk_container_set_border_width(GTK_CONTAINER(window), 4); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); gtk_widget_realize(window); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(key_pressed), NULL); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(foldersel_size_allocate_cb), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window); vbox = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(window), vbox); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0); tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, GDK_TYPE_COLOR, G_TYPE_INT); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store), FOLDERSEL_FOLDERNAME, foldersel_folder_name_compare, NULL, NULL); treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store)); g_object_unref(G_OBJECT(tree_store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), prefs_common.use_stripes_everywhere); gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), FOLDERSEL_FOLDERNAME); if (prefs_common.folder_search_wildcard) gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview), foldersel_search_name_func, NULL, NULL); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selection, foldersel_selected, NULL, NULL); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(foldersel_tree_activated), NULL); gtk_container_add(GTK_CONTAINER(scrolledwin), treeview); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_spacing(column, 2); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FOLDERSEL_PIXBUF, "pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN, "pixbuf-expander-closed", FOLDERSEL_PIXBUF, NULL); /* create text renderer */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FOLDERSEL_FOLDERNAME, "foreground-gdk", FOLDERSEL_FOREGROUND, "weight", FOLDERSEL_BOLD, NULL); g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); entry = gtk_entry_new(); gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE); gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(foldersel_entry_activated), NULL); gtkut_stock_button_set_create(&confirm_area, &new_button, GTK_STOCK_NEW, &cancel_button, GTK_STOCK_CANCEL, &ok_button, GTK_STOCK_OK); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_button); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(foldersel_ok), NULL); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(foldersel_cancel), NULL); g_signal_connect(G_OBJECT(new_button), "clicked", G_CALLBACK(foldersel_new_folder), NULL); if (!geometry.min_height) { geometry.min_width = 300; geometry.min_height = 360; } gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry, GDK_HINT_MIN_SIZE); gtk_widget_set_size_request(window, prefs_common.folderselwin_width, prefs_common.folderselwin_height); gtk_widget_show_all(vbox); }
int main (int argc, char *argv[]) { GtkTreeModel *model; gtk_init_with_args (&argc, &argv, NULL, entries, NULL, NULL); model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING)); test_run ("list store append", model, (ClearFunc*)gtk_list_store_clear, (InsertFunc*)list_store_append); test_run ("list store prepend", model, (ClearFunc*)gtk_list_store_clear, (InsertFunc*)list_store_prepend); test_run ("list store insert", model, (ClearFunc*)gtk_list_store_clear, (InsertFunc*)list_store_insert); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), compare, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); test_run ("list store insert (sorted)", model, (ClearFunc*)gtk_list_store_clear, (InsertFunc*)list_store_insert); g_object_unref (model); model = GTK_TREE_MODEL (gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_STRING)); test_run ("tree store append", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_append); test_run ("tree store prepend", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_prepend); test_run ("tree store insert (flat)", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_insert_flat); test_run ("tree store insert (deep)", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_insert_deep); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), compare, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); test_run ("tree store insert (flat, sorted)", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_insert_flat); test_run ("tree store insert (deep, sorted)", model, (ClearFunc*)gtk_tree_store_clear, (InsertFunc*)tree_store_insert_deep); return 0; }
static GtkTreeModel * create_object_tree_model(void) { return GTK_TREE_MODEL(gtk_tree_store_new(OBJECT_COLUMN_TYPE_NUM, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN)); }
void terminal_edit_keys_dialog_show (GtkWindow *transient_parent) { TerminalApp *app; GtkWidget *dialog, *tree_view, *disable_mnemonics_button, *disable_menu_accel_button; GtkTreeViewColumn *column; GtkCellRenderer *cell_renderer; GtkTreeStore *tree; guint i; if (edit_keys_dialog != NULL) goto done; if (!terminal_util_load_builder_file ("keybinding-editor.ui", "keybindings-dialog", &dialog, "disable-mnemonics-checkbutton", &disable_mnemonics_button, "disable-menu-accel-checkbutton", &disable_menu_accel_button, "accelerators-treeview", &tree_view, NULL)) return; app = terminal_app_get (); terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MNEMONICS, disable_mnemonics_button, 0); terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MENU_BAR_ACCEL, disable_menu_accel_button, 0); /* Column 1 */ cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("_Action"), cell_renderer, "text", ACTION_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); gtk_tree_view_column_set_sort_column_id (column, ACTION_COLUMN); /* Column 2 */ cell_renderer = gtk_cell_renderer_accel_new (); g_object_set (cell_renderer, "editable", TRUE, "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK, NULL); g_signal_connect (cell_renderer, "accel-edited", G_CALLBACK (accel_edited_callback), tree_view); g_signal_connect (cell_renderer, "accel-cleared", G_CALLBACK (accel_cleared_callback), tree_view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut _Key")); gtk_tree_view_column_pack_start (column, cell_renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, cell_renderer, accel_set_func, NULL, NULL); gtk_tree_view_column_set_sort_column_id (column, KEYVAL_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); /* Add the data */ tree = edit_keys_store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); #ifdef MATE_ENABLE_DEBUG _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS) g_signal_connect (tree, "row-changed", G_CALLBACK (row_changed), NULL); #endif for (i = 0; i < G_N_ELEMENTS (all_entries); ++i) { GtkTreeIter parent_iter; guint j; gtk_tree_store_append (tree, &parent_iter, NULL); gtk_tree_store_set (tree, &parent_iter, ACTION_COLUMN, _(all_entries[i].user_visible_name), -1); for (j = 0; j < all_entries[i].n_elements; ++j) { KeyEntry *key_entry = &(all_entries[i].key_entry[j]); GtkTreeIter iter; gtk_tree_store_insert_with_values (tree, &iter, &parent_iter, -1, ACTION_COLUMN, _(key_entry->user_visible_name), KEYVAL_COLUMN, key_entry, -1); } } gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (tree), KEYVAL_COLUMN, accel_compare_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (tree), ACTION_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (tree)); g_object_unref (tree); gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view)); g_signal_connect (notification_group, "accel-changed", G_CALLBACK (treeview_accel_changed_cb), tree); edit_keys_dialog = dialog; g_signal_connect (dialog, "destroy", G_CALLBACK (edit_keys_dialog_destroy_cb), tree); g_signal_connect (dialog, "response", G_CALLBACK (edit_keys_dialog_response_cb), NULL); gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 350); done: gtk_window_set_transient_for (GTK_WINDOW (edit_keys_dialog), transient_parent); gtk_window_present (GTK_WINDOW (edit_keys_dialog)); }
static void _lib_tag_gui_update (gpointer instance,gpointer self) { dt_lib_module_t *dm = (dt_lib_module_t *)self; dt_lib_keywords_t *d = (dt_lib_keywords_t*)dm->data; GtkTreeStore *store = gtk_tree_store_new(1, G_TYPE_STRING); /* initialize the tree store with known tags */ sqlite3_stmt *stmt; GtkTreeIter uncategorized, temp; memset(&uncategorized,0,sizeof(GtkTreeIter)); DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT name,icon,description FROM tags ORDER BY UPPER(name) DESC", -1, &stmt, NULL); gtk_tree_store_clear(store); while (sqlite3_step(stmt) == SQLITE_ROW) { if(strchr((const char *)sqlite3_column_text(stmt, 0),'|')==0) { /* add uncategorized root iter if not exists */ if (!uncategorized.stamp) { gtk_tree_store_insert(store, &uncategorized, NULL,0); gtk_tree_store_set(store, &uncategorized, 0, _(UNCATEGORIZED_TAG), -1); } /* adding a uncategorized tag */ gtk_tree_store_insert(store, &temp, &uncategorized,0); gtk_tree_store_set(store, &temp, 0, sqlite3_column_text(stmt, 0), -1); } else { int level = 0; char *value; GtkTreeIter current,iter; char **pch = g_strsplit((char *)sqlite3_column_text(stmt, 0),"|", -1); if (pch != NULL) { int j = 0; while (pch[j] != NULL) { gboolean found=FALSE; int children = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store),level>0?¤t:NULL); /* find child with name, if not found create and continue */ for (int k=0; k<children; k++) { if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), &iter, level>0?¤t:NULL, k)) { gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &value, -1); if (strcmp(value, pch[j])==0) { current = iter; found = TRUE; break; } } } /* lets add new keyword and assign current */ if (!found) { gtk_tree_store_insert(store, &iter, level>0?¤t:NULL,0); gtk_tree_store_set(store, &iter, 0, pch[j], -1); current = iter; } level++; j++; } g_strfreev(pch); } } } gtk_tree_view_set_model(d->view, GTK_TREE_MODEL(store)); /* free store, treeview has its own storage now */ g_object_unref(store); }
/* \brief Create the tree model for the "Library" view. * \par Function Description * Creates a tree where the branches are the available library * sources and the leaves are the footprints. */ static GtkTreeModel * create_lib_tree_model (GhidLibraryWindow * library_window) { GtkTreeStore *tree; GtkTreeIter iter, p_iter, e_iter, c_iter; gchar *name; gboolean exists; tree = gtk_tree_store_new (N_MENU_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER); MENU_LOOP (&Library); { /* Watch for directory changes of library parts and create new | parent iter at each change. */ if (!menu->directory) /* Shouldn't happen */ menu->directory = g_strdup ("???"); exists = FALSE; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tree), &e_iter)) do { gtk_tree_model_get (GTK_TREE_MODEL (tree), &e_iter, MENU_NAME_COLUMN, &name, -1); if (!strcmp (name, menu->directory)) { exists = TRUE; break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tree), &e_iter)); if (exists) p_iter = e_iter; else { gtk_tree_store_append (tree, &p_iter, NULL); gtk_tree_store_set (tree, &p_iter, MENU_NAME_COLUMN, menu->directory, MENU_LIBRARY_COLUMN, NULL, MENU_ENTRY_COLUMN, NULL, -1); } gtk_tree_store_append (tree, &iter, &p_iter); gtk_tree_store_set (tree, &iter, MENU_NAME_COLUMN, menu->Name, MENU_LIBRARY_COLUMN, menu, MENU_ENTRY_COLUMN, NULL, -1); ENTRY_LOOP (menu); { gtk_tree_store_append (tree, &c_iter, &iter); gtk_tree_store_set (tree, &c_iter, MENU_NAME_COLUMN, entry->ListEntry, MENU_LIBRARY_COLUMN, menu, MENU_ENTRY_COLUMN, entry, -1); } END_LOOP; } END_LOOP; return (GtkTreeModel *) tree; }
static GtkTreeModel* create_model(void) { GtkTreeStore* treestore = gtk_tree_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER); GtkTreeIter rootlevel, toplevel; int t; file_info root_file_data, current_file_data, *addeditem = NULL; char tempstring[STRINGSIZE]; // EnableControls(FALSE); strcpy(root_file_data.filename, "/"); root_file_data.filesize = 0; root_file_data.filetype = FIROOT; strcpy(root_file_data.fullpath, ""); root_file_data.partition = 255; root_file_data.number_of_children = 0; AddToTreeStore(treestore, NULL, &rootlevel, &root_file_data, NULL); /* gtk_tree_store_append(treestore, &rootlevel, NULL); //create blank entry root_directory = AddFileDataToList(&root_file_data); addeditem = root_directory; gtk_tree_store_set(treestore, &rootlevel, COL_FILENAME, root_file_data.filename, COL_POINTER, addeditem, -1);*/ for (t=0; t<5; ++t) { if (t == 1) continue; //skip the non-filesystem partition snprintf(tempstring, STRINGSIZE-1, "p%d",t); //partition directory name strcpy(current_file_data.filename, tempstring); current_file_data.filesize = 0; strcpy(current_file_data.fullpath, "/"); strcpy(current_file_data.dirpath, "/"); current_file_data.partition = t; current_file_data.filetype = FIPART; current_file_data.number_of_children = 0; strcpy(tempstring, "add filename: "); if (strlen(tempstring) + strlen(current_file_data.filename) < STRINGSIZE) strcat(tempstring, current_file_data.filename); // Log("add filename:"); Log(DEBUGGING, "current_file_data.filename: %s", current_file_data.filename); AddToTreeStore(treestore, &rootlevel, &toplevel, ¤t_file_data, &root_file_data); if (ChangePartition(t) == FALSE) { EnableControls(TRUE); return NULL; } if(ChangeDirectory("/")==FALSE) { EnableControls(TRUE); return NULL; } //RecursiveListing("/",addeditem,t); // strcpy(tempstring, "/"); RecursiveListing("/", addeditem, &toplevel, t, 0, treestore); //m_directory_tree.Expand(hItem[t],TVE_EXPAND);//hmm? //TODO: map filename data to some data in memory } //m_directory_tree.Expand(rItem,TVE_EXPAND); ChangePartition(0); //make sure we're back at the media partition!!! ChangeDirectory("/DCIM"); //Log(); EnableControls(TRUE); return GTK_TREE_MODEL(treestore); }
/** * Build data storage by querying the X server for all input devices. * Can be called multiple times, in which case it'll clean out and re-fill * update the tree store. */ static GtkTreeStore* query_devices(GDeviceSetup* gds) { GtkTreeStore *treestore; GtkTreeModel *model; GtkTreeIter iter, child; XIDeviceInfo *devices, *dev; int ndevices; int i, j; int icontype; GdkPixbuf *icon; int valid, child_valid; int id, masterid; if (!gds->treeview) { treestore = gtk_tree_store_new(NUM_COLS, G_TYPE_UINT, /* deviceid*/ G_TYPE_STRING, /* name */ G_TYPE_UINT, GDK_TYPE_PIXBUF, G_TYPE_UINT ); model = GTK_TREE_MODEL(treestore); } else { model = gtk_tree_view_get_model(gds->treeview); treestore = GTK_TREE_STORE(model); } gds->generation++; devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices); /* First, run through all master device and append them to the tree store */ for (i = 0; i < ndevices; i++) { dev = &devices[i]; if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard) continue; valid = gtk_tree_model_get_iter_first(model, &iter); g_debug("MD %d: %s", dev->deviceid, dev->name); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &id, -1); if (id == dev->deviceid) { gtk_tree_store_set(treestore, &iter, COL_GENERATION, gds->generation, -1); valid = 0xFF; break; } valid = gtk_tree_model_iter_next(model, &iter); } if (valid != 0xFF) /* new MD */ { icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD; icon = load_icon(icontype); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, COL_ID, dev->deviceid, COL_NAME, dev->name, COL_USE, dev->use, COL_ICON, icon, COL_GENERATION, gds->generation, -1); g_object_unref(icon); } } /* search for Floating fake master device */ valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &id, -1); if (id == ID_FLOATING) break; valid = gtk_tree_model_iter_next(model, &iter); } if (!valid) { /* Attach a fake master device for "Floating" */ icon = load_icon(ICON_FLOATING); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, COL_ID, ID_FLOATING, COL_NAME, "Floating", COL_USE, ID_FLOATING, COL_ICON, icon, COL_GENERATION, gds->generation, -1); g_object_unref(icon); } else { GtkTreeIter prev; GtkTreeIter pos = iter; /* current position of Floating */ /* always move Floating fake device to end of list */ while(valid) { prev = iter; valid = gtk_tree_model_iter_next(model, &iter); } gtk_tree_store_move_after(treestore, &pos, &prev); /* update generation too */ gtk_tree_store_set(treestore, &pos, COL_GENERATION, gds->generation, -1); } /* now that we added all MDs, run through again and add SDs to the * respective MD */ for (i = 0; i < ndevices; i++) { dev = &devices[i]; if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard) continue; g_debug("SD %d: %s", dev->deviceid, dev->name); valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1); if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING)) { /* found master, check if we're already attached to it in * the tree model */ child_valid = gtk_tree_model_iter_children(model, &child, &iter); while (child_valid) { gtk_tree_model_get(model, &child, COL_ID, &id); if (id == dev->deviceid) { gtk_tree_store_set(treestore, &child, COL_GENERATION, gds->generation, -1); child_valid = 0xFF; break; } child_valid = gtk_tree_model_iter_next(model, &child); } /* new slave device, attach */ if (child_valid != 0xFF) { gtk_tree_store_append(treestore, &child, &iter); gtk_tree_store_set(treestore, &child, COL_ID, dev->deviceid, COL_NAME, dev->name, COL_USE, dev->use, COL_GENERATION, gds->generation, -1); } break; } valid = gtk_tree_model_iter_next(model, &iter); } } XIFreeDeviceInfo(devices); /* clean tree store of anything that doesn't have the current server generation */ valid = gtk_tree_model_get_iter_first(model, &iter); while(valid) { int gen; child_valid = gtk_tree_model_iter_children(model, &child, &iter); while(child_valid) { gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1); if (gen < gds->generation) child_valid = gtk_tree_store_remove(treestore, &child); else child_valid = gtk_tree_model_iter_next(model, &child); } gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1); if (gen < gds->generation) valid = gtk_tree_store_remove(treestore, &iter); else valid = gtk_tree_model_iter_next(model, &iter); } return treestore; }
GtkWidget *gtkui_cheats() { // Create the Cheats window if (cheatwindow) { return NULL; } cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager"); GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox); GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow, 512, 256); treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview); infobar = gtk_info_bar_new(); infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL); gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0); GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar)); gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0); GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0); GtkWidget *cheatopen = gtk_widget_new( GTK_TYPE_BUTTON, "label", "Open", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0); GtkWidget *cheatclear = gtk_widget_new( GTK_TYPE_BUTTON, "label", "Clear", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0); GtkWidget *cheatremove = gtk_widget_new( GTK_TYPE_BUTTON, "label", "Remove", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0); GtkWidget *descbox = gtk_widget_new( GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0); GtkWidget *desclabel = gtk_widget_new( GTK_TYPE_LABEL, "label", "Description:", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-left", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0); descedit = gtk_widget_new( GTK_TYPE_ENTRY, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0); GtkWidget *ggbox = gtk_widget_new( GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0); GtkWidget *gglabel = gtk_widget_new( GTK_TYPE_LABEL, "label", "Game Genie:", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-left", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0); ggedit = gtk_widget_new( GTK_TYPE_ENTRY, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0); GtkWidget *genieadd = gtk_widget_new( GTK_TYPE_BUTTON, "label", "Add", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0); GtkWidget *parbox = gtk_widget_new( GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0); GtkWidget *parlabel = gtk_widget_new( GTK_TYPE_LABEL, "label", "Pro Action Rocky:", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-left", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0); paredit = gtk_widget_new( GTK_TYPE_ENTRY, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0); GtkWidget *paradd = gtk_widget_new( GTK_TYPE_BUTTON, "label", "Add", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0); GtkWidget *cheatok = gtk_widget_new( GTK_TYPE_BUTTON, "label", "OK", "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE); treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new(); GtkTreeViewColumn *column[5]; // create the display columns column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL); column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL); column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL); column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL); column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL); // add the display column and renderer to the tree view gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]); gtkui_cheats_fill_tree(nstpaths.cheatpath); /*g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(gtkui_cheats_check), NULL);*/ g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(gtkui_cheats_toggle), NULL); g_signal_connect(G_OBJECT(cheatopen), "clicked", G_CALLBACK(gtkui_cheats_load), NULL); g_signal_connect(G_OBJECT(cheatclear), "clicked", G_CALLBACK(gtkui_cheats_clear), NULL); g_signal_connect(G_OBJECT(cheatremove), "clicked", G_CALLBACK(gtkui_cheats_remove), NULL); g_signal_connect(G_OBJECT(genieadd), "clicked", G_CALLBACK(gtkui_cheats_gg_add), NULL); g_signal_connect(G_OBJECT(paradd), "clicked", G_CALLBACK(gtkui_cheats_par_add), NULL); g_signal_connect(G_OBJECT(cheatok), "clicked", G_CALLBACK(gtkui_cheats_ok), NULL); g_signal_connect(G_OBJECT(cheatwindow), "destroy", G_CALLBACK(gtkui_cheats_ok), NULL); gtk_widget_show_all(cheatwindow); gtk_widget_hide(infobar); return cheatwindow; }
static GtkWidget * create_tree (void) { GtkTreeSelection *selection; GtkCellRenderer *cell; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkTreeStore *model; GtkTreeIter iter; GtkWidget *box, *label, *scrolled_window; Demo *d = gtk_demos; model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT); tree_view = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_BROWSE); gtk_widget_set_size_request (tree_view, 200, -1); /* this code only supports 1 level of children. If we * want more we probably have to use a recursing function. */ while (d->title) { Demo *children = d->children; gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, TITLE_COLUMN, d->title, FILENAME_COLUMN, d->filename, FUNC_COLUMN, d->func, STYLE_COLUMN, PANGO_STYLE_NORMAL, -1); d++; if (!children) continue; while (children->title) { GtkTreeIter child_iter; gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter); gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter, TITLE_COLUMN, children->title, FILENAME_COLUMN, children->filename, FUNC_COLUMN, children->func, STYLE_COLUMN, PANGO_STYLE_NORMAL, -1); children++; } } cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Widget (double click for demo)", cell, "text", TITLE_COLUMN, "style", STYLE_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column)); gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter); gtk_tree_selection_select_iter (GTK_TREE_SELECTION (selection), &iter); g_signal_connect (selection, "changed", G_CALLBACK (selection_cb), model); g_signal_connect (tree_view, "row_activated", G_CALLBACK (row_activated_cb), model); gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); label = gtk_label_new ("Widget (double click for demo)"); box = gtk_notebook_new (); gtk_notebook_append_page (GTK_NOTEBOOK (box), scrolled_window, label); gtk_widget_grab_focus (tree_view); g_object_unref (model); return box; }
static void init_tree() { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeStore *store; int i; PangoFontDescription *font_desc = pango_font_description_from_string(prefs.divelist_font); gtk_widget_modify_font(yearly_tree, font_desc); pango_font_description_free(font_desc); renderer = gtk_cell_renderer_text_new (); /* don't use empty strings "" - they confuse gettext */ char *columnstop[] = { N_("Year"), N_("#"), N_("Duration"), " ", " ", " ", N_("Depth"), " ", " ", N_("SAC"), " ", " ", N_("Temperature"), " ", " " }; const char *columnsbot[15]; columnsbot[0] = C_("Stats", " > Month"); columnsbot[1] = " "; columnsbot[2] = C_("Duration","Total"); columnsbot[3] = C_("Duration","Average"); columnsbot[4] = C_("Duration","Shortest"); columnsbot[5] = C_("Duration","Longest"); columnsbot[6] = C_("Depth", "Average"); columnsbot[7] = C_("Depth","Minimum"); columnsbot[8] = C_("Depth","Maximum"); columnsbot[9] = C_("SAC","Average"); columnsbot[10]= C_("SAC","Minimum"); columnsbot[11]= C_("SAC","Maximum"); columnsbot[12]= C_("Temp","Average"); columnsbot[13]= C_("Temp","Minimum"); columnsbot[14]= C_("Temp","Maximum"); /* Add all the columns to the tree view */ for (i = 0; i < N_COLUMNS; ++i) { char buf[256]; column = gtk_tree_view_column_new(); snprintf(buf, sizeof(buf), "%s\n%s", _(columnstop[i]), columnsbot[i]); gtk_tree_view_column_set_title(column, buf); gtk_tree_view_append_column(GTK_TREE_VIEW(yearly_tree), column); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", i); gtk_tree_view_column_set_resizable(column, TRUE); } /* Field types */ store = gtk_tree_store_new ( N_COLUMNS, // Columns in structure G_TYPE_STRING, // Period (year or month) G_TYPE_STRING, // Number of dives G_TYPE_STRING, // Total duration G_TYPE_STRING, // Average dive duation G_TYPE_STRING, // Shortest dive G_TYPE_STRING, // Longest dive G_TYPE_STRING, // Average depth G_TYPE_STRING, // Shallowest dive G_TYPE_STRING, // Deepest dive G_TYPE_STRING, // Average air consumption (SAC) G_TYPE_STRING, // Minimum SAC G_TYPE_STRING, // Maximum SAC G_TYPE_STRING, // Average temperature G_TYPE_STRING, // Minimum temperature G_TYPE_STRING // Maximum temperature ); gtk_tree_view_set_model (GTK_TREE_VIEW (yearly_tree), GTK_TREE_MODEL (store)); g_object_unref (store); }
static void parasite_widget_tree_init(ParasiteWidgetTree *widget_tree, ParasiteWidgetTreeClass *klass) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; widget_tree->priv = PARASITE_WIDGET_TREE_GET_PRIVATE(widget_tree); widget_tree->priv->model = gtk_tree_store_new( NUM_COLUMNS, G_TYPE_POINTER, // WIDGET G_TYPE_STRING, // WIDGET_NAME G_TYPE_STRING, // WIDGET_NAME G_TYPE_BOOLEAN, // WIDGET_REALIZED G_TYPE_BOOLEAN, // WIDGET_VISIBLE G_TYPE_BOOLEAN, // WIDGET_MAPPED G_TYPE_STRING, // WIDGET_WINDOW G_TYPE_STRING, // WIDGET_ADDRESS G_TYPE_STRING); // ROW_COLOR widget_tree->priv->edit_mode_enabled = FALSE; gtk_tree_view_set_model(GTK_TREE_VIEW(widget_tree), GTK_TREE_MODEL(widget_tree->priv->model)); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(widget_tree), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(widget_tree), WIDGET_NAME); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget_tree)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(parasite_widget_tree_on_widget_selected), widget_tree); // Widget column renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, NULL); column = gtk_tree_view_column_new_with_attributes("Widget", renderer, "text", WIDGET_TYPE, "foreground", ROW_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); gtk_tree_view_column_set_resizable(column, TRUE); // Name column renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, NULL); column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", WIDGET_NAME, "foreground", ROW_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); gtk_tree_view_column_set_resizable(column, TRUE); // Realized column renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT(renderer), "activatable", TRUE, "indicator-size", TREE_CHECKBOX_SIZE, NULL); column = gtk_tree_view_column_new_with_attributes("Realized", renderer, "active", WIDGET_REALIZED, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(on_toggle_realize), widget_tree); // Mapped column renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT(renderer), "activatable", TRUE, "indicator-size", TREE_CHECKBOX_SIZE, NULL); column = gtk_tree_view_column_new_with_attributes("Mapped", renderer, "active", WIDGET_MAPPED, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); //g_signal_connect(G_OBJECT(renderer), "toggled", // G_CALLBACK(on_toggle_map), widget_tree); // Visible column renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT(renderer), "activatable", TRUE, "indicator-size", TREE_CHECKBOX_SIZE, NULL); column = gtk_tree_view_column_new_with_attributes("Visible", renderer, "active", WIDGET_VISIBLE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); //g_signal_connect(G_OBJECT(renderer), "toggled", // G_CALLBACK(on_toggle_visible), widget_tree); // X Window column renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, "family", "monospace", NULL); column = gtk_tree_view_column_new_with_attributes("X Window", renderer, "text", WIDGET_WINDOW, "foreground", ROW_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); gtk_tree_view_column_set_resizable(column, TRUE); // Poinder Address column renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "scale", TREE_TEXT_SCALE, "family", "monospace", NULL); column = gtk_tree_view_column_new_with_attributes("Pointer Address", renderer, "text", WIDGET_ADDRESS, "foreground", ROW_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(widget_tree), column); gtk_tree_view_column_set_resizable(column, TRUE); }
static void run_automated_tests (void) { g_print ("Running automated tests...\n"); /* FIXME TreePath basic verification */ /* FIXME generic consistency checks on the models */ { /* Make sure list store mutations don't crash anything */ GtkListStore *store; GtkTreeModel *model; gint i; GtkTreeIter iter; store = gtk_list_store_new (1, G_TYPE_INT); model = GTK_TREE_MODEL (store); i = 0; while (i < 100) { gtk_list_store_append (store, &iter); ++i; } while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); gtk_list_store_append (store, &iter); /* inserts before last node in list */ i = 0; while (i < 100) { gtk_list_store_insert_before (store, &iter, &iter); ++i; } /* inserts after the node before the last node */ i = 0; while (i < 100) { gtk_list_store_insert_after (store, &iter, &iter); ++i; } /* inserts after the last node */ gtk_list_store_append (store, &iter); i = 0; while (i < 100) { gtk_list_store_insert_after (store, &iter, &iter); ++i; } /* remove everything again */ while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); /* Prepends */ gtk_list_store_prepend (store, &iter); i = 0; while (i < 100) { gtk_list_store_prepend (store, &iter); ++i; } /* remove everything again */ while (gtk_tree_model_get_iter_first (model, &iter)) gtk_list_store_remove (store, &iter); g_object_unref (store); } { /* Make sure tree store mutations don't crash anything */ GtkTreeStore *store; GtkTreeIter root; store = gtk_tree_store_new (1, G_TYPE_INT); gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL); /* Remove test until it is rewritten to work */ /* treestore_torture_recurse (store, &root, 0);*/ g_object_unref (store); } g_print ("Passed.\n"); }
void bestelakoak() { GtkWidget *frame; GtkWidget *alignment; GtkWidget *fixed; GtkWidget *cmdGehi; GtkWidget *cmdKendu; GtkWidget *cmdAdos; GtkWidget *cmdUtzi; GtkWidget *cmdKen; GtkWidget *labela; GtkWidget *cmdGehitu; GtkWidget *taula; GtkWidget *eventbox; GtkWidget *cmdZenbakiak3; GtkWidget *cmdZenbakiak2; GtkWidget *cmdZenbakiak4; GtkWidget *cmdZenbakiak5; GtkWidget *cmdZenbakiak6; GtkWidget *cmdZenbakiak9; GtkWidget *cmdZenbakiak8; GtkWidget *cmdZenbakiak7; GtkWidget *cmdZenbakiak0; GtkWidget *cmdZenbakiak10; GtkWidget *cmdZenbakiak11; GtkWidget *cmdZenbakiak1; GtkTreeModel *model; GtkCellRenderer *renderer; /* Lehioa sortu eta konfiguratu */ frmBestelakoak = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_position (GTK_WINDOW (frmBestelakoak), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_modal (GTK_WINDOW (frmBestelakoak), TRUE); gtk_window_set_decorated (GTK_WINDOW (frmBestelakoak), FALSE); //gtk_window_set_type_hint (GTK_WINDOW (frmBestelakoak), GDK_WINDOW_TYPE_HINT_DIALOG); //gtk_window_set_transient_for(GTK_WINDOW(frmBestelakoak), GTK_WINDOW(frmKontua)); /* Lehioaren egitura sortu eta kokatu */ frame = gtk_frame_new (""); gtk_container_add (GTK_CONTAINER (frmBestelakoak), frame); gdk_color_parse("#e3e0e0", &kolorea); gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); fixed = gtk_fixed_new (); gtk_container_add (GTK_CONTAINER (alignment), fixed); labela = gtk_label_new ("<span size='large'><b> Sartu zerrendan bestelako gastuak </b></span>"); gtk_fixed_put (GTK_FIXED (fixed), labela, 0, 0); gtk_widget_set_size_request (labela, 312, 32); gtk_label_set_use_markup (GTK_LABEL (labela), TRUE); /* Kalkulagailua sortu eta kokatu */ frame = gtk_frame_new (NULL); gtk_fixed_put (GTK_FIXED (fixed), frame, 0, 32); gdk_color_parse("#858484", &kolorea); gtk_widget_modify_bg(frame, GTK_STATE_NORMAL, &kolorea); gtk_widget_set_size_request (frame, 250, 300); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_container_add(GTK_CONTAINER(frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); taula = gtk_table_new (10, 3, TRUE); gtk_container_add (GTK_CONTAINER (alignment), taula); gtk_table_set_row_spacings (GTK_TABLE (taula), 4); gtk_table_set_col_spacings (GTK_TABLE (taula), 4); txtZenbakiak = gtk_entry_new (); gtk_table_attach (GTK_TABLE (taula), txtZenbakiak, 0, 3, 0, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_entry_set_invisible_char (GTK_ENTRY (txtZenbakiak), 9679); gtk_entry_set_text(GTK_ENTRY(txtZenbakiak), "0"); cmdZenbakiak3 = gtk_button_new_with_label("3"); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak3, 2, 3, 6, 8, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak3), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak2 = gtk_button_new_with_label("2"); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak2, 1, 2, 6, 8, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak2), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak4 = gtk_button_new_with_label("4"); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak4, 0, 1, 4, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak4), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak5 = gtk_button_new_with_label("5"); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak5, 1, 2, 4, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak5), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak6 = gtk_button_new_with_label("6"); gtk_widget_show (cmdZenbakiak6); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak6, 2, 3, 4, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak6), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak9 = gtk_button_new_with_label("9"); gtk_widget_show (cmdZenbakiak9); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak9, 2, 3, 2, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak9), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak8 = gtk_button_new_with_label("8"); gtk_widget_show (cmdZenbakiak8); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak8, 1, 2, 2, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak8), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak7 = gtk_button_new_with_label("7"); gtk_widget_show (cmdZenbakiak7); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak7, 0, 1, 2, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak7), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak0 = gtk_button_new_with_label("0"); gtk_widget_show (cmdZenbakiak0); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak0, 0, 1, 8, 10, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak0), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak10 = gtk_button_new_with_label(","); gtk_widget_show (cmdZenbakiak10); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak10, 1, 2, 8, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak10), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak11 = gtk_button_new_with_label("C"); gtk_widget_show (cmdZenbakiak11); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak11, 2, 3, 8, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak11), "clicked", G_CALLBACK(btmZenbakia), NULL); cmdZenbakiak1 = gtk_button_new_with_label("1"); gtk_widget_show (cmdZenbakiak1); gtk_table_attach (GTK_TABLE (taula), cmdZenbakiak1, 0, 1, 6, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(G_OBJECT(cmdZenbakiak1), "clicked", G_CALLBACK(btmZenbakia), NULL); labela = gtk_label_new("<span size='x-large'>>></span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdGehitu = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdGehitu), labela); gtk_fixed_put (GTK_FIXED (fixed), cmdGehitu, 256, 136); gtk_widget_set_size_request (cmdGehitu, 96, 64); g_signal_connect(G_OBJECT(cmdGehitu), "clicked", G_CALLBACK(btmGehitu), NULL); labela = gtk_label_new("<span size='x-large'> Kendu </span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdKendu = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdKendu), labela); gtk_fixed_put (GTK_FIXED (fixed), cmdKendu, 256, 216); gtk_widget_set_size_request (cmdKendu, 96, 64); g_signal_connect(G_OBJECT(cmdKendu), "clicked", G_CALLBACK(btmKendu), NULL); model = GTK_TREE_MODEL (gtk_tree_store_new(1, G_TYPE_STRING)); lista = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (lista), -1, "Sartutakoak", renderer, "text", 0, NULL); gtk_fixed_put (GTK_FIXED (fixed), lista, 368, 0); gtk_widget_set_size_request (lista, 208, 560); labela = gtk_label_new ("<span size='large'><b> Zenbat zarete ordaintzeko? </b></span>"); gtk_fixed_put (GTK_FIXED (fixed), labela, 16, 344); gtk_widget_set_size_request (labela, 296, 32); gtk_label_set_use_markup (GTK_LABEL (labela), TRUE); labela = gtk_label_new("<span size='x-large'>+</span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdGehi = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdGehi), labela); gtk_fixed_put (GTK_FIXED (fixed), cmdGehi, 112, 384); gtk_widget_set_size_request (cmdGehi, 64, 48); g_signal_connect(G_OBJECT(cmdGehi), "clicked", G_CALLBACK(btmGehi), NULL); gdk_color_parse("#bff9ed", &kolorea); gtk_widget_modify_bg(cmdGehi, GTK_STATE_NORMAL, &kolorea); gtk_widget_modify_bg(cmdGehi, GTK_STATE_PRELIGHT, &kolorea); labela = gtk_label_new("<span size='x-large'>-</span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdKen = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdKen), labela); gtk_fixed_put (GTK_FIXED (fixed), cmdKen, 176, 384); gtk_widget_set_size_request (cmdKen, 64, 48); g_signal_connect(G_OBJECT(cmdKen), "clicked", G_CALLBACK(btmKen), NULL); gdk_color_parse("#fdb5d5", &kolorea); gtk_widget_modify_bg(cmdKen, GTK_STATE_NORMAL, &kolorea); gtk_widget_modify_bg(cmdKen, GTK_STATE_PRELIGHT, &kolorea); lblZenbat = gtk_label_new ("<span size='xx-large'><b>1</b></span>"); gtk_widget_set_size_request (lblZenbat, 96, 48); gtk_label_set_use_markup (GTK_LABEL (lblZenbat), TRUE); eventbox = gtk_event_box_new(); gtk_widget_set_size_request (eventbox, 96, 48); gtk_container_add(GTK_CONTAINER(eventbox), lblZenbat); gdk_color_parse("black", &kolorea); gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL, &kolorea); gdk_color_parse("yellow", &kolorea); gtk_widget_modify_fg(lblZenbat, GTK_STATE_NORMAL, &kolorea); gtk_fixed_put (GTK_FIXED (fixed), eventbox, 16, 384); labela = gtk_label_new("<span size='x-large'>Ados</span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdAdos = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdAdos), labela); gtk_widget_show (cmdAdos); gtk_fixed_put (GTK_FIXED (fixed), cmdAdos, 24, 480); gtk_widget_set_size_request (cmdAdos, 136, 48); g_signal_connect(G_OBJECT(cmdAdos), "clicked", G_CALLBACK(btmAdos), NULL); labela = gtk_label_new("<span size='x-large'>Utzi</span>"); gtk_label_set_use_markup(GTK_LABEL(labela), TRUE); cmdUtzi = gtk_button_new(); gtk_container_add(GTK_CONTAINER(cmdUtzi), labela); gtk_widget_show (cmdUtzi); gtk_fixed_put (GTK_FIXED (fixed), cmdUtzi, 192, 480); gtk_widget_set_size_request (cmdUtzi, 136, 48); g_signal_connect(G_OBJECT(cmdUtzi), "clicked", G_CALLBACK(btmUtzi), NULL); /* Dena bistaratu eta martxan jarri */ form_load(); gtk_widget_show_all(frmBestelakoak); gtk_main(); }
void display_desktop_init(GtkWindow *window) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; display_label_title = GTK_LABEL(lookup_widget(GTK_WIDGET(window), "label_title")); display_desktop_treeview = GTK_TREE_VIEW(lookup_widget(GTK_WIDGET(window), "desktop_treeview")); display_current = NULL; display_desktop_model = GTK_TREE_MODEL(gtk_tree_store_new(DESKTOP_TREE_NCOLS, /* DESKTOP_TREE_PIXBUF */ GDK_TYPE_PIXBUF, /* DESKTOP_TREE_ID */ G_TYPE_STRING, /* DESKTOP_TREE_GEOMETRY */ G_TYPE_STRING, /* DESKTOP_TREE_STYLE */ PANGO_TYPE_STYLE, /* DESKTOP_TREE_SCALE */ G_TYPE_FLOAT, /* DESKTOP_TREE_DISPLAY */ G_TYPE_POINTER, /* DESKTOP_TREE_FRAME */ G_TYPE_POINTER)); gtk_tree_view_set_model(display_desktop_treeview, display_desktop_model); /* List selection */ display_desktop_selection = gtk_tree_view_get_selection(display_desktop_treeview); gtk_tree_selection_set_mode(display_desktop_selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(display_desktop_selection, (GtkTreeSelectionFunc) display_desktop_select, NULL, NULL); /* Setup row activation handler */ gtk_signal_connect(GTK_OBJECT(display_desktop_treeview), "row-activated", GTK_SIGNAL_FUNC(display_desktop_row_activated), NULL); /* Column #0: Status pixbuf and Desktop/Frame id */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Desktop / Frame"); gtk_tree_view_column_set_expand(column, TRUE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DESKTOP_TREE_PIXBUF); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_TREE_ID); gtk_tree_view_column_add_attribute(column, renderer, "style", DESKTOP_TREE_STYLE); gtk_tree_view_column_add_attribute(column, renderer, "scale", DESKTOP_TREE_SCALE); gtk_tree_view_append_column(display_desktop_treeview, column); /* Column #1: Frame geometry */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(display_desktop_treeview, -1, "Geometry", renderer, "text", DESKTOP_TREE_GEOMETRY, "style", DESKTOP_TREE_STYLE, "scale", DESKTOP_TREE_SCALE, NULL); /* Collect all available display connections */ display_desktop_mklist(); if ( display_timeout == 0 ) display_timeout = g_timeout_add(1000, (GSourceFunc) display_desktop_heartbeat, NULL); }
/* * Creates (or activates) the addlist window */ void mpc_addlist_create(void) { GtkWidget * scrollwindow; GtkTreeSelection * selection; GtkWidget *hbox; GtkWidget *vbox; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget * buttonbar; GtkWidget * button; GtkWidget * bar; GtkWidget * url_label; GtkWidget * url_add; if (!mpc_addlist) { /* * Create the addlist window */ mpc_addlist = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass(GTK_WINDOW(mpc_addlist), "playlistadd", "gkrellmpc"); gtk_window_set_title(GTK_WINDOW(mpc_addlist), _("MPD ADD SONGS")); gtk_container_border_width (GTK_CONTAINER(mpc_addlist), 10); gtk_window_set_default_size(GTK_WINDOW(mpc_addlist), mpc_addlist_width, mpc_addlist_height); gtk_window_set_position(GTK_WINDOW(mpc_addlist), GTK_WIN_POS_CENTER); g_signal_connect(GTK_OBJECT(mpc_addlist), "configure_event", G_CALLBACK(mpc_addlist_configure_event), NULL); g_signal_connect(GTK_OBJECT(mpc_addlist), "delete_event", G_CALLBACK(mpc_addlist_delete_event), NULL); g_signal_connect(GTK_OBJECT(mpc_addlist), "destroy", G_CALLBACK(mpc_addlist_destroy_event), NULL); g_signal_connect(mpc_addlist, "key-release-event", G_CALLBACK(mpc_cb_addlist_key), NULL); /* * Create URL label */ url_label = gtk_label_new("URL:"); /* * Create the URL entry box */ mpc_addlist_url = gtk_entry_new(); /* * Create the URL add button */ url_add = gtk_button_new_from_stock(GTK_STOCK_ADD); g_signal_connect(GTK_OBJECT(url_add), "clicked", G_CALLBACK(mpc_cb_addlist_button_add), "url"); /* * Create the bar */ bar = gtk_hseparator_new(); /* * Create the data store */ mpc_addlist_store = gtk_tree_store_new(MPC_ADDLIST_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); /* * Create addlist tree */ mpc_addlist_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mpc_addlist_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(mpc_addlist_tree), TRUE); // gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mpc_addlist_tree), FALSE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mpc_addlist_tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); g_signal_connect(mpc_addlist_tree, "row-activated", G_CALLBACK(mpc_cb_addlist_row), NULL); /* * Create the scrollwindow the addlist goes in */ scrollwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER(scrollwindow), mpc_addlist_tree); /* * Create the visual columns */ renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer , "stock-id", MPC_ADDLIST_COLUMN_ICON , NULL); gtk_tree_view_column_set_sort_column_id (column, MPC_ADDLIST_COLUMN_ICON); gtk_tree_view_append_column(GTK_TREE_VIEW(mpc_addlist_tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer , "text", MPC_ADDLIST_COLUMN_DISPLAYNAME , NULL); gtk_tree_view_column_set_sort_column_id (column, MPC_ADDLIST_COLUMN_DISPLAYNAME); gtk_tree_view_set_search_column(GTK_TREE_VIEW(mpc_addlist_tree), MPC_ADDLIST_COLUMN_DISPLAYNAME); gtk_tree_view_append_column(GTK_TREE_VIEW(mpc_addlist_tree), column); /* * Create the bottom buttons */ buttonbar = gtk_hbutton_box_new(); button = gtk_button_new_from_stock(GTK_STOCK_ADD); g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(mpc_cb_addlist_button_add), "list"); gtk_container_add(GTK_CONTAINER(buttonbar), button); button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(mpc_cb_addlist_button_close), NULL); gtk_container_add(GTK_CONTAINER(buttonbar), button); /* * And pack everything */ hbox = gtk_hbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(hbox), url_label, 0, 0, 0); gtk_box_pack_start(GTK_BOX(hbox), mpc_addlist_url, 1, 1, 0); gtk_box_pack_start(GTK_BOX(hbox), url_add, 0, 0, 0); vbox = gtk_vbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(vbox), hbox, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), bar, 0, 0, 0); gtk_box_pack_start(GTK_BOX(vbox), scrollwindow, 1, 1, 0); gtk_box_pack_start(GTK_BOX(vbox), buttonbar, 0, 0, 0); gtk_container_add(GTK_CONTAINER(mpc_addlist), vbox); /* * Update the addlist */ mpc_addlist_update(); /* * Finally show everything */ gtk_widget_show_all(mpc_addlist); } else { /* * Make the addlist window the foreground window */ gtk_window_present(GTK_WINDOW(mpc_addlist)); } }
PrefabSelector::PrefabSelector () : _widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING)), _fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted( GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view( GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted))) { std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/"; _selectedSelectionStrategy = PREFAB_SELECT_EXTEND; GtkWidget* scr = gtk_scrolled_window_new(0, 0); gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN); { gtk_tree_view_set_enable_search(_view, TRUE); gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME); gtk_tree_view_set_headers_visible(_view, TRUE); gtk_tree_view_set_headers_clickable(_view, TRUE); #if GTK_CHECK_VERSION(2,10,0) gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL); #endif g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this); { GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Prefab")); gtk_tree_view_column_set_expand(column, FALSE); gtk_tree_view_column_set_sort_indicator(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME); gtk_tree_view_append_column(_view, column); GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1); gtk_tree_view_column_pack_start(column, imageRenderer, false); gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE); GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_end(column, nameRenderer, false); gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION); } gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view)); g_object_unref(G_OBJECT(_store)); } GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0); gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0); { // options GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0); GtkRadioButton* radioExtendSelection = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection"))); gtk_widget_ref(GTK_WIDGET(radioExtendSelection)); gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0); g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer( g_signal_connect(radioExtendSelection, "toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this))); GtkRadioButton * radioUnselect = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert"))); gtk_widget_ref(GTK_WIDGET(radioUnselect)); gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0); g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer( g_signal_connect(G_OBJECT(radioUnselect), "toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this))); GtkRadioButton * radioReplace = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection"))); gtk_widget_ref(GTK_WIDGET(radioReplace)); gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0); g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer( g_signal_connect(G_OBJECT(radioReplace), "toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this))); } { //search entry, connect to file filter GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3); GtkWidget *searchEntry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3); gtk_widget_show(searchEntry); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered), (GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL); g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL); _filterEntry = GTK_ENTRY(searchEntry); #if GTK_CHECK_VERSION(2,10,0) gtk_tree_view_set_search_entry(_view, _filterEntry); #endif } /* fill prefab store with data */ Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store)); Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store))); gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING); }
void gif_receive_messages(void *server) { int server_sockfd = *(int *)server; gifhdr_t *gifheader; int rcv_status; char *gifdata, *gifbuffer; char PATHNAME[MAX_PATH_LENGTH]; pthread_t pthd = pthread_self(); while(1) { gifbuffer = (char *) malloc(BUFF_SIZE); rcv_status = recv(server_sockfd, gifbuffer, BUFF_SIZE, 0); if(rcv_status < 0) //发生错误 { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO, strerror(errno)); gdk_threads_leave(); pthread_cancel(pthd); //非正常退出 } else if(rcv_status == 0) //断开连接 { contacts_chat_window_id_t *ptr; GtkWidget *widget; gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO, "Server Disconnected"); gdk_threads_leave(); while(head != NULL) // freeing the allocated spaces for linked list { ptr = head; head = head->next; free(ptr); } gdk_threads_enter(); gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree); widget = lookup_widget(gifmain, "butConnect"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "mnuConnect"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "mnuDisconect"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "butAdd"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "mnuAdd"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "mnuDelete"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "butConf"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "butOffline"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "mnuOffline"); gtk_widget_set_sensitive(widget, FALSE); gdk_threads_leave(); pthread_cancel(pthd); } gifheader = (gifhdr_t *) malloc(sizeof(gifhdr_t)); memcpy(gifheader, gifbuffer, HEADER_LENGTH); if((gifheader->length) > 0) { gifdata = (char *) malloc(gifheader->length); memcpy(gifdata, (gifbuffer + HEADER_LENGTH), gifheader->length); } else { gifdata = NULL; } switch(gifheader->type) { case GIF_ADDRLIST_MSG: { contacts_chat_window_id_t *ptr; user_status_t *usrs; int i, counter; gdk_threads_enter(); GtkWidget *widget; GtkTreeStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter parent_iter, child_iter; GdkPixbuf *img; GtkTreeSelection *select; gdk_threads_leave(); if(gifheader->reserved == 1) { // removing the tree from the container for refresing gdk_threads_enter(); gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree); gdk_threads_leave(); while(head != NULL) // freeing the allocated spaces for linked list { ptr = head; head = head->next; free(ptr); } } gdk_threads_enter(); widget = lookup_widget(gifmain, "butConnect"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "mnuConnect"); gtk_widget_set_sensitive(widget, FALSE); widget = lookup_widget(gifmain, "mnuDisconect"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "butAdd"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "mnuAdd"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "mnuDelete"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "butConf"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "butOffline"); gtk_widget_set_sensitive(widget, TRUE); widget = lookup_widget(gifmain, "mnuOffline"); gtk_widget_set_sensitive(widget, TRUE); gdk_threads_leave(); //creating a model gdk_threads_enter(); store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF); gdk_threads_leave(); //creating a view gdk_threads_enter(); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gdk_threads_leave(); //adding the view to the scrolledwindow gdk_threads_enter(); gtk_container_add(GTK_CONTAINER(scrolledwindow1), tree); gdk_threads_leave(); //creating first column gdk_threads_enter(); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("Status", renderer, "pixbuf", STATUS_COLUMN_PIXMAP, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gdk_threads_leave(); //creating second column gdk_threads_enter(); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Contacts", renderer, "text", CONTACTS_COLUMN_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gdk_threads_leave(); //Acquire a top-level iterator gdk_threads_enter(); gtk_tree_store_append(store, &parent_iter, NULL); if(gifheader->length != 0) { gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Available", -1); } else { gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Not Available", -1); } gdk_threads_leave(); i = counter = 0; usrs = (user_status_t *) malloc(sizeof(user_status_t)); while(counter < (gifheader->length)) { contacts_chat_window_id_t *ptr; memcpy(usrs, (gifdata + (i * sizeof(user_status_t))), sizeof(user_status_t)); // setting the window id for each contacts and constructing a linked list ptr = (contacts_chat_window_id_t *) malloc(sizeof(contacts_chat_window_id_t)); strcpy(ptr->contacts_name, usrs->loginid); ptr->window_id = i; ptr->window_open = 0; if(head == NULL) { head = ptr; ptr->next = NULL; } else { ptr->next = head; head = ptr; } // setting the status image for online clients and offline clients gdk_threads_enter(); if(usrs->status == 1) { get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps"); img = gdk_pixbuf_new_from_file(PATHNAME, NULL); } else { get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps"); img = gdk_pixbuf_new_from_file(PATHNAME, NULL); } gdk_threads_leave(); //Acquire a child iterator gdk_threads_enter(); gtk_tree_store_append(store, &child_iter, &parent_iter); gtk_tree_store_set(store, &child_iter, CONTACTS_COLUMN_TEXT, usrs->loginid, STATUS_COLUMN_PIXMAP, img, -1); gdk_threads_leave(); i++; counter = i * sizeof(user_status_t); } free(usrs); gdk_threads_enter(); gtk_tree_view_expand_all(GTK_TREE_VIEW(tree)); gtk_widget_show(tree); gdk_threads_leave(); // signal handling for "changed" event gdk_threads_enter(); select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(gif_call_client_for_chat), NULL); gdk_threads_leave(); if((gifheader->length) != 0) { free(gifdata); } free(gifheader); free(gifbuffer); break; } case GIF_CHAT_MSG: { contacts_chat_window_id_t *ptr; GtkWidget *display_text; GtkTextBuffer *buff; GtkTextIter start, end; int line_no; for(ptr = head; ptr != NULL; ptr = ptr->next) { if((strcmp(ptr->contacts_name, gifheader->sender)) == 0) break; else continue; } if(ptr->window_open == 0) { GtkWidget *widget; GtkTextBuffer *buff; ptr->window_open = 1; // since the window is gonna be opened gdk_threads_enter(); chat_window[ptr->window_id] = create_Chat(); widget = lookup_widget(chat_window[ptr->window_id], "entInput"); gtk_window_set_focus(GTK_WINDOW (chat_window[ptr->window_id]), widget); gtk_window_set_title(GTK_WINDOW (chat_window[ptr->window_id]), gifheader->sender); gtk_widget_show(chat_window[ptr->window_id]); gdk_threads_leave(); // creating tags(foreground color) for the buffer gdk_threads_enter(); widget = lookup_widget(chat_window[ptr->window_id], "txtDisplay"); buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_create_tag(buff, "red_foreground", "foreground", "red", NULL); gtk_text_buffer_create_tag(buff, "blue_foreground", "foreground", "blue", NULL); gdk_threads_leave(); } gdk_threads_enter(); display_text = lookup_widget(chat_window[ptr->window_id], "txtDisplay"); buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(display_text)); gtk_text_buffer_insert_at_cursor(buff, gifheader->sender, -1); gtk_text_buffer_insert_at_cursor(buff, " : ", -1); gtk_text_buffer_insert_at_cursor(buff, gifdata, -1); gdk_threads_leave(); // setting the color(blue) for client's name in the display text box gdk_threads_enter(); line_no = gtk_text_buffer_get_line_count(buff); gtk_text_buffer_get_iter_at_line(buff, &start, line_no); gtk_text_buffer_get_iter_at_line_offset(buff, &end, line_no, strlen (gifheader->sender)); gtk_text_buffer_apply_tag_by_name(buff, "blue_foreground", &start, &end); gtk_text_buffer_insert_at_cursor(buff, "\n", -1); gdk_threads_leave(); if((gifheader->length) != 0) free(gifdata); free(gifheader); free(gifbuffer); break; } case GIF_SUCCESS_N_ERROR_MSG: { switch(gifheader->reserved) { case GIF_ERROR_LOGIN_INCORRECT: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO, "Login Incorrect"); gdk_threads_leave(); break; } case GIF_SUCCESS_ADD_CONTACTS: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO, "Your new contact has been successfully added"); gdk_threads_leave(); break; } case GIF_ERROR_ADD_CONTACTS: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO,"The contact id you entered does not belong to a gchat user"); gdk_threads_leave(); break; } case GIF_SUCCESS_DELETE_CONTACTS: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO,"Deleted. See the new list after you re-login"); gdk_threads_leave(); break; } case GIF_ERROR_DELETE_CONTACTS_NOT_A_CONTACT: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO,"1. The id you entered is not in your contact list"); gdk_threads_leave(); break; } case GIF_ERROR_DELETE_CONTACTS_NOT_A_MEMBER: { gdk_threads_enter(); message_dialog(GTK_MESSAGE_INFO,"2. The id you entered is not in your contact list"); gdk_threads_leave(); break; } } if((gifheader->length) != 0) { free(gifdata); } free(gifheader); free(gifbuffer); break; } case GIF_OFFLINE_MSG: { int counter; char *message; offline_msgs_send_t *omsgs_se; gdk_threads_enter(); GtkWidget *widget; GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter iter; GdkPixbuf *img; gdk_threads_leave(); if(gifheader->reserved == 1) //刷新联系人在线状态 { offline_messages_count = 0; //creating a model gdk_threads_enter(); store = gtk_list_store_new(OFFLINE_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); offline_temp_store = store; gdk_threads_leave(); //creating a view gdk_threads_enter(); offline_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gdk_threads_leave(); //adding the view to the scrolledwindow gdk_threads_enter(); gtk_container_add(GTK_CONTAINER(scrolledwindow4), offline_tree); gdk_threads_leave(); //creating first column gdk_threads_enter(); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("New/Old", renderer, "pixbuf", OFFLINE_NEW_PIXMAP, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column); gdk_threads_leave(); //creating second column gdk_threads_enter(); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "foreground", "red", NULL); column = gtk_tree_view_column_new_with_attributes("From", renderer, "text", OFFLINE_SENDER_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column); gdk_threads_leave(); //creating third column gdk_threads_enter(); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "foreground", "dark green", NULL); column = gtk_tree_view_column_new_with_attributes("Date & Time", renderer, "text",OFFLINE_DATESERIAL_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column); gdk_threads_leave(); //creating fourth column gdk_threads_enter(); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", OFFLINE_MSG_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column); gdk_threads_leave(); } else { _DEBUG("error: condition"); pthread_cancel(pthd); return; } counter = 0; omsgs_se = (offline_msgs_send_t *) malloc(sizeof(offline_msgs_send_t)); while(counter < (gifheader->length)) { gdk_threads_enter(); widget = lookup_widget(offline, "butOfflineDelete"); gtk_widget_set_sensitive(widget, TRUE); gdk_threads_leave(); memcpy(omsgs_se, (gifdata + counter), sizeof(offline_msgs_send_t)); counter = counter + sizeof(offline_msgs_send_t); message = (char *) malloc(omsgs_se->length); strncpy(message, (gifdata + counter), omsgs_se->length); counter = counter + (omsgs_se->length); // setting the status image for online clients and offline clients gdk_threads_enter(); if(omsgs_se->new == 1) { get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps"); img = gdk_pixbuf_new_from_file(PATHNAME, NULL); } else { get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps"); img = gdk_pixbuf_new_from_file(PATHNAME, NULL); } gdk_threads_leave(); //Acquire a child iterator gdk_threads_enter(); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, OFFLINE_NEW_PIXMAP, img, OFFLINE_SENDER_TEXT, omsgs_se->sender, OFFLINE_DATESERIAL_TEXT, omsgs_se->dateserial, OFFLINE_MSG_TEXT, message, -1); gdk_threads_leave(); offline_messages_count++; free(message); } free(omsgs_se); gdk_threads_enter(); gtk_widget_show(offline_tree); gdk_threads_leave(); if(gifheader->reserved == 1) { GtkTreeSelection *select; // signal handling for "changed" event gdk_threads_enter(); select = gtk_tree_view_get_selection(GTK_TREE_VIEW(offline_tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK (gif_select_offline_messages), NULL); gdk_threads_leave(); } if((gifheader->length) != 0) free(gifdata); free(gifheader); free(gifbuffer); break; } } }
gint main (gint argc, gchar ** argv) { GstElement *pipeline, *src, *mxfdemux; GstBus *bus; GtkWidget *scrolled_window, *treeview; if (argc < 2) { g_print ("usage: %s MXF-FILE\n", argv[0]); return -1; } if (!g_thread_supported ()) g_thread_init (NULL); gst_init (NULL, NULL); gtk_init (NULL, NULL); pipeline = gst_pipeline_new ("pipeline"); src = gst_element_factory_make ("filesrc", "src"); g_object_set (G_OBJECT (src), "location", argv[1], NULL); mxfdemux = gst_element_factory_make ("mxfdemux", "mxfdemux"); g_signal_connect (mxfdemux, "pad-added", G_CALLBACK (on_pad_added), NULL); if (!src || !mxfdemux) { g_error ("Unable to create all elements"); return -2; } gst_bin_add_many (GST_BIN (pipeline), src, mxfdemux, NULL); if (!gst_element_link_many (src, mxfdemux, NULL)) { g_error ("Failed to link elements"); return -3; } bus = gst_element_get_bus (pipeline); gst_bus_add_signal_watch (bus); g_signal_connect (bus, "message", G_CALLBACK (on_message), NULL); gst_object_unref (bus); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 640, 480); g_signal_connect (window, "delete-event", gtk_main_quit, NULL); scrolled_window = gtk_scrolled_window_new (NULL, NULL); treestore = gtk_tree_store_new (1, G_TYPE_STRING, NULL); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treestore)); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), gtk_tree_view_column_new_with_attributes ("Element", gtk_cell_renderer_text_new (), "text", 0, NULL)); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); gtk_container_add (GTK_CONTAINER (window), scrolled_window); gst_element_set_state (pipeline, GST_STATE_PLAYING); gtk_main (); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
void ctree_init(void) { GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd); GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; gint i; tree = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF); model = GTK_TREE_MODEL(tree); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Name")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COLUMN_NAME, "font", COLUMN_FONT, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Attr"), renderer, "pixbuf", COLUMN_ATTR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); for (i = 0; i < CTREE_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); ctree_set_basetree(); }
static gboolean callback_button_box_click (GtkWidget * widget, GdkEvent * event, gpointer user_data) { GList *list, *header_list; GList *hlist = NULL, *slist = NULL; GtkWidget *notebook = NULL; GtkWidget *textview = NULL; GFile *hexfile; GtkWidget *sc_window, *tree_view; gboolean is_header, is_slice, is_hexval; CodecComponents component = (CodecComponents) user_data; char *xml_name = ui->current_xml; char *hex_name = ui->current_hex; switch (component) { case COMPONENTS_HEADERS_GENERAL: is_header = TRUE; is_slice = FALSE; is_hexval = FALSE; break; case COMPONENTS_HEADERS_SLICE: is_slice = TRUE; is_header = FALSE; is_hexval = FALSE; break; case COMPONENTS_HEXVAL: is_hexval = TRUE; is_header = FALSE; is_slice = FALSE; break; default: break; } if (ui->prev_page) gtk_widget_destroy (GTK_WIDGET (ui->prev_page)); if (ui->notebook_hash) g_hash_table_destroy (ui->notebook_hash); ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal); if (!is_hexval) { header_list = analyzer_get_list_header_strings (xml_name); while (header_list) { if (strcmp (header_list->data, "comment")) { if (is_header && !g_str_has_prefix (header_list->data, "slice")) hlist = g_list_append (hlist, header_list->data); else if (is_slice && g_str_has_prefix (header_list->data, "slice")) hlist = g_list_append (hlist, header_list->data); } header_list = header_list->next; } notebook = gtk_notebook_new (); g_object_set (G_OBJECT (notebook), "expand", TRUE, NULL); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook)); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), TRUE); g_list_foreach (hlist, (GFunc) populate_notebook, (gpointer) notebook); while (hlist) { sc_window = g_hash_table_lookup (ui->notebook_hash, hlist->data); if (sc_window && GTK_IS_BIN (sc_window)) tree_view = gtk_bin_get_child (GTK_BIN (sc_window)); if (tree_view) { list = analyzer_get_list_analyzer_node_from_xml (xml_name, hlist->data); if (list) { GtkTreeStore *treestore; GtkTreeModel *model; treestore = gtk_tree_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); g_list_foreach (list, (GFunc) fill_tree_store, treestore); analyzer_node_list_free (list); list = NULL; model = GTK_TREE_MODEL (treestore); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), model); g_object_unref (model); } } hlist = hlist->next; } ui->prev_page = notebook; gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), notebook); } else { /*Display the hex dump of the frame */ GtkWidget *scrolled_window; GtkTextBuffer *buffer; gchar *contents; gsize length; textview = gtk_text_view_new (); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 20); g_object_set (G_OBJECT (textview), "expand", TRUE, "editable", FALSE, NULL); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scrolled_window), textview); hexfile = g_file_new_for_path (hex_name); if (hexfile) { if (g_file_load_contents (hexfile, NULL, &contents, &length, NULL, NULL)) { buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview)); gtk_text_buffer_set_text (buffer, contents, length); g_free (contents); g_object_unref (G_OBJECT (hexfile)); } } ui->prev_page = scrolled_window; gtk_container_add (GTK_CONTAINER (ui->parsed_info_vbox), scrolled_window); } gtk_widget_show_all (ui->main_window); return TRUE; }
static void heap_view_init (HeapView* self) { GtkTreeViewColumn* col = NULL; GtkCellRenderer* renderer = NULL; GtkTreeSelection* selection = NULL; self->priv = g_new0 (HeapViewPrivate, 1); /* prepare the store */ self->priv->store = gtk_tree_store_new (COLUMN_NUMBER, G_TYPE_INT, // type G_TYPE_POINTER, // presentity G_TYPE_STRING, // name G_TYPE_STRING, // status G_TYPE_STRING); // presence gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store), COLUMN_NAME, GTK_SORT_ASCENDING); /* prepare the view */ self->priv->view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->store))); g_object_unref (self->priv->store); gtk_tree_view_set_headers_visible (self->priv->view, FALSE); /* show the name of a group */ col = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME); gtk_tree_view_column_set_alignment (col, 0.0); g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL); g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_append_column (self->priv->view, col); gtk_tree_view_column_set_cell_data_func (col, renderer, hide_show_depending_on_type, GINT_TO_POINTER (TYPE_GROUP), NULL); /* show the name+status of a presentity */ col = gtk_tree_view_column_new (); renderer = gm_cell_renderer_bitext_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME); gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS); gtk_tree_view_column_set_alignment (col, 0.0); g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL); gtk_tree_view_append_column (self->priv->view, col); gtk_tree_view_column_set_cell_data_func (col, renderer, hide_show_depending_on_type, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); /* show the presence of a presentity */ col = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "stock-id", COLUMN_PRESENCE); gtk_tree_view_append_column (self->priv->view, col); gtk_tree_view_column_set_cell_data_func (col, renderer, hide_show_depending_on_type, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); /* notify when the selection changed */ selection = gtk_tree_view_get_selection (self->priv->view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self); /* show a popup menu when right-click */ g_signal_connect (self->priv->view, "event-after", G_CALLBACK (on_right_click_in_the_view), self); }