callbacks.c

linux下的FFT 频谱分析

        {
            str = sconf_get_string((char*)(l->data),"name");
            if ( !str )
                exit_nicely("Could not read config value of \"%s/name\".\n", (char*)(l->data));

            item = gtk_menu_item_new_with_mnemonic(str);
            gtk_widget_show(item);
            gtk_container_add (GTK_CONTAINER(submenu), item);
            g_signal_connect((gpointer)item, "activate",G_CALLBACK(switch_profile),l->data);

            l = l->next;
        }
    }

    view_grid = 0;
    switch_profile(NULL,custom_settings);
}




/* This handler is called periodically to take care of retrieving new data from
    the sound data reader and refreshing screen when pointer moved etc.
*/
int refresh_handler(gpointer user_data)
{
    if ( button_pressed_x!=-1 ) 
        refresh_status |= REFRESH_SELECTION;

    if ( refresh_status&REFRESH_FFT_STOP )
    {
        draw();
        return TRUE;
    }
    
    refresh_status |= REFRESH_FFT_SAMPLE;

    draw();
    return TRUE;
}



/* When a window needs refresh... */
gint expose_event(GtkWidget *widget, GdkEventExpose *event)
{
    if ( ! main_pixmap )
    {
        fprintf(stderr, "expose_event: Yes, it happened - not configured!\n");
        configure_event(widget, NULL);
        return FALSE;
    }

    gdk_draw_pixmap(widget->window,
            widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
            main_pixmap,
            event->area.x, event->area.y,
            event->area.x, event->area.y,
            event->area.width, event->area.height);

    refresh_status |= REFRESH_ALL;
    return FALSE;
}


/* When a mouse button is pressed, remember its position for drawing the selection
    rectangle.
*/
gboolean button_press_event(GtkWidget *widget, GdkEventButton *event)
{
    button_pressed_x = event->x;
    button_pressed_y = event->y;
    button_current_x = event->x;
    button_current_y = event->y;
    return TRUE;
}


/* Mouse moved - save the current position, so that the refresh handler knows
    the dimensions of the selection rectangle and scalebar can update the ruler.
*/
gboolean motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
{
    button_current_x = event->x;
    button_current_y = event->y;

    refresh_status |= REFRESH_POINTER_SCALEBAR;

    return TRUE;
}



/* Selection rectangle is definite - zoom if necessary */
gboolean button_release_event(GtkWidget *widget, GdkEventButton *event)
{
    default_zoom_event(button_pressed_x,button_current_x);
    refresh_status |= REFRESH_ALL;

    button_pressed_x = -1;
    return TRUE;
}



/* Handling of key press events which did not fit in the menu.
    TODO: The recognised keys should be documented somewhere!
*/
gint key_press_event (GtkWidget *widget, GdkEventKey *event)
{
    if ( event->keyval == GDK_e )
    {
        fprintf(stderr,"sending echo...\n");
        *msg_from_gui = MSG_ECHO_REQUEST;
    }

    return FALSE;
}




void selection_rectangle_draw(GdkPixmap *pixmap, int width,int height)
{
    int x,y,w,h;

    if ( button_current_x<0 ) button_current_x=0;
    if ( button_current_y<0 ) button_current_y=0;
    if ( button_current_x>width ) button_current_x=width;
    if ( button_current_y>height ) button_current_y=height;

    if (button_pressed_x<button_current_x)
    {
        x = button_pressed_x;
        w = button_current_x-button_pressed_x;
    }
    else
    {
        x = button_current_x;
        w = button_pressed_x-button_current_x;
    }

    if (button_pressed_y<button_current_y)
    {
        y = button_pressed_y;
        h = button_current_y-button_pressed_y;
    }
    else
    {
        y = button_current_y;
        h = button_pressed_y-button_current_y;
    }

    gdk_draw_rectangle(pixmap, gc_select, 0, x,y,w,h);
}






void
on_quit1_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    exit_nicely(NULL);
}



/* Display another part of the spectra */
void
on_move_left1_activate                 (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    default_move_left();

    refresh_status |= REFRESH_ALL;
}

void
on_move_right1_activate                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    default_move_right();

    refresh_status |= REFRESH_ALL;
}


void
on_zoom_in1_activate                   (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_WAVES )
        waves_zoom_in();
    else
        default_zoom_in();

    refresh_status |= REFRESH_ALL;
}


void
on_zoom_out1_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_WAVES )
        waves_zoom_out();
    else
        default_zoom_out();

    refresh_status |= REFRESH_ALL;
}



void
on_zoom_out_total_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    default_zoom_out_total();

    refresh_status |= REFRESH_ALL;
}




void
on_zoom_restore1_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_WAVES )
        waves_zoom_restore();
    else
        default_zoom_restore();

    refresh_status |= REFRESH_ALL;
}


void
on_custom_grid1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    default_custom_grid_toggle();

    refresh_status |= REFRESH_FFT_SAMPLE;
}


void
on_grid1_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_FOURIER )
        fourier_grid_toggle();

    refresh_status |= REFRESH_FFT_SAMPLE;
}



void
on_pause1_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( refresh_status&REFRESH_FFT_STOP )
    {
        refresh_status = refresh_status&(~REFRESH_FFT_STOP);
        refresh_status |= REFRESH_ALL;
        *msg_from_gui = MSG_OK;
    }
    else
    {
        refresh_status |= REFRESH_FFT_STOP;
        *msg_from_gui = MSG_PAUSE_REQUEST;
    }
}


void
on_interpolate1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    fourier_display_type_toggle();
    spectrogram_interpolate_toggle();

    refresh_status |= REFRESH_FFT_SAMPLE;
}


void
on_display_spectra1                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_FOURIER ) return;
    g_source_remove(refresh_handler_id);
    refresh_handler_id = 0;
    mode = MODE_FOURIER;
    read_profile();
    configure_event(darea,NULL);
}


void
on_display_spectrogram1                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    /* Switching to spectrogram mode again will clear the screen */
    
    g_source_remove(refresh_handler_id);
    refresh_handler_id = 0;
    mode = MODE_SPECTROGRAM;
    read_profile();
    configure_event(darea,NULL);
    spectrogram_init_intensity();
}


void
on_display_waves1_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    if ( mode==MODE_WAVES ) return;
    g_source_remove(refresh_handler_id);
    refresh_handler_id = 0;
    mode = MODE_WAVES;
    read_profile();
    configure_event(darea,NULL);
}


void
on_constant2_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    intensity_scale_mode=INTENSITY_SCALE_CONSTANT;
    spectrogram_init_intensity();
    waves_init_intensity();
}


void
on_flexible2_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    intensity_scale_mode=INTENSITY_SCALE_FLEXIBLE;
}


void
on_smart2_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    intensity_scale_mode=INTENSITY_SCALE_SMART;
    spectrogram_init_intensity();
}




void
on_logarithmic1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
    fourier_logarithmic_intensity_toggle();
    spectrogram_logarithmic_intensity_toggle();
    spectrogram_init_intensity();

    refresh_status |= REFRESH_FFT_SAMPLE;
}