static void generateWavePeriod(void) { int waveType = 0; double waveFreq; int i; struct iio_device *trigger = iio_context_find_device(ctx, "hrtimer-1"); unsigned long triggerFreq; long long triggerFreqLL = 0; iio_device_attr_read_longlong(trigger, "frequency", &triggerFreqLL); triggerFreq = triggerFreqLL; /* Set the maximum frequency that user can select to 10% of the input generator frequency. */ if (triggerFreq >= 10) gtk_range_set_range(GTK_RANGE(scale_freq), 0.1, triggerFreq / 10); wave_ampl = gtk_range_get_value(GTK_RANGE(scale_ampl)); wave_offset = gtk_range_get_value(GTK_RANGE(scale_offset)); waveFreq = gtk_range_get_value(GTK_RANGE(scale_freq)); buffer_size = (unsigned int)round(triggerFreq / waveFreq); if (buffer_size < 2) buffer_size = 2; else if (buffer_size > 10000) buffer_size = 10000; current_sample = 0; soft_buffer_ch0 = g_renew(uint8_t, soft_buffer_ch0, buffer_size); gtk_range_set_value(GTK_RANGE(scale_freq), (double)triggerFreq / buffer_size); gtk_widget_queue_draw(scale_freq); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_sine))) waveType = SINEWAVE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_square))) waveType = SQUAREWAVE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_triangle))) waveType = TRIANGLE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_sawtooth))) waveType = SAWTOOTH; FillSoftBuffer(waveType, soft_buffer_ch0); /* Also generate a preview of the output signal. */ float_soft_buff = g_renew(gfloat, float_soft_buff, 2 * buffer_size); X = g_renew(gfloat, X, 2 * buffer_size); for (i = 0; i < 2 * buffer_size; i++) X[i] = i; for (i = 0; i < 2 * buffer_size; i++) float_soft_buff[i] = soft_buffer_ch0[i % buffer_size] * 3.3 / 256; gtk_databox_graph_remove_all(GTK_DATABOX(databox)); databox_graph = gtk_databox_lines_new((2 * buffer_size), X, float_soft_buff, &color_prev_graph, 2); databox_graph_dots = gtk_databox_points_new((2 * buffer_size), X, float_soft_buff, &color_prev_graph_dots, 5); gtk_databox_graph_add(GTK_DATABOX(databox), databox_graph_dots); gtk_databox_graph_add(GTK_DATABOX(databox), databox_graph); gtk_databox_set_total_limits(GTK_DATABOX(databox), -0.2, (i - 1), 3.5, -0.2); }
static void create_grid (void) { GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *close_button; GtkWidget *box; GtkWidget *label; GtkWidget *table; GtkWidget *separator; GtkDataboxGraph *graph; gfloat *X; gfloat *Y; GdkColor color; gint i; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 500, 500); g_signal_connect (GTK_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Double Grid Example"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); label = gtk_label_new ("This is an example of two grids\nLove it or hate it.\nI love it...\n\nFor basic understanding see basics :-)"); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0); /* Create a GtkDatabox widget along with scrollbars and rulers */ gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table, TRUE, TRUE, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); color.red = 8192; color.green = 8192; color.blue = 8192; gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color); X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { X[i] = i; Y[i] = 100. * sin (i * 2 * G_PI / POINTS); } color.red = 0; color.green = 65535; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 3); gtk_databox_graph_add (GTK_DATABOX (box), graph); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { Y[i] = 100. * cos (i * 2 * G_PI / POINTS); } color.red = 65535; color.green = 0; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 3); gtk_databox_graph_add (GTK_DATABOX (box), graph); /* Here we start with the first grid */ color.red = 0; color.green = 0; color.blue = 65535; graph = gtk_databox_grid_new (7, 7, &color, 2); gtk_databox_graph_add (GTK_DATABOX (box), graph); color.red = 51000; color.green = 0; color.blue = 0; graph = gtk_databox_grid_new (15, 15, &color, 2); gtk_databox_graph_add (GTK_DATABOX (box), graph); gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), GTK_OBJECT (box)); gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0); gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); gtk_widget_show_all (window); }
static void create_basics (void) { GtkWidget *window = NULL; GtkWidget *vbox; GtkWidget *close_button; GtkWidget *box; GtkWidget *label; GtkWidget *separator; GtkWidget *table; GtkWidget *scrollbar; GtkWidget *ruler; GtkDataboxGraph *graph; gfloat min_x, max_x; gfloat min_y, max_y; gfloat *X; gfloat *Y; gfloat buffer; GdkColor color; gint i; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 500, 500); g_signal_connect (GTK_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Basics"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new ("\nThe code for this example demonstrates\n the the basic use of elementary functions\nfor utilizing the GtkDatabox widget.\n\nUsage:\nDraw a selection with the left button pressed,\nThan click into the selection.\nUse the right mouse button to zoom out.\nShift+ right mouse button zooms to default."); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); /* Instead of the following stuff, you could also call * gtk_databox_create_box_with_scrollbars_and_rulers * as it is done in the other examples. * Of course, you are more flexible in using scrollbars and rulers * by doing it yourself. */ table = gtk_table_new (3, 3, FALSE); box = gtk_databox_new (); gtk_table_attach (GTK_TABLE (table), box, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); /* You can associate a scrollbar with a GtkDatabox widget either * this way ...*/ scrollbar = gtk_hscrollbar_new (NULL); gtk_databox_set_adjustment_x (GTK_DATABOX (box), gtk_range_get_adjustment (GTK_RANGE (scrollbar))); gtk_table_attach (GTK_TABLE (table), scrollbar, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL, 0, 0); /* or this way ... */ scrollbar = gtk_vscrollbar_new (gtk_databox_get_adjustment_y (GTK_DATABOX (box))); gtk_table_attach (GTK_TABLE (table), scrollbar, 2, 3, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ruler = gtk_databox_ruler_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_sensitive (ruler, FALSE); gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL, 0, 0); gtk_databox_set_ruler_x (GTK_DATABOX (box), GTK_DATABOX_RULER (ruler)); ruler = gtk_databox_ruler_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_sensitive (ruler, FALSE); gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2, GTK_FILL, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); gtk_databox_set_ruler_y (GTK_DATABOX (box), GTK_DATABOX_RULER (ruler)); /* end of gtk_databox_create_box_with_scrollbars_and_rulers */ gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); color.red = 16383; color.green = 16383; color.blue = 16383; gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color); X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { X[i] = i; Y[i] = 100. * sin (i * 2 * G_PI / POINTS); } color.red = 0; color.green = 65535; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); X = g_new0 (gfloat, STEPS); Y = g_new0 (gfloat, STEPS); for (i = 0; i < STEPS / 2; i++) { X[i * 2] = X[i * 2 + 1] = 2 * (i + .5) * POINTS / STEPS; if (i > 0) Y[i * 2 - 1] = 100. * sin ((i * 2) * 2 * G_PI / STEPS); Y[i * 2] = 100. * sin ((i * 2) * 2 * G_PI / STEPS); if (i == STEPS / 2 - 1) Y[i * 2 + 1] = 100. * sin (((i + 1) * 2) * 2 * G_PI / STEPS); } color.red = 65535; color.green = 0; color.blue = 0; graph = gtk_databox_lines_new (STEPS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); X = g_new0 (gfloat, BARS); Y = g_new0 (gfloat, BARS); for (i = 0; i < BARS; i++) { X[i] = i * POINTS / BARS; Y[i] = 80. * sin (i * 2 * G_PI / BARS); } color.red = 0; color.green = 65535; color.blue = 65535; graph = gtk_databox_bars_new (BARS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); color.red = 32768; color.green = 32768; color.blue = 32768; graph = gtk_databox_cross_simple_new (&color, 0); gtk_databox_graph_add (GTK_DATABOX (box), graph); /* Instead of doing stuff what you see below, you could call * gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); * as is done in the other examples * Of course, you are more flexible in adjusting the scaling by doing * it yourself, though. */ if (0 > gtk_databox_calculate_extrema (GTK_DATABOX (box), &min_x, &max_x, &min_y, &max_y)) { g_warning ("Calculating extrema failed. Resorting to default values"); min_x = -100.; min_y = -100.; max_x = +100.; max_y = +100.; } else { gfloat width = max_x - min_x; gfloat height = max_y - min_y; gfloat border = 0.05; min_x -= border * width; min_y -= border * height; max_x += border * width; max_y += border * height; } /* We want larger y values to be higher on the screen */ buffer = min_y; min_y = max_y; max_y = buffer; gtk_databox_set_total_limits (GTK_DATABOX (box), min_x, max_x, min_y, max_y); /* end of gtk_databox_auto_rescale */ separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), GTK_OBJECT (box)); gtk_box_pack_start (GTK_BOX (vbox), close_button, FALSE, FALSE, 0); gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); gtk_widget_grab_focus (close_button); gtk_widget_show_all (window); gdk_window_set_cursor (box->window, gdk_cursor_new (GDK_CROSS)); }
static void create_basics () { GtkWidget *window = NULL; GtkWidget *box; GtkWidget *scrollbar; GtkWidget *ruler; GtkDataboxGraph *graph; gfloat min_x, max_x; gfloat min_y, max_y; gfloat *X; gfloat *Y; gfloat buffer; GdkRGBA color; gint i; GladeXML *gxml; gxml = glade_xml_new (GLADE_FILE, NULL, NULL); /* This is important */ glade_xml_signal_autoconnect (gxml); window = glade_xml_get_widget (gxml, "window"); /* You could associate a scrollbar with a GtkDatabox widget either * this way ...*/ scrollbar = glade_xml_get_widget (gxml, "scrollbar_x"); box = glade_xml_get_widget (gxml, "box"); gtk_databox_set_adjustment_x (GTK_DATABOX (box), gtk_range_get_adjustment (GTK_RANGE (scrollbar))); /* or this way ... */ scrollbar = glade_xml_get_widget (gxml, "scrollbar_y"); gtk_databox_set_adjustment_y (GTK_DATABOX (box), gtk_range_get_adjustment (GTK_RANGE (scrollbar))); ruler = glade_xml_get_widget (gxml, "ruler_x"); gtk_databox_set_ruler_x (GTK_DATABOX (box), GTK_DATABOX_RULER (ruler)); ruler = glade_xml_get_widget (gxml, "ruler_y"); gtk_databox_set_ruler_y (GTK_DATABOX (box), GTK_DATABOX_RULER (ruler)); /* end of gtk_databox_create_box_with_scrollbars_and_rulers */ color.red = 0.33; color.green = 0.33; color.blue = 0.33; gtk_widget_override_background_color (box, GTK_STATE_FLAG_NORMAL, &color); X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { X[i] = i; Y[i] = 100. * sin (i * 2 * G_PI / POINTS); } color.red = 0; color.green = 1; color.blue = 0; color.alpha = 1; graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); X = g_new0 (gfloat, STEPS); Y = g_new0 (gfloat, STEPS); for (i = 0; i < STEPS / 2; i++) { X[i * 2] = X[i * 2 + 1] = 2 * (i + .5) * POINTS / STEPS; if (i > 0) Y[i * 2 - 1] = 100. * sin ((i * 2) * 2 * G_PI / STEPS); Y[i * 2] = 100. * sin ((i * 2) * 2 * G_PI / STEPS); if (i == STEPS / 2 - 1) Y[i * 2 + 1] = 100. * sin (((i + 1) * 2) * 2 * G_PI / STEPS); } color.red = 1; color.green = 0; color.blue = 0; color.alpha = 1; graph = gtk_databox_lines_new (STEPS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); X = g_new0 (gfloat, BARS); Y = g_new0 (gfloat, BARS); for (i = 0; i < BARS; i++) { X[i] = i * POINTS / BARS; Y[i] = 80. * sin (i * 2 * G_PI / BARS); } color.red = 0; color.green = 1; color.blue = 1; color.alpha = 1; graph = gtk_databox_bars_new (BARS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); color.red = 0.5; color.green = 0.5; color.blue = 0.5; graph = gtk_databox_cross_simple_new (&color, 0); gtk_databox_graph_add (GTK_DATABOX (box), graph); /* Instead of doing stuff what you see below, you could call * gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); * as is done in the other examples * Of course, you are more flexible in adjusting the scaling by doing * it yourself, though. */ if (0 > gtk_databox_calculate_extrema (GTK_DATABOX (box), &min_x, &max_x, &min_y, &max_y)) { g_warning ("Calculating extrema failed. Resorting to default values"); min_x = -100.; min_y = -100.; max_x = +100.; max_y = +100.; } else { gfloat width = max_x - min_x; gfloat height = max_y - min_y; gfloat border = 0.05; min_x -= border * width; min_y -= border * height; max_x += border * width; max_y += border * height; } /* We want larger y values to be higher on the screen */ buffer = min_y; min_y = max_y; max_y = buffer; gtk_databox_set_total_limits (GTK_DATABOX (box), min_x, max_x, min_y, max_y); /* end of gtk_databox_auto_rescale */ gtk_widget_show (window); gdk_window_set_cursor (box->window, gdk_cursor_new (GDK_CROSS)); }
static void create_colors (void) { static GtkWidget *window = NULL; GtkWidget *box1 = NULL; GtkWidget *box2 = NULL; GtkWidget *close_button = NULL; GtkWidget *box = NULL; GtkWidget *separator; GtkWidget *label; GtkWidget *menu; GtkWidget *root_menu; GtkWidget *menu_bar; gfloat *X = NULL; gfloat *Y = NULL; gint i, j; GdkColor color; GtkDataboxGraph *graph; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 500, 300); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Colors"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box = gtk_databox_new (); gtk_databox_set_enable_selection (GTK_DATABOX (box), FALSE); gtk_databox_set_enable_zoom (GTK_DATABOX (box), FALSE); color.red = 0; color.green = 0; color.blue = 0; gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color); menu = gtk_menu_new (); root_menu = gtk_menu_item_new_with_label ("Color Menu"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu); menu_bar = gtk_menu_bar_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu); gtk_box_pack_start (GTK_BOX (box1), menu_bar, FALSE, TRUE, 0); label = gtk_label_new ("You can change the colors of the shown datasets via the menu.\n\n"); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (box), "destroy", G_CALLBACK (gtk_main_quit), NULL); for (i = 0; i < NO_OF_DATASETS; i++) { if (!i) X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (j = 0; j < POINTS; j++) { X[j] = j; Y[j] = 100. * sin ((i + 1) * 2 * j * G_PI / POINTS); } color.red = 65535 * ((i + 1) % 2); color.green = (65535 / 2) * ((i + 1) % 3); color.blue = (65535 / 3) * ((i + 1) % 4); graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); create_menu_entry (menu, i, box, graph); } gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); gtk_box_pack_start (GTK_BOX (box1), box, TRUE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), (gpointer) NULL); gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); gtk_widget_show_all (window); }
static void create_signals (void) { GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *close_button; GtkWidget *box; GtkWidget *table; GtkWidget *label; GtkWidget *separator; gfloat *X; gfloat *Y; GtkDataboxGraph *graph; GdkColor color; gint i; GtkWidget **entries; GtkWidget *hbox; entries = g_new0 (GtkWidget *, SHOW_NUM_ENTRIES); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 500, 500); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Signals Examples"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); label = gtk_label_new ("The output on the shell and in the text boxes below\nshow you the information that you can get\n by using signals.\n\nSee basics for a usage of this window..."); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0); hbox = gtk_hbox_new (TRUE, 3); gtk_box_pack_start (GTK_BOX (box1), hbox, FALSE, TRUE, 0); entries[SHOW_ACTUAL_X] = show_entry (hbox, "Actual X"); entries[SHOW_ACTUAL_Y] = show_entry (hbox, "Actual Y"); entries[SHOW_MARKED_X] = show_entry (hbox, "Marked X"); entries[SHOW_MARKED_Y] = show_entry (hbox, "Marked Y"); entries[SHOW_DELTA_X] = show_entry (hbox, "Delta X"); entries[SHOW_DELTA_Y] = show_entry (hbox, "Delta Y"); /* Create a GtkDatabox widget along with scrollbars and rulers */ gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table, TRUE, TRUE, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); entries[SHOW_BOX] = box; X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { X[i] = i+100.; Y[i] = 100. * sin (i * 2 * G_PI / POINTS); } color.red = 0; color.green = 65535; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { Y[i] = 100. * cos (i * 2 * G_PI / POINTS); } color.red = 65535; color.green = 0; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); gtk_databox_auto_rescale (GTK_DATABOX (box), 0.00); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (G_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), G_OBJECT (box)); gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); g_signal_connect (G_OBJECT (box), "zoomed", G_CALLBACK (handle_signal_zoomed), NULL); g_signal_connect (G_OBJECT (box), "selection-started", G_CALLBACK (handle_signal_selection_started), NULL); g_signal_connect (G_OBJECT (box), "selection-finalized", G_CALLBACK (handle_signal_selection_finalized), NULL); g_signal_connect (G_OBJECT (box), "selection-canceled", G_CALLBACK (handle_signal_selection_canceled), NULL); g_signal_connect_swapped (G_OBJECT (box), "motion_notify_event", G_CALLBACK (show_motion_notify_cb), entries); g_signal_connect (G_OBJECT (box), "button_press_event", G_CALLBACK (show_button_press_cb), entries); g_signal_connect (G_OBJECT (box), "selection-changed", G_CALLBACK (show_changed_cb), entries); gtk_widget_show_all (window); }
/** * facq_baf_view_plot_draw_page: * @plot: A #FacqBAFViewPlot object. * @n_page: the number of page that we want to plot, it should be >= 1. This * will be used to calculate the values of the times vector. * * You must call this function to update the plot with a new graph, * created from the slices stored in the temporal buffer, that will * be moved to the final buffer. * * Calculates the time array, calculating the time of each slice, * erases any previous graph in the plot, copies the slices pushed * to the temporal buffer to the final buffer, and creates new graphs * for the new slices pushed in the buffer. Finally the new graphs * are plotted, the temporal limits and amplitude limits are set and the * chunk counter is reset. * */ void facq_baf_view_plot_draw_page(FacqBAFViewPlot *plot,gdouble n_page) { guint i = 0; gfloat initial_time = 0, period = 0; GdkColor color; GtkDataboxGraph *graph = NULL; g_return_if_fail(FACQ_IS_BAF_VIEW_PLOT(plot)); g_return_if_fail(n_page >= 1); /* set the time array in the temporal array */ initial_time = ((n_page-1)*plot->priv->samples_per_page*plot->priv->period); period = (gfloat)plot->priv->period; for(i = 0;i < plot->priv->samples_per_page;i++){ plot->priv->time[i] = initial_time + i*period; } /* erase any previous existing graph */ if(plot->priv->signal){ for(i = 0;i < plot->priv->signal->len;i++){ if(GTK_DATABOX_IS_GRAPH(g_ptr_array_index(plot->priv->signal,i))){ gtk_databox_graph_remove(GTK_DATABOX(plot->priv->databox), g_ptr_array_index(plot->priv->signal,i)); } } g_ptr_array_free(plot->priv->signal,TRUE); plot->priv->signal = NULL; } /* copy the temporal buffers copy_samples and copy_time to the final buffers */ facq_baf_view_plot_copy_buffers(plot); /* create the new graphs for the final buffer */ plot->priv->signal = g_ptr_array_new_with_free_func( (GDestroyNotify)facq_baf_view_plot_signal_destroy); for(i = 0;i < plot->priv->n_channels;i++){ facq_gdk_color_from_index(i,&color); #ifdef G_OS_WIN32 /* Performance fix for windows, gdk_draw_lines() is too slow * when plotting with a large number of samples so we plot * points instead, note that this is a windows only problem. */ if(plot->priv->samples_per_page <= (2000.0/plot->priv->n_channels)){ graph = gtk_databox_lines_new(plot->priv->next_chunk, plot->priv->copy_time, plot->priv->copy_samples[i], &color,1); } else { graph = gtk_databox_points_new(plot->priv->next_chunk, plot->priv->copy_time, plot->priv->copy_samples[i], &color,1); } #else graph = gtk_databox_lines_new(plot->priv->next_chunk, plot->priv->copy_time, plot->priv->copy_samples[i], &color,1); #endif g_ptr_array_add(plot->priv->signal,(gpointer) graph); /* add the graphs to the box */ gtk_databox_graph_add(GTK_DATABOX(plot->priv->databox),graph); } /* set the limits */ gtk_databox_set_total_limits(GTK_DATABOX(plot->priv->databox), plot->priv->time[0], plot->priv->time[plot->priv->samples_per_page-1], plot->priv->max+0.5,plot->priv->min-0.5); /* plot it! */ gtk_widget_queue_draw(plot->priv->databox); /* set current_chunk to 0 so we can push more samples later */ plot->priv->next_chunk = 0; }
static void create_basics (void) { GtkWidget *window = NULL; GtkWidget *vbox; GtkWidget *close_button; GtkWidget *box; GtkWidget *label; GtkWidget *separator; GtkWidget *table; GtkDataboxGraph *graph; gfloat *X; gfloat *Y; GdkColor color; gint i; /* We define some data */ X = g_new0 (gfloat, POINTS); Y = g_new0 (gfloat, POINTS); for (i = 0; i < POINTS; i++) { X[i] = i; Y[i] = sin (i * 4 * G_PI / POINTS); } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 500, 500); g_signal_connect (GTK_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Basics"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new ("\nThe code for this example demonstrates\n the simplest way to use a GtkDatabox widget.\n\nUsage:\nDraw a selection with the left button pressed,\nThan click into the selection.\nUse the right mouse button to zoom out.\nShift+ right mouse button zooms to default."); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0); /* ----------------------------------------------------------------- * This is all you need: * ----------------------------------------------------------------- */ /* Create the GtkDatabox widget */ gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table, TRUE, TRUE, TRUE, TRUE); /* Put it somewhere */ gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); /* Add your data data in some color */ color.red = 0; color.green = 0; color.blue = 0; graph = gtk_databox_points_new (POINTS, X, Y, &color, 1); gtk_databox_graph_add (GTK_DATABOX (box), graph); gtk_databox_set_total_limits (GTK_DATABOX (box), -1000., 5000., -10000., 23000.); gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); /* ----------------------------------------------------------------- * Done :-) * ----------------------------------------------------------------- */ separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), GTK_OBJECT (box)); gtk_box_pack_start (GTK_BOX (vbox), close_button, FALSE, FALSE, 0); gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); gtk_widget_grab_focus (close_button); gtk_widget_show_all (window); gdk_window_set_cursor (box->window, gdk_cursor_new (GDK_CROSS)); }
static void create_markerss (void) { GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *close_button; GtkWidget *box; GtkWidget *table; GtkWidget *label; GtkWidget *separator; gfloat *X; gfloat *Y; gint i; GtkDataboxGraph *graph; GdkColor color; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (window, 600, 600); g_signal_connect (GTK_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Markers"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); label = gtk_label_new ("Some markerss (green) are shown below.\nThe text corresponds to the position of the text, relative to the markers.\n\nThere are also some texts (yellow).\n\nData points are red\n"); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0); gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table, TRUE, TRUE, TRUE, TRUE); gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); color.red = 16383; color.green = 16383; color.blue = 16383; gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color); X = g_new0 (gfloat, 20 + 4 + 5); Y = g_new0 (gfloat, 20 + 4 + 5); for (i = 0; i < 20 + 4 + 5; ++i) { X[i] = i % 4; Y[i] = i / 4; } X[20] = -0.5; Y[20] = -0.5; X[21] = -0.5; Y[21] = 4.5; X[22] = 3.5; Y[22] = -0.5; X[23] = 3.5; Y[23] = 4.5; X[24] = -1.; Y[24] = -1.; X[25] = -1.; Y[25] = +5.; X[26] = +4.; Y[26] = -1.; X[27] = +4.; Y[27] = +5.; X[28] = +1.5; Y[28] = +2.; color.red = 65535; color.green = 0; color.blue = 0; graph = gtk_databox_points_new (20 + 4 + 5, X, Y, &color, 3); gtk_databox_graph_add (GTK_DATABOX (box), graph); color.red = 0; color.green = 65535; color.blue = 0; graph = gtk_databox_markers_new (20, X, Y, &color, 15, GTK_DATABOX_MARKERS_TRIANGLE); gtk_databox_graph_add (GTK_DATABOX (box), graph); setM (graph, 0, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE); setM (graph, 1, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE); setM (graph, 2, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE); setM (graph, 3, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE); setM (graph, 4, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE); setM (graph, 5, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE); setM (graph, 6, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE); setM (graph, 7, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE); setM (graph, 8, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE); setM (graph, 9, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE); setM (graph, 10, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE); setM (graph, 11, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE); setM (graph, 12, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE); setM (graph, 13, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE); setM (graph, 14, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE); setM (graph, 15, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE); setM (graph, 16, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_SW, "SW", TRUE); setM (graph, 17, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_NW, "NW", TRUE); setM (graph, 18, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_SE, "SE", TRUE); setM (graph, 19, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_NE, "NE", TRUE); graph = gtk_databox_markers_new (4, X + 20, Y + 20, &color, 1, GTK_DATABOX_MARKERS_DASHED_LINE); gtk_databox_graph_add (GTK_DATABOX (box), graph); setL (graph, 0, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE); setL (graph, 1, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE); setL (graph, 2, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE); setL (graph, 3, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE); color.red = 65535; color.green = 65535; color.blue = 0; graph = gtk_databox_markers_new (5, X + 20 + 4, Y + 20 + 4, &color, 1, GTK_DATABOX_MARKERS_NONE); gtk_databox_graph_add (GTK_DATABOX (box), graph); setT (graph, 0, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE); setT (graph, 1, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE); setT (graph, 2, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE); setT (graph, 3, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE); setT (graph, 4, GTK_DATABOX_MARKERS_TEXT_CENTER, "Centered", TRUE); gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0); close_button = gtk_button_new_with_label ("close"); g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked", G_CALLBACK (gtk_main_quit), GTK_OBJECT (box)); gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0); gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (close_button); gtk_widget_show_all (window); }