gsegyviewscaling.c

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

    if (1 == event->button) {
        if (GDK_BUTTON_PRESS == event->type && private->inside_viewport) {
            private->dragging_viewport = TRUE;
            private->slow_pointer_screen = event->x;
            private->fast_pointer_screen = event->y;
            g_timeout_add (100, (GSourceFunc)g_segy_view_scaling_viewport_area_motion_idle,
                           (gpointer)G_SEGY_VIEW_SCALING (data));
        } else if (GDK_BUTTON_RELEASE == event->type) {
            private->dragging_viewport = FALSE;
        }
    }

    return FALSE;
}

static gboolean g_segy_view_scaling_viewport_area_motion_event_handler (GtkWidget *widget,
                                                                        GdkEventMotion *event,
                                                                        gpointer data) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (G_SEGY_VIEW_SCALING (data));
    gboolean inside_viewport = FALSE;
    gint x, y;
    GdkModifierType state;

    if (event->is_hint) {
        gdk_window_get_pointer (event->window, &x, &y, &state);
    } else {
        x = event->x;
        y = event->y;
        state = event->state;
    }

    if (private->dragging_viewport) {
        gdouble slow_start_data = private->horiz_start + (x - private->slow_pointer_screen) /
                                                         (gdouble)(private->viewport_area->allocation.width - 1);
        gdouble fast_start_data = private->vert_start + (y - private->fast_pointer_screen) /
                                                        (gdouble)(private->viewport_area->allocation.height - 1);
        if (slow_start_data < 0)
            slow_start_data = 0;
        if (slow_start_data + private->horiz_size > 1.0)
            slow_start_data = 1.0 - private->horiz_size;
        if (fast_start_data < 0)
            fast_start_data = 0;
        if (fast_start_data + private->vert_size > 1.0)
            fast_start_data = 1.0 - private->vert_size;

        private->horiz_start = slow_start_data;
        private->vert_start = fast_start_data;

        private->slow_pointer_screen = x;
        private->fast_pointer_screen = y;

        g_segy_view_scaling_draw_viewport (G_SEGY_VIEW_SCALING (data));

        gtk_seis_view_gl_set_data_viewport (private->seis_view, slow_start_data,
                                                                private->horiz_size,
                                                                fast_start_data,
                                                                private->vert_size);
        gtk_seis_view_gl_redraw (private->seis_view);
    } else {
        gdouble viewport_x_start = 1 + (private->viewport_area->allocation.width - 1) * private->horiz_start;
        gdouble viewport_y_start = 1 + (private->viewport_area->allocation.height - 1) * private->vert_start;
        gdouble viewport_x_end = viewport_x_start + (private->viewport_area->allocation.width - 1) * private->horiz_size;
        gdouble viewport_y_end = viewport_y_start + (private->viewport_area->allocation.height - 1) * private->vert_size;
        if (x >= viewport_x_start && x <= viewport_x_end &&
            y >= viewport_y_start && y <= viewport_y_end)
            inside_viewport = TRUE;

        if (inside_viewport != private->inside_viewport) {
            if (inside_viewport)
                gdk_window_set_cursor (private->viewport_area->window, private->fleur_cursor);
            else
                gdk_window_set_cursor (private->viewport_area->window, NULL);
            private->inside_viewport = inside_viewport;
        }
    }

    return FALSE;
}

static void g_segy_view_scaling_close_button_handler (GtkWidget *widget, gpointer data) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (G_SEGY_VIEW_SCALING (data));

    gtk_widget_hide (private->window);
}

static gboolean g_segy_view_scaling_window_close_handler (GtkWidget *widget, GdkEvent *event, gpointer data) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (G_SEGY_VIEW_SCALING (data));

    gtk_widget_hide (private->window);

    return TRUE;
}

void g_segy_view_scaling_enable_viewport_change (GSEGYViewScaling *self, gboolean enable) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (self);

    if (private->window) {
        gtk_widget_set_sensitive (private->horiz_frame, enable);
        gtk_widget_set_sensitive (private->vert_frame, enable);
        gtk_widget_set_sensitive (private->viewport_frame, enable);
    }

    private->enable_viewport_change = enable;
}

GtkWidget* g_segy_view_scaling_get_main_widget (GSEGYViewScaling *self) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_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), FALSE);
        gtk_window_set_resizable (GTK_WINDOW (private->window), FALSE);
        gtk_window_set_title (GTK_WINDOW (private->window), _("Data view parameters"));
        gtk_signal_connect (GTK_OBJECT (private->window), "delete_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_window_close_handler), (gpointer)G_OBJECT (self));

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

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

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

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

        private->amp_frame = gtk_frame_new (_("Amplitude"));
        gtk_widget_set_size_request (private->amp_frame, 200, -1);
        gtk_box_pack_start (GTK_BOX (private->vbox1), private->amp_frame, TRUE, TRUE, 0);

        private->amp_vbox = gtk_vbox_new (TRUE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->amp_vbox), 3);
        gtk_container_add (GTK_CONTAINER (private->amp_frame), private->amp_vbox);

        private->amp_scale = gtk_hscale_new_with_range (0.5, 2.0, 0.05);
        gtk_range_set_value (GTK_RANGE (private->amp_scale), private->traces_scale);
        gtk_scale_set_draw_value (GTK_SCALE (private->amp_scale), TRUE);
        gtk_box_pack_start (GTK_BOX (private->amp_vbox), private->amp_scale, TRUE, TRUE, 3);
        gtk_signal_connect (GTK_OBJECT (private->amp_scale), "value-changed",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_amp_scale_handler),
                            (gpointer)G_OBJECT (self));
        gtk_signal_connect (GTK_OBJECT (private->amp_scale), "enter_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_enter_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->amp_scale), "leave_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_leave_handler),
                            (gpointer)self);

        private->horiz_frame = gtk_frame_new (_("Horizontal"));
        gtk_widget_set_size_request (private->horiz_frame, 200, -1);
        gtk_box_pack_start (GTK_BOX (private->vbox1), private->horiz_frame, TRUE, TRUE, 0);

        private->horiz_vbox = gtk_vbox_new (TRUE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->horiz_vbox), 3);
        gtk_container_add (GTK_CONTAINER (private->horiz_frame), private->horiz_vbox);

        private->horiz_scale = gtk_hscale_new_with_range (1.0 / (gfloat)private->trace_num, 1.0, 0.1);
        if (private->trace_num > 50)
            gtk_range_set_increments (GTK_RANGE (private->horiz_scale), 50.0 / (gfloat)private->trace_num,
                                                                        50.0 / (gfloat)private->trace_num);
        else
            gtk_range_set_increments (GTK_RANGE (private->horiz_scale), 1.0 / (gfloat)private->trace_num,
                                                                        1.0 / (gfloat)private->trace_num);
        gtk_range_set_value (GTK_RANGE (private->horiz_scale), private->horiz_size);
        gtk_scale_set_draw_value (GTK_SCALE (private->horiz_scale), FALSE);
        gtk_box_pack_start (GTK_BOX (private->horiz_vbox), private->horiz_scale, TRUE, TRUE, 3);
        gtk_signal_connect (GTK_OBJECT (private->horiz_scale), "value-changed",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_horiz_scale_handler),
                            (gpointer)G_OBJECT (self));
        gtk_signal_connect (GTK_OBJECT (private->horiz_scale), "enter_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_enter_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->horiz_scale), "leave_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_leave_handler),
                            (gpointer)self);

        private->vert_frame = gtk_frame_new (_("Vertical"));
        gtk_widget_set_size_request (private->vert_frame, -1, 150);
        gtk_box_pack_start (GTK_BOX (private->hbox), private->vert_frame, FALSE, FALSE, 3);

        private->vert_hbox = gtk_hbox_new (TRUE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->vert_hbox), 3);
        gtk_container_add (GTK_CONTAINER (private->vert_frame), private->vert_hbox);

        private->vert_scale = gtk_vscale_new_with_range (1.0 / (gfloat)private->sample_num, 1.0, 0.1);
        if (private->sample_num > 100)
            gtk_range_set_increments (GTK_RANGE (private->vert_scale), 100.0 / (gfloat)private->sample_num,
                                                                       100.0 / (gfloat)private->sample_num);
        else
            gtk_range_set_increments (GTK_RANGE (private->vert_scale), 1.0 / (gfloat)private->sample_num,
                                                                       1.0 / (gfloat)private->sample_num);
        gtk_range_set_value (GTK_RANGE (private->vert_scale), private->vert_size);
        gtk_scale_set_draw_value (GTK_SCALE (private->vert_scale), FALSE);
        gtk_box_pack_start (GTK_BOX (private->vert_hbox), private->vert_scale, TRUE, TRUE, 3);
        gtk_signal_connect (GTK_OBJECT (private->vert_scale), "value-changed",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_vert_scale_handler),
                            (gpointer)G_OBJECT (self));
        gtk_signal_connect (GTK_OBJECT (private->vert_scale), "enter_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_enter_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->vert_scale), "leave_notify_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_scale_leave_handler),
                            (gpointer)self);

        g_segy_view_scaling_change_ensemble (self, private->trace_num, private->sample_num);

        private->viewport_frame = gtk_frame_new (_("Viewport"));
        gtk_box_pack_start (GTK_BOX (private->vbox), private->viewport_frame, TRUE, TRUE, 0);

        private->viewport_vbox = gtk_vbox_new (TRUE, 3);
        gtk_container_set_border_width (GTK_CONTAINER (private->viewport_vbox), 5);
        gtk_container_add (GTK_CONTAINER (private->viewport_frame), private->viewport_vbox);
        
        private->viewport_area = gtk_drawing_area_new ();
        gtk_widget_set_size_request (private->viewport_area, -1, 200);
        gtk_box_pack_start (GTK_BOX (private->viewport_vbox), private->viewport_area, TRUE, TRUE, 0);

        gtk_signal_connect (GTK_OBJECT (private->viewport_area), "expose_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_viewport_area_expose_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->viewport_area), "configure_event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_viewport_area_configure_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->viewport_area), "button-press-event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_viewport_area_button_event_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->viewport_area), "button-release-event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_viewport_area_button_event_handler),
                            (gpointer)self);
        gtk_signal_connect (GTK_OBJECT (private->viewport_area), "motion-notify-event",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_viewport_area_motion_event_handler),
                            (gpointer)self);

        gtk_widget_set_events (private->viewport_area, gtk_widget_get_events (private->viewport_area)
                                                      | GDK_BUTTON_PRESS_MASK
                                                      | GDK_BUTTON_RELEASE_MASK
                                                      | GDK_POINTER_MOTION_MASK
                                                      | GDK_POINTER_MOTION_HINT_MASK);

        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->close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
        gtk_container_add (GTK_CONTAINER (private->button_box), private->close_button);
        gtk_signal_connect (GTK_OBJECT (private->close_button), "clicked",
                            GTK_SIGNAL_FUNC (g_segy_view_scaling_close_button_handler),
                            (gpointer)G_OBJECT (self));

        private->fleur_cursor = gdk_cursor_new (GDK_FLEUR);

        g_segy_view_scaling_enable_viewport_change (self, private->enable_viewport_change);

        gtk_widget_show_all (private->vbox);

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

    return private->window;
}

gboolean g_segy_view_scaling_has_main_widget (GSEGYViewScaling *self) {
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (self);

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

GSEGYViewScaling* g_segy_view_scaling_new (GtkSeisViewGl *seis_view) {
    GSEGYViewScaling *new_view_scaling = G_SEGY_VIEW_SCALING (g_object_new (G_SEGY_TYPE_VIEW_SCALING, NULL));
    GSEGYViewScalingPrivate *private = G_SEGY_VIEW_SCALING_GET_PRIVATE (new_view_scaling);

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

    private->notify_slow_start_id = g_signal_connect (G_OBJECT (private->seis_view), "notify::slow-start-data",
                                                      (GCallback)g_segy_view_scaling_horiz_start_handler, (gpointer)new_view_scaling);
    private->notify_fast_start_id = g_signal_connect (G_OBJECT (private->seis_view), "notify::fast-start-data",
                                                      (GCallback)g_segy_view_scaling_vert_start_handler, (gpointer)new_view_scaling);
    private->notify_slow_size_id = g_signal_connect (G_OBJECT (private->seis_view), "notify::slow-size-data",
                                                     (GCallback)g_segy_view_scaling_horiz_size_handler, (gpointer)new_view_scaling);
    private->notify_fast_size_id = g_signal_connect (G_OBJECT (private->seis_view), "notify::fast-size-data",
                                                     (GCallback)g_segy_view_scaling_vert_size_handler, (gpointer)new_view_scaling);
    private->notify_traces_scale_id = g_signal_connect (G_OBJECT (private->seis_view), "notify::traces-scale",
                                                        (GCallback)g_segy_view_scaling_traces_scale_handler, (gpointer)new_view_scaling);
    private->seis_view_is_threaded = gtk_seis_view_gl_is_threaded (private->seis_view);

    return new_view_scaling;
}