gsegywigglepanel.c

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

/* 
 * GTKSEISVIEWUI - Library of interface elements for GSEGYView
 *
 * Copyright (C) 2006 Vladimir Bashkardin
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more av.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author:  Vladimir Bashkardin  <[e-mail]>
 */

#include <gtkseisviewgl/gtkseisviewgl.h>

#include "gsegyfileaux.h"
#include "gsegyfileui_marshal.h"
#include "gsegywigglepanel.h"

G_DEFINE_TYPE (GSEGYWigglePanel, g_segy_wiggle_panel, G_TYPE_OBJECT)

#define G_SEGY_WIGGLE_PANEL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), G_SEGY_TYPE_WIGGLE_PANEL, GSEGYWigglePanelPrivate))

typedef struct _GSEGYWigglePanelPrivate GSEGYWigglePanelPrivate;

struct _GSEGYWigglePanelPrivate {
    GtkWidget *frame;
    GtkWidget *hbox;
    GtkWidget *vbox1;
    GtkWidget *wiggle_mode_check;
    GtkWidget *vd_mode_check;
    GtkWidget *va_mode_check;
    GtkWidget *vseparator;
    GtkWidget *vbox2;
    GtkWidget *va_positive_radio;
    GtkWidget *va_negative_radio;
    GtkWidget *inverse_check;

    GtkSeisViewDisplayMode display_mode;
    GtkSeisViewVAFill      va_fill_mode;
    gboolean               inverse_polarity;
};

static void g_segy_wiggle_panel_init (GSEGYWigglePanel *self) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    private->frame = NULL;
    private->hbox = NULL;
    private->vbox1 = NULL;
    private->wiggle_mode_check = NULL;
    private->vd_mode_check = NULL;
    private->va_mode_check = NULL;
    private->vseparator = NULL;
    private->vbox2 = NULL;
    private->va_positive_radio = NULL;
    private->va_negative_radio = NULL;
    private->inverse_check = NULL;

    private->display_mode = GTK_SEIS_VIEW_VA | GTK_SEIS_VIEW_VD | GTK_SEIS_VIEW_WIGGLE;
    private->va_fill_mode = GTK_SEIS_VIEW_VA_POSITIVE;
    private->inverse_polarity = FALSE;

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

static void g_segy_wiggle_panel_finalize (GObject *object) {
    GSEGYWigglePanel *self = G_SEGY_WIGGLE_PANEL (object);
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    if (private->frame)
        gtk_widget_destroy (private->frame);

#ifdef DEBUG
    g_print ("<GSEGYWigglePanel is finalized>\n");
#endif
    if (G_OBJECT_CLASS (g_segy_wiggle_panel_parent_class)->finalize)
        G_OBJECT_CLASS (g_segy_wiggle_panel_parent_class)->finalize (object);
}

static void g_segy_wiggle_panel_class_init (GSEGYWigglePanelClass *klass) {
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

    gobject_class->finalize = g_segy_wiggle_panel_finalize;

    g_type_class_add_private (klass, sizeof (GSEGYWigglePanelPrivate));

    klass->display_mode = NULL;
    klass->va_fill_mode = NULL;
    klass->inverse_polarity = NULL;

    klass->display_mode_id = g_signal_new ("display_mode_change",
                                           G_TYPE_FROM_CLASS ((gpointer)G_OBJECT_CLASS (klass)),
                                           G_SIGNAL_RUN_LAST,
                                           G_STRUCT_OFFSET (GSEGYWigglePanelClass, display_mode),
                                           NULL, NULL,
                                           g_segyui_marshal_VOID__INT,
                                           G_TYPE_NONE, 1, G_TYPE_INT);

    klass->va_fill_mode_id = g_signal_new ("va_fill_mode_change",
                                           G_TYPE_FROM_CLASS ((gpointer)G_OBJECT_CLASS (klass)),
                                           G_SIGNAL_RUN_LAST,
                                           G_STRUCT_OFFSET (GSEGYWigglePanelClass, va_fill_mode),
                                           NULL, NULL,
                                           g_segyui_marshal_VOID__INT,
                                           G_TYPE_NONE, 1, G_TYPE_INT);

    klass->inverse_polarity_id = g_signal_new ("polarity_change",
                                               G_TYPE_FROM_CLASS ((gpointer)G_OBJECT_CLASS (klass)),
                                               G_SIGNAL_RUN_LAST,
                                               G_STRUCT_OFFSET (GSEGYWigglePanelClass, inverse_polarity),
                                               NULL, NULL,
                                               g_segyui_marshal_VOID__BOOLEAN,
                                               G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

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

static void g_segy_wiggle_panel_display_mode_change_signal (GSEGYWigglePanel *self) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    g_signal_emit (self, G_SEGY_WIGGLE_PANEL_GET_CLASS (self)->display_mode_id, 0, private->display_mode);
}

static void g_segy_wiggle_panel_va_fill_mode_change_signal (GSEGYWigglePanel *self) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    g_signal_emit (self, G_SEGY_WIGGLE_PANEL_GET_CLASS (self)->va_fill_mode_id, 0, private->va_fill_mode);
}

static void g_segy_wiggle_panel_polarity_change_signal (GSEGYWigglePanel *self) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    g_signal_emit (self, G_SEGY_WIGGLE_PANEL_GET_CLASS (self)->inverse_polarity_id, 0, private->inverse_polarity);
}

static void g_segy_wiggle_panel_wiggle_mode_handler (GtkWidget *widget, gpointer data) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (G_SEGY_WIGGLE_PANEL (data));
    GtkSeisViewDisplayMode new_mode = 0;

    if (FALSE == gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->wiggle_mode_check)) &&
        FALSE == gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->vd_mode_check)) &&
        FALSE == gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->va_mode_check))) {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
        return;
    }

    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->wiggle_mode_check)))
        new_mode |= GTK_SEIS_VIEW_WIGGLE;
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->vd_mode_check)))
        new_mode |= GTK_SEIS_VIEW_VD;
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->va_mode_check)))
        new_mode |= GTK_SEIS_VIEW_VA;

    if (private->display_mode != new_mode) {
        gboolean fill_mode_available = (new_mode & GTK_SEIS_VIEW_VA) != 0;
        gtk_widget_set_sensitive (private->va_positive_radio, fill_mode_available);
        gtk_widget_set_sensitive (private->va_negative_radio, fill_mode_available);

        gboolean inverse_polarity_available = new_mode & GTK_SEIS_VIEW_VA || new_mode & GTK_SEIS_VIEW_WIGGLE;
        gtk_widget_set_sensitive (private->inverse_check, inverse_polarity_available);

        private->display_mode = new_mode;
        g_segy_wiggle_panel_display_mode_change_signal (G_SEGY_WIGGLE_PANEL (data));
    }
}

static void g_segy_wiggle_panel_va_fill_mode_handler (GtkWidget *widget, gpointer data) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (G_SEGY_WIGGLE_PANEL (data));
    GtkSeisViewVAFill new_mode;

    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->va_positive_radio)))
        new_mode = GTK_SEIS_VIEW_VA_POSITIVE;
    else
        new_mode = GTK_SEIS_VIEW_VA_NEGATIVE;

    private->va_fill_mode = new_mode;

    g_segy_wiggle_panel_va_fill_mode_change_signal (G_SEGY_WIGGLE_PANEL (data));
}

static void g_segy_wiggle_panel_inverse_polarity_handler (GtkWidget *widget, gpointer data) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (G_SEGY_WIGGLE_PANEL (data));

    private->inverse_polarity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (private->inverse_check));

    g_segy_wiggle_panel_polarity_change_signal (G_SEGY_WIGGLE_PANEL (data));
}

GtkWidget* g_segy_wiggle_panel_get_main_widget (GSEGYWigglePanel *self) {
    GSEGYWigglePanelPrivate *private = G_SEGY_WIGGLE_PANEL_GET_PRIVATE (self);

    if (NULL == private->frame) {
        private->frame = gtk_frame_new (_("Display mode"));
        gtk_container_set_border_width (GTK_CONTAINER (private->frame), 0);

        private->hbox = gtk_hbox_new (FALSE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->hbox), 3);
        gtk_container_add (GTK_CONTAINER (private->frame), private->hbox);

        private->vbox1 = gtk_vbox_new (FALSE, 3);
        gtk_box_pack_start (GTK_BOX (private->hbox), private->vbox1, FALSE, FALSE, 0);

        private->wiggle_mode_check = gtk_check_button_new_with_label (_("Wiggle traces"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (private->wiggle_mode_check), TRUE);
        gtk_box_pack_start (GTK_BOX (private->vbox1), private->wiggle_mode_check, FALSE, FALSE, 0);

        private->vd_mode_check = gtk_check_button_new_with_label (_("Variable density"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (private->vd_mode_check), TRUE);
        gtk_box_pack_start (GTK_BOX (private->vbox1), private->vd_mode_check, FALSE, FALSE, 0);

        private->va_mode_check = gtk_check_button_new_with_label (_("Variable area"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (private->va_mode_check), TRUE);
        gtk_box_pack_start (GTK_BOX (private->vbox1), private->va_mode_check, FALSE, FALSE, 0);

        private->vseparator = gtk_vseparator_new ();
        gtk_box_pack_start (GTK_BOX (private->hbox), private->vseparator, FALSE, FALSE, 0);

        private->vbox2 = gtk_vbox_new (FALSE, 3);
        gtk_box_pack_start (GTK_BOX (private->hbox), private->vbox2, FALSE, FALSE, 0);

        private->va_positive_radio = gtk_radio_button_new_with_label (NULL, _("Positive fill"));
        gtk_box_pack_start (GTK_BOX (private->vbox2), private->va_positive_radio, FALSE, FALSE, 0);

        private->va_negative_radio =
                 gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (private->va_positive_radio),
                                                              _("Negative fill"));
        gtk_box_pack_start (GTK_BOX (private->vbox2), private->va_negative_radio, FALSE, FALSE, 0);

        private->inverse_check = gtk_check_button_new_with_label (_("Inverse polarity"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (private->inverse_check), FALSE);
        gtk_box_pack_start (GTK_BOX (private->vbox2), private->inverse_check, FALSE, FALSE, 0);

        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (private->va_positive_radio), TRUE);

        gtk_signal_connect (GTK_OBJECT (private->wiggle_mode_check), "toggled",
                            GTK_SIGNAL_FUNC (g_segy_wiggle_panel_wiggle_mode_handler),
                            (gpointer)G_OBJECT (self));
        gtk_signal_connect (GTK_OBJECT (private->vd_mode_check), "toggled",
                            GTK_SIGNAL_FUNC (g_segy_wiggle_panel_wiggle_mode_handler),
                            (gpointer)G_OBJECT (self));
        gtk_signal_connect (GTK_OBJECT (private->va_mode_check), "toggled",
                            GTK_SIGNAL_FUNC (g_segy_wiggle_panel_wiggle_mode_handler),
                            (gpointer)G_OBJECT (self));

        gtk_signal_connect (GTK_OBJECT (private->va_positive_radio), "toggled",
                            GTK_SIGNAL_FUNC (g_segy_wiggle_panel_va_fill_mode_handler),
                            (gpointer)G_OBJECT (self));

        gtk_signal_connect (GTK_OBJECT (private->inverse_check), "toggled",
                            GTK_SIGNAL_FUNC (g_segy_wiggle_panel_inverse_polarity_handler),
                            (gpointer)G_OBJECT (self));

        gtk_widget_show_all (private->frame);
    }

    return private->frame;
}

GSEGYWigglePanel* g_segy_wiggle_panel_new (void) {
    return g_object_new (G_SEGY_TYPE_WIGGLE_PANEL, NULL);
}