static void facq_baf_view_plot_constructed(GObject *self)
{
FacqBAFViewPlot *plot = FACQ_BAF_VIEW_PLOT(self);
GdkColor color;
GtkDataboxGraph *grid = NULL;
gtk_databox_create_box_with_scrollbars_and_rulers(&plot->priv->databox,
&plot->priv->table,
FALSE,FALSE,TRUE,TRUE);
color.red = color.green = color.blue = 0;
gtk_widget_modify_bg(plot->priv->databox,GTK_STATE_NORMAL,&color);
color.red = color.blue = 0;
color.green = 65535;
grid = gtk_databox_grid_new(7,7,&color,1);
gtk_databox_graph_add(GTK_DATABOX(plot->priv->databox),grid);
color.red = color.blue = 0;
color.green = 32767;
grid = gtk_databox_grid_new(15,15,&color,1);
gtk_databox_graph_add(GTK_DATABOX(plot->priv->databox),grid);
gtk_databox_set_total_limits(GTK_DATABOX(plot->priv->databox),0,10,10,-10);
gtk_databox_set_enable_zoom(GTK_DATABOX(plot->priv->databox),TRUE);
gtk_databox_set_enable_selection(GTK_DATABOX(plot->priv->databox),TRUE);
gtk_widget_set_size_request(plot->priv->table,512,256);
gtk_widget_show_all(plot->priv->table);
}
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_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));
}
/**
* 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));
}
