gseisviewtoolscale.c

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

/* 
 * GTKSEISVIEWGL - Library for rendering of 2D seismic data
 *
 * 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 <GL/gl.h>

#include <gtk/gtkgl.h>

#include "gtkseisviewgl_marshal.h"
#include "gtkseisviewgl.h"
#include "gseisviewtoolscale.h"

G_DEFINE_TYPE (GSeisViewToolScale, g_seis_view_tool_scale, G_SEIS_TYPE_VIEW_TOOL)

#define G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), G_SEIS_TYPE_VIEW_TOOL_SCALE, GSeisViewToolScalePrivate))

typedef struct _GSeisViewToolScalePrivate GSeisViewToolScalePrivate;

struct _GSeisViewToolScalePrivate {
    GdkCursor *hdouble_arrow_cursor;
    GdkCursor *vdouble_arrow_cursor;
    GdkWindow *cursor_window;

    gboolean   vert_scaling;
    gboolean   horiz_scaling;

    guint16    start_pointer_pos_screen;
    gdouble    scale_area_start;
    gdouble    scale_area_size;

    gboolean   is_threaded;
};

static gboolean g_seis_view_tool_cursor_hdouble_arrow_idle (GSeisViewTool *tool) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    if (private->is_threaded)
        gdk_threads_enter ();
    gdk_window_set_cursor (private->cursor_window, private->hdouble_arrow_cursor);
    gdk_flush ();
    if (private->is_threaded)
        gdk_threads_leave ();

    return FALSE;
}

static gboolean g_seis_view_tool_cursor_vdouble_arrow_idle (GSeisViewTool *tool) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    if (private->is_threaded)
        gdk_threads_enter ();
    gdk_window_set_cursor (private->cursor_window, private->vdouble_arrow_cursor);
    gdk_flush ();
    if (private->is_threaded)
        gdk_threads_leave ();

    return FALSE;
}

static gboolean g_seis_view_tool_cursor_default_idle (GSeisViewTool *tool) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    if (private->is_threaded)
        gdk_threads_enter ();
    gdk_window_set_cursor (private->cursor_window, NULL);
    gdk_flush ();
    if (private->is_threaded)
        gdk_threads_leave ();

    return FALSE;
}

static void g_seis_view_tool_attach_notify_int (GSeisViewTool *tool, GtkWidget *seis_view_gl) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    private->is_threaded = gtk_seis_view_gl_is_threaded (GTK_SEIS_VIEW_GL (seis_view_gl));
    private->cursor_window = seis_view_gl->window;
}

static void g_seis_view_tool_detach_notify_int (GSeisViewTool *tool, GtkWidget *seis_view_gl) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    private->is_threaded = gtk_seis_view_gl_is_threaded (GTK_SEIS_VIEW_GL (seis_view_gl));

    if (FALSE == tool->show_cross) {
        if (private->is_threaded) {
            g_idle_add ((GSourceFunc)g_seis_view_tool_cursor_default_idle,
                        (gpointer)tool);
        } else {
            gdk_window_set_cursor (seis_view_gl->window, NULL);
            gdk_flush ();
        }
    }

    tool->show_cross = TRUE;
    private->vert_scaling = FALSE;
    private->horiz_scaling = FALSE;
}

static void g_seis_view_tool_button_event_int (GSeisViewTool *tool, GtkWidget *seis_view_gl, GdkEventButton *event,
                                               GSeisViewDataVisibility *data_visibility) {
    GtkSeisViewGl *seis_view = GTK_SEIS_VIEW_GL (seis_view_gl);
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    if (3 == event->button) {
        if (GDK_BUTTON_RELEASE == event->type) {
            if (private->vert_scaling) {
                tool->show_cross = TRUE;
                private->vert_scaling = FALSE;

                if (private->is_threaded) {
                    g_idle_add ((GSourceFunc)g_seis_view_tool_cursor_default_idle,
                                (gpointer)tool);
                } else {
                    gdk_window_set_cursor (seis_view_gl->window, NULL);
                    gdk_flush ();
                }
            }
        } else if (GDK_BUTTON_PRESS == event->type) {
            if (FALSE == private->horiz_scaling) {
                private->scale_area_start = data_visibility->fast_start_data;
                private->scale_area_size = data_visibility->fast_size_data;
                private->start_pointer_pos_screen = data_visibility->fast_pointer_pos_screen -
                                                    data_visibility->fast_start_screen;
                private->vert_scaling = TRUE;
                tool->show_cross = FALSE;

                if (NULL == private->cursor_window)
                    private->cursor_window = seis_view_gl->window;

                if (private->is_threaded) {
                    g_idle_add ((GSourceFunc)g_seis_view_tool_cursor_vdouble_arrow_idle,
                                (gpointer)tool);
                } else {
                    gdk_window_set_cursor (seis_view_gl->window, private->vdouble_arrow_cursor);
                    gdk_flush ();
                }
            }
        }
    }

    if (2 == event->button && GDK_BUTTON_RELEASE == event->type) {
        gtk_seis_view_gl_set_traces_scale (GTK_SEIS_VIEW_GL (seis_view_gl), 1.0);
        gtk_seis_view_gl_redraw (seis_view);
    }

    if (1 == event->button) {
        if (GDK_BUTTON_RELEASE == event->type) {
            if (private->horiz_scaling) {
                tool->show_cross = TRUE;
                private->horiz_scaling = FALSE;

                if (private->is_threaded) {
                    g_idle_add ((GSourceFunc)g_seis_view_tool_cursor_default_idle,
                                (gpointer)tool);
                } else {
                    gdk_window_set_cursor (seis_view_gl->window, NULL);
                    gdk_flush ();
                }
            }
        } else if (GDK_BUTTON_PRESS == event->type) {
            if (FALSE == private->vert_scaling) {
                private->scale_area_start = data_visibility->slow_start_data;
                private->scale_area_size = data_visibility->slow_size_data;
                private->start_pointer_pos_screen = data_visibility->slow_pointer_pos_screen -
                                                    data_visibility->slow_start_screen;
                private->horiz_scaling = TRUE;
                tool->show_cross = FALSE;

                if (NULL == private->cursor_window)
                    private->cursor_window = seis_view_gl->window;

                if (private->is_threaded) {
                    g_idle_add ((GSourceFunc)g_seis_view_tool_cursor_hdouble_arrow_idle,
                                (gpointer)tool);
                } else {
                    gdk_window_set_cursor (seis_view_gl->window, private->hdouble_arrow_cursor);
                    gdk_flush ();
                }
            }
        }
    }
}

static void g_seis_view_tool_scroll_event_int (GSeisViewTool *tool, GtkWidget *seis_view_gl, GdkEventScroll *event,
                                               GSeisViewDataVisibility *data_visibility) {
    gfloat scale;

    g_object_get (G_OBJECT (seis_view_gl), "traces_scale", &scale, NULL);

    if (GDK_SCROLL_UP == event->direction)
        scale += 0.05;
    else if (GDK_SCROLL_DOWN == event->direction)
        scale -= 0.05;

    gtk_seis_view_gl_set_traces_scale (GTK_SEIS_VIEW_GL (seis_view_gl), scale);
    gtk_seis_view_gl_redraw (GTK_SEIS_VIEW_GL (seis_view_gl));
}

static void g_seis_view_tool_motion_event_int (GSeisViewTool *tool, GtkWidget *seis_view_gl, GdkEventMotion *event,
                                               GSeisViewDataVisibility *data_visibility) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL (tool));

    if (private->vert_scaling) {
        guint16 pointer_pos = data_visibility->fast_pointer_pos_screen - data_visibility->fast_start_screen;
        guint16 half_height = data_visibility->fast_size_screen / 2;
        gdouble fast_start_data, fast_size_data;
        if (private->start_pointer_pos_screen < half_height) {
            if (pointer_pos >= half_height)
                return;
            fast_size_data = private->scale_area_size *
                             (private->start_pointer_pos_screen / (gdouble)data_visibility->fast_size_screen - 0.5) /
                             (pointer_pos / (gdouble)data_visibility->fast_size_screen - 0.5);
            fast_start_data = private->scale_area_start + private->scale_area_size / 2.0 - fast_size_data / 2.0;
        } else {
            if (pointer_pos <= half_height)
                return;
            fast_size_data = private->scale_area_size *
                             (-private->start_pointer_pos_screen / (gdouble)data_visibility->fast_size_screen + 0.5) /
                             (-pointer_pos / (gdouble)data_visibility->fast_size_screen + 0.5);
            fast_start_data = private->scale_area_start + private->scale_area_size / 2.0 - fast_size_data / 2.0;
        }
        gtk_seis_view_gl_set_data_viewport (GTK_SEIS_VIEW_GL (seis_view_gl), data_visibility->slow_start_data,
                                            data_visibility->slow_size_data,
                                            fast_start_data, fast_size_data);
        gtk_seis_view_gl_redraw (GTK_SEIS_VIEW_GL (seis_view_gl));
    } else if (private->horiz_scaling) {
        guint16 pointer_pos = data_visibility->slow_pointer_pos_screen - data_visibility->slow_start_screen;
        guint16 half_width = data_visibility->slow_size_screen / 2;
        gdouble slow_start_data, slow_size_data;
        if (private->start_pointer_pos_screen < half_width) {
            if (pointer_pos >= half_width)
                return;
            slow_size_data = private->scale_area_size *
                             (private->start_pointer_pos_screen / (gdouble)data_visibility->slow_size_screen - 0.5) /
                             (pointer_pos / (gdouble)data_visibility->slow_size_screen - 0.5);
            slow_start_data = private->scale_area_start + private->scale_area_size / 2.0 - slow_size_data / 2.0;
        } else {
            if (pointer_pos <= half_width)
                return;
            slow_size_data = private->scale_area_size *
                             (-private->start_pointer_pos_screen / (gdouble)data_visibility->slow_size_screen + 0.5) /
                             (-pointer_pos / (gdouble)data_visibility->slow_size_screen + 0.5);
            slow_start_data = private->scale_area_start + private->scale_area_size / 2.0 - slow_size_data / 2.0;
        }
        gtk_seis_view_gl_set_data_viewport (GTK_SEIS_VIEW_GL (seis_view_gl), slow_start_data, slow_size_data,
                                            data_visibility->fast_start_data, data_visibility->fast_size_data);
        gtk_seis_view_gl_redraw (GTK_SEIS_VIEW_GL (seis_view_gl));
    }
}

static void g_seis_view_tool_scale_init (GSeisViewToolScale *self) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (self);

    (G_SEIS_VIEW_TOOL (self))->event_mask |= G_SEIS_VIEW_TOOL_MOTION_EVENT |
                                             G_SEIS_VIEW_TOOL_BUTTON_EVENT |
                                             G_SEIS_VIEW_TOOL_SCROLL_EVENT;

    (G_SEIS_VIEW_TOOL (self))->show_cross = TRUE;

    private->vert_scaling = FALSE;
    private->horiz_scaling = FALSE;
    private->cursor_window = NULL;

    private->hdouble_arrow_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
    private->vdouble_arrow_cursor = gdk_cursor_new (GDK_SB_V_DOUBLE_ARROW);

    private->is_threaded = FALSE;

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

static void g_seis_view_tool_scale_finalize (GObject *object) {
    GSeisViewToolScalePrivate *private = G_SEIS_VIEW_TOOL_SCALE_GET_PRIVATE (G_SEIS_VIEW_TOOL_SCALE (object));

    if (private->hdouble_arrow_cursor)
        gdk_cursor_unref (private->hdouble_arrow_cursor);

    if (private->vdouble_arrow_cursor)
        gdk_cursor_unref (private->vdouble_arrow_cursor);

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

static void g_seis_view_tool_scale_class_init (GSeisViewToolScaleClass *klass) {
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
    GSeisViewToolClass *tool_class = G_SEIS_VIEW_TOOL_CLASS (klass);

    gobject_class->finalize = g_seis_view_tool_scale_finalize;

    g_type_class_add_private (klass, sizeof (GSeisViewToolScalePrivate));

    tool_class->view_attach_notify = g_seis_view_tool_attach_notify_int;
    tool_class->view_detach_notify = g_seis_view_tool_detach_notify_int;
    tool_class->view_button_event = g_seis_view_tool_button_event_int;
    tool_class->view_scroll_event = g_seis_view_tool_scroll_event_int;
    tool_class->view_motion_event = g_seis_view_tool_motion_event_int;

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

GSeisViewToolScale* g_seis_view_tool_scale_new () {
    return g_object_new (G_SEIS_TYPE_VIEW_TOOL_SCALE, NULL);
}