static void grilo_browse_cb (GrlSource *grilo_source, guint operation_id, GrlMedia *media, guint remaining, RBGriloSource *source, const GError *error) { if (operation_id != source->priv->browse_op) { return; } if (error != NULL) { /* do something? */ rb_debug ("got error for %s: %s", grl_source_get_name (grilo_source), error->message); source->priv->browse_op = 0; return; } if (media != NULL) { source->priv->browse_got_results = TRUE; source->priv->browse_position++; } if (media && GRL_IS_MEDIA_BOX (media)) { GtkTreeIter new_row; if (source->priv->browse_container == NULL) { /* insert at the end */ gtk_tree_store_insert_with_values (source->priv->browser_model, &new_row, NULL, -1, 0, g_object_ref (media), 1, grl_media_get_title (media), 2, CONTAINER_UNKNOWN_MEDIA, 3, 0, -1); } else { int n; /* insert before the expand marker row */ n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model), &source->priv->browse_container_iter); gtk_tree_store_insert_with_values (source->priv->browser_model, &new_row, &source->priv->browse_container_iter, n - 1, 0, g_object_ref (media), 1, grl_media_get_title (media), 2, CONTAINER_UNKNOWN_MEDIA, 3, 0, -1); } /* and insert an expand marker below it too */ gtk_tree_store_insert_with_values (source->priv->browser_model, NULL, &new_row, -1, 0, NULL, 1, "...", /* needs to be translatable? */ 2, CONTAINER_MARKER, 3, 0, -1); } else if (media && GRL_IS_MEDIA_AUDIO (media)) { source->priv->browse_got_media = TRUE; } if (remaining == 0) { source->priv->browse_op = 0; if (source->priv->browse_got_results == FALSE && source->priv->browse_container != NULL) { /* no more results for this container, so delete the marker row */ delete_marker_row (source, &source->priv->browse_container_iter); set_container_type (source, &source->priv->browse_container_iter, FALSE); gtk_tree_store_set (source->priv->browser_model, &source->priv->browse_container_iter, 3, -1, -1); } else if (source->priv->browse_container != NULL) { if (source->priv->browse_got_media) { set_container_type (source, &source->priv->browse_container_iter, TRUE); } if (source->priv->browse_position >= CONTAINER_GIVE_UP_POINT && gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model), &source->priv->browse_container_iter) == 1) { /* no containers yet, so remove the marker row */ delete_marker_row (source, &source->priv->browse_container_iter); } else { /* store browse position for next time we want more */ gtk_tree_store_set (source->priv->browser_model, &source->priv->browse_container_iter, 3, source->priv->browse_position, -1); maybe_expand_container (source); } } else if (source->priv->browse_container == NULL) { if (source->priv->browse_got_results) { /* get all top-level containers */ browse_next (source); } else if (source->priv->browse_got_media) { GtkTreeIter root_iter; GtkTreeSelection *selection; /* root container has media, so show it in the browser */ gtk_tree_store_insert_with_values (source->priv->browser_model, &root_iter, NULL, 0, 0, NULL, 1, grl_source_get_name (source->priv->grilo_source), 2, CONTAINER_HAS_MEDIA, 3, 0, -1); /* select it, so we start fetching the media */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view)); gtk_tree_selection_select_iter (selection, &root_iter); } } } }
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); }
bool SidebarIndexPage::selectPageNr(size_t page, size_t pdfPage, GtkTreeIter* parent) { XOJ_CHECK_TYPE(SidebarIndexPage); GtkTreeIter iter; Document* doc = control->getDocument(); doc->lock(); GtkTreeModel* model = doc->getContentsModel(); if (model == NULL) { doc->unlock(); return false; } g_object_ref(model); doc->unlock(); if (parent == NULL) { // check if there is already the current page selected GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeViewBookmarks)); if (gtk_tree_selection_get_selected(selection, &model, &iter)) { XojLinkDest* link = NULL; gtk_tree_model_get(model, &iter, DOCUMENT_LINKS_COLUMN_LINK, &link, -1); if (link && link->dest) { LinkDestination* dest = link->dest; if (dest->getPdfPage() == pdfPage) { g_object_unref(model); g_object_unref(link); // already bookmak from this page selected return true; } } g_object_unref(link); } } gboolean valid = gtk_tree_model_iter_children(model, &iter, parent); while (valid) { XojLinkDest* link = NULL; gtk_tree_model_get(model, &iter, DOCUMENT_LINKS_COLUMN_LINK, &link, -1); if (link->dest->getPdfPage() == pdfPage) { GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeViewBookmarks)); gtk_tree_selection_select_iter(selection, &iter); g_object_unref(link); g_object_unref(model); return true; } else { g_object_unref(link); if (selectPageNr(page, pdfPage, &iter)) { g_object_unref(model); return true; } else { valid = gtk_tree_model_iter_next(model, &iter); } } } g_object_unref(model); return false; }
static void _xfdashboard_settings_xfconf_changed_theme(XfdashboardSettings *self, const gchar *inProperty, const GValue *inValue, XfconfChannel *inChannel) { XfdashboardSettingsPrivate *priv; const gchar *newValue; GtkTreeModel *model; GtkTreeIter iter; gboolean selectionFound; g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self)); g_return_if_fail(inValue); g_return_if_fail(XFCONF_IS_CHANNEL(inChannel)); priv=self->priv; newValue=DEFAULT_THEME; /* Get new value to set at widget */ if(G_LIKELY(G_VALUE_TYPE(inValue)==G_TYPE_STRING)) newValue=g_value_get_string(inValue); /* Iterate through themes' model and lookup matching item * against new theme name and select it */ selectionFound=FALSE; model=gtk_tree_view_get_model(GTK_TREE_VIEW(priv->widgetThemes)); if(newValue && gtk_tree_model_get_iter_first(model, &iter)) { do { gchar *value; gtk_tree_model_get(model, &iter, COLUMN_THEME_NAME, &value, -1); if(G_UNLIKELY(g_str_equal(value, newValue))) { GtkTreePath *selectionPath; selectionPath=gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes)), &iter); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(priv->widgetThemes), selectionPath, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free(selectionPath); selectionFound=TRUE; } g_free(value); } while(!selectionFound && gtk_tree_model_iter_next(model, &iter)); } /* If no selection was found, deselect any selected entry at widget */ if(!selectionFound) { GtkTreeSelection *selection; selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes)); gtk_tree_selection_unselect_all(selection); } }
static void goa_panel_init (GoaPanel *panel) { GtkWidget *button; GtkWidget *w; GError *error; GtkStyleContext *context; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter iter; panel->builder = gtk_builder_new (); error = NULL; if (gtk_builder_add_from_file (panel->builder, CINNAMONCC_UI_DIR "/online-accounts.ui", &error) == 0) { goa_warning ("Error loading UI file: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } panel->toolbar = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbar")); panel->toolbar_add_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-add")); g_signal_connect (panel->toolbar_add_button, "clicked", G_CALLBACK (on_toolbar_add_button_clicked), panel); panel->toolbar_remove_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-remove")); g_signal_connect (panel->toolbar_remove_button, "clicked", G_CALLBACK (on_toolbar_remove_button_clicked), panel); context = gtk_widget_get_style_context (GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-scrolledwindow"))); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM); context = gtk_widget_get_style_context (panel->toolbar); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); panel->accounts_treeview = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-treeview")); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)), "changed", G_CALLBACK (on_tree_view_selection_changed), panel); button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-button-add")); g_signal_connect (button, "clicked", G_CALLBACK (on_add_button_clicked), panel); panel->accounts_vbox = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-vbox")); /* TODO: probably want to avoid _sync() ... */ error = NULL; panel->client = goa_client_new_sync (NULL /* GCancellable */, &error); if (panel->client == NULL) { goa_warning ("Error getting a GoaClient: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget")); gtk_widget_set_sensitive (w, FALSE); g_error_free (error); goto out; } g_signal_connect (panel->client, "account-changed", G_CALLBACK (on_account_changed), panel); panel->accounts_model = goa_panel_accounts_model_new (panel->client); gtk_tree_view_set_model (GTK_TREE_VIEW (panel->accounts_treeview), GTK_TREE_MODEL (panel->accounts_model)); g_signal_connect (panel->accounts_model, "row-deleted", G_CALLBACK (on_model_row_deleted), panel); g_signal_connect (panel->accounts_model, "row-inserted", G_CALLBACK (on_model_row_inserted), panel); column = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (panel->accounts_treeview), column); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); g_object_set (G_OBJECT (renderer), "stock-size", GTK_ICON_SIZE_DIALOG, NULL); gtk_tree_view_column_set_attributes (column, renderer, "gicon", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30, NULL); gtk_tree_view_column_set_attributes (column, renderer, "markup", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_MARKUP, NULL); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_end (column, renderer, FALSE); g_object_set (G_OBJECT (renderer), "icon-name", "dialog-error-symbolic", NULL); gtk_tree_view_column_set_attributes (column, renderer, "visible", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ATTENTION_NEEDED, NULL); /* Select the first row, if any */ if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (panel->accounts_model), &iter)) gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)), &iter); out: w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget")); gtk_widget_reparent (w, GTK_WIDGET (panel)); gtk_widget_show_all (w); }
static void fill_data (gint n_columns) { GtkTreeIter iter; GtkListStore *model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (list_view))); GIOChannel *channel; if (options.extra_data && *options.extra_data) { gchar **args = options.extra_data; gint i = 0; gtk_widget_freeze_child_notify (list_view); while (args[i] != NULL) { gint j; gtk_list_store_append (model, &iter); for (j = 0; j < n_columns; j++, i++) { YadColumn *col = (YadColumn *) g_slist_nth_data (options.list_data.columns, j); GdkPixbuf *pb; if (args[i] == NULL) break; switch (col->type) { case YAD_COLUMN_CHECK: case YAD_COLUMN_RADIO: if (strcasecmp ((gchar *) args[i], "true") == 0) gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, TRUE, -1); else gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, FALSE, -1); break; case YAD_COLUMN_NUM: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtoll (args[i], NULL, 10), -1); break; case YAD_COLUMN_FLOAT: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtod (args[i], NULL), -1); break; case YAD_COLUMN_IMAGE: pb = get_pixbuf (args[i], YAD_SMALL_ICON); if (pb) { gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, pb, -1); g_object_unref (pb); } break; default: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, args[i], -1); break; } } } gtk_widget_thaw_child_notify (list_view); if (settings.always_selected) { GtkTreeIter it; GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (list_view)); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (list_view)); gtk_tree_model_get_iter_first (model, &it); gtk_tree_selection_select_iter (sel, &it); } } if (options.common_data.listen || !(options.extra_data && *options.extra_data)) { channel = g_io_channel_unix_new (0); g_io_channel_set_encoding (channel, NULL, NULL); g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL); g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, GINT_TO_POINTER (n_columns)); } }
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr) { Open_with_data *data = NULL; GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1, *custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; GdkPixbuf *pixbuf; gchar *text = NULL; gchar *title; const gchar *icon_name = NULL; const gchar* const *desktop_dirs; gint x = 0; data = g_new0(Open_with_data,1); data->file_list = filenames; data->dialog1 = gtk_dialog_new (); if (nr == 1) title = _("Open With"); else title = _("Open the selected files with"); gtk_window_set_title (GTK_WINDOW (data->dialog1),title); gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE); gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window)); gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE); gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5); gtk_widget_set_size_request(data->dialog1,380,380); dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox; vbox1 = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0); hbox1 = gtk_hbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0); if (nr == 1) { icon_name = xa_get_stock_mime_icon(filename); pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL); mime_icon = gtk_image_new_from_pixbuf(pixbuf); if (pixbuf) g_object_unref(pixbuf); gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0); gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0); open_text = gtk_label_new(""); gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10); text = g_strdup_printf(_("Open <i>%s</i> with:"),filename); gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE); gtk_label_set_markup (GTK_LABEL (open_text),text); g_free(text); } scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL); gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0); g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL); data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore)); gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE); GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview)); g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data); /* First column: icon + text */ 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, TRUE); gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); /* Hidden column with the application executable name */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_visible(column,FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column); custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:")); gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0); hbox_expander = gtk_hbox_new(FALSE,5); data->custom_command_entry = gtk_entry_new(); g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data); browse = gtk_button_new_with_label(_("Browse")); g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data); gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0); gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander); dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area; gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1)); okbutton1 = gtk_button_new_from_stock ("gtk-open"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK); g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); gtk_widget_show_all(data->dialog1); /* Let's parse the desktop files in all the system data dirs */ desktop_dirs = g_get_system_data_dirs(); while (desktop_dirs[x]) { xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]); x++; } gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter); gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter); g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data); g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data); }
/* * Open the window to select and type the picture properties */ void Picture_Properties_Button_Clicked (GObject *object) { GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow; GtkWidget *type, *label, *desc; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter type_iter_to_select, iter; GtkTreeModel *model; GtkWindow *parent_window = NULL; GList *selection_list = NULL; GList *l; gint selection_nbr, selection_i = 1; gint response; EtPictureType pic_type; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); selection_list = gtk_tree_selection_get_selected_rows(selection, NULL); selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection)); for (l = selection_list; l != NULL; l = g_list_next (l)) { GtkTreePath *path = l->data; Picture *pic = NULL; GtkTreeSelection *selectiontype; gchar *title; GtkTreePath *rowPath; gboolean valid; // Get corresponding picture valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path); if (valid) gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1); title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++, selection_nbr); PictureTypesWindow = gtk_dialog_new_with_buttons(title, parent_window, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_free(title); gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK); ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT); type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (store); gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_title (column, _("Image Type")); gtk_tree_view_column_set_attributes(column, renderer, "text", PICTURE_TYPE_COLUMN_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(type), column); gtk_widget_set_size_request(type, 256, 256); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0); // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { /* Load picture type (only Front Cover!). */ GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)), PICTURE_TYPE_COLUMN_TYPE_CODE, ET_PICTURE_TYPE_FRONT_COVER, -1); /* Line to select by default. */ type_iter_to_select = itertype; break; } // Other tag types default: { // Load pictures types for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++) { GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (pic_type)), PICTURE_TYPE_COLUMN_TYPE_CODE, pic_type, -1); /* Line to select by default. */ if (pic->type == pic_type) type_iter_to_select = itertype; } break; } } // Select the line by default selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select); // Set visible the current selected line rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0); gtk_tree_path_free(rowPath); // Description of the picture label = gtk_label_new (_("Image Description:")); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4); // Entry for the description desc = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0); if (pic->description) { gchar *tmp = Try_To_Validate_Utf8_String(pic->description); gtk_entry_set_text(GTK_ENTRY(desc), tmp); g_free(tmp); } // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE); break; } // Other tag types default: { break; } } gtk_widget_show_all(PictureTypesWindow); response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow)); if (response == GTK_RESPONSE_OK) { GtkTreeModel *modeltype; GtkTreeIter itertype; modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type)); selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype)) { gchar *buffer, *pic_info; gint t; gtk_tree_model_get(modeltype, &itertype, PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1); pic->type = t; buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc))); Strip_String(buffer); if (pic->description) g_free(pic->description); /* If the entry was empty, buffer will be the empty string "". * This can be safely passed to the underlying * FLAC__metadata_object_picture_set_description(). See * https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804 * and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for * downstream bugs when 0 was passed instead. */ pic->description = buffer; // Update value in the PictureEntryView pic_info = Picture_Info(pic); gtk_list_store_set(GTK_LIST_STORE(model), &iter, PICTURE_COLUMN_TEXT, pic_info, -1); g_free(pic_info); } } gtk_widget_destroy(PictureTypesWindow); } g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free); }
void PictureEntry_Update (Picture *pic, gboolean select_it) { GdkPixbufLoader *loader = 0; GError *error = NULL; g_return_if_fail (pic != NULL || PictureEntryView != NULL); if (!pic->data) { PictureEntry_Clear(); return; } loader = gdk_pixbuf_loader_new(); if (loader) { if (gdk_pixbuf_loader_write(loader, pic->data, pic->size, &error)) { GtkTreeSelection *selection; GdkPixbuf *pixbuf; if (!gdk_pixbuf_loader_close(loader, &error)) { Log_Print(LOG_ERROR,_("Error with 'loader_close': %s"), error->message); g_error_free(error); } selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { GtkListStore *picture_store; GtkTreeIter iter1; GdkPixbuf *scaled_pixbuf; gint scaled_pixbuf_width; gint scaled_pixbuf_height; gchar *pic_info; g_object_ref(pixbuf); g_object_unref(loader); // Keep aspect ratio of the picture pic->width = gdk_pixbuf_get_width(pixbuf); pic->height = gdk_pixbuf_get_height(pixbuf); if (pic->width > pic->height) { scaled_pixbuf_width = 96; scaled_pixbuf_height = 96 * pic->height / pic->width; }else { scaled_pixbuf_width = 96 * pic->width / pic->height; scaled_pixbuf_height = 96; } scaled_pixbuf = gdk_pixbuf_scale_simple(pixbuf, scaled_pixbuf_width, scaled_pixbuf_height, //GDK_INTERP_NEAREST); // Lower quality but better speed GDK_INTERP_BILINEAR); g_object_unref(pixbuf); picture_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView))); pic_info = Picture_Info(pic); gtk_list_store_insert_with_values (picture_store, &iter1, G_MAXINT, PICTURE_COLUMN_PIC, scaled_pixbuf, PICTURE_COLUMN_TEXT, pic_info, PICTURE_COLUMN_DATA, Picture_Copy_One (pic), -1); g_free(pic_info); if (select_it) gtk_tree_selection_select_iter(selection, &iter1); g_object_unref(scaled_pixbuf); }else { GtkWidget *msgdialog; g_object_unref(loader); Log_Print (LOG_ERROR, "%s", _("Cannot display the image because not enough data has been read to determine how to create the image buffer.")); msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Cannot display the image")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog), _("Not enough data has been read to determine how to create the image buffer.")); gtk_window_set_title (GTK_WINDOW (msgdialog), _("Load Image File")); gtk_dialog_run(GTK_DIALOG(msgdialog)); gtk_widget_destroy(msgdialog); } }else { Log_Print(LOG_ERROR,_("Error with 'loader_write': %s"), error->message); g_error_free(error); } } // Do also for next picture if (pic->next) PictureEntry_Update(pic->next, select_it); return; }
/** * gtr_message_table_navigate: * @table: * @navigation: * @func: (scope call): * * Returns: (transfer none): */ GtrMsg * gtr_message_table_navigate (GtrMessageTable * table, GtrMessageTableNavigation navigation, GtrMessageTableNavigationFunc func) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; GtrMsg *msg; gboolean cont = TRUE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table->priv->treeview)); if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return NULL; switch (navigation) { case GTR_NAVIGATE_FIRST: if (!gtk_tree_model_get_iter_first (model, &iter)) return NULL; break; case GTR_NAVIGATE_LAST: { gint n_children; n_children = gtk_tree_model_iter_n_children (model, NULL); if (n_children <= 0) return NULL; if (!gtk_tree_model_iter_nth_child (model, &iter, NULL, n_children - 1)) return NULL; } break; case GTR_NAVIGATE_NEXT: if (func) { while (cont) { if (!gtk_tree_model_iter_next (model, &iter)) return NULL; gtk_tree_model_get (model, &iter, GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg, -1); if (func (msg)) cont = FALSE; } } else if (!gtk_tree_model_iter_next (model, &iter)) return NULL; break; case GTR_NAVIGATE_PREV: if (func) { while (cont) { if (!gtk_tree_model_iter_previous (model, &iter)) return NULL; gtk_tree_model_get (model, &iter, GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg, -1); if (func (msg)) cont = FALSE; } } else if (!gtk_tree_model_iter_previous (model, &iter)) return NULL; break; } gtk_tree_selection_select_iter (selection, &iter); path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (table->priv->treeview), path, NULL, TRUE, 0.5, 0.0); gtk_tree_model_get (model, &iter, GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg, -1); return msg; }
static void PopulateForm(int pgs) { if (pgs & (1<<TAB_CONFIG)) { int mode3d, i; GtkListStore *modes3d; GtkTreeIter iter; GtkComboBox *box3d; char buf[64]; mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1); if (mode3d < 0) { int i, cd[] = { 32, 24, 16, 15, 8, 0 }; for (i=0; cd[i]; ) { if (cd[i] >= settings.bpp3d) i++; else break; } for ( ; cd[i]; i++) { mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1); if (mode3d < 0) continue; settings.bpp3d = cd[i]; break; } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"fullscreencheck")), settings.fullscreen); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"alwaysshowcheck")), settings.forcesetup); box3d = GTK_COMBO_BOX(lookup_widget(startwin,"vmode3dcombo")); modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(box3d)); gtk_list_store_clear(modes3d); for (i=0; i<validmodecnt; i++) { if (validmode[i].fs != settings.fullscreen) continue; // all modes get added to the 3D mode list Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp); gtk_list_store_append(modes3d, &iter); gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1); if (i == mode3d) { g_signal_handlers_block_by_func(box3d, on_vmode3dcombo_changed, NULL); gtk_combo_box_set_active_iter(box3d, &iter); g_signal_handlers_unblock_by_func(box3d, on_vmode3dcombo_changed, NULL); } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputmousecheck")), settings.usemouse); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputjoycheck")), settings.usejoy); } if (pgs & (1<<TAB_GAME)) { struct grpfile *fg; int i; GtkListStore *list; GtkTreeIter iter; GtkTreeView *gamelist; gamelist = GTK_TREE_VIEW(lookup_widget(startwin,"gamelist")); list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist)); gtk_list_store_clear(list); for (fg = foundgrps; fg; fg=fg->next) { for (i = 0; i<numgrpfiles; i++) if (fg->crcval == grpfiles[i].crcval) break; if (i == numgrpfiles) continue; // unrecognised grp file gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1); if (!Bstrcasecmp(fg->name, settings.selectedgrp)) { GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist); g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL); gtk_tree_selection_select_iter(sel, &iter); g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL); } } } }
GtkWidget * module_dialog_new (Gimp *gimp) { GtkWidget *shell; GtkWidget *vbox; GtkWidget *sw; GtkWidget *view; GtkWidget *image; ModuleDialog *dialog; GtkTreeSelection *sel; GtkTreeIter iter; GtkTreeViewColumn *col; GtkCellRenderer *rend; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); dialog = g_slice_new0 (ModuleDialog); dialog->gimp = gimp; shell = gimp_dialog_new (_("Module Manager"), "gimp-modules", NULL, 0, gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG, GTK_STOCK_REFRESH, RESPONSE_REFRESH, GTK_STOCK_CLOSE, GTK_STOCK_CLOSE, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell), GTK_RESPONSE_CLOSE, RESPONSE_REFRESH, -1); g_signal_connect (shell, "response", G_CALLBACK (dialog_response), dialog); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP " "for the changes to take effect.")); gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0); if (gimp->write_modulerc) gtk_widget_show (dialog->hint); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request (sw, 124, 100); gtk_widget_show (sw); dialog->list = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GIMP_TYPE_MODULE); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list)); g_object_unref (dialog->list); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); g_list_foreach (gimp->module_db->modules, make_list_item, dialog); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (dialog_enabled_toggled), dialog); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED); gtk_tree_view_append_column (GTK_TREE_VIEW (view), col); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1, _("Module"), gtk_cell_renderer_text_new (), "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), view); gtk_widget_show (view); dialog->table = gtk_table_new (2, N_INFOS, FALSE); gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0); gtk_widget_show (dialog->table); dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0); gtk_widget_show (image); dialog->error_label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (dialog->error_box), dialog->error_label, TRUE, TRUE, 0); gtk_widget_show (dialog->error_label); dialog_info_init (dialog, dialog->table); dialog_info_update (gimp->module_db, dialog->selected, dialog); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_connect (sel, "changed", G_CALLBACK (dialog_select_callback), dialog); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter)) gtk_tree_selection_select_iter (sel, &iter); /* hook the GimpModuleDB signals so we can refresh the display * appropriately. */ g_signal_connect (gimp->module_db, "add", G_CALLBACK (dialog_info_add), dialog); g_signal_connect (gimp->module_db, "remove", G_CALLBACK (dialog_info_remove), dialog); g_signal_connect (gimp->module_db, "module-modified", G_CALLBACK (dialog_info_update), dialog); g_signal_connect (shell, "destroy", G_CALLBACK (dialog_destroy_callback), dialog); return shell; }
static void examinee_tree_selection_changed_cb (GtkTreeSelection *selection, gpointer user_data) { GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data); GPInstructAnalyzerExamineeViewPrivate *priv = view->priv; GPInstructLogAnalyzerExaminee *examinee; GtkTreeIter iter, iterProject, iterCategory, iterLesson, iterGroup; GtkTreeModel *model; guint min; gdouble sec; guint items, frequency, score; gdouble ave_score, percentage, time_spent, ave_time_spent; gchar *items_text, *frequency_text, *score_text, *ave_score_text, *percentage_text, *time_text, *ave_time_text; gtk_tree_store_clear (priv->project_store); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, EXAMINEE_STRUCT_POINTER_COLUMN, &examinee, -1); if (examinee) { GPInstructLogAnalyzerProject *project = examinee->project; items = project->items_length; frequency = project->times_taken; score = project->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = project->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, &iterProject, NULL, -1, PROJECT_TITLE_COLUMN, gpinstruct_project_get_title (project->object), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_PROJECT, PROJECT_STRUCT_POINTER_COLUMN, project, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); GList *categories = project->categories; while (categories) { GPInstructLogAnalyzerCategory *category = (GPInstructLogAnalyzerCategory*) categories->data; items = category->items_length; frequency = category->times_taken; score = category->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = category->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, &iterCategory, &iterProject, -1, PROJECT_TITLE_COLUMN, gpinstruct_category_get_title (category->object), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_CATEGORY, PROJECT_STRUCT_POINTER_COLUMN, category, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); GList *lessons = category->lessons; while (lessons) { GPInstructLogAnalyzerLesson *lesson = (GPInstructLogAnalyzerLesson*) lessons->data; items = lesson->items_length; frequency = lesson->times_taken; score = lesson->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = lesson->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, &iterLesson, &iterCategory, -1, PROJECT_TITLE_COLUMN, gpinstruct_lesson_get_title (lesson->object), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_LESSON, PROJECT_STRUCT_POINTER_COLUMN, lesson, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); GList *elements = lesson->elements; while (elements) { if (((GPInstructLogAnalyzerLessonElement*) elements->data)->is_test) { GPInstructLogAnalyzerTest *test = ((GPInstructLogAnalyzerLessonElement*) elements->data)->test; items = test->items_length; frequency = test->times_taken; score = test->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = test->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterLesson, -1, PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST, PROJECT_STRUCT_POINTER_COLUMN, test, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); } else { GPInstructLogAnalyzerGroup *group = ((GPInstructLogAnalyzerLessonElement*) elements->data)->group; items = group->items_length; frequency = group->times_taken; score = group->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = group->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, &iterGroup, &iterLesson, -1, PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (group->object)), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_GROUP, PROJECT_STRUCT_POINTER_COLUMN, group, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); GList *tests = group->tests; while (tests) { GPInstructLogAnalyzerTest *test = (GPInstructLogAnalyzerTest*) tests->data; items = test->items_length; frequency = test->times_taken; score = test->items_correctly_answered; ave_score = (frequency? (gdouble) score/frequency:0); percentage = (items?(ave_score/items):0) * 100; time_spent = test->time_spent; ave_time_spent = frequency? time_spent/frequency:0; items_text = g_strdup_printf ("%d", items); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); ave_score_text = g_strdup_printf ("%.2f", ave_score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterGroup, -1, PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)), PROJECT_ITEMS_COLUMN, items_text, PROJECT_FREQUENCY_COLUMN, frequency_text, PROJECT_SCORE_COLUMN, score_text, PROJECT_AVE_SCORE_COLUMN, ave_score_text, PROJECT_PERCENTAGE_COLUMN, percentage_text, PROJECT_TIME_COLUMN, time_text, PROJECT_AVE_TIME_COLUMN, ave_time_text, PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST, PROJECT_STRUCT_POINTER_COLUMN, test, -1); g_free (items_text); g_free (frequency_text); g_free (score_text); g_free (ave_score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); tests = tests->next; } } elements = elements->next; } lessons = lessons->next; } categories = categories->next; } gtk_tree_view_expand_all (GTK_TREE_VIEW (priv->project_treeview)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->project_store), &iter)) { selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->project_treeview)); gtk_tree_selection_select_iter (selection, &iter); GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->project_scrolledwindow)); gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment)); } } } }
static void project_tree_selection_changed_cb (GtkTreeSelection *selection, gpointer user_data) { GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data); GPInstructAnalyzerExamineeViewPrivate *priv = view->priv; GtkTreeIter iter, iterItem, iterChoice; GtkTreeModel *model; guint struct_type; GPInstructLogAnalyzerTest *test; guint min; gdouble sec; guint children, frequency, score; gdouble percentage, time_spent, ave_time_spent; gchar *title_text, *children_text, *frequency_text, *score_text, *percentage_text, *time_text, *ave_time_text; gtk_tree_store_clear (priv->test_store); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, PROJECT_STRUCT_TYPE_COLUMN, &struct_type, PROJECT_STRUCT_POINTER_COLUMN, &test, -1); if (struct_type == STRUCT_TYPE_TEST) { GList *items = test->items; guint item_num = 0; while (items) { GPInstructLogAnalyzerItem *item = items->data; children = item->choices_length; frequency = item->times_answered; score = item->times_correctly_answered; percentage = (frequency?((gdouble) score/frequency):0) * 100; time_spent = item->time_spent; ave_time_spent = frequency? time_spent/frequency:0; title_text = gpinstruct_lesson_test_get_item (test->object, item_num); children_text = g_strdup_printf ("%d", children); frequency_text = g_strdup_printf ("%d", frequency); score_text = g_strdup_printf ("%d", score); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->test_store, &iterItem, NULL, -1, TEST_TITLE_COLUMN, title_text, TEST_ITEMS_COLUMN, children_text, TEST_FREQUENCY_COLUMN, frequency_text, TEST_SCORE_COLUMN, score_text, TEST_PERCENTAGE_COLUMN, percentage_text, TEST_TIME_COLUMN, time_text, TEST_AVE_TIME_COLUMN, ave_time_text, -1); g_free (title_text); g_free (children_text); g_free (frequency_text); g_free (score_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); GList *choices = item->choices; guint choice_num = 0; while (choices) { GPInstructLogAnalyzerChoice *choice = choices->data; if (test->is_string) title_text = g_strdup (choice->string); else title_text = gpinstruct_lesson_test_get_choice (test->object, item_num, choice_num); frequency = choice->times_chosen; percentage = (item->times_answered?((gdouble) frequency/item->times_answered):0) * 100; time_spent = choice->time_spent; ave_time_spent = frequency? time_spent/frequency:0; frequency_text = g_strdup_printf ("%d", frequency); percentage_text = g_strdup_printf ("%.2f%%", percentage); min = time_spent / 60; sec = time_spent - (min * 60); time_text = g_strdup_printf ("%dm %.2fs", min, sec); min = ave_time_spent / 60; sec = ave_time_spent - (min * 60); ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec); gtk_tree_store_insert_with_values (priv->test_store, &iterChoice, &iterItem, -1, TEST_TITLE_COLUMN, title_text, TEST_FREQUENCY_COLUMN, frequency_text, TEST_PERCENTAGE_COLUMN, percentage_text, TEST_TIME_COLUMN, time_text, TEST_AVE_TIME_COLUMN, ave_time_text, -1); g_free (title_text); g_free (frequency_text); g_free (percentage_text); g_free (time_text); g_free (ave_time_text); choice_num++; choices = choices->next; } item_num++; items = items->next; } if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->test_store), &iter)) { selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->test_treeview)); gtk_tree_selection_select_iter (selection, &iter); GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->test_scrolledwindow)); gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment)); } } } }
/** @brief iterate over active pane file list to check for matches @param from the button, menu item etc which was activated @param art action runtime data @return TRUE if action completed successfully, else FALSE */ static gboolean _e2p_select_same (gpointer from, E2_ActionRuntime *art) { E2_PaneRuntime *rt; ViewInfo *selview; GtkTreeModel *models; GtkTreeIter iters; rt = e2_pane_get_runtime (from, art->data, NULL); selview = (ViewInfo *)rt; WAIT_FOR_REFRESH(selview) models = selview->model; if (gtk_tree_model_get_iter_first (models, &iters)) { //it's not empty ViewInfo *othview; GtkTreeModel *modelo; GtkTreeSelection *sel; GList *selpaths, *rowpath; GHashTable *selitems; FileInfo *info; gboolean fullmatch, forward; const gchar *seps; e2_filelist_disable_refresh (); othview = (rt == curr_pane) ? &other_pane->view : &curr_pane->view; WAIT_FOR_REFRESH(othview) selpaths = gtk_tree_selection_get_selected_rows (othview->selection, &modelo); if (selpaths == NULL) { e2_filelist_enable_refresh (); return FALSE; } // art->action->data is NULL for full name-scan, non-NULL for partial fullmatch = (art->action->data == NULL); if (fullmatch) { //warning prevention seps = NULL; forward = TRUE; } else { seps = e2_option_str_get ("selmatch-separators"); if (seps != NULL && *seps == '\0') { fullmatch = TRUE; forward = TRUE; } else forward = e2_option_bool_get ("selmatch-start"); } // Log the selected items, for quick lookup selitems = (fullmatch) ? g_hash_table_new (g_str_hash, g_str_equal): g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); for (rowpath = selpaths; rowpath != NULL; rowpath = rowpath->next) { GtkTreePath *path; GtkTreeIter itero; path = (GtkTreePath *) rowpath->data; if (gtk_tree_model_get_iter (modelo, &itero, path)) { gtk_tree_model_get (modelo, &itero, FINFO, &info, -1); if (fullmatch) g_hash_table_insert (selitems, info->filename, info); //no key dup, info must persist else { gchar c; gchar *target; if (forward) { for (target = info->filename; (c = *target) != '\0'; target++) { if (strchr (seps, c) != NULL) //assumes no UTF-8 chars { target = g_strndup (info->filename, target - info->filename); g_hash_table_insert (selitems, target, info); break; } } if (c == '\0') g_hash_table_insert (selitems, g_strdup (info->filename), info); } else { for (target = info->filename + strlen (info->filename) - 1 ; target >= info->filename; target--) { if (strchr (seps, *target) != NULL) //assumes no UTF-8 chars { target = g_strndup (info->filename, target - info->filename); g_hash_table_insert (selitems, target, info); break; } } if (target < info->filename) g_hash_table_insert (selitems, g_strdup (info->filename), info); } } } gtk_tree_path_free (path); } g_list_free (selpaths); sel = selview->selection; gtk_tree_selection_unselect_all (sel); //start with clean slate do { gboolean partial; gchar *scan; gtk_tree_model_get (models, &iters, FINFO, &info, -1); //We only check for name, ignore other statbuf parameters partial = FALSE; scan = NULL; if (!fullmatch) { gchar c; if (forward) { for (scan = info->filename; (c = *scan) != '\0'; scan++) { if (strchr (seps, c) != NULL) //assumes no UTF-8 chars, too bad if different sep from other pane { partial = TRUE; break; } } } else { for (scan = info->filename + strlen (info->filename) - 1 ; scan >= info->filename; scan--) { c = *scan; if (strchr (seps, c) != NULL) //assumes no UTF-8 chars { partial = TRUE; break; } } } } if (partial) scan = g_strndup (info->filename, scan - info->filename); else scan = info->filename; if (g_hash_table_lookup (selitems, scan) != NULL) gtk_tree_selection_select_iter (sel, &iters); if (partial) g_free (scan); } while (gtk_tree_model_iter_next (models, &iters)); g_hash_table_destroy (selitems); //ensure some part of selection is visible selpaths = gtk_tree_selection_get_selected_rows (sel, NULL); if (selpaths != NULL) { printd (DEBUG, "scroll to show selection"); GtkTreePath *tpath = gtk_tree_path_copy ((GtkTreePath *)selpaths->data); //this kills other selections gtk_tree_view_set_cursor (GTK_TREE_VIEW (selview->treeview), tpath, NULL, FALSE); //so back again, and cleanup g_list_foreach (selpaths, (GFunc)_e2p_selsame_reselect, sel); g_list_free (selpaths); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (selview->treeview), tpath, NULL, TRUE, 0.382, 0.0); gtk_tree_path_free (tpath); } e2_filelist_enable_refresh (); return TRUE; } return FALSE; }
/* * This function sets the custom list when the language list has changed in * the language dialog (launched from language button or F10 menu). */ void lang_set_custom_callback (gchar *language) { GtkListStore *lang_model = mdm_lang_get_model (); GtkTreeIter iter; gboolean valid; char *locale_name; int i=0; /* Do nothing if there is no language widget */ if (language_widget == NULL) return; /* * Handle for either combo box or list style, depending on which is being * used. . */ if (GTK_IS_COMBO_BOX (language_widget)) { valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model), &iter); while (valid) { gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter, LOCALE_COLUMN, &locale_name, -1); if (strcmp (language, locale_name) == 0) { gtk_combo_box_set_active (GTK_COMBO_BOX (language_widget), i); break; } valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter); i++; } } else if (GTK_IS_SCROLLED_WINDOW (language_widget) && GTK_IS_TREE_VIEW (GTK_BIN (language_widget)->child)) { GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (language_widget)->child); GtkTreeModel *tm = gtk_tree_view_get_model (tv); GtkTreeSelection *selection = gtk_tree_view_get_selection (tv); GtkTreeIter loopiter; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter)) { do { char *locale_file; gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &locale_file, -1); if (locale_file != NULL && strcmp (language, locale_file) == 0) { GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter); gtk_tree_selection_select_iter (selection, &loopiter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv), path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter)); } } }
void fe_userlist_insert (session *sess, struct User *newuser, int row, int sel) { GtkTreeModel *model = sess->res->user_model; GdkPixbuf *pix = get_user_icon (sess->server, newuser); GtkTreeIter iter; char *nick; int nick_color = 0; if (prefs.pchat_away_track && newuser->away) nick_color = COL_AWAY; else if (prefs.pchat_gui_ulist_color) nick_color = text_color_of(newuser->nick); nick = newuser->nick; if (!prefs.pchat_gui_ulist_icons) { nick = malloc (strlen (newuser->nick) + 2); nick[0] = newuser->prefix[0]; if (!nick[0] || nick[0] == ' ') strcpy (nick, newuser->nick); else strcpy (nick + 1, newuser->nick); pix = NULL; } gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, row, COL_PIX, pix, COL_NICK, nick, COL_HOST, newuser->hostname, COL_USER, newuser, COL_GDKCOLOR, nick_color ? &colors[nick_color] : NULL, -1); if (!prefs.pchat_gui_ulist_icons) { free (nick); } /* is it me? */ if (newuser->me && sess->gui->nick_box) { if (!sess->gui->is_tab || sess == current_tab) mg_set_access_icon (sess->gui, pix, sess->server->is_away); } #if 0 if (prefs.hilitenotify && notify_isnotify (sess, newuser->nick)) { gtk_clist_set_foreground ((GtkCList *) sess->gui->user_clist, row, &colors[prefs.nu_color]); } #endif /* is it the front-most tab? */ if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree)) == model) { if (sel) gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (sess->gui->user_tree)), &iter); } }
/* * This function sets the custom list when the session list has changed in * the session dialog (launched from session button or F10 menu). */ void greeter_custom_set_session (gchar *session) { GList *tmp; int i=0; /* * Since the sessions are created before the session list is generated, * keep track of the session and set active row when it is setup. This * function will get a NULL when the session is initialized to NULL * at startup, so just return. */ if (session == NULL) return; else { /* * If the session_widget hasn't been setup yet (which it won't be when * the greeter_sessioninit function is called, then just store the * session and we'll set the value when the combo box is initialized later. */ g_free (session_key); session_key = g_strdup (session); } /* Do nothing if there is no session widget */ if (session_widget == NULL) return; /* Last isn't in the session list, so handle separate. */ if (strcmp (session, LAST_SESSION) == 0) { if (GTK_IS_COMBO_BOX (session_widget)) { gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), 0); } else if (GTK_IS_SCROLLED_WINDOW (session_widget) && GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child)) { GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child); GtkTreeModel *tm = gtk_tree_view_get_model (tv); GtkTreeSelection *selection = gtk_tree_view_get_selection (tv); GtkTreeIter loopiter; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter)) gtk_tree_selection_select_iter (selection, &loopiter); } } /* * Handle for either combo box or list style, depending on which is being * used. . */ if (GTK_IS_COMBO_BOX (session_widget)) { for (tmp = sessions; tmp != NULL; tmp = tmp->next) { char *file; i++; file = tmp->data; if (strcmp (session, file) == 0) { gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), i); break; } } } else if (GTK_IS_SCROLLED_WINDOW (session_widget) && GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child)) { GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child); GtkTreeModel *tm = gtk_tree_view_get_model (tv); GtkTreeSelection *selection = gtk_tree_view_get_selection (tv); GtkTreeIter loopiter; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter)) { do { char *file; gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &file, -1); if (file != NULL && strcmp (session, file) == 0) { GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter); gtk_tree_selection_select_iter (selection, &loopiter); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv), path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter)); } } }
static void PopulateForm(unsigned char pgs) { if ((pgs == ALL) || (pgs == POPULATE_VIDEO)) { int32_t mode3d, i; GtkListStore *modes3d; GtkTreeIter iter; char buf[64]; mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1); if (mode3d < 0) { int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 }; for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; } for (; cd[i]; i++) { mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1); if (mode3d < 0) continue; settings.bpp3d = cd[i]; break; } } modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo))); gtk_list_store_clear(modes3d); for (i=0; i<validmodecnt; i++) { if (validmode[i].fs != settings.fullscreen) continue; // all modes get added to the 3D mode list Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp); gtk_list_store_append(modes3d, &iter); gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1); if (i == mode3d) { g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL); gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter); g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL); } } } if ((pgs == ALL) || (pgs == POPULATE_CONFIG)) { GtkListStore *devlist, *modsdir; GtkTreeIter iter; GtkTreePath *path; char *value; unsigned char i, r = 0; const char *availabledev[] = { "Keyboard only", "Keyboard and mouse", "Keyboard and joystick", "All supported devices" }; // populate input devices combo devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo))); gtk_list_store_clear(devlist); for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++) { gtk_list_store_append(devlist, &iter); gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1); } switch (settings.usemouse) { case 0: if (settings.usejoy) gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK); else gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB); break; case 1: if (settings.usejoy) gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL); else gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE); break; } // populate custom mod combo modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo))); gtk_list_store_clear(modsdir); gtk_list_store_append(modsdir, &iter); gtk_list_store_set(modsdir, &iter, 0,"None", -1); r = GetModsDirNames(modsdir); for (i=0; i<=r; i++) { path = gtk_tree_path_new_from_indices(i, -1); gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path); gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1); if (Bstrcmp(settings.custommoddir, "/") == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE); settings.custommoddir = NULL; break; } if (Bstrcmp(settings.custommoddir, value) == 0) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo), &iter); break; } } // populate check buttons gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen); #ifdef POLYMER gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer); #endif gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup); } if ((pgs == ALL) || (pgs == POPULATE_GAME)) { struct grpfile *fg; int32_t i; GtkListStore *list; GtkTreeIter iter; GtkTreeView *gamelist; gamelist = GTK_TREE_VIEW(stwidgets.gamelist); list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist)); gtk_list_store_clear(list); for (fg = foundgrps; fg; fg=fg->next) { for (i = 0; i<numgrpfiles; i++) if (fg->crcval == grpfiles[i].crcval) break; if (i == numgrpfiles) continue; // unrecognised grp file gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1); if (!Bstrcasecmp(fg->name, settings.selectedgrp)) { GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist); g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL); gtk_tree_selection_select_iter(sel, &iter); g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL); } } } }
static void choices_tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data); GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv; GPInstructObject *object; GtkTreeIter iter; GtkWidget *scrolled_window, *text_view; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->choices_store), &iter, path)) { object = questions_tree_view_get_current_data (editor); if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object)) { guint choice = gtk_tree_path_get_indices (path)[0]; GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object); GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Choice Properties"), GTK_WINDOW (priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); text_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), gpinstruct_lesson_test_multi_choice_question_get_choice (question, choice), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Text:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); gtk_widget_show_all (content_area); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { GtkTextIter start, end; gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), &start, &end); gchar *text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_choice (question, choice, text); g_free (text); update_choices_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data)); gpinstruct_editor_window_set_modified (priv->window, TRUE); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->choices_store), &iter, NULL, choice); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), &iter); } gtk_widget_destroy (dialog); } } }
gboolean edit_bookmarks( GtkWindow* parent ) { GList* l; GtkWidget* dlg; GtkWidget* btn_box; GtkWidget* add_btn; GtkWidget* delete_btn; GtkWidget* scroll; GtkWidget* list_view; GtkListStore* list; GtkTreeViewColumn* col; GtkTreeIter it; GtkTreeSelection* sel; gchar *name, *path, *item; gboolean ret = FALSE; PtkBookmarks* bookmarks; GtkCellRenderer *renderer, *icon_renderer; GdkPixbuf* icon; dlg = gtk_dialog_new_with_buttons ( _("Edit Bookmarks"), parent, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL ); gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); list = gtk_list_store_new( NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING ); icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(), "gnome-fs-directory", 20, 0, NULL ); bookmarks = ptk_bookmarks_get(); for( l = bookmarks->list; l; l = l->next ) { gtk_list_store_append( list, &it ); gtk_list_store_set( list, &it, COL_ICON, icon, COL_NAME, l->data, COL_DIRPATH, ptk_bookmarks_item_get_path((char*)l->data), -1); } if( icon ) g_object_unref( icon ); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN); list_view = gtk_tree_view_new_with_model( GTK_TREE_MODEL(list) ); g_object_set_data( G_OBJECT(dlg), "list_view", list_view ); sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(list_view) ); gtk_tree_selection_set_mode( sel, GTK_SELECTION_BROWSE ); if( gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(list), &it ) ) { gtk_tree_selection_select_iter( sel, &it ); } icon_renderer = gtk_cell_renderer_pixbuf_new(); renderer = gtk_cell_renderer_text_new(); g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL ); g_signal_connect( renderer, "edited", G_CALLBACK(on_name_edited), list ); col = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", COL_ICON, NULL ); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); col = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_fixed_width(col, 160); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); renderer = gtk_cell_renderer_text_new(); g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL ); g_signal_connect( renderer, "edited", G_CALLBACK(on_path_edited), list ); col = gtk_tree_view_column_new_with_attributes(_("Path"), renderer, "text", COL_DIRPATH, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col ); gtk_tree_view_set_reorderable ( GTK_TREE_VIEW(list_view), TRUE ); gtk_container_add( GTK_CONTAINER(scroll), list_view); btn_box = gtk_hbutton_box_new(); gtk_button_box_set_layout ( GTK_BUTTON_BOX(btn_box), GTK_BUTTONBOX_START ); add_btn = gtk_button_new_from_stock ( GTK_STOCK_ADD ); g_signal_connect( add_btn, "clicked", G_CALLBACK(on_add), dlg ); gtk_box_pack_start ( GTK_BOX(btn_box), add_btn, TRUE, TRUE, 0 ); delete_btn = gtk_button_new_from_stock ( GTK_STOCK_DELETE ); g_signal_connect( delete_btn, "clicked", G_CALLBACK(on_delete), dlg ); gtk_box_pack_start ( GTK_BOX(btn_box), delete_btn, TRUE, TRUE, 0 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), btn_box, FALSE, FALSE, 4 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), scroll, TRUE, TRUE, 0 ); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), gtk_label_new(_("Use drag & drop to sort the items")), FALSE, FALSE, 4 ); gtk_window_set_default_size ( GTK_WINDOW(dlg), 480, 400 ); gtk_widget_show_all( dlg ); gtk_widget_grab_focus( list_view ); pcmanfm_ref(); if( gtk_dialog_run( GTK_DIALOG(dlg) ) == GTK_RESPONSE_OK ) { l = NULL; if( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(list), &it ) ) { do { gtk_tree_model_get( GTK_TREE_MODEL(list), &it, COL_NAME, &name, COL_DIRPATH, &path, -1 ); if( ! name ) name = g_path_get_basename( path ); item = ptk_bookmarks_item_new( name, strlen(name), path ? path : "", path ? strlen(path) : 0 ); l = g_list_append( l, item ); g_free(name); g_free(path); } while( gtk_tree_model_iter_next( GTK_TREE_MODEL(list), &it) ); } ptk_bookmarks_set( l ); ret = TRUE; } ptk_bookmarks_unref(); gtk_widget_destroy( dlg ); pcmanfm_unref(); return ret; }
static void questions_tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data); GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv; GPInstructObject *object; GtkTreeIter iter; GtkWidget *scrolled_window, *text_view, *explanation_view, *answer_combobox; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->questions_store), &iter, path)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->questions_store), &iter, DATA_COLUMN, &object, -1); if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object)) { GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object); guint choices_num = gpinstruct_lesson_test_multi_choice_question_get_choices_length (question); GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Question Properties"), GTK_WINDOW (priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); text_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), gpinstruct_lesson_test_multi_choice_question_get_text (question), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), text_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Text:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); explanation_view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (explanation_view), GTK_WRAP_WORD_CHAR); gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)), gpinstruct_lesson_test_multi_choice_question_get_explanation (question), -1); gtk_container_add (GTK_CONTAINER (scrolled_window), explanation_view); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Explanation:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0); if (choices_num) { answer_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->choices_store)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (answer_combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (answer_combobox), renderer, "text", TITLE_COLUMN, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (answer_combobox), gpinstruct_lesson_test_multi_choice_question_get_answer (question)); gtk_box_pack_start (GTK_BOX (content_area), gtk_label_new (_("Answer:")), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), answer_combobox, FALSE, TRUE, 0); } gtk_widget_show_all (content_area); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { GtkTextIter start, end; gchar *text; gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), &start, &end); text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_text (question, text); g_free (text); gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)), &start, &end); text = gtk_text_iter_get_text (&start, &end); gpinstruct_lesson_test_multi_choice_question_set_explanation (question, text); g_free (text); if (choices_num) gpinstruct_lesson_test_multi_choice_question_set_answer (question, gtk_combo_box_get_active (GTK_COMBO_BOX (answer_combobox))); update_questions_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data)); gpinstruct_editor_window_set_modified (priv->window, TRUE); gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->questions_store), &iter, NULL, gtk_tree_path_get_indices (path)[0]); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), &iter); } gtk_widget_destroy (dialog); } } }
/**************************************************************** ... *****************************************************************/ void itree_select(GtkTreeSelection *selection, ITree *it) { gtk_tree_selection_select_iter(selection, &it->it); }
static void ft_manager_add_handler_to_list (EmpathyFTManager *manager, EmpathyFTHandler *handler, const GError *error) { GtkTreeRowReference *row_ref; GtkTreeIter iter; GtkTreeSelection *selection; GtkTreePath *path; GIcon *icon; const char *content_type, *second_line; char *first_line, *message; EmpathyFTManagerPriv *priv = GET_PRIV (manager); icon = NULL; /* get the icon name from the mime-type of the file. */ content_type = empathy_ft_handler_get_content_type (handler); if (content_type != NULL) icon = g_content_type_get_icon (content_type); /* append the handler in the store */ gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model), &iter, G_MAXINT, COL_FT_OBJECT, handler, COL_ICON, icon, -1); if (icon != NULL) g_object_unref (icon); /* insert the new row_ref in the hash table */ path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path); gtk_tree_path_free (path); g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler), row_ref); /* select the new row */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_select_iter (selection, &iter); if (error != NULL) { message = ft_manager_format_error_message (handler, error); ft_manager_update_handler_message (manager, row_ref, message); g_free (message); return; } /* update the row with the initial values. * the only case where we postpone this is in case we're managing * an outgoing+hashing transfer, as the hashing started signal will * take care of updating the information. */ if (empathy_ft_handler_is_incoming (handler) || !empathy_ft_handler_get_use_hash (handler)) { first_line = ft_manager_format_contact_info (handler); second_line = _("Waiting for the other participant's response"); message = g_strdup_printf ("%s\n%s", first_line, second_line); ft_manager_update_handler_message (manager, row_ref, message); g_free (first_line); g_free (message); } /* hook up the signals and start the transfer */ ft_manager_start_transfer (manager, handler); }
static void add_account (GoaPanel *panel) { GtkWindow *parent; GtkWidget *dialog; gint response; GList *providers; GList *l; GoaObject *object; GError *error; providers = NULL; parent = GTK_WINDOW (cc_shell_get_toplevel (cc_panel_get_shell (CC_PANEL (panel)))); dialog = goa_panel_add_account_dialog_new (panel->client); gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); providers = goa_provider_get_all (); for (l = providers; l != NULL; l = l->next) { GoaProvider *provider; provider = GOA_PROVIDER (l->data); goa_panel_add_account_dialog_add_provider (GOA_PANEL_ADD_ACCOUNT_DIALOG (dialog), provider); } gtk_widget_show_all (dialog); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response != GTK_RESPONSE_OK) { gtk_widget_destroy (dialog); goto out; } error = NULL; object = goa_panel_add_account_dialog_get_account (GOA_PANEL_ADD_ACCOUNT_DIALOG (dialog), &error); gtk_widget_destroy (dialog); /* We might have an object even when error is set. * eg., if we failed to store the credentials in the keyring. */ if (object != NULL) { GtkTreeIter iter; /* navigate to newly created object */ if (goa_panel_accounts_model_get_iter_for_object (panel->accounts_model, object, &iter)) { gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)), &iter); } g_object_unref (object); } if (error != NULL) { if (!(error->domain == GOA_ERROR && error->code == GOA_ERROR_DIALOG_DISMISSED)) { dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Error creating account")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message); gtk_widget_show_all (dialog); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } g_error_free (error); } out: g_list_foreach (providers, (GFunc) g_object_unref, NULL); g_list_free (providers); }
static GtkWidget * ical_get_preview (icalcomponent *icalcomp) { GtkWidget *preview; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter iter; GHashTable *timezones; icalcomponent *subcomp; icaltimezone *users_zone; if (!icalcomp || !is_icalcomp_usable (icalcomp)) return NULL; store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, E_TYPE_CAL_COMPONENT); timezones = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, free_zone_cb); users_zone = get_users_timezone (); /* get timezones first */ for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_VTIMEZONE_COMPONENT); subcomp; subcomp = icalcomponent_get_next_component (icalcomp, ICAL_VTIMEZONE_COMPONENT)) { icaltimezone *zone = icaltimezone_new (); if (!icaltimezone_set_component (zone, icalcomponent_new_clone (subcomp)) || !icaltimezone_get_tzid (zone)) { icaltimezone_free (zone, 1); } else { g_hash_table_insert (timezones, (gchar *) icaltimezone_get_tzid (zone), zone); } } /* then each component */ for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT); subcomp; subcomp = icalcomponent_get_next_component (icalcomp, ICAL_ANY_COMPONENT)) { icalcomponent_kind kind = icalcomponent_isa (subcomp); if (kind == ICAL_VEVENT_COMPONENT || kind == ICAL_VTODO_COMPONENT || kind == ICAL_VJOURNAL_COMPONENT) { ECalComponent *comp = e_cal_component_new (); ECalComponentText summary = { 0 }; ECalComponentDateTime dt = { 0 }; gchar *formatted_dt; if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp))) { g_object_unref (comp); continue; } e_cal_component_get_summary (comp, &summary); e_cal_component_get_dtstart (comp, &dt); formatted_dt = format_dt (&dt, timezones, users_zone); gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, 0, kind == ICAL_VEVENT_COMPONENT ? (e_cal_component_has_attendees (comp) ? C_("iCalImp", "Meeting") : C_("iCalImp", "Event")) : kind == ICAL_VTODO_COMPONENT ? C_("iCalImp", "Task") : kind == ICAL_VJOURNAL_COMPONENT ? C_("iCalImp", "Memo") : "??? Other ???", 1, formatted_dt ? formatted_dt : "", 2, summary.value && *summary.value ? summary.value : summary.altrep && *summary.altrep ? summary.altrep : "", 3, comp, -1); g_free (formatted_dt); e_cal_component_free_datetime (&dt); g_object_unref (comp); } } if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) { g_object_unref (store); g_hash_table_destroy (timezones); return NULL; } preview = e_web_view_preview_new (); gtk_widget_show (preview); g_object_set_data_full (G_OBJECT (preview), "iCalImp-timezones", timezones, (GDestroyNotify) g_hash_table_destroy); g_object_set_data (G_OBJECT (preview), "iCalImp-userszone", users_zone); tree_view = e_web_view_preview_get_tree_view (E_WEB_VIEW_PREVIEW (preview)); g_return_val_if_fail (tree_view != NULL, NULL); gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store)); g_object_unref (store); /* Translators: Column header for a component type; it can be Event, Task or Memo */ gtk_tree_view_insert_column_with_attributes ( tree_view, -1, C_("iCalImp", "Type"), gtk_cell_renderer_text_new (), "text", 0, NULL); /* Translators: Column header for a component start date/time */ gtk_tree_view_insert_column_with_attributes ( tree_view, -1, C_("iCalImp", "Start"), gtk_cell_renderer_text_new (), "text", 1, NULL); /* Translators: Column header for a component summary */ gtk_tree_view_insert_column_with_attributes ( tree_view, -1, C_("iCalImp", "Summary"), gtk_cell_renderer_text_new (), "text", 2, NULL); if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1) e_web_view_preview_show_tree_view (E_WEB_VIEW_PREVIEW (preview)); selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_select_iter (selection, &iter); g_signal_connect ( selection, "changed", G_CALLBACK (preview_selection_changed_cb), preview); preview_selection_changed_cb (selection, E_WEB_VIEW_PREVIEW (preview)); return preview; }
static void activate (GApplication *app) { GtkBuilder *builder; GtkWindow *window; GtkWidget *widget; GtkTreeModel *model; GtkTreeIter iter; GError *error = NULL; GtkWidget *sw; GtkWidget *scrollbar; GtkWidget *menu; GtkWidget *item; static GActionEntry win_entries[] = { { "run", activate_run, NULL, NULL, NULL } }; builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, "/ui/main.ui", &error); if (error != NULL) { g_critical ("%s", error->message); exit (1); } window = (GtkWindow *)gtk_builder_get_object (builder, "window"); gtk_application_add_window (GTK_APPLICATION (app), window); g_action_map_add_action_entries (G_ACTION_MAP (window), win_entries, G_N_ELEMENTS (win_entries), window); notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook"); info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview"); source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview"); headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar"); treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview"); model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow"); scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw)); menu = gtk_menu_new (); item = gtk_menu_item_new_with_label ("Start"); g_signal_connect (item, "activate", G_CALLBACK (start_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_menu_item_new_with_label ("End"); g_signal_connect (item, "activate", G_CALLBACK (end_cb), scrollbar); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show_all (menu); g_signal_connect (scrollbar, "popup-menu", G_CALLBACK (scrollbar_popup), menu); load_file (gtk_demos[0].name, gtk_demos[0].filename); populate_model (model); g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model); widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection"); g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model); gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter); gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter); gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview)); gtk_widget_show_all (GTK_WIDGET (window)); g_object_unref (builder); }
int handle_lobby(GladeXML* g_lobby_xml, GladeXML* g_table_info_xml, GladeXML* g_lobby_tabs_xml, GladeXML* g_cashier_button_xml, GladeXML* g_clock_xml, GtkLayout* screen, int init) { static int s_selected_table = 0; s_screen = screen; if(init) { textdomain ("poker2d"); int i; s_lobby_xml = g_lobby_xml; s_lobby_window = gui_get_widget(g_lobby_xml, "lobby_window"); g_assert(s_lobby_window); set_nil_draw_focus(s_lobby_window); if(screen) gtk_layout_put(screen, s_lobby_window, 0, 0); s_notebook = GTK_NOTEBOOK(gui_get_widget(g_lobby_xml, "notebook")); g_assert(s_notebook); for(i = 0; i < VARIANTS_COUNT; i++) { char tmp[32]; s_variants_store[i] = gtk_list_store_new(12, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); snprintf(tmp, 32, "%s_treeview", s_variants_names[i]); GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_lobby_xml, tmp)); GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview); g_signal_connect(selection, "changed", (GCallback)on_lobby_list_treeview_selection_changed, &s_selected_table); s_variants_selection[i] = selection; g_signal_connect(treeview, "row-activated", (GCallback)on_row_activated, &s_selected_table); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_variants_store[i])); GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new(); #define TABLE_COLUMN_ID 0 #define TABLE_COLUMN_MY 1 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("My") ); gtk_tree_view_column_pack_start(column, pixbuf_renderer, TRUE); gtk_tree_view_column_add_attribute(column, pixbuf_renderer, "pixbuf", TABLE_COLUMN_MY); } { GError* error = 0; gchar* filename; filename = glade_xml_relative_file(g_lobby_xml, "table_bullet_my.png"); if(g_file_test(filename, G_FILE_TEST_EXISTS)) { pixbuf_table_my = gdk_pixbuf_new_from_file(filename, &error); if(pixbuf_table_my == NULL) { GtkIconTheme* theme = gtk_icon_theme_get_default(); error = 0; pixbuf_table_my = gtk_icon_theme_load_icon(theme, "stock_book_open", 16, 0, &error); if (!pixbuf_table_my) { g_warning ("Couldn't load icon: %s", error->message); } } } g_free(filename); } #define SET_COLUMN(TITLE, INDEX) \ { \ GtkTreeViewColumn* column = gtk_tree_view_column_new(); \ gtk_tree_view_append_column(treeview, column); \ gtk_tree_view_column_set_title(column, TITLE); \ gtk_tree_view_column_pack_start(column, text_renderer, TRUE); \ gtk_tree_view_column_add_attribute(column, text_renderer, "text", INDEX); \ } #define TABLE_COLUMN_NAME 2 SET_COLUMN( gettext("Name"), TABLE_COLUMN_NAME); #define TABLE_COLUMN_STRUCTURE 3 SET_COLUMN( gettext("Structure"), TABLE_COLUMN_STRUCTURE); #define TABLE_COLUMN_SEATS 4 SET_COLUMN( gettext("Seats"), TABLE_COLUMN_SEATS); #define TABLE_COLUMN_AVG_POT 5 SET_COLUMN( gettext("Avg.pot"), TABLE_COLUMN_AVG_POT); #define TABLE_COLUMN_HANDS_PER_HOUR 6 SET_COLUMN( gettext("Hands/h"), TABLE_COLUMN_HANDS_PER_HOUR); #define TABLE_COLUMN_PERCENT_FLOP 7 SET_COLUMN( gettext("Flop%"), TABLE_COLUMN_PERCENT_FLOP); #define TABLE_COLUMN_PLAYING 8 SET_COLUMN( gettext("Playing"), TABLE_COLUMN_PLAYING); #define TABLE_COLUMN_OBSERVING 9 #define TABLE_COLUMN_WAITING 10 #define TABLE_COLUMN_TIMEOUT 11 #undef SET_COLUMN } s_players_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "players_label")); s_tables_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "tables_label")); GUI_BRANCH(g_lobby_xml, on_all_radio_clicked); GUI_BRANCH(g_lobby_xml, on_money_one_radio_clicked); GUI_BRANCH(g_lobby_xml, on_money_two_radio_clicked); s_table_info_window = gui_get_widget(g_table_info_xml, "table_info_window"); g_assert(s_table_info_window); if(screen) gtk_layout_put(screen, s_table_info_window, 0, 0); { s_players_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_table_info_xml, "players_treeview")); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_players_store)); GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new(); #define PLAYERS_COLUMN_NAME 0 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("Players") ); gtk_tree_view_column_pack_start(column, text_renderer, TRUE); gtk_tree_view_column_add_attribute(column, text_renderer, "text", 0); } #define PLAYERS_COLUMN_CHIPS 1 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("Chips") ); gtk_tree_view_column_pack_start(column, text_renderer, TRUE); gtk_tree_view_column_add_attribute(column, text_renderer, "text", 1); } #define PLAYERS_COLUMN_FLAG 2 } s_go_to_label = GTK_LABEL(glade_xml_get_widget(g_table_info_xml, "label_go_to")); s_go_to_button = GTK_BUTTON(glade_xml_get_widget(g_table_info_xml, "button_go_to")); g_signal_connect(GTK_OBJECT(s_go_to_button), "clicked", (GtkSignalFunc)on_go_to_clicked, &s_selected_table); s_lobby_tabs_window = gui_get_widget(g_lobby_tabs_xml, "lobby_tabs_window"); g_assert(s_lobby_tabs_window); gtk_widget_set_size_request(s_lobby_tabs_window, gui_width(screen), -1); if(screen) gtk_layout_put(screen, s_lobby_tabs_window, 0, 0); GUI_BRANCH(g_lobby_tabs_xml, on_table_toggled); GUI_BRANCH(g_lobby_tabs_xml, on_tourney_toggled); s_cashier_button_window = gui_get_widget(g_cashier_button_xml, "cashier_button_window"); g_assert(s_cashier_button_window); if(screen) gtk_layout_put(screen, s_cashier_button_window, 0, 0); s_cashier_button = GTK_BUTTON(gui_get_widget(g_cashier_button_xml, "cashier_button")); g_assert(s_cashier_button); GUI_BRANCH(g_cashier_button_xml, on_cashier_button_pressed); s_clock_window = gui_get_widget(g_clock_xml, "clock_window"); g_assert(s_clock_window); if(screen) gtk_layout_put(screen, s_clock_window, 0, 0); s_clock_label = gui_get_widget(g_clock_xml, "clock_label"); close_lobby(); } char* tag = get_string(); if(!strcmp(tag, "show")) { g_lobby_tab_state = lobby; { char* label = get_string(); gtk_button_set_label(s_cashier_button, label); g_free(label); } if (screen != NULL || s_lobby_shown == 0) { // // calculate windows position // int screen_width = gui_width(screen); int screen_height = gui_height(screen); int top_left_x = (screen_width - 1000) / 2; int top_left_y = (screen_height - 450) / 2; { static position_t position; position.x = screen_width - 610; position.y = top_left_y; gui_place(s_lobby_window, &position, screen); } { static position_t position; position.x = top_left_x; position.y = top_left_y; gui_place(s_table_info_window, &position, screen); } { static position_t position; position.x = 0; position.y = 33; gui_place(s_lobby_tabs_window, &position, screen); } { static position_t position; position.x = top_left_x; position.y = top_left_y + 435; gui_place(s_cashier_button_window, &position, screen); } s_lobby_shown = 1; } { gui_bottom_right(s_clock_window, screen); } s_selected_table = 0; { char* type = get_string(); if(!strcmp(type, "holdem")) { gtk_notebook_set_current_page(s_notebook, VARIANT_HOLDEM); } else if(!strcmp(type, "omaha")) { gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA); } else if(!strcmp(type, "omaha8")) { gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA8); } else if(!strcmp(type, "7stud")) { gtk_notebook_set_current_page(s_notebook, VARIANT_7STUD); } GtkToggleButton* button = GTK_TOGGLE_BUTTON(gui_get_widget(g_lobby_tabs_xml, type)); g_assert(button); gtk_toggle_button_set_active(button, TRUE); g_free(type); } { char* currency_serial = get_string(); char* button; GtkWidget* radio; if(!strcmp(currency_serial, "money_two")) { button = "money_two_radio"; } else if(!strcmp(currency_serial, "money_one")) { button = "money_one_radio"; } else { button = "all_radio"; } { //moneyone GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_one_radio"); char* label = get_string(); gtk_button_set_label(GTK_BUTTON(sl), label); g_free(label); } { //moneytwo GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_two_radio"); char* label = get_string(); gtk_button_set_label(GTK_BUTTON(sl), label); g_free(label); } s_disable_buttons = 1; radio = gui_get_widget(s_lobby_xml, button); g_assert(radio); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE); s_disable_buttons = 0; g_free(currency_serial); } } else if(!strcmp(tag, "hide")) { g_lobby_tab_state = none; close_lobby(); } else if(!strcmp(tag, "info")) { char* players_count = get_string(); char* tables_count = get_string(); gtk_label_set_text(s_players_label, players_count); gtk_label_set_text(s_tables_label, tables_count); g_free(players_count); g_free(tables_count); } else if(!strcmp(tag, "holdem") || !strcmp(tag, "omaha") || !strcmp(tag, "omaha8") || !strcmp(tag, "7stud")) { int selected = get_int(); int rows = get_int(); int i; int variant_index = VARIANT_HOLDEM; if(!strcmp(tag, "holdem")) { variant_index = VARIANT_HOLDEM; } else if(!strcmp(tag, "omaha")) { variant_index = VARIANT_OMAHA; } else if(!strcmp(tag, "omaha8")) { variant_index = VARIANT_OMAHA8; } else if(!strcmp(tag, "7stud")) { variant_index = VARIANT_7STUD; } gtk_list_store_clear(s_variants_store[variant_index]); for(i = 0; i < rows; i++) { int id = get_int(); GtkTreeIter iter; gtk_list_store_append(s_variants_store[variant_index], &iter); gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_ID, id, -1); if(selected == id) gtk_tree_selection_select_iter(s_variants_selection[variant_index], &iter); { char* my = get_string(); GdkPixbuf* pixbuf = 0; if(!strcmp(my, "yes")) { pixbuf = pixbuf_table_my; } gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_MY, pixbuf, -1); } #define SET_COLUMN(INDEX) \ { \ char* content = get_string(); \ gtk_list_store_set(s_variants_store[variant_index], &iter, INDEX, content, -1); \ g_free(content); \ } SET_COLUMN(TABLE_COLUMN_NAME); SET_COLUMN(TABLE_COLUMN_STRUCTURE); SET_COLUMN(TABLE_COLUMN_SEATS); SET_COLUMN(TABLE_COLUMN_AVG_POT); SET_COLUMN(TABLE_COLUMN_HANDS_PER_HOUR); SET_COLUMN(TABLE_COLUMN_PERCENT_FLOP); SET_COLUMN(TABLE_COLUMN_PLAYING); SET_COLUMN(TABLE_COLUMN_OBSERVING); SET_COLUMN(TABLE_COLUMN_WAITING); SET_COLUMN(TABLE_COLUMN_TIMEOUT); #undef SET_COLUMN } s_selected_table = selected; if(!selected) { gtk_list_store_clear(s_players_store); gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), FALSE); } } else if(!strcmp(tag, "players")) { int players_count = get_int(); int i; gtk_label_set_text(s_go_to_label, gettext("GO TO TABLE") ); gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), TRUE); gtk_list_store_clear(s_players_store); for(i = 0; i < players_count; i++) { char* name = get_string(); char* chips = get_string(); int flag = get_int(); GtkTreeIter iter; gtk_list_store_append(s_players_store, &iter); gtk_list_store_set(s_players_store, &iter, PLAYERS_COLUMN_NAME, name, PLAYERS_COLUMN_CHIPS, chips, PLAYERS_COLUMN_FLAG, flag, -1); g_free(name); g_free(chips); } } // // set clock time // { time_t _time; char date_buffer[8]; time(&_time); struct tm* _tm = gmtime(&_time); snprintf(date_buffer, sizeof (date_buffer), "%02d:%02d", _tm->tm_hour, _tm->tm_min); gtk_label_set_text(GTK_LABEL(s_clock_label), date_buffer); } g_free(tag); return TRUE; }
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 I_PickIWad_Gtk (WadStuff *wads, int numwads, bool showwin, int defaultiwad) { GtkWidget *window; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *bbox; GtkWidget *widget; GtkWidget *tree; GtkWidget *check; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkTreeIter iter, defiter; int close_style = 0; int i; char caption[100]; // Create the dialog window. window = gtk_window_new (GTK_WINDOW_TOPLEVEL); mysnprintf(caption, countof(caption), GAMESIG " %s: Select an IWAD to use", GetVersionString()); gtk_window_set_title (GTK_WINDOW(window), caption); gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER(window), 10); g_signal_connect (window, "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (window, "key_press_event", G_CALLBACK(CheckEscape), NULL); // Create the vbox container. vbox = gtk_vbox_new (FALSE, 10); gtk_container_add (GTK_CONTAINER(window), vbox); // Create the top label. widget = gtk_label_new ("ZDoom found more than one IWAD\nSelect from the list below to determine which one to use:"); gtk_box_pack_start (GTK_BOX(vbox), widget, false, false, 0); gtk_misc_set_alignment (GTK_MISC(widget), 0, 0); // Create a list store with all the found IWADs. store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); for (i = 0; i < numwads; ++i) { const char *filepart = strrchr (wads[i].Path, '/'); if (filepart == NULL) filepart = wads[i].Path; else filepart++; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, filepart, 1, wads[i].Name.GetChars(), 2, i, -1); if (i == defaultiwad) { defiter = iter; } } // Create the tree view control to show the list. tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("IWAD", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Game", renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column); gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(tree), true, true, 0); g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(DoubleClickChecker), &close_style); g_signal_connect(G_OBJECT(tree), "key_press_event", G_CALLBACK(AllowDefault), window); // Select the default IWAD. selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree)); gtk_tree_selection_select_iter (selection, &defiter); // Create the hbox for the bottom row. hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_end (GTK_BOX(vbox), hbox, false, false, 0); // Create the "Don't ask" checkbox. check = gtk_check_button_new_with_label ("Don't ask me this again"); gtk_box_pack_start (GTK_BOX(hbox), check, false, false, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), !showwin); // Create the OK/Cancel button box. bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX(bbox), 10); gtk_box_pack_end (GTK_BOX(hbox), bbox, false, false, 0); // Create the OK button. widget = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0); GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT); gtk_widget_grab_default (widget); g_signal_connect (widget, "clicked", G_CALLBACK(ClickedOK), &close_style); g_signal_connect (widget, "activate", G_CALLBACK(ClickedOK), &close_style); // Create the cancel button. widget = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0); g_signal_connect (widget, "clicked", G_CALLBACK(gtk_main_quit), &window); // Finally we can show everything. gtk_widget_show_all (window); gtk_main (); if (close_style == 1) { GtkTreeModel *model; GValue value = { 0, { {0} } }; // Find out which IWAD was selected. gtk_tree_selection_get_selected (selection, &model, &iter); gtk_tree_model_get_value (GTK_TREE_MODEL(model), &iter, 2, &value); i = g_value_get_int (&value); g_value_unset (&value); // Set state of queryiwad based on the checkbox. queryiwad = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check)); } else { i = -1; } if (GTK_IS_WINDOW(window)) { gtk_widget_destroy (window); // If we don't do this, then the X window might not actually disappear. while (g_main_context_iteration (NULL, FALSE)) {} } return i; }