/* construct widget above */ void gui_init(struct dt_imageio_module_storage_t *self) { self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t)); dt_storage_facebook_gui_data_t *ui = self->gui_data; ui->facebook_api = fb_api_init(); self->widget = gtk_vbox_new(FALSE, 0); //create labels ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) ); ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy"))); ui->label_status = GTK_LABEL(gtk_label_new(NULL)); gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5); //create entries GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username))); GtkCellRenderer *p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL); ui->entry_album_title = GTK_ENTRY(gtk_entry_new()); ui->entry_album_summary = GTK_ENTRY(gtk_entry_new()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary)); //retrieve saved accounts ui_refresh_users(ui); //////// album list ///////// GtkWidget *albumlist = gtk_hbox_new(FALSE, 0); GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album))); p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE); gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0); ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_new_text()); GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1); gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store)); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login"))); ui->connected = FALSE; //pack the ui ////the auth box GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5); GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2); ////the album creation box ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0); //connect buttons to signals g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui); g_object_unref(model_username); g_object_unref(model_album); g_object_unref(list_store); }
/**************************************************************** Create spy's tech stealing dialog *****************************************************************/ static void create_advances_list(struct player *pplayer, struct player *pvictim) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; spy_tech_shell = gtk_dialog_new_with_buttons(_("Steal Technology"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Steal"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_tech_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_tech_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Advance to Steal")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))), label); vbox = gtk_grid_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing(GTK_GRID(vbox), 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_widget_set_hexpand(view, TRUE); gtk_widget_set_vexpand(view, TRUE); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Advances:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_set_size_request(sw, -1, 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ if (pvictim) { /* you don't want to know what lag can do -- Syela */ GtkTreeIter it; GValue value = { 0, }; advance_index_iterate(A_FIRST, i) { if(player_invention_state(pvictim, i)==TECH_KNOWN && (player_invention_state(pplayer, i)==TECH_UNKNOWN || player_invention_state(pplayer, i)==TECH_PREREQS_KNOWN)) { gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); g_value_set_static_string(&value, advance_name_for_player(client.conn.playing, i)); gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, i, -1); } } advance_index_iterate_end; gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); g_value_set_string(&value, astr_str(&str)); astr_free(&str); } gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, A_UNSET, -1); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_advances_callback), NULL); g_signal_connect(spy_tech_shell, "response", G_CALLBACK(spy_advances_response), NULL); steal_advance = 0; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
/* create the "open with" dialog. */ void dlg_open_with (FrWindow *window, GList *file_list) { DialogData *data; GAppInfo *app; GList *scan, *app_names = NULL; char **editors; int i; GtkWidget *cancel_button; GtkTreeIter iter; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkIconTheme *theme; int icon_size; if (file_list == NULL) return; data = g_new0 (DialogData, 1); data->settings = g_settings_new (ENGRAMPA_SCHEMA_GENERAL); data->builder = _gtk_builder_new_from_file ("open-with.ui"); if (data->builder == NULL) { g_free (data); return; } data->file_list = path_list_dup (file_list); data->window = window; /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "open_with_dialog"); data->o_app_tree_view = _gtk_builder_get_widget (data->builder, "o_app_list_tree_view"); data->o_recent_tree_view = _gtk_builder_get_widget (data->builder, "o_recent_tree_view"); data->o_app_entry = _gtk_builder_get_widget (data->builder, "o_app_entry"); data->o_del_button = _gtk_builder_get_widget (data->builder, "o_del_button"); data->ok_button = _gtk_builder_get_widget (data->builder, "o_ok_button"); cancel_button = _gtk_builder_get_widget (data->builder, "o_cancel_button"); gtk_widget_set_sensitive (data->ok_button, FALSE); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (open_with__destroy_cb), data); g_signal_connect (G_OBJECT (data->o_app_entry), "changed", G_CALLBACK (app_entry__changed_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_app_tree_view))), "changed", G_CALLBACK (app_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_app_tree_view), "row_activated", G_CALLBACK (app_activated_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_recent_tree_view))), "changed", G_CALLBACK (recent_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_recent_tree_view), "row_activated", G_CALLBACK (recent_activated_cb), data); g_signal_connect (G_OBJECT (data->ok_button), "clicked", G_CALLBACK (open_cb), data); g_signal_connect_swapped (G_OBJECT (cancel_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (G_OBJECT (data->o_del_button), "clicked", G_CALLBACK (delete_recent_cb), data); /* Set data. */ /* * registered applications list. */ data->app_list = NULL; for (scan = data->file_list; scan; scan = scan->next) { const char *mime_type; const char *name = scan->data; mime_type = get_file_mime_type_for_path (name, FALSE); if ((mime_type != NULL) && ! g_content_type_is_unknown (mime_type)) data->app_list = g_list_concat (data->app_list, g_app_info_get_all_for_type (mime_type)); } data->app_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->app_model), TEXT_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_app_tree_view), data->app_model); g_object_unref (G_OBJECT (data->app_model)); theme = gtk_icon_theme_get_default (); icon_size = get_folder_pixbuf_size_for_list (GTK_WIDGET (data->dialog)); for (scan = data->app_list; scan; scan = scan->next) { gboolean found; char *utf8_name; GdkPixbuf *icon_image = NULL; app = scan->data; found = FALSE; if (app_names != NULL) { GList *p; for (p = app_names; p && !found; p = p->next) if (strcmp ((char*)p->data, g_app_info_get_executable (app)) == 0) found = TRUE; } if (found) continue; app_names = g_list_prepend (app_names, (char*) g_app_info_get_executable (app)); utf8_name = g_locale_to_utf8 (g_app_info_get_name (app), -1, NULL, NULL, NULL); icon_image = get_icon_pixbuf (g_app_info_get_icon (app), icon_size, theme); gtk_list_store_append (GTK_LIST_STORE (data->app_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->app_model), &iter, ICON_COLUMN, icon_image, TEXT_COLUMN, utf8_name, DATA_COLUMN, app, -1); g_free (utf8_name); } column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", TEXT_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_app_tree_view), column); if (app_names) g_list_free (app_names); /* * recent editors list. */ data->recent_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->recent_model), 0, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_recent_tree_view), data->recent_model); g_object_unref (G_OBJECT (data->recent_model)); editors = g_settings_get_strv (data->settings, PREF_GENERAL_EDITORS); for (i = 0; editors[i] != NULL; i++) { gtk_list_store_append (GTK_LIST_STORE (data->recent_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->recent_model), &iter, 0, editors[i], -1); } g_strfreev (editors); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_recent_tree_view), column); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show_all (data->dialog); }
static GObject * debug_dialog_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; EmpathyDebugDialogPriv *priv; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *image; GtkWidget *label; GtkToolItem *item; GtkCellRenderer *renderer; GtkListStore *level_store; GtkTreeIter iter; object = G_OBJECT_CLASS (empathy_debug_dialog_parent_class)->constructor (type, n_construct_params, construct_params); priv = GET_PRIV (object); gtk_window_set_title (GTK_WINDOW (object), _("Debug Window")); gtk_window_set_default_size (GTK_WINDOW (object), 800, 400); vbox = GTK_DIALOG (object)->vbox; toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_show (toolbar); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); /* CM */ priv->cm_chooser = gtk_combo_box_new_text (); priv->cms = gtk_list_store_new (NUM_COLS_CM, G_TYPE_STRING, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->cm_chooser), GTK_TREE_MODEL (priv->cms)); gtk_widget_show (priv->cm_chooser); item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_container_add (GTK_CONTAINER (item), priv->cm_chooser); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); g_signal_connect (priv->cm_chooser, "changed", G_CALLBACK (debug_dialog_cm_chooser_changed_cb), object); gtk_widget_show (GTK_WIDGET (priv->cm_chooser)); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Save */ priv->save_button = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE); g_signal_connect (priv->save_button, "clicked", G_CALLBACK (debug_dialog_save_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->save_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->save_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->save_button, -1); /* Copy */ priv->copy_button = gtk_tool_button_new_from_stock (GTK_STOCK_COPY); g_signal_connect (priv->copy_button, "clicked", G_CALLBACK (debug_dialog_copy_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->copy_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->copy_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->copy_button, -1); /* Clear */ priv->clear_button = gtk_tool_button_new_from_stock (GTK_STOCK_CLEAR); g_signal_connect (priv->clear_button, "clicked", G_CALLBACK (debug_dialog_clear_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->clear_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->clear_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->clear_button, -1); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Pause */ priv->paused = FALSE; image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_MENU); gtk_widget_show (image); priv->pause_button = gtk_toggle_tool_button_new (); gtk_toggle_tool_button_set_active ( GTK_TOGGLE_TOOL_BUTTON (priv->pause_button), priv->paused); g_signal_connect (priv->pause_button, "toggled", G_CALLBACK (debug_dialog_pause_toggled_cb), object); gtk_widget_show (GTK_WIDGET (priv->pause_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->pause_button), TRUE); gtk_tool_button_set_label (GTK_TOOL_BUTTON (priv->pause_button), _("Pause")); gtk_tool_button_set_icon_widget ( GTK_TOOL_BUTTON (priv->pause_button), image); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->pause_button, -1); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Level */ priv->level_label = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (priv->level_label)); label = gtk_label_new (_("Level ")); gtk_widget_show (label); gtk_container_add (GTK_CONTAINER (priv->level_label), label); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->level_label, -1); priv->level_filter = gtk_combo_box_new_text (); gtk_widget_show (priv->level_filter); item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_container_add (GTK_CONTAINER (item), priv->level_filter); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); level_store = gtk_list_store_new (NUM_COLS_LEVEL, G_TYPE_STRING, G_TYPE_UINT); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->level_filter), GTK_TREE_MODEL (level_store)); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Debug"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_DEBUG, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Info"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_INFO, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Message"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_MESSAGE, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Warning"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_WARNING, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Critical"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_CRITICAL, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Error"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_ERROR, -1); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->level_filter), 0); g_signal_connect (priv->level_filter, "changed", G_CALLBACK (debug_dialog_filter_changed_cb), object); /* Debug treeview */ priv->view = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->view), TRUE); g_signal_connect (priv->view, "button-press-event", G_CALLBACK (debug_dialog_button_press_event_cb), object); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "yalign", 0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Time"), renderer, "text", COL_DEBUG_TIMESTAMP, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Domain"), renderer, "text", COL_DEBUG_DOMAIN, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Category"), renderer, "text", COL_DEBUG_CATEGORY, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Level"), renderer, "text", COL_DEBUG_LEVEL_STRING, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "family", "Monospace", NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Message"), renderer, "text", COL_DEBUG_MESSAGE, NULL); priv->store = gtk_list_store_new (NUM_DEBUG_COLS, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); priv->store_filter = gtk_tree_model_filter_new ( GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (priv->store_filter), debug_dialog_visible_func, object, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->view), priv->store_filter); /* Scrolled window */ priv->scrolled_win = g_object_ref (gtk_scrolled_window_new (NULL, NULL)); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (priv->view); gtk_container_add (GTK_CONTAINER (priv->scrolled_win), priv->view); gtk_widget_show (priv->scrolled_win); /* Not supported label */ priv->not_supported_label = g_object_ref (gtk_label_new ( _("The selected connection manager does not support the remote " "debugging extension."))); gtk_widget_show (priv->not_supported_label); gtk_box_pack_start (GTK_BOX (vbox), priv->not_supported_label, TRUE, TRUE, 0); priv->view_visible = FALSE; debug_dialog_set_toolbar_sensitivity (EMPATHY_DEBUG_DIALOG (object), FALSE); debug_dialog_fill_cm_chooser (EMPATHY_DEBUG_DIALOG (object)); gtk_widget_show (GTK_WIDGET (object)); return object; }
void properties_cb (GtkAction *action, EyesApplet *eyes_applet) { GtkWidget *pbox, *hbox; GtkWidget *vbox, *indent; GtkWidget *categories_vbox; GtkWidget *category_vbox, *control_vbox; GtkWidget *tree; GtkWidget *scrolled; GtkWidget *label; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GtkTreeIter iter; DIR *dfd; struct dirent *dp; int i; #ifdef PATH_MAX gchar filename [PATH_MAX]; #else gchar *filename; #endif gchar *title; if (eyes_applet->prop_box.pbox) { gtk_window_set_screen ( GTK_WINDOW (eyes_applet->prop_box.pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_window_present (GTK_WINDOW (eyes_applet->prop_box.pbox)); return; } pbox = gtk_dialog_new_with_buttons (_("Geyes Preferences"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_screen (GTK_WINDOW (pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_widget_set_size_request (GTK_WIDGET (pbox), 300, 200); gtk_dialog_set_default_response(GTK_DIALOG (pbox), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pbox), FALSE); gtk_container_set_border_width (GTK_CONTAINER (pbox), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), 2); g_signal_connect (pbox, "response", G_CALLBACK (presponse_cb), eyes_applet); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), vbox, TRUE, TRUE, 0); categories_vbox = gtk_vbox_new (FALSE, 18); gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0); gtk_widget_show (categories_vbox); category_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0); gtk_widget_show (category_vbox); title = g_strconcat ("<span weight=\"bold\">", _("Themes"), "</span>", NULL); label = gtk_label_new (_(title)); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0); g_free (title); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); indent = gtk_label_new (HIG_IDENTATION); gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0); gtk_widget_show (indent); control_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0); gtk_widget_show (control_vbox); label = gtk_label_new_with_mnemonic (_("_Select a theme:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (control_vbox), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_list_store_new (TOTAL_COLS, G_TYPE_STRING, G_TYPE_STRING); tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tree); g_object_unref (model); gtk_container_add (GTK_CONTAINER (scrolled), tree); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("not used", cell, "text", COL_THEME_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); g_signal_connect (selection, "changed", G_CALLBACK (theme_selected_cb), eyes_applet); if ( ! key_writable (eyes_applet->applet, "theme_path")) { gtk_widget_set_sensitive (tree, FALSE); gtk_widget_set_sensitive (label, FALSE); } for (i = 0; i < NUM_THEME_DIRECTORIES; i++) { if ((dfd = opendir (theme_directories[i])) != NULL) { while ((dp = readdir (dfd)) != NULL) { if (dp->d_name[0] != '.') { gchar *theme_dir; gchar *theme_name; #ifdef PATH_MAX strcpy (filename, theme_directories[i]); strcat (filename, dp->d_name); #else asprintf (&filename, theme_directories[i], dp->d_name); #endif theme_dir = g_strdup_printf ("%s/", filename); theme_name = g_path_get_basename (filename); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_THEME_DIR, &filename, COL_THEME_NAME, theme_name, -1); if (!g_ascii_strncasecmp (eyes_applet->theme_dir, theme_dir, strlen (theme_dir))) { GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), path, NULL, FALSE); gtk_tree_path_free (path); } g_free (theme_name); g_free (theme_dir); } } closedir (dfd); } } #ifndef PATH_MAX g_free (filename); #endif gtk_box_pack_start (GTK_BOX (control_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show_all (pbox); eyes_applet->prop_box.pbox = pbox; return; }
/* * Function to use anywhere in the application to send a message to the LogList */ void Log_Print (Log_Error_Type error_type, gchar const *format, ...) { va_list args; gchar *string; GtkTreeIter iter; static gboolean first_time = TRUE; static gchar *file_path = NULL; FILE *file = NULL; va_start (args, format); string = g_strdup_vprintf(format, args); va_end (args); // If the log window is displayed then messages are displayed, else // the messages are stored in a temporary list. if (LogList && logListModel) { gchar *time = Log_Format_Date(); // Remove lines that exceed the limit if (LogListNbrRows > LOG_MAX_LINES - 1 && gtk_tree_model_get_iter_first(GTK_TREE_MODEL(logListModel), &iter)) { gtk_list_store_remove(GTK_LIST_STORE(logListModel), &iter); } LogListNbrRows++; gtk_list_store_append(logListModel, &iter); gtk_list_store_set(logListModel, &iter, LOG_PIXBUF, Log_Get_Stock_Id_From_Error_Type(error_type), LOG_TIME_TEXT, time, LOG_TEXT, string, LOG_ROW_BACKGROUND, NULL, LOG_ROW_FOREGROUND, NULL, -1); Log_List_Set_Row_Visible(GTK_TREE_MODEL(logListModel), &iter); g_free(time); }else { Log_Data *LogData = g_malloc0(sizeof(Log_Data)); LogData->time = Log_Format_Date(); LogData->error_type = error_type; LogData->string = g_strdup(string); LogPrintTmpList = g_list_append(LogPrintTmpList,LogData); //g_print("%s",string); } // Store also the messages in the log file. if (!file_path) { gchar *cache_path = g_build_filename (g_get_user_cache_dir (), PACKAGE_TARNAME, NULL); if (!g_file_test (cache_path, G_FILE_TEST_IS_DIR)) { gint result = g_mkdir_with_parents (cache_path, S_IRWXU); if (result == -1) { g_printerr ("%s", "Unable to create cache directory"); g_free (cache_path); return; } } file_path = g_build_filename (cache_path, LOG_FILE, NULL); g_free (cache_path); } // The first time, the whole file is deleted. Else, text is appended. if (first_time) file = fopen(file_path,"w+"); else file = fopen(file_path,"a+"); //g_free(file_path); if (file) { gchar *time = Log_Format_Date(); gchar *data = g_strdup_printf("%s %s\n",time,string); fwrite(data,strlen(data),1,file); g_free(data); g_free(time); first_time = FALSE; fclose(file); } g_free(string); }
static void setup_protocol (VinagreConnectDialog *dialog) { GHashTable *extensions; GHashTableIter hash_iter; gpointer key, value; GtkTreeIter tree_iter; GtkCellRenderer *rend; gchar *last_protocol; gint selected, i; dialog->protocol_store = gtk_list_store_new (N_PROTOCOLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT); extensions = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ()); last_protocol = vinagre_cache_prefs_get_string ("connection", "last-protocol", NULL); g_hash_table_iter_init (&hash_iter, extensions); selected = 0; i = 0; while (g_hash_table_iter_next (&hash_iter, &key, &value)) { gchar **description; GtkWidget *widget; VinagreProtocol *ext = (VinagreProtocol *)value; description = vinagre_protocol_get_public_description (ext); if (!description || !description[0]) continue; widget = vinagre_protocol_get_connect_widget (ext, NULL); gtk_list_store_append (dialog->protocol_store, &tree_iter); gtk_list_store_set (dialog->protocol_store, &tree_iter, PROTOCOL_NAME, description[0], PROTOCOL_DESCRIPTION, description[1], PROTOCOL_MDNS, vinagre_protocol_get_mdns_service (ext), PROTOCOL_OPTIONS, widget, PROTOCOL_PLUGIN, ext, -1); if (last_protocol && g_str_equal (last_protocol, description[0])) selected = i; g_strfreev (description); if (widget) g_object_unref (widget); i++; } gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->protocol_combo), GTK_TREE_MODEL (dialog->protocol_store)); rend = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->protocol_combo), rend, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (dialog->protocol_combo), rend, "text", 0); g_signal_connect (dialog->protocol_combo, "changed", G_CALLBACK (protocol_combo_changed), dialog); gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->protocol_combo), selected); g_free (last_protocol); }
/* * Static methods */ static void status_menu_populate (StatusMenu *self, GSList *custom_status_array [NUM_STATUS_TYPES]) { gboolean has_custom_messages = false; GSList *custom_status = NULL; GSList *liter = NULL; GtkTreeIter iter; GdkPixbuf* icon = NULL; gtk_list_store_clear (GTK_LIST_STORE (self->priv->list_store)); for (int i = 0 ; i < NUM_STATUS_TYPES ; i++) { statuses [i] = gettext (statuses [i]); custom_status = custom_status_array [i]; liter = custom_status; icon = gtk_widget_render_icon (GTK_WIDGET (self), stock_status [i], GTK_ICON_SIZE_MENU, NULL); gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_ICON, icon, COL_MESSAGE, statuses[i], COL_MESSAGE_TYPE, i, COL_SEPARATOR, false, -1); gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_ICON, icon, COL_MESSAGE, _("Custom message..."), COL_MESSAGE_TYPE, NUM_STATUS_CUSTOM_TYPES + (i + 1), COL_SEPARATOR, false, -1); while (liter) { gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_ICON, icon, COL_MESSAGE, (char*) (liter->data), COL_MESSAGE_TYPE, NUM_STATUS_TYPES + (i + 1), COL_SEPARATOR, false, -1); liter = g_slist_next (liter); has_custom_messages = true; } if (i < NUM_STATUS_TYPES - 1) { gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_SEPARATOR, true, -1); } g_object_unref (icon); } /* Clear message */ if (has_custom_messages) { gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_SEPARATOR, true, -1); icon = gtk_widget_render_icon (GTK_WIDGET (self), GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU, NULL); gtk_list_store_append (GTK_LIST_STORE (self->priv->list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (self->priv->list_store), &iter, COL_ICON, icon, COL_MESSAGE, _("Clear"), COL_MESSAGE_TYPE, TYPE_CLEAR, COL_SEPARATOR, false, -1); g_object_unref (icon); } status_menu_set_option (self, self->priv->personal_details->get_presence (), self->priv->personal_details->get_status ()); }
static void status_menu_clear_status_message_dialog_run (StatusMenu *self) { GtkTreeIter iter, liter; GSList *conf_list [3] = { NULL, NULL, NULL }; GtkWidget *dialog = NULL; GtkWidget *vbox = NULL; GtkWidget *frame = NULL; GtkWidget *tree_view = NULL; GdkPixbuf *pixbuf = NULL; GtkTreeSelection *selection = NULL; GtkListStore *list_store = NULL; GtkCellRenderer *renderer = NULL; GtkTreeViewColumn *column = NULL; GtkWidget *label = NULL; bool found = false; bool close = false; int response = 0; int i = 0; gchar *message = NULL; gchar *presence = NULL; gchar *status = NULL; // Current status presence = gm_conf_get_string (PERSONAL_DATA_KEY "short_status"); status = gm_conf_get_string (PERSONAL_DATA_KEY "long_status"); // Build the dialog dialog = gtk_dialog_new_with_buttons (_("Custom Message"), self->priv->parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_DELETE, GTK_RESPONSE_APPLY, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DELETE); vbox = gtk_vbox_new (false, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox, false, false, 2); label = gtk_label_new (_("Delete custom messages:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, false, false, 2); list_store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); g_object_unref (list_store); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), false); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", 0, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); frame = gtk_frame_new (NULL); gtk_container_add (GTK_CONTAINER (frame), tree_view); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 2); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->priv->list_store), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, COL_MESSAGE_TYPE, &i, -1); if (i == TYPE_CUSTOM_ONLINE || i == TYPE_CUSTOM_AWAY || i == TYPE_CUSTOM_DND) { gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter, COL_ICON, &pixbuf, COL_MESSAGE, &message, -1); gtk_list_store_append (GTK_LIST_STORE (list_store), &liter); gtk_list_store_set (GTK_LIST_STORE (list_store), &liter, COL_ICON, pixbuf, COL_MESSAGE, message, COL_MESSAGE_TYPE, i, -1); g_free (message); g_object_unref (pixbuf); } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (self->priv->list_store), &iter)); } // Select the first iter selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) gtk_tree_selection_select_iter (selection, &iter); gtk_widget_show_all (dialog); while (!close) { response = gtk_dialog_run (GTK_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_APPLY: if (gtk_tree_selection_get_selected (selection, NULL, &iter)) gtk_list_store_remove (GTK_LIST_STORE (list_store), &iter); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) gtk_tree_selection_select_iter (selection, &iter); else close = true; break; case GTK_RESPONSE_CLOSE: default: close = true; } } if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter, 1, &message, 2, &i, -1); if (status && message && !strcmp (status, message)) found = true; conf_list[i - NUM_STATUS_TYPES - 1] = g_slist_append (conf_list[i - NUM_STATUS_TYPES - 1], g_strdup (message)); g_free (message); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter)); } for (int j = 0 ; j < 3 ; j++) { gm_conf_set_string_list (status_types_keys[j], conf_list[j]); g_slist_foreach (conf_list[j], (GFunc) g_free, NULL); g_slist_free (conf_list[j]); } if (!found) { // Reset current config self->priv->personal_details->set_presence_info ("online", ""); } gtk_widget_destroy (dialog); }
bi_import_result gnc_bi_import_read_file (const gchar * filename, const gchar * parser_regexp, GtkListStore * store, guint max_rows, bi_import_stats * stats) { // some statistics bi_import_stats stats_fallback; FILE *f; // regexp char *line; gchar *line_utf8, *temp; GMatchInfo *match_info; GError *err; GRegex *regexpat; // model GtkTreeIter iter; f = g_fopen (filename, "rt"); if (!f) { //gnc_error_dialog( 0, _("File %s cannot be opened."), filename ); return RESULT_OPEN_FAILED; } // set up statistics if (!stats) stats = &stats_fallback; // compile the regular expression and check for errors err = NULL; regexpat = g_regex_new (parser_regexp, G_REGEX_EXTENDED | G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES, 0, &err); if (err != NULL) { GtkWidget *dialog; gchar *errmsg; errmsg = g_strdup_printf (_("Error in regular expression '%s':\n%s"), parser_regexp, err->message); g_error_free (err); err = NULL; dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", errmsg); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_free (errmsg); errmsg = 0; fclose (f); return RESULT_ERROR_IN_REGEXP; } // start the import stats->n_imported = 0; stats->n_ignored = 0; stats->ignored_lines = g_string_new (NULL); #define buffer_size 1000 line = g_malloc0 (buffer_size); while (!feof (f) && ((max_rows == 0) || (stats->n_imported + stats->n_ignored < max_rows))) { int l; // read one line if (!fgets (line, buffer_size, f)) break; // eof // now strip the '\n' from the end of the line l = strlen (line); if ((l > 0) && (line[l - 1] == '\n')) line[l - 1] = 0; // convert line from locale into utf8 line_utf8 = g_locale_to_utf8 (line, -1, NULL, NULL, NULL); // parse the line match_info = NULL; // it seems, that in contrast to documentation, match_info is not alsways set -> g_match_info_free will segfault if (g_regex_match (regexpat, line_utf8, 0, &match_info)) { // match found stats->n_imported++; // fill in the values gtk_list_store_append (store, &iter); FILL_IN_HELPER ("id", ID); /* FIXME: Should "id" be translated? I don't think so. */ FILL_IN_HELPER ("date_opened", DATE_OPENED); FILL_IN_HELPER ("owner_id", OWNER_ID); FILL_IN_HELPER ("billing_id", BILLING_ID); FILL_IN_HELPER ("notes", NOTES); FILL_IN_HELPER ("date", DATE); FILL_IN_HELPER ("desc", DESC); FILL_IN_HELPER ("action", ACTION); FILL_IN_HELPER ("account", ACCOUNT); FILL_IN_HELPER ("quantity", QUANTITY); FILL_IN_HELPER ("price", PRICE); FILL_IN_HELPER ("disc_type", DISC_TYPE); FILL_IN_HELPER ("disc_how", DISC_HOW); FILL_IN_HELPER ("discount", DISCOUNT); FILL_IN_HELPER ("taxable", TAXABLE); FILL_IN_HELPER ("taxincluded", TAXINCLUDED); FILL_IN_HELPER ("tax_table", TAX_TABLE); FILL_IN_HELPER ("date_posted", DATE_POSTED); FILL_IN_HELPER ("due_date", DUE_DATE); FILL_IN_HELPER ("account_posted", ACCOUNT_POSTED); FILL_IN_HELPER ("memo_posted", MEMO_POSTED); FILL_IN_HELPER ("accu_splits", ACCU_SPLITS); } else { // ignore line stats->n_ignored++; g_string_append (stats->ignored_lines, line_utf8); g_string_append_c (stats->ignored_lines, '\n'); } g_match_info_free (match_info); match_info = 0; g_free (line_utf8); line_utf8 = 0; } g_free (line); line = 0; g_regex_unref (regexpat); regexpat = 0; fclose (f); if (stats == &stats_fallback) // stats are not requested -> free the string g_string_free (stats->ignored_lines, TRUE); return RESULT_OK; }
/* private function of gimp_unit_menu_callback () */ static void gimp_unit_menu_create_selection (GimpUnitMenu *menu) { GtkWidget *parent = gtk_widget_get_toplevel (GTK_WIDGET (menu)); GtkWidget *vbox; GtkWidget *scrolled_win; GtkListStore *list; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreePath *path; GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; GimpUnit unit; gint num_units; if (gtk_window_get_modal (GTK_WINDOW (parent))) flags |= GTK_DIALOG_MODAL; menu->selection = gimp_dialog_new (_("Unit Selection"), "gimp-unit-selection", parent, flags, gimp_standard_help_func, "gimp-unit-dialog", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (menu->selection), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_add_weak_pointer (G_OBJECT (menu->selection), (gpointer) &menu->selection); g_signal_connect (menu->selection, "response", G_CALLBACK (gimp_unit_menu_selection_response), menu); g_signal_connect_object (menu, "unmap", G_CALLBACK (gtk_widget_destroy), menu->selection, G_CONNECT_SWAPPED); /* the main vbox */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (menu->selection))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* the selection list */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); list = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); menu->tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list)); g_object_unref (list); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (menu->tv), -1, _("Unit"), gtk_cell_renderer_text_new (), "text", UNIT_COLUMN, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (menu->tv), -1, _("Factor"), gtk_cell_renderer_text_new (), "text", FACTOR_COLUMN, NULL); /* the unit lines */ num_units = gimp_unit_get_number_of_units (); for (unit = GIMP_UNIT_END; unit < num_units; unit++) { gchar *string; gtk_list_store_append (list, &iter); string = gimp_unit_format_string (menu->format, unit); gtk_list_store_set (list, &iter, UNIT_COLUMN, string, -1); g_free (string); string = gimp_unit_format_string ("(%f)", unit); gtk_list_store_set (list, &iter, FACTOR_COLUMN, string, -1); g_free (string); gtk_list_store_set (list, &iter, DATA_COLUMN, unit, -1); } gtk_widget_set_size_request (menu->tv, -1, 150); gtk_container_add (GTK_CONTAINER (scrolled_win), menu->tv); g_signal_connect (menu->tv, "row-activated", G_CALLBACK (gimp_unit_menu_selection_row_activated_callback), menu); gtk_widget_show (menu->tv); g_signal_connect (menu->tv, "destroy", G_CALLBACK (gtk_widget_destroyed), &menu->tv); gtk_widget_show (vbox); gtk_widget_show (menu->selection); if (menu->unit >= GIMP_UNIT_END) { path = gtk_tree_path_new (); gtk_tree_path_append_index (path, menu->unit - GIMP_UNIT_END); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (menu->tv)); gtk_tree_selection_select_path (sel, path); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (menu->tv), path, NULL, FALSE, 0.0, 0.0); } }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *hbox, *vbox; GtkWidget *vbox2, *bbox; GtkWidget *button; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *swindow; GtkTreeModel *sample_model; gint i; gtk_init (&argc, &argv); /* First initialize all the models for signal purposes */ left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING); sample_tree_view_top = gtk_tree_view_new_with_model (sample_model); sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model); top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top)); bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom)); top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model); bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model); for (i = 0; i < 10; i++) { GtkTreeIter iter; gchar *string = g_strdup_printf ("%d", i); gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter); gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1); g_free (string); } /* Set up the test windows. */ 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), 300, 300); gtk_window_set_title (GTK_WINDOW (window), "Top Window"); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (window), swindow); gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top); gtk_widget_show_all (window); 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), 300, 300); gtk_window_set_title (GTK_WINDOW (window), "Bottom Window"); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (window), swindow); gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom); gtk_widget_show_all (window); /* Set up the main window */ 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), 500, 300); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); /* Left Pane */ cell = gtk_cell_renderer_text_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); left_tree_view = gtk_tree_view_new_with_model (left_tree_model); gtk_container_add (GTK_CONTAINER (swindow), left_tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1, "Unattached Columns", cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view); column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0); /* Middle Pane */ vbox2 = gtk_vbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); bbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic ("<< (_Q)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic (">> (_W)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); bbox = gtk_vbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_mnemonic ("<< (_E)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic (">> (_R)"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)), "changed", G_CALLBACK (selection_changed), button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); /* Right Pane */ vbox2 = gtk_vbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1, NULL, cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view); column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column); gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1, NULL, cell, "text", 0, NULL); cell = gtk_cell_renderer_toggle_new (); g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view); column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL); gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column); gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); /* Drag and Drop */ gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE); gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 8); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_mnemonic ("_Add new Column"); g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show_all (window); gtk_main (); return 0; }
static gboolean ui_authenticate(dt_storage_facebook_gui_data_t *ui) { if (ui->facebook_api == NULL) { ui->facebook_api = fb_api_init(); } FBContext *ctx = ui->facebook_api; gboolean mustsaveaccount = FALSE; gchar *uiselectedaccounttoken = NULL; GtkTreeIter iter; gtk_combo_box_get_active_iter(ui->comboBox_username, &iter); GtkTreeModel *accountModel = gtk_combo_box_get_model(ui->comboBox_username); gtk_tree_model_get(accountModel, &iter, 1, &uiselectedaccounttoken, -1); if (ctx->token != NULL) { g_free(ctx->token); ctx->token = NULL; } if (uiselectedaccounttoken != NULL) { ctx->token = g_strdup(uiselectedaccounttoken); } //check selected token if we already have one if (ctx->token != NULL && !fb_test_auth_token(ctx)) { g_free(ctx->token); ctx->token = NULL; } if(ctx->token == NULL) { mustsaveaccount = TRUE; ctx->token = facebook_get_user_auth_token(ui);//ask user to log in } if (ctx->token == NULL) { return FALSE; } else { if (mustsaveaccount) { FBAccountInfo *accountinfo = fb_get_account_info(ui->facebook_api); g_return_val_if_fail(accountinfo != NULL, FALSE); save_account_info(ui, accountinfo); //add account to user list and select it GtkListStore *model = GTK_LIST_STORE(gtk_combo_box_get_model(ui->comboBox_username)); GtkTreeIter iter; gboolean r; gchar *uid; gboolean updated = FALSE; for (r = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(model), &iter); r == TRUE; r = gtk_tree_model_iter_next (GTK_TREE_MODEL(model), &iter)) { gtk_tree_model_get (GTK_TREE_MODEL(model), &iter, COMBO_USER_MODEL_ID_COL, &uid, -1); if (g_strcmp0(uid, accountinfo->id) == 0) { gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username, COMBO_USER_MODEL_TOKEN_COL, accountinfo->token, -1); updated = TRUE; break; } } if (!updated) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username, COMBO_USER_MODEL_TOKEN_COL, accountinfo->token, COMBO_USER_MODEL_ID_COL, accountinfo->id, -1); } gtk_combo_box_set_active_iter(ui->comboBox_username, &iter); //we have to re-set the current token here since ui_combo_username_changed is called //on gtk_combo_box_set_active_iter (and thus is resetting the active token) ctx->token = g_strdup(accountinfo->token); fb_account_info_destroy(accountinfo); } return TRUE; } }
static void ui_refresh_albums_fill(FBAlbum *album, GtkListStore *list_store) { GtkTreeIter iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_ALBUM_MODEL_NAME_COL, album->name, COMBO_ALBUM_MODEL_ID_COL, album->id, -1); }
static void seahorse_generate_select_constructed (GObject *obj) { SeahorseGenerateSelect *self = SEAHORSE_GENERATE_SELECT (obj); gchar *text; GtkCellRenderer *pixcell; GtkTreeSelection *selection; GtkTreeIter iter; GList *actions; GList *l, *k; GIcon *icon; GtkBuilder *builder; const gchar *path; GError *error = NULL; const gchar *icon_name; GtkAction *action; G_OBJECT_CLASS (seahorse_generate_select_parent_class)->constructed (obj); self->store = gtk_list_store_new (COLUMN_N_COLUMNS, G_TYPE_ICON, G_TYPE_STRING, GTK_TYPE_ACTION); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self->store), on_list_sort, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); self->action_groups = seahorse_registry_object_instances ("generator"); for (l = self->action_groups; l != NULL; l = g_list_next (l)) { actions = gtk_action_group_list_actions (l->data); for (k = actions; k != NULL; k = g_list_next (k)) { action = k->data; text = g_strdup_printf (TEMPLATE, gtk_action_get_label (action), gtk_action_get_tooltip (action)); icon = gtk_action_get_gicon (action); if (icon == NULL) { icon_name = gtk_action_get_icon_name (action); if (icon_name) icon = g_themed_icon_new (icon_name); gtk_action_get_stock_id (action); } else { g_object_ref (icon); } gtk_list_store_append (self->store, &iter); gtk_list_store_set (self->store, &iter, COLUMN_TEXT, text, COLUMN_ICON, icon, COLUMN_ACTION, k->data, -1); g_clear_object (&icon); } g_list_free (actions); } builder = gtk_builder_new (); path = "/org/gnome/Seahorse/seahorse-generate-select.xml"; gtk_builder_add_from_resource (builder, path, &error); if (error != NULL) { g_warning ("couldn't load ui file: %s", path); g_clear_error (&error); g_object_unref (builder); return; } /* Setup the dialog */ gtk_window_set_modal (GTK_WINDOW (self), TRUE); gtk_window_set_default_size (GTK_WINDOW (self), -1, 410); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), GTK_WIDGET (gtk_builder_get_object (builder, "generate-select")), TRUE, TRUE, 0); gtk_dialog_add_buttons (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Continue"), GTK_RESPONSE_OK, NULL); /* Hook it into the view */ self->view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "keytype-tree")); g_object_unref (builder); pixcell = gtk_cell_renderer_pixbuf_new (); g_object_set (pixcell, "stock-size", GTK_ICON_SIZE_DND, NULL); gtk_tree_view_insert_column_with_attributes (self->view, -1, "", pixcell, "gicon", COLUMN_ICON, NULL); gtk_tree_view_insert_column_with_attributes (self->view, -1, "", gtk_cell_renderer_text_new (), "markup", COLUMN_TEXT, NULL); gtk_tree_view_set_model (self->view, GTK_TREE_MODEL (self->store)); /* Setup selection, select first item */ selection = gtk_tree_view_get_selection (self->view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->store), &iter); gtk_tree_selection_select_iter (selection, &iter); g_signal_connect (self->view, "row-activated", G_CALLBACK (on_row_activated), self); g_object_set (self->view, "height-request", 410, NULL); g_signal_connect (self, "response", G_CALLBACK (on_response), self); }
static gint glspi_choose(lua_State* L) { const gchar *arg1=NULL; gint i, n; GtkResponseType rv; GtkWidget*dialog, *ok_btn, *cancel_btn, *tree, *scroll; GtkListStore *store; GtkTreeIter iter; GtkTreeSelection *select; if ( (lua_gettop(L)!=2) || (!lua_istable(L,2)) ) { return FAIL_TABLE_ARG(2); } if (!lua_isnil(L, 1)) { if (!lua_isstring(L, 1)) { return FAIL_STRING_ARG(1); } arg1=lua_tostring(L, 1); } n=lua_objlen(L,2); for (i=1;i<=n; i++) { lua_rawgeti(L,2,i); if (!lua_isstring(L, -1)) { return glspi_fail_elem_type(L, __FUNCTION__, 2, i, "string"); } lua_pop(L, 1); } store=gtk_list_store_new(1, G_TYPE_STRING); for (i=1;i<=n; i++) { lua_rawgeti(L,2,i); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, lua_tostring(L, -1), -1); lua_pop(L, 1); } dialog = new_dlg(GTK_MESSAGE_OTHER, GTK_BUTTONS_NONE, arg1, NULL); ok_btn=gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); cancel_btn=gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_widget_grab_default(ok_btn); set_dialog_title(L,dialog); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1, NULL, gtk_cell_renderer_text_new(), "text", 0, NULL); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); scroll=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),scroll); gtk_container_add(GTK_CONTAINER(scroll),tree); gtk_widget_set_size_request(tree, 320, 240); gtk_widget_show_all(dialog); gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE); gtk_signal_connect(GTK_OBJECT(tree), "button-press-event", GTK_SIGNAL_FUNC(on_tree_clicked), dialog); gtk_signal_connect(GTK_OBJECT(tree), "key-release-event", GTK_SIGNAL_FUNC(on_tree_key_release), dialog); rv=glspi_dialog_run(GTK_DIALOG(dialog)); if (GTK_RESPONSE_OK == rv ) { gchar *txt=NULL; GtkTreeModel *model; if (gtk_tree_selection_get_selected(select, &model, &iter)) { gtk_tree_model_get(model, &iter, 0, &txt, -1); } if (txt) { lua_pushstring(L, txt); g_free(txt); } else { lua_pushnil(L); } } else { lua_pushnil(L); } gtk_widget_destroy(dialog); return 1; }
PreferencesPageDCC * preferences_page_dcc_new (gpointer prefs_dialog, GtkBuilder *xml) { PreferencesPageDCC *page = g_object_new (PREFERENCES_PAGE_DCC_TYPE, NULL); PreferencesDialog *p = (PreferencesDialog *) prefs_dialog; #define GW(name) GtkWidget *name = GTK_WIDGET (gtk_builder_get_object (xml, #name)) GW(download_dir_button); GW(completed_dir_button); GW(convert_spaces); GW(save_nicknames_dcc); GW(autoaccept_dcc_chat); GW(autoaccept_dcc_file); GW(get_dcc_ip_from_server); GW(use_specified_dcc_ip); GW(special_ip_address); GW(individual_send_throttle); GW(global_send_throttle); GW(individual_receive_throttle); GW(global_receive_throttle); #undef GW page->special_ip_address = special_ip_address; gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (download_dir_button), get_default_download_dir(), NULL); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (download_dir_button), prefs.dccdir); if (strlen (prefs.dcc_completed_dir) == 0) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dccdir); } else { gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (completed_dir_button), get_default_download_dir(), NULL); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dcc_completed_dir); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (convert_spaces), prefs.dcc_send_fillspaces); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (save_nicknames_dcc), prefs.dccwithnick); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_chat), prefs.autodccchat); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_file), prefs.autodccsend); if (prefs.ip_from_server) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (get_dcc_ip_from_server), TRUE); gtk_widget_set_sensitive (special_ip_address, FALSE); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (use_specified_dcc_ip), TRUE); gtk_entry_set_text (GTK_ENTRY (special_ip_address), prefs.dcc_ip_str); gtk_widget_set_sensitive (special_ip_address, FALSE); } gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_send_throttle), (gdouble) prefs.dcc_max_send_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_send_throttle), (gdouble) prefs.dcc_global_max_send_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_receive_throttle), (gdouble) prefs.dcc_max_get_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_receive_throttle), (gdouble) prefs.dcc_global_max_get_cps); g_signal_connect (G_OBJECT (download_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dccdir); g_signal_connect (G_OBJECT (completed_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dcc_completed_dir); g_signal_connect (G_OBJECT (convert_spaces), "toggled", G_CALLBACK (toggle_changed), &prefs.dcc_send_fillspaces); g_signal_connect (G_OBJECT (save_nicknames_dcc), "toggled", G_CALLBACK (toggle_changed), &prefs.dccwithnick); g_signal_connect (G_OBJECT (autoaccept_dcc_chat), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccchat); g_signal_connect (G_OBJECT (autoaccept_dcc_file), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccsend); g_signal_connect (G_OBJECT (get_dcc_ip_from_server), "toggled", G_CALLBACK (get_ip_from_server_changed), page); g_signal_connect (G_OBJECT (special_ip_address), "changed", G_CALLBACK (special_ip_changed), NULL); g_signal_connect (G_OBJECT (individual_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_send_cps); g_signal_connect (G_OBJECT (global_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_send_cps); g_signal_connect (G_OBJECT (individual_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_get_cps); g_signal_connect (G_OBJECT (global_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_get_cps); GtkIconTheme *theme = gtk_icon_theme_get_default (); PREFERENCES_PAGE (page)->icon = gtk_icon_theme_load_icon (theme, "xchat-gnome-dcc", 16, 0, NULL); GtkTreeIter iter; gtk_list_store_append (p->page_store, &iter); gtk_list_store_set (p->page_store, &iter, 0, PREFERENCES_PAGE (page)->icon, 1, _("File Transfers & DCC"), 2, 3, -1); return page; }
void connection_dialog(gboolean auto_connect) { gint i; connecting = NULL; wait_for_tuner = FALSE; dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(dialog), "Connect"); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(ui.window)); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); g_signal_connect(dialog, "destroy", G_CALLBACK(connection_dialog_destroy), NULL); content = gtk_vbox_new(FALSE, 3); gtk_container_add(GTK_CONTAINER(dialog), content); r_serial = gtk_radio_button_new_with_label(NULL, "Serial port"); gtk_box_pack_start(GTK_BOX(content), r_serial, TRUE, TRUE, 2); c_serial = gtk_combo_box_text_new(); #ifdef G_OS_WIN32 gchar tmp[10]; for(i=1; i<=20; i++) { g_snprintf(tmp, sizeof(tmp), "COM%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c_serial), tmp); if(g_ascii_strcasecmp(tmp, conf.serial) == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(c_serial), i-1); } } #else struct dirent *dir; DIR *d = opendir("/dev"); i=0; if(d) { while((dir = readdir(d))) { #ifdef __APPLE__ if(!strncmp(dir->d_name, "cu.usbserial", 12)) #else if(!strncmp(dir->d_name, "ttyUSB", 6) || !strncmp(dir->d_name, "ttyACM", 6) || !strncmp(dir->d_name, "ttyS", 4) || !strncmp(dir->d_name, "rfcomm", 6)) #endif { gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c_serial), dir->d_name); if(g_ascii_strcasecmp(dir->d_name, conf.serial) == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(c_serial), i); } i++; } } closedir(d); } #endif g_signal_connect(c_serial, "changed", G_CALLBACK(connection_dialog_select), r_serial); gtk_box_pack_start(GTK_BOX(content), c_serial, TRUE, TRUE, 0); r_tcp = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(r_serial), "TCP/IP"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(r_tcp), conf.network); gtk_box_pack_start(GTK_BOX(content), r_tcp, TRUE, TRUE, 2); box_tcp1 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(content), box_tcp1); l_host = gtk_label_new("Host:"); gtk_box_pack_start(GTK_BOX(box_tcp1), l_host, TRUE, FALSE, 1); ls_host = gtk_list_store_new(1, G_TYPE_STRING); if(conf.host) { for(i=0; conf.host[i]; i++) { GtkTreeIter iter; gtk_list_store_append(ls_host, &iter); gtk_list_store_set(ls_host, &iter, 0, conf.host[i], -1); } } e_host = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(ls_host)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(e_host), 0); gtk_combo_box_set_active(GTK_COMBO_BOX(e_host), 0); g_signal_connect(e_host, "changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp1), e_host, TRUE, FALSE, 1); l_port = gtk_label_new("Port:"); gtk_box_pack_start(GTK_BOX(box_tcp1), l_port, TRUE, FALSE, 1); e_port = gtk_entry_new_with_max_length(5); gtk_entry_set_width_chars(GTK_ENTRY(e_port), 5); gchar *s_port = g_strdup_printf("%d", conf.port); gtk_entry_set_text(GTK_ENTRY(e_port), s_port); g_free(s_port); g_signal_connect(e_port, "changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp1), e_port, TRUE, FALSE, 1); box_tcp2 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(content), box_tcp2); l_password = gtk_label_new("Password:"******"changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp2), e_password, TRUE, TRUE, 1); c_password = gtk_check_button_new_with_label("Keep"); if(conf.password && strlen(conf.password)) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_password), TRUE); } g_signal_connect(c_password, "toggled", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp2), c_password, FALSE, FALSE, 1); box_status_wrapper = gtk_hbox_new(TRUE, 5); gtk_box_pack_start(GTK_BOX(content), box_status_wrapper, FALSE, FALSE, 1); box_status = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box_status_wrapper), box_status, FALSE, FALSE, 1); spinner = gtk_spinner_new(); gtk_box_pack_start(GTK_BOX(box_status), spinner, FALSE, FALSE, 1); l_status = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(box_status), l_status, FALSE, FALSE, 1); box_button = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(box_button), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(box_button), 5); gtk_box_pack_start(GTK_BOX(content), box_button, FALSE, FALSE, 5); b_connect = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect(dialog, "key-press-event", G_CALLBACK(connection_dialog_key), b_connect); g_signal_connect(b_connect, "clicked", G_CALLBACK(connection_dialog_connect), NULL); gtk_container_add(GTK_CONTAINER(box_button), b_connect); b_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped(b_cancel, "clicked", G_CALLBACK(gtk_widget_destroy), dialog); gtk_container_add(GTK_CONTAINER(box_button), b_cancel); #ifdef G_OS_WIN32 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui.b_ontop))) { gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE); } #endif gtk_widget_show_all(dialog); gtk_widget_hide(spinner); gtk_widget_hide(l_status); connect_button(FALSE); if(auto_connect || (conf.auto_reconnect && successfully_connected)) { gtk_button_clicked(GTK_BUTTON(b_connect)); } }
void seahorse_gpgme_add_subkey_new (SeahorseGpgmeKey *pkey, GtkWindow *parent) { SeahorseWidget *swidget; GtkComboBox* combo; GtkTreeModel *model; GtkTreeIter iter; GtkCellRenderer *renderer; GtkWidget *widget, *datetime; swidget = seahorse_object_widget_new ("add-subkey", parent, G_OBJECT (pkey)); g_return_if_fail (swidget != NULL); gtk_window_set_title (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)), g_strdup_printf (_("Add subkey to %s"), seahorse_object_get_label (SEAHORSE_OBJECT (pkey)))); combo = GTK_COMBO_BOX (seahorse_widget_get_widget (swidget, "type")); model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT)); gtk_combo_box_set_model (combo, model); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", COMBO_STRING); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("DSA (sign only)"), COMBO_INT, 0, -1); gtk_combo_box_set_active_iter (combo, &iter); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("ElGamal (encrypt only)"), COMBO_INT, 1, -1); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("RSA (sign only)"), COMBO_INT, 2, -1); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("RSA (encrypt only)"), COMBO_INT, 3, -1); widget = seahorse_widget_get_widget (swidget, "datetime-placeholder"); g_return_if_fail (widget != NULL); datetime = egg_datetime_new (); gtk_container_add (GTK_CONTAINER (widget), datetime); gtk_widget_show (datetime); gtk_widget_set_sensitive (datetime, FALSE); g_object_set_data (G_OBJECT (swidget), "expires-datetime", datetime); }
void vmat_create_list (class vmat_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); GtkListStore *model=NULL; GtkTreeIter iter; char strsql[400]; int kolstr=0; SQLCURSOR cur; SQL_str row; printf("vmat_create_list %d\n",data->snanomer); data->kl_shift=0; //0-отжата 1-нажата gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(vmat_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(vmat_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); //gtk_list_store_clear(model); if(data->metkarr == 0) sprintf(strsql,"select kodm,naimat,ei,cenapr from Material where kodgr=%d \ and cenapr != 0. and ei != '' order by naimat asc",data->kodgr); if(data->metkarr == 1) sprintf(strsql,"select kodus,naius,ei,cena from Uslugi where kodgr=%d \ and cena != 0. and ei != '' order by naius asc",data->kodgr); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } //gtk_list_store_clear(model); iceb_u_str s1; iceb_u_str s2; iceb_u_str s3; iceb_u_str s4; float kolstr1=0.; data->kolzap=0; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); //код s1.new_plus(row[0]); //наименование s2.new_plus(iceb_u_toutf(row[1])); //единица измерения s3.new_plus(iceb_u_toutf(row[2])); //цена sprintf(strsql,"%.2f",atof(row[3])); s4.new_plus(strsql); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_KOD,s1.ravno(), COL_NAIM,s2.ravno(), COL_EI,s3.ravno(), COL_CENA,s4.ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); vmat_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VVERH]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VNIZ]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK2]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VVERH]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK_VNIZ]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); if(data->kolzap > 0) l_vmat_setstr(data); //стать на нужную строку iceb_u_str stroka; iceb_u_str zagolov; sprintf(strsql,"%s:%d %s",gettext("Группа"),data->kodgr,data->naigr.ravno()); zagolov.plus_ps(strsql); zagolov.plus(gettext("Выберите нужную запись")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
static void tb_editor_drag_data_rcvd_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint ltime, TBEditorWidget *tbw) { GtkTreeView *tree = GTK_TREE_VIEW(widget); gboolean del = FALSE; if (data->length >= 0 && data->format == 8) { gboolean is_sep; gchar *text = NULL; text = (gchar*) data->data; /* We allow re-ordering the Location item but not removing it from the list. */ if (g_strcmp0(text, "Location") == 0 && widget != tbw->drag_source) return; is_sep = (g_strcmp0(text, "Separator") == 0); /* If the source of the action is equal to the target, we do just re-order and so need * to delete the separator to get it moved, not just copied. */ if (is_sep && widget == tbw->drag_source) is_sep = FALSE; if (tree != tbw->tree_available || ! is_sep) { GtkTreeIter iter, iter_before, *iter_before_ptr; GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(tree)); if (tbw->last_drag_path != NULL) { gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter_before, tbw->last_drag_path); if (gtk_list_store_iter_is_valid(store, &iter_before)) iter_before_ptr = &iter_before; else iter_before_ptr = NULL; if (tbw->last_drag_pos == GTK_TREE_VIEW_DROP_BEFORE || tbw->last_drag_pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE) gtk_list_store_insert_before(store, &iter, iter_before_ptr); else gtk_list_store_insert_after(store, &iter, iter_before_ptr); tb_editor_set_item_values(tbw, text, store, &iter); } else { gtk_list_store_append(store, &iter); tb_editor_set_item_values(tbw, text, store, &iter); } tb_editor_scroll_to_iter(tree, &iter); } if (tree != tbw->tree_used || ! is_sep) del = TRUE; } tbw->drag_source = NULL; /* reset the value just to be sure */ tb_editor_free_path(tbw); gtk_drag_finish(context, TRUE, del, ltime); }
static void add_ims(GevoAddBuddyDialog *dialog, EContact *contact, const char *name, GList *list, const char *id) { PurpleAccount *account = NULL; GList *l; GtkTreeIter iter; GdkPixbuf *pixbuf; if (list == NULL) return; for (l = purple_connections_get_all(); l != NULL; l = l->next) { PurpleConnection *gc = (PurpleConnection *)l->data; account = purple_connection_get_account(gc); if (!strcmp(purple_account_get_protocol_id(account), id)) break; account = NULL; } if (account == NULL) return; pixbuf = pidgin_create_prpl_icon(account, 0.5); for (l = list; l != NULL; l = l->next) { char *account_name = (char *)l->data; if (account_name == NULL) continue; if (purple_find_buddy(dialog->account, account_name) != NULL) continue; gtk_list_store_append(dialog->model, &iter); gtk_list_store_set(dialog->model, &iter, COLUMN_NAME, name, COLUMN_PRPL_ICON, pixbuf, COLUMN_USERNAME, account_name, COLUMN_DATA, contact, -1); if (!strcmp(purple_account_get_protocol_id(account), purple_account_get_protocol_id(dialog->account)) && dialog->username != NULL && !strcmp(account_name, dialog->username)) { GtkTreeSelection *selection; /* This is it. Select it. */ selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(dialog->treeview)); gtk_tree_selection_select_iter(selection, &iter); } } if (pixbuf != NULL) g_object_unref(G_OBJECT(pixbuf)); g_list_foreach(list, (GFunc)g_free, NULL); g_list_free(list); }
int main(int argc, char*argv[]) { bindtextdomain ("testGtkGstreamer", "./locale"); bind_textdomain_codeset ("testGtkGstreamer", "UTF-8"); textdomain ("testGtkGstreamer"); setlocale(LC_ALL, ""); GtkWidget* window = NULL; GError *error = NULL; GOptionContext *context; // gtk_init(&argc, &argv); context = g_option_context_new (_("- a simple gtk gstreamer program")); g_option_context_add_main_entries (context, entries, "testGtkGstreamer"); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("option parsing failed: %s\n", error->message); exit (1); } gst_init (&argc, &argv); GtkBuilder* builder = gtk_builder_new_from_file("./main.ui"); gtk_builder_connect_signals(builder, builder); window = GTK_WIDGET(gtk_builder_get_object(builder, "mainWindow")); // g_signal_connect(window, "delete-event", G_CALLBACK(onWindowDeleteEvent), builder); // g_signal_connect(window, "destroy", G_CALLBACK(onDestoryed), builder); GtkWidget* video_area = GTK_WIDGET(gtk_builder_get_object(builder, "video_area")); g_signal_connect(video_area, "realize", G_CALLBACK(on_video_area_realize), builder); GtkWidget* playpausebtn = GTK_WIDGET(gtk_builder_get_object(builder, "video_play_pause")); GtkWidget* image = gtk_image_new_from_icon_name ("media-playback-start-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (playpausebtn), image); gtk_widget_set_valign (GTK_WIDGET (playpausebtn), GTK_ALIGN_CENTER); gtk_style_context_add_class (gtk_widget_get_style_context (playpausebtn), "image-button"); GtkWidget* hellobtn = GTK_WIDGET(gtk_builder_get_object(builder, "helloworld")); g_signal_connect(hellobtn, "clicked", G_CALLBACK(onButtonClicked), builder); GtkListStore* model = gtk_list_store_new(LIST_COLUMNS_N, G_TYPE_STRING, G_TYPE_STRING); int i = 0; for (i = 0; i < 50; i++) { GtkTreeIter iter; gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, LIST_NO, g_strdup_printf("%d", i + 1), LIST_TITLE, g_strdup_printf("This is column %d", i + 1), -1); } GtkWidget* cb1 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox")); gtk_combo_box_set_model(GTK_COMBO_BOX(cb1), GTK_TREE_MODEL(model)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(cb1), LIST_NO); gtk_widget_show_all(GTK_WIDGET(window)); gtk_widget_realize(GTK_WIDGET(video_area)); create_gst_pipline(); gst_element_set_state (g_pipeline, GST_STATE_PLAYING); gtk_main(); gst_element_set_state (g_pipeline, GST_STATE_NULL); gst_object_unref(GST_OBJECT(g_pipeline)); g_free(g_filename); return 0; }
static void populate_treeview(GevoAddBuddyDialog *dialog, const gchar *uri) { EBookQuery *query; EBook *book; gboolean status; GList *cards, *c; if (dialog->book != NULL) { g_object_unref(dialog->book); dialog->book = NULL; } if (dialog->contacts != NULL) { g_list_foreach(dialog->contacts, (GFunc)g_object_unref, NULL); g_list_free(dialog->contacts); dialog->contacts = NULL; } gtk_list_store_clear(dialog->model); if (!gevo_load_addressbook(uri, &book, NULL)) { purple_debug_error("evolution", "Error retrieving default addressbook\n"); return; } query = e_book_query_field_exists(E_CONTACT_FULL_NAME); if (query == NULL) { purple_debug_error("evolution", "Error in creating query\n"); g_object_unref(book); return; } status = e_book_get_contacts(book, query, &cards, NULL); e_book_query_unref(query); if (!status) { purple_debug_error("evolution", "Error %d in getting card list\n", status); g_object_unref(book); return; } for (c = cards; c != NULL; c = c->next) { EContact *contact = E_CONTACT(c->data); const char *name; GList *aims, *jabbers, *yahoos, *msns, *icqs, *novells; name = e_contact_get_const(contact, E_CONTACT_FULL_NAME); aims = e_contact_get(contact, E_CONTACT_IM_AIM); jabbers = e_contact_get(contact, E_CONTACT_IM_JABBER); yahoos = e_contact_get(contact, E_CONTACT_IM_YAHOO); msns = e_contact_get(contact, E_CONTACT_IM_MSN); icqs = e_contact_get(contact, E_CONTACT_IM_ICQ); novells = e_contact_get(contact, E_CONTACT_IM_GROUPWISE); if (aims == NULL && jabbers == NULL && yahoos == NULL && msns == NULL && icqs == NULL && novells == NULL) { GtkTreeIter iter; gtk_list_store_append(dialog->model, &iter); gtk_list_store_set(dialog->model, &iter, COLUMN_NAME, name, COLUMN_DATA, contact, -1); } else { add_ims(dialog, contact, name, aims, "prpl-oscar"); add_ims(dialog, contact, name, aims, "prpl-aim"); add_ims(dialog, contact, name, jabbers, "prpl-jabber"); add_ims(dialog, contact, name, yahoos, "prpl-yahoo"); add_ims(dialog, contact, name, msns, "prpl-msn"); add_ims(dialog, contact, name, icqs, "prpl-icq"); add_ims(dialog, contact, name, icqs, "prpl-oscar"); add_ims(dialog, contact, name, novells, "prpl-novell"); } } dialog->contacts = cards; dialog->book = book; }
static void gth_slideshow_preferences_construct (GthSlideshowPreferences *self, const char *current_transition, gboolean automatic, int delay, gboolean wrap_around, gboolean random_order) { GtkListStore *model; GtkCellRenderer *renderer; GList *transitions; int i, i_active; GList *scan; GtkTreeIter iter; self->priv->builder = _gtk_builder_new_from_file ("slideshow-preferences.ui", "slideshow"); gtk_container_add (GTK_CONTAINER (self), _gtk_builder_get_widget (self->priv->builder, "preferences_page")); model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); self->priv->transition_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->transition_combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->transition_combobox), renderer, "text", TRANSITION_COLUMN_DISPLAY_NAME, NULL); transitions = gth_main_get_registered_objects (GTH_TYPE_TRANSITION); for (i = 0, i_active = 0, scan = transitions; scan; scan = scan->next, i++) { GthTransition *transition = scan->data; if (g_strcmp0 (gth_transition_get_id (transition), current_transition) == 0) i_active = i; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, TRANSITION_COLUMN_ID, gth_transition_get_id (transition), TRANSITION_COLUMN_DISPLAY_NAME, gth_transition_get_display_name (transition), -1); } if (g_strcmp0 ("random", current_transition) == 0) i_active = i; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, TRANSITION_COLUMN_ID, "random", TRANSITION_COLUMN_DISPLAY_NAME, _("Random"), -1); gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->transition_combobox), i_active); gtk_widget_show (self->priv->transition_combobox); gtk_box_pack_start (GTK_BOX (_gtk_builder_get_widget (self->priv->builder, "transition_box")), self->priv->transition_combobox, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton")), automatic); gtk_spin_button_set_value (GTK_SPIN_BUTTON (_gtk_builder_get_widget (self->priv->builder, "change_delay_spinbutton")), ((float) delay) / 1000.0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "wrap_around_checkbutton")), wrap_around); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "random_order_checkbutton")), random_order); /* signals */ g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "personalize_checkbutton"), "toggled", G_CALLBACK (personalize_checkbutton_toggled_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton"), "toggled", G_CALLBACK (automatic_checkbutton_toggled_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "remove_file_button"), "clicked", G_CALLBACK (remove_file_button_clicked_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "add_file_button"), "clicked", G_CALLBACK (add_file_button_clicked_cb), self); }
static void setup_main_window (UmUserPanelPrivate *d) { GtkWidget *userlist; GtkTreeModel *model; GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GtkWidget *button; GtkTreeIter iter; gint expander_size; gchar *title; GIcon *icon; gchar *names[3]; userlist = get_widget (d, "list-treeview"); store = gtk_list_store_new (NUM_USER_LIST_COLS, UM_TYPE_USER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_BOOLEAN); model = (GtkTreeModel *)store; gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), sort_users, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (userlist), model); gtk_tree_view_set_search_column (GTK_TREE_VIEW (userlist), USER_COL); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (userlist), match_user, NULL, NULL); g_object_unref (model); g_signal_connect (d->um, "users-loaded", G_CALLBACK (users_loaded), d); gtk_widget_style_get (userlist, "expander-size", &expander_size, NULL); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (userlist), - (expander_size + 6)); title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("My Account")); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, TITLE_COL, title, HEADING_ROW_COL, TRUE, SORT_KEY_COL, 0, AUTOLOGIN_COL, FALSE, -1); g_free (title); title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("Other Accounts")); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, TITLE_COL, title, HEADING_ROW_COL, TRUE, SORT_KEY_COL, 2, AUTOLOGIN_COL, FALSE, -1); g_free (title); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "pixbuf", FACE_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", NAME_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", TITLE_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", HEADING_ROW_COL); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); gtk_tree_view_column_set_cell_data_func (column, cell, (GtkTreeCellDataFunc) autologin_cell_data_func, d, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (userlist), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (userlist)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (selected_user_changed), d); gtk_tree_selection_set_select_function (selection, dont_select_headings, NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (get_widget (d, "list-scrolledwindow")), 300); gtk_widget_set_size_request (get_widget (d, "list-scrolledwindow"), 200, -1); button = get_widget (d, "add-user-toolbutton"); g_signal_connect (button, "clicked", G_CALLBACK (add_user), d); button = get_widget (d, "remove-user-toolbutton"); g_signal_connect (button, "clicked", G_CALLBACK (delete_user), d); button = get_widget (d, "user-icon-nonbutton"); add_unlock_tooltip (button); button = get_widget (d, "full-name-entry"); g_signal_connect (button, "editing-done", G_CALLBACK (change_name_done), d); button = get_widget (d, "account-type-combo"); g_signal_connect (button, "editing-done", G_CALLBACK (account_type_changed), d); button = get_widget (d, "account-password-button"); g_signal_connect (button, "start-editing", G_CALLBACK (change_password), d); button = get_widget (d, "account-language-combo"); g_signal_connect (button, "editing-done", G_CALLBACK (language_changed), d); button = get_widget (d, "autologin-switch"); g_signal_connect (button, "notify::active", G_CALLBACK (autologin_changed), d); button = get_widget (d, "account-fingerprint-button"); g_signal_connect (button, "clicked", G_CALLBACK (change_fingerprint), d); d->permission = (GPermission *)polkit_permission_new_sync ("org.freedesktop.accounts.user-administration", NULL, NULL, NULL); g_signal_connect (d->permission, "notify", G_CALLBACK (on_permission_changed), d); on_permission_changed (d->permission, NULL, d); button = get_widget (d, "add-user-toolbutton"); names[0] = "changes-allow-symbolic"; names[1] = "changes-allow"; names[2] = NULL; icon = (GIcon *)g_themed_icon_new_from_names (names, -1); setup_tooltip_with_embedded_icon (button, _("To create a user account,\nclick the * icon first"), "*", icon); button = get_widget (d, "remove-user-toolbutton"); setup_tooltip_with_embedded_icon (button, _("To delete the selected user account,\nclick the * icon first"), "*", icon); g_object_unref (icon); }
/**************************************************************** Creates spy's building sabotaging dialog *****************************************************************/ static void create_improvements_list(struct player *pplayer, struct city *pcity) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeIter it; spy_sabotage_shell = gtk_dialog_new_with_buttons(_("Sabotage Improvements"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Sabotage"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_sabotage_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_sabotage_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Improvement to Sabotage")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))), label); vbox = gtk_grid_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing(GTK_GRID(vbox), 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_widget_set_hexpand(view, TRUE); gtk_widget_set_vexpand(view, TRUE); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Improvements:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, _("City Production"), 1, -1, -1); city_built_iterate(pcity, pimprove) { if (pimprove->sabotage > 0) { gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, city_improvement_name_translation(pcity, pimprove), 1, improvement_number(pimprove), -1); } } city_built_iterate_end; gtk_list_store_append(store, &it); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); gtk_list_store_set(store, &it, 0, astr_str(&str), 1, B_LAST, -1); astr_free(&str); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_improvements_callback), NULL); g_signal_connect(spy_sabotage_shell, "response", G_CALLBACK(spy_improvements_response), NULL); sabotage_improvement = -2; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
static void action_combo_box_update_model (EActionComboBox *combo_box) { GtkListStore *list_store; GSList *list; g_hash_table_remove_all (combo_box->priv->index); if (combo_box->priv->action == NULL) { gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), NULL); return; } /* We store values in the sort column as floats so that we can * insert separators in between consecutive integer values and * still maintain the proper ordering. */ list_store = gtk_list_store_new ( 2, GTK_TYPE_RADIO_ACTION, G_TYPE_FLOAT); list = gtk_radio_action_get_group (combo_box->priv->action); combo_box->priv->group_has_icons = FALSE; while (list != NULL) { GtkTreeRowReference *reference; GtkRadioAction *action = list->data; GtkTreePath *path; GtkTreeIter iter; gchar *icon_name = NULL; gchar *stock_id = NULL; gboolean visible = FALSE; gint value; g_object_get (action, "icon-name", &icon_name, "stock-id", &stock_id, "visible", &visible, NULL); if (!visible) { g_free (icon_name); g_free (stock_id); list = g_slist_next (list); continue; } combo_box->priv->group_has_icons |= (icon_name != NULL || stock_id != NULL); g_free (icon_name); g_free (stock_id); gtk_list_store_append (list_store, &iter); g_object_get (action, "value", &value, NULL); gtk_list_store_set ( list_store, &iter, COLUMN_ACTION, list->data, COLUMN_SORT, (gfloat) value, -1); path = gtk_tree_model_get_path ( GTK_TREE_MODEL (list_store), &iter); reference = gtk_tree_row_reference_new ( GTK_TREE_MODEL (list_store), path); g_hash_table_insert ( combo_box->priv->index, GINT_TO_POINTER (value), reference); gtk_tree_path_free (path); list = g_slist_next (list); } gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (list_store), COLUMN_SORT, GTK_SORT_ASCENDING); gtk_combo_box_set_model ( GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (list_store)); g_object_unref (list_store); action_combo_box_action_changed_cb ( combo_box->priv->action, combo_box->priv->action, combo_box); }
/** * unicapgtk_device_selection_rescan: * @combo: an #UnicapgtkDeviceSelection * * Tiggers rescan of available video capture devices and updates the * combo box. * * Returns: number of available devices */ gint unicapgtk_device_selection_rescan( UnicapgtkDeviceSelection *combo ) { unicap_device_t device; GtkListStore *store; GtkTreeIter iter; gint i; g_return_val_if_fail( UNICAPGTK_IS_DEVICE_SELECTION( combo ), 0 ); store = GTK_LIST_STORE( gtk_combo_box_get_model( GTK_COMBO_BOX( combo ) ) ); g_return_val_if_fail( GTK_IS_LIST_STORE( store ), 0 ); if( GTK_WIDGET_REALIZED( combo ) ) { gdk_window_set_cursor( GTK_WIDGET( combo )->window, combo->busy_cursor ); gdk_display_sync( gtk_widget_get_display( GTK_WIDGET( combo ) ) ); } gtk_list_store_clear( store ); gtk_combo_box_set_active( GTK_COMBO_BOX( combo ), -1 ); unicap_reenumerate_devices( NULL ); for( i = 0; SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ); i++ ) { gchar *label; gboolean available = !unicap_is_stream_locked( &device ); label = format_device_label( combo->label_fmt_string, &device ); gtk_list_store_append( store, &iter); gtk_list_store_set( store, &iter, UNICAPGTK_DEVICE_ID, device.identifier, UNICAPGTK_DEVICE_MODEL, device.model_name, UNICAPGTK_DEVICE_VENDOR, device.vendor_name, LABEL, label, SENSITIVE, available, -1); g_free( label ); } if( i == 0 ) { device_combo_box_add_none_entry( store ); } if( combo->include_rescan_entry ) { device_combo_box_add_rescan_entry( store ); } if( combo->active_device ) { unicapgtk_device_selection_set_by_id( combo, combo->active_device ); } if( GTK_WIDGET_REALIZED( combo ) ) { gdk_window_set_cursor( GTK_WIDGET( combo )->window, NULL ); } return i; }
static gboolean gtk_app_chooser_widget_add_section (GtkAppChooserWidget *self, const gchar *heading_title, gboolean show_headings, gboolean recommended, gboolean fallback, GList *applications, GList *exclude_apps) { gboolean heading_added, unref_icon; GtkTreeIter iter; GAppInfo *app; gchar *app_string, *bold_string; GIcon *icon; GList *l; gboolean retval; retval = FALSE; heading_added = FALSE; bold_string = g_strdup_printf ("<b>%s</b>", heading_title); for (l = applications; l != NULL; l = l->next) { app = l->data; if (!g_app_info_supports_uris (app) && !g_app_info_supports_files (app)) continue; if (!g_app_info_should_show (app)) continue; if (g_list_find_custom (exclude_apps, app, (GCompareFunc) compare_apps_func)) continue; if (!heading_added && show_headings) { gtk_list_store_append (self->priv->program_list_store, &iter); gtk_list_store_set (self->priv->program_list_store, &iter, COLUMN_HEADING_TEXT, bold_string, COLUMN_HEADING, TRUE, COLUMN_RECOMMENDED, recommended, COLUMN_FALLBACK, fallback, -1); heading_added = TRUE; } app_string = g_markup_printf_escaped ("%s", g_app_info_get_name (app) != NULL ? g_app_info_get_name (app) : ""); icon = g_app_info_get_icon (app); unref_icon = FALSE; if (icon == NULL) { icon = g_themed_icon_new ("application-x-executable"); unref_icon = TRUE; } gtk_list_store_append (self->priv->program_list_store, &iter); gtk_list_store_set (self->priv->program_list_store, &iter, COLUMN_APP_INFO, app, COLUMN_GICON, icon, COLUMN_NAME, g_app_info_get_name (app), COLUMN_DESC, app_string, COLUMN_EXEC, g_app_info_get_executable (app), COLUMN_HEADING, FALSE, COLUMN_RECOMMENDED, recommended, COLUMN_FALLBACK, fallback, -1); retval = TRUE; g_free (app_string); if (unref_icon) g_object_unref (icon); } g_free (bold_string); return retval; }