gsegydataview.c

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

    return FALSE;
}

static gboolean g_segy_data_view_remove_signal_thread (GSEGYDataView *self) {
    gdk_threads_enter ();
    g_signal_emit (self, G_SEGY_DATA_VIEW_GET_CLASS (self)->view_remove_id, 0);
    gdk_threads_leave ();
    return FALSE;
}

static void g_segy_data_view_class_init (GSEGYDataViewClass *klass) {
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = g_segy_data_view_finalize;

    g_type_class_add_private (klass, sizeof (GSEGYDataViewPrivate));

    klass->view_remove = NULL;

    klass->view_remove_id = g_signal_new ("view_remove",
                                          G_TYPE_FROM_CLASS ((gpointer)G_OBJECT_CLASS (klass)),
                                          G_SIGNAL_RUN_LAST,
                                          G_STRUCT_OFFSET (GSEGYDataViewClass, view_remove),
                                          NULL, NULL,
                                          g_segyui_marshal_VOID__VOID,
                                          G_TYPE_NONE, 0);

#ifdef DEBUG
    g_print ("<GSEGYDataView class is inited>\n");
#endif
}

GSEGYDataView* g_segy_data_view_new (const gchar *name, GSEGYSeismicAccessor *seismic_accessor) {
    if (NULL == seismic_accessor)
        return NULL;

    GSEGYDataView *new_data_view = G_SEGY_DATA_VIEW (g_object_new (G_SEGY_TYPE_DATA_VIEW, NULL));
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (new_data_view);

    if (name)
        private->name = g_strdup (name);

    private->seismic_accessor = seismic_accessor;
    g_object_ref (G_OBJECT (private->seismic_accessor));

    return new_data_view;
}

static gboolean g_segy_data_view_memory_check (GSEGYDataView *self, guint64 ensemble_size, gfloat memory_threshold) {
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (self);
    guint64 total_memory = 0;

#if defined WIN32
    MEMORYSTATUS mem_status;

    GlobalMemoryStatus (&mem_status);

    total_memory = mem_status.dwAvailPhys;
#elif defined LINUX
    struct sysinfo sys_info;

    sys_info.totalram = 0;

    if (0 == sysinfo (&sys_info))
        total_memory = sys_info.totalram;
#endif

    if (0 == total_memory || total_memory * memory_threshold > ensemble_size)
        return TRUE;

    GtkWidget *memory_dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (private->data_window)),
                                                       GTK_DIALOG_MODAL,
                                                       GTK_MESSAGE_QUESTION,
                                                       GTK_BUTTONS_YES_NO,
                                                       _("You are about to load the ensemble\n"
                                                         "which requires %dMB of the memory.\n"
                                                         "With the amount of the physical memory\n"
                                                         "available on the computer this may cause\n"
                                                         "heavy swapping or even loading failure.\n"
                                                         "Would you like to proceed?\n"),
                                                         (guint)(ensemble_size / (gfloat)(1 << 20) + 0.5));

    if (GTK_RESPONSE_YES == gtk_dialog_run (GTK_DIALOG (memory_dialog))) {
        gtk_widget_destroy (memory_dialog);
        return TRUE;
    } else {
        gtk_widget_destroy (memory_dialog);
        return FALSE;
    }
}

static gboolean g_segy_data_view_show_error (gpointer data) {
    GSEGYDataView *self = G_SEGY_DATA_VIEW (data);
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (self);
    GtkWidget *error_dialog;
    gboolean gdk_lock = (private->dataset_thread != NULL);

    if (G_SEGY_FILE_NO_ERROR == private->error.id)
        return FALSE;

    const gchar *error_message = gsegy_view_get_file_error_message (&private->error);
#ifdef DEBUG
    g_printf ("Error id = %d, message - %s\n", private->error.id, error_message);
#endif

    if (gdk_lock)
        gdk_threads_enter ();

    if (private->error.id < G_SEGY_FILE_DOES_NOT_EXIST && private->error.gerror) {
        gchar *full_error_message = g_strconcat (error_message, " : ", private->error.gerror->message, NULL);
        error_dialog = gtk_message_dialog_new (NULL,
                                               GTK_DIALOG_MODAL,
                                               GTK_MESSAGE_ERROR,
                                               GTK_BUTTONS_OK,
                                               full_error_message);
        g_free (full_error_message);
    } else
        error_dialog = gtk_message_dialog_new (NULL,
                                               GTK_DIALOG_MODAL,
                                               GTK_MESSAGE_ERROR,
                                               GTK_BUTTONS_OK,
                                               error_message);

    if (private->error.gerror)
        g_error_free (private->error.gerror);

    gtk_dialog_run (GTK_DIALOG (error_dialog));
    gtk_widget_destroy (error_dialog);

    if (gdk_lock)
        gdk_threads_leave ();

    return FALSE;
}

static gboolean g_segy_data_view_close_handler (GtkWidget *widget, GdkEvent *event, gpointer data) {
    g_segy_data_view_hide (G_SEGY_DATA_VIEW (data));
    return TRUE;
}

static gboolean g_segy_data_view_select_ensemble_render_data (gpointer data) {
    GSEGYDataView *self = G_SEGY_DATA_VIEW (data);
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (self);

    if (private->dataset_thread)
        gdk_threads_enter ();

    if (private->data) {
        if (private->properties)
            g_segy_properties_change_ensemble (private->properties, private->current_ensemble, private->fast_num,
                                               g_segy_seismic_accessor_get_sample_interval (private->seismic_accessor));
        if (private->view_scaling)
            g_segy_view_scaling_change_ensemble (private->view_scaling, private->slow_num, private->fast_num);
        if (private->cursor_panel)
            g_segy_cursor_panel_set_ensemble_data (private->cursor_panel, private->data,
                                                   &private->data[private->slow_num * private->fast_num],
                                                   private->current_ensemble,
                                                   private->slow_num, private->fast_num);
        gtk_seis_view_gl_set_data (GTK_SEIS_VIEW_GL (private->seis_view_gl), private->data,
                                   private->slow_num, private->fast_num,
                                   &private->data[private->slow_num * private->fast_num]);
        gtk_seis_view_gl_redraw (GTK_SEIS_VIEW_GL (private->seis_view_gl));
    } else {
        gdk_window_set_cursor (private->seis_view_gl->window, NULL);
    }

    if (private->dataset_thread) {
        gdk_threads_leave ();
        g_thread_join (private->dataset_thread);
        private->dataset_thread = NULL;
    }

    return FALSE;
}

static void *g_segy_data_view_select_ensemble_thread (void *args) {
    GSEGYDataView *self = (GSEGYDataView*)args;
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (self);

    if (NULL == private->seismic_accessor)
        return NULL;

    g_async_queue_ref (private->dataset_progress);
    g_mutex_lock (private->data_mutex);

    GSEGYFileError error;
    error.gerror = NULL;
    error.id = G_SEGY_FILE_NO_ERROR;

    if (FALSE == private->reload) {
        if (private->data)
            g_free (private->data);

        private->data = g_segy_seismic_accessor_get_data (private->seismic_accessor, private->current_ensemble,
                                                          &private->slow_num, &private->fast_num, TRUE, &error);
    }

    if (private->dataset_progress && g_async_queue_try_pop (private->dataset_progress)) {
        if (error.gerror)
            g_error_free (error.gerror);
        g_mutex_unlock (private->data_mutex);
        g_async_queue_unref (private->dataset_progress);
        return NULL;
    }

    if (error.id == G_SEGY_FILE_NO_ERROR)
        g_idle_add ((GSourceFunc)g_segy_data_view_select_ensemble_render_data, (gpointer)self);
    else {
        private->error.gerror = error.gerror;
        private->error.id = error.id;
        g_idle_add ((GSourceFunc)g_segy_data_view_show_error, (gpointer)self);
        g_idle_add ((GSourceFunc)g_segy_data_view_remove_signal_thread, (gpointer)self);
    }

    g_mutex_unlock (private->data_mutex);
    g_async_queue_unref (private->dataset_progress);
    return NULL;
}

static void g_segy_data_view_select_ensemble (GSEGYDataView *self) {
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (self);
    private->error.gerror = NULL;

    if (NULL == private->seismic_accessor)
        return;

    guint32 number_of_traces = g_segy_seismic_accessor_get_number_of_traces_for_second_level (private->seismic_accessor,
                                                                                              private->current_ensemble);
    guint32 number_of_samples =  g_segy_seismic_accessor_get_number_of_samples (private->seismic_accessor);
    guint64 ensemble_size = number_of_traces * number_of_samples * sizeof (gfloat);

    if (ensemble_size && FALSE == g_segy_data_view_memory_check (self, ensemble_size, 0.25))
        return;

    gdk_window_set_cursor (private->seis_view_gl->window, private->watch_cursor);

    if (private->ensemble_select) {
        if (private->reload)
            gtk_widget_set_sensitive (g_segy_ensemble_select_get_main_widget (private->ensemble_select), FALSE);
        else
            g_segy_ensemble_select_disable (private->ensemble_select);
    }

    gtk_widget_set_sensitive (g_segy_gain_panel_get_main_widget (private->gain_panel), FALSE);

    if (private->dataset_thread) {
        g_thread_join (private->dataset_thread);
        private->dataset_thread = NULL;
    }

    if (private->cursor_panel)
        g_segy_cursor_panel_set_ensemble_data (private->cursor_panel, NULL, NULL, 0, 0, 0);

    private->dataset_thread = g_thread_create (g_segy_data_view_select_ensemble_thread, self, TRUE, &private->error.gerror);
    if (FALSE == private->dataset_thread) {
#ifdef DEBUG
        if (private->error.gerror)
            g_printf ("Failed to create thread: %s\n", private->error.gerror->message);
        else
            g_printf ("Failed to create thread, no reason given\n");
#endif
        if (private->error.gerror) {
            g_error_free (private->error.gerror);
            private->error.gerror = NULL;
        }

        g_mutex_lock (private->data_mutex);

        if (FALSE == private->reload) {
            if (private->data)
                g_free (private->data);

            private->data = g_segy_seismic_accessor_get_data (private->seismic_accessor, private->current_ensemble,
                                                              &private->slow_num, &private->fast_num, TRUE,
                                                              &private->error);
        }

        if (private->data) {
            g_segy_data_view_select_ensemble_render_data ((gpointer)self);
        } else {
            g_segy_data_view_show_error ((gpointer)self);
            g_segy_data_view_remove_signal ((gpointer)self);
        }
        g_mutex_unlock (private->data_mutex);
    }
}

static void g_segy_data_view_ensemble_select_handler (GSEGYEnsembleSelect *ensemble_select, gint ensemble_num,
                                                      gpointer data) {
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (G_SEGY_DATA_VIEW (data));

    private->current_ensemble = ensemble_num;
    g_segy_data_view_select_ensemble (G_SEGY_DATA_VIEW (data));
}

static void g_segy_data_view_data_is_set_handler (GtkWidget *widget, gpointer data) {
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (G_SEGY_DATA_VIEW (data));

    if (private->seis_view_is_threaded)
        gdk_threads_enter ();
    gdk_window_set_cursor (private->seis_view_gl->window, NULL);
    if (private->ensemble_select) {
        if (private->reload)
            gtk_widget_set_sensitive (g_segy_ensemble_select_get_main_widget (private->ensemble_select), TRUE);
        else
            g_segy_ensemble_select_enable (private->ensemble_select);
    }

    gtk_widget_set_sensitive (g_segy_gain_panel_get_main_widget (private->gain_panel), TRUE);

    private->reload = FALSE;

    if (private->seis_view_is_threaded)
        gdk_threads_leave ();
}

static void g_segy_data_view_hlight_scroll_up_handler (GSeisViewToolHighlight *hlight_tool, gpointer data) {
    GSEGYDataViewPrivate *private = G_SEGY_DATA_VIEW_GET_PRIVATE (G_SEGY_DATA_VIEW (data));

    if (private->ensemble_select) {
        if (private->seis_view_is_threaded)
            gdk_threads_enter ();
        g_segy_ensemble_select_previous (private->ensemble_select);
        if (private->seis_view_is_threaded)
            gdk_threads_leave ();