gsegysaveimage.c

segy 显示程序！希望能给正在做这部分朋友提供一部分资料

        g_error_free (save_error);
        gtk_dialog_run (GTK_DIALOG (failure_dialog));
        gtk_widget_destroy (failure_dialog);
    }

    g_idle_add ((GSourceFunc)g_segy_save_image_render_finished, (gpointer)self);
    if (private->seis_view_is_threaded)
        gdk_threads_leave ();
}

static void g_segy_save_image_ok_button_handler (GtkWidget *widget, gpointer data) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (G_SEGY_SAVE_IMAGE (data));

    if (private->in_progress || FALSE == g_segy_save_image_check_filename (G_SEGY_SAVE_IMAGE (data)))
        return;

    g_async_queue_try_pop (private->render_progress);
    g_async_queue_try_pop (private->render_finished);

    private->in_progress = TRUE;

    gtk_widget_set_sensitive (private->vbox1, FALSE);
    gtk_widget_set_sensitive (private->ok_button, FALSE);
    gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (private->progress_bar), 0);
    gtk_widget_show (private->progress_bar);

    gtk_seis_view_gl_render_to_pixbuf (private->seis_view, gtk_spin_button_get_value (GTK_SPIN_BUTTON (private->width_spin)),
                                                           gtk_spin_button_get_value (GTK_SPIN_BUTTON (private->height_spin)));
}

static void g_segy_save_image_cancel_button_handler (GtkWidget *widget, gpointer data) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (G_SEGY_SAVE_IMAGE (data));

    if (private->in_progress) {
        gtk_widget_hide (private->progress_bar);
        gtk_widget_set_sensitive (private->cancel_button, FALSE);
        g_async_queue_push (private->render_progress, G_SEGY_SAVE_IMAGE (data));
    } else
        gtk_widget_hide (private->window);
}

static void g_segy_save_image_map_handler (GtkWidget *widget, gpointer data) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (G_SEGY_SAVE_IMAGE (data));
    guint old_width = gtk_spin_button_get_value (GTK_SPIN_BUTTON (private->width_spin));
    guint old_height = gtk_spin_button_get_value (GTK_SPIN_BUTTON (private->height_spin));
    guint new_width = GTK_WIDGET (private->seis_view)->allocation.width;
    guint new_height = GTK_WIDGET (private->seis_view)->allocation.height;


    gtk_spin_button_set_range (GTK_SPIN_BUTTON (private->width_spin), new_width, MAX_DIMENSION);
    gtk_spin_button_set_increments (GTK_SPIN_BUTTON (private->width_spin), 1, 100);
    gtk_spin_button_set_value (GTK_SPIN_BUTTON (private->width_spin), old_width < new_width
                               ? new_width : old_width);
    gtk_spin_button_set_range (GTK_SPIN_BUTTON (private->height_spin), new_height, MAX_DIMENSION);
    gtk_spin_button_set_increments (GTK_SPIN_BUTTON (private->height_spin), 1, 100);
    gtk_spin_button_set_value (GTK_SPIN_BUTTON (private->height_spin), old_height < new_height
                               ? new_height : old_height);

    gtk_widget_set_sensitive (private->parent_window, FALSE);
}

static void g_segy_save_image_unmap_handler (GtkWidget *widget, gpointer data) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (G_SEGY_SAVE_IMAGE (data));

    gtk_widget_set_sensitive (private->parent_window, TRUE);

    gtk_seis_view_gl_redraw (private->seis_view);
}

static gboolean g_segy_save_image_window_close_handler (GtkWidget *widget, GdkEvent *event, gpointer data) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (G_SEGY_SAVE_IMAGE (data));

    if (private->in_progress) {
        private->in_progress = FALSE;
        gtk_widget_hide (private->progress_bar);
        gtk_widget_set_sensitive (private->cancel_button, FALSE);
        g_async_queue_push (private->render_progress, G_SEGY_SAVE_IMAGE (data));
    }

    gtk_widget_hide (private->window);

    return TRUE;
}

static GtkWidget *g_segy_save_image_parse_box_tree (GtkWidget *widget, GType widget_type) {

    if (FALSE == GTK_IS_CONTAINER (widget)) {
        if (G_OBJECT_TYPE (widget) == widget_type)
            return widget;
        else
            return NULL;
    }

    GList* children = g_list_first (gtk_container_get_children (GTK_CONTAINER (widget)));

    if (NULL == children) {
        if (G_OBJECT_TYPE (widget) == widget_type)
            return widget;
        else
            return NULL;
    }

    GtkWidget *child;
    while (children) {
        child = (GtkWidget*)children->data;
        if (child) {
            GtkWidget *parsed_widget = g_segy_save_image_parse_box_tree (child, widget_type);
            if (parsed_widget)
                return parsed_widget;
        }
        children = g_list_next (children);
    }
    return NULL;
}

GtkWidget* g_segy_save_image_get_main_widget (GSEGYSaveImage *self) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (self);

    if (NULL == private->window) {
        private->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        gtk_container_set_border_width (GTK_CONTAINER (private->window), 7);
        gtk_window_set_modal (GTK_WINDOW (private->window), TRUE);
        gtk_window_set_resizable (GTK_WINDOW (private->window), FALSE);
        gtk_window_set_title (GTK_WINDOW (private->window), _("Save image"));
        gtk_window_set_transient_for (GTK_WINDOW (private->window), GTK_WINDOW (private->parent_window));
        gtk_signal_connect (GTK_OBJECT (private->window), "delete_event",
                            GTK_SIGNAL_FUNC (g_segy_save_image_window_close_handler), (gpointer)G_OBJECT (self));

        private->vbox = gtk_vbox_new (FALSE, 3);
        gtk_container_add (GTK_CONTAINER (private->window), private->vbox);

        if (FALSE == gtk_seis_view_gl_can_render_offscreen (private->seis_view)) {
            private->warning_frame = gtk_frame_new (_("WARNING!"));
            gtk_box_pack_start (GTK_BOX (private->vbox), private->warning_frame, FALSE, FALSE, 3);

            private->warning_label = gtk_label_new (_("The graphics card on this machine "
                                                      "does not support offscreen rendering.\n"
                                                      "Please make sure that the data view "
                                                      "is not obscured by other windows\n"
                                                      "while the cupture process proceeds. "
                                                      "Otherwise the image will be garbled.\n"));
            g_object_set (G_OBJECT (private->warning_label), "xpad", 10, "ypad", 10, 
                                                             "justify" , GTK_JUSTIFY_CENTER, NULL);
            gtk_container_add (GTK_CONTAINER (private->warning_frame), private->warning_label);
        }

        private->frame = gtk_frame_new (_("Image file"));
        gtk_box_pack_start (GTK_BOX (private->vbox), private->frame, FALSE, FALSE, 3);

        private->vbox1 = gtk_vbox_new (FALSE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->vbox1), 5);
        gtk_container_add (GTK_CONTAINER (private->frame), private->vbox1);

        private->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SAVE);
#if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 4
        gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (private->file_chooser), FALSE);
#endif
        GSList* formats_list = gdk_pixbuf_get_formats ();
        GdkPixbufFormat *format_desc = NULL;
        GtkFileFilter *default_filter = NULL;

        while (formats_list) {
            format_desc = (GdkPixbufFormat*)formats_list->data;
            const gchar *format_name = gdk_pixbuf_format_get_name (format_desc);

            if (format_desc && gdk_pixbuf_format_is_writable (format_desc) &&
                g_ascii_strncasecmp (format_name, "ico", 3)) {
                GtkFileFilter *file_filter = gtk_file_filter_new ();
                gtk_file_filter_set_name (file_filter, format_name);
                gchar **extensions = gdk_pixbuf_format_get_extensions (format_desc);
                gint i = 0;
                while (extensions[i]) {
                    gtk_file_filter_add_pattern (file_filter, extensions[i]);
                    i++;
                }
                gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (private->file_chooser), file_filter);
                if (0 == g_ascii_strncasecmp (format_name, "png" ,3))
                    default_filter = file_filter;
            }
            formats_list = g_slist_next (formats_list);
        }
        if (default_filter)
            gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (private->file_chooser), default_filter);

        gtk_box_pack_start (GTK_BOX (private->vbox1), private->file_chooser, FALSE, FALSE, 3);

        private->dimensions_frame = gtk_frame_new (_("Dimensions"));
        gtk_box_pack_start (GTK_BOX (private->vbox), private->dimensions_frame, FALSE, FALSE, 3);

        private->hbox = gtk_hbox_new (FALSE, 15);
        gtk_container_set_border_width (GTK_CONTAINER (private->hbox), 5);
        gtk_container_add (GTK_CONTAINER (private->dimensions_frame), private->hbox);

        private->width_label = gtk_label_new (_("Width:"));
        gtk_box_pack_start (GTK_BOX (private->hbox), private->width_label, FALSE, FALSE, 0);

        private->width_spin = gtk_spin_button_new_with_range (600, MAX_DIMENSION, 1);
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (private->width_spin), 0.1);
        gtk_box_pack_start (GTK_BOX (private->hbox), private->width_spin, FALSE, FALSE, 0);

        private->height_label = gtk_label_new (_("Height:"));
        gtk_box_pack_start (GTK_BOX (private->hbox), private->height_label, FALSE, FALSE, 0);

        private->height_spin = gtk_spin_button_new_with_range (600, MAX_DIMENSION, 1);
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (private->height_spin), 0.1);
        gtk_box_pack_start (GTK_BOX (private->hbox), private->height_spin, FALSE, FALSE, 0);

        private->progress_bar = gtk_progress_bar_new ();
        gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (private->progress_bar), GTK_PROGRESS_LEFT_TO_RIGHT);
        gtk_progress_bar_set_bar_style  (GTK_PROGRESS_BAR (private->progress_bar), GTK_PROGRESS_CONTINUOUS);
        gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (private->progress_bar), 0.01);
        gtk_box_pack_start (GTK_BOX (private->vbox), private->progress_bar, TRUE, TRUE, 5);

        gtk_box_pack_start (GTK_BOX (private->vbox), gtk_hseparator_new (), TRUE, TRUE, 5);

        private->button_box = gtk_hbutton_box_new ();
        gtk_button_box_set_layout (GTK_BUTTON_BOX (private->button_box), GTK_BUTTONBOX_SPREAD);
        gtk_box_set_spacing (GTK_BOX (private->button_box), 20);
        gtk_box_pack_start (GTK_BOX (private->vbox), private->button_box, FALSE, FALSE, 5);

        private->ok_button = gtk_button_new_from_stock (GTK_STOCK_OK);
        gtk_container_add (GTK_CONTAINER (private->button_box), private->ok_button);
        gtk_signal_connect (GTK_OBJECT (private->ok_button), "clicked",
                            GTK_SIGNAL_FUNC (g_segy_save_image_ok_button_handler),
                            (gpointer)G_OBJECT (self));
        private->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
        gtk_container_add (GTK_CONTAINER (private->button_box), private->cancel_button);
        gtk_signal_connect (GTK_OBJECT (private->cancel_button), "clicked",
                            GTK_SIGNAL_FUNC (g_segy_save_image_cancel_button_handler),
                            (gpointer)G_OBJECT (self));

        gtk_signal_connect (GTK_OBJECT (private->window), "map",
                            GTK_SIGNAL_FUNC (g_segy_save_image_map_handler),
                            (gpointer)G_OBJECT (self));

        gtk_signal_connect (GTK_OBJECT (private->window), "unmap",
                            GTK_SIGNAL_FUNC (g_segy_save_image_unmap_handler),
                            (gpointer)G_OBJECT (self));

        gtk_widget_show_all (private->vbox);
        gtk_widget_hide (private->progress_bar);

        GtkWidget *tree_view = g_segy_save_image_parse_box_tree (private->file_chooser, GTK_TYPE_TREE_VIEW);
        if (tree_view)
            gtk_widget_set_size_request (tree_view, -1, 300);

        gsegy_view_set_window_icon (GTK_WINDOW (private->window));
    }

    return private->window;
}

gboolean g_segy_save_image_has_main_widget (GSEGYSaveImage *self) {
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (self);

    return (private->window != NULL);
}

GSEGYSaveImage* g_segy_save_image_new (GtkSeisViewGl *seis_view, GtkWidget *parent_window) {
    GSEGYSaveImage *new_save_image = G_SEGY_SAVE_IMAGE (g_object_new (G_SEGY_TYPE_SAVE_IMAGE, NULL));
    GSEGYSaveImagePrivate *private = G_SEGY_SAVE_IMAGE_GET_PRIVATE (new_save_image);

    private->parent_window = parent_window;
    private->seis_view = seis_view;
    g_object_ref (G_OBJECT (private->seis_view));
    gtk_widget_ref (private->parent_window);

    private->pixbuf_progress_signal_id = g_signal_connect (G_OBJECT (private->seis_view), "pixbuf_progress",
                                                           (GCallback)g_segy_save_image_pixbuf_progress_handler, (gpointer)new_save_image);
    private->pixbuf_rendered_signal_id = g_signal_connect (G_OBJECT (private->seis_view), "pixbuf_rendered",
                                                           (GCallback)g_segy_save_image_pixbuf_rendered_handler, (gpointer)new_save_image);
    private->seis_view_is_threaded = gtk_seis_view_gl_is_threaded (private->seis_view);

    return new_save_image;
}