GtkWidget *
gog_barcol_plot_pref (GogBarColPlot *barcol, GOCmdContext *cc)
{
GtkWidget *w;
GtkBuilder *gui =
go_gtk_builder_load ("res:go:plot_barcol/gog-barcol-prefs.ui",
GETTEXT_PACKAGE, cc);
if (gui == NULL)
return NULL;
w = go_gtk_builder_get_widget (gui, "gap_spinner");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), barcol->gap_percentage);
g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))),
"value_changed",
G_CALLBACK (cb_gap_changed), barcol);
w = go_gtk_builder_get_widget (gui, "overlap_spinner");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), barcol->overlap_percentage);
g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))),
"value_changed",
G_CALLBACK (cb_overlap_changed), barcol);
w = go_gtk_builder_get_widget (gui, "before-grid");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
(GOG_PLOT (barcol))->rendering_order == GOG_PLOT_RENDERING_BEFORE_GRID);
g_signal_connect (G_OBJECT (w),
"toggled",
G_CALLBACK (display_before_grid_cb), barcol);
w = GTK_WIDGET (g_object_ref (gtk_builder_get_object (gui, "gog-barcol-prefs")));
g_object_unref (gui);
return w;
}
static void
gog_matrix_plot_init (GogMatrixPlot *matrix)
{
GogPlot *plot = GOG_PLOT (matrix);
plot->rendering_order = GOG_PLOT_RENDERING_BEFORE_GRID;
}
static void
role_plot_post_add (GogObject *parent, GogObject *plot)
{
GogChart *chart = GOG_CHART (parent);
gboolean ok = TRUE;
GogPlotClass *plot_klass = GOG_PLOT_CLASS (G_OBJECT_GET_CLASS (plot));
GogAxisSet axis_set = plot_klass->axis_set & ~GOG_AXIS_SET_FUNDAMENTAL;
if (axis_set) {
int i = GOG_AXIS_VIRTUAL, j = 1 << GOG_AXIS_VIRTUAL;
for (; i < GOG_AXIS_TYPES; i++, j <<= 1)
if ((axis_set & j) != 0 && (chart->axis_set & j) == 0) {
GogObject *axis = GOG_OBJECT (g_object_new (GOG_TYPE_AXIS, "type", i, NULL));
chart->axis_set |= j;
switch (i) {
case GOG_AXIS_PSEUDO_3D:
gog_object_add_by_name (GOG_OBJECT (chart), "Pseudo-3D-Axis", axis);
break;
case GOG_AXIS_COLOR:
gog_object_add_by_name (GOG_OBJECT (chart), "Color-Axis", axis);
break;
case GOG_AXIS_BUBBLE:
gog_object_add_by_name (GOG_OBJECT (chart), "Bubble-Axis", axis);
break;
default:
g_warning ("Unknown axis type: %x\n", i);
}
}
}
/* APPEND to keep order, there won't be that many */
chart->plots = g_slist_append (chart->plots, plot);
gog_chart_request_cardinality_update (chart);
if (chart->plots->next == NULL)
ok = gog_chart_axis_set_assign (chart,
gog_plot_axis_set_pref (GOG_PLOT (plot)));
ok |= gog_plot_axis_set_assign (GOG_PLOT (plot),
chart->axis_set);
/* a quick post condition to keep us on our toes */
g_return_if_fail (ok);
}
static void
gog_chart_view_render (GogView *view, GogViewAllocation const *bbox)
{
GSList *ptr;
GogView *child_view;
gboolean grid_line_rendered = FALSE;
GogChart *chart = GOG_CHART (gog_view_get_model (view));
cview_parent_klass->render (view, bbox);
if (gog_chart_is_3d (chart)) {
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (!GOG_IS_AXIS (child_view->model) && !GOG_IS_PLOT (child_view->model) && !GOG_IS_LABEL (child_view->model))
gog_view_render (ptr->data, bbox);
}
/* now render plot and axes */
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (!GOG_IS_AXIS (child_view->model))
continue;
gog_view_render (ptr->data, bbox);
grid_line_render (ptr, bbox);
}
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (!GOG_IS_PLOT (child_view->model))
continue;
gog_view_render (ptr->data, bbox);
}
} else {
/* KLUDGE: render grid lines before axis */
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (!grid_line_rendered && GOG_IS_AXIS (child_view->model)) {
plot_render (view, bbox, GOG_PLOT_RENDERING_BEFORE_GRID);
grid_line_render (ptr, bbox);
plot_render (view, bbox, GOG_PLOT_RENDERING_BEFORE_AXIS);
grid_line_rendered = TRUE;
}
if (GOG_IS_PLOT (child_view->model)) {
if (!GOG_PLOT (child_view->model)->rendering_order)
gog_view_render (ptr->data, bbox);
} else if (!GOG_IS_LABEL (child_view->model))
gog_view_render (ptr->data, bbox);
}
}
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (!GOG_IS_LABEL (child_view->model))
continue;
gog_view_render (ptr->data, bbox);
}
}
static void
plot_render (GogView *view, GogViewAllocation const *bbox, GogPlotRenderingOrder order)
{
GSList *ptr;
GogView *child_view;
/* Render some plots before axes */
for (ptr = view->children ; ptr != NULL ; ptr = ptr->next) {
child_view = ptr->data;
if (GOG_IS_PLOT (child_view->model) &&
GOG_PLOT (child_view->model)->rendering_order == order)
gog_view_render (ptr->data, bbox);
}
}
static void
gog_pie_plot_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogPiePlot *pie = GOG_PIE_PLOT (obj);
switch (param_id) {
case PLOT_PROP_INITIAL_ANGLE: {
double a = g_value_get_double (value);
a = fmod (a, 360);
if (a < 0) a += 360;
pie->initial_angle = a;
break;
}
case PLOT_PROP_DEFAULT_SEPARATION: {
double f = g_value_get_double (value);
pie->default_separation = CLAMP (f, 0., 5.);
break;
}
case PLOT_PROP_IN_3D:
pie->in_3d = g_value_get_boolean (value);
break;
case PLOT_PROP_SPAN:
pie->span = g_value_get_double (value);
break;
case PLOT_PROP_SHOW_NEGS : {
GSList *ptr = GOG_PLOT (obj)->series;
pie->show_negatives = gog_show_neg_mode_from_str (g_value_get_string (value));
/* we need to update all the series */
while (ptr) {
gog_object_request_update (GOG_OBJECT (ptr->data));
ptr = ptr->next;
}
break;
}
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return; /* NOTE : RETURN */
}
/* none of the attributes triggers a size change yet.
* When we add data labels we'll need it */
gog_object_emit_changed (GOG_OBJECT (obj), FALSE);
}
static void
gog_xy_dropbar_get_property (GObject *obj, guint param_id,
GValue *value, GParamSpec *pspec)
{
GogPlot *plot = GOG_PLOT (obj);
GogXYDropBarPlot *dropbar = GOG_XY_DROPBAR_PLOT (obj);
switch (param_id) {
case XY_DROPBAR_PROP_FILL_BEFORE_GRID:
g_value_set_boolean (value, plot->rendering_order == GOG_PLOT_RENDERING_BEFORE_GRID);
break;
case XY_DROPBAR_PROP_HORIZONTAL:
g_value_set_boolean (value, dropbar->horizontal);
break;
case XY_DROPBAR_PROP_WIDTH:
g_value_set_double (value, dropbar->width);
break;
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
break;
}
}
static void
role_plot_pre_remove (GogObject *parent, GogObject *plot)
{
GogChart *chart = GOG_CHART (parent);
gog_plot_axis_clear (GOG_PLOT (plot), GOG_AXIS_SET_ALL);
chart->plots = g_slist_remove (chart->plots, plot);
gog_chart_request_cardinality_update (chart);
if (chart->plots == NULL)
gog_chart_axis_set_assign (chart, GOG_AXIS_SET_UNKNOWN);
if (chart->grid != NULL &&
chart->axis_set != GOG_AXIS_SET_XY &&
chart->axis_set != GOG_AXIS_SET_X &&
chart->axis_set != GOG_AXIS_SET_XY_pseudo_3d &&
chart->axis_set != GOG_AXIS_SET_XY_COLOR &&
chart->axis_set != GOG_AXIS_SET_RADAR) {
GogObject *grid = chart->grid; /* clear_parent clears ::grid */
gog_object_clear_parent (GOG_OBJECT (grid));
g_object_unref (grid);
}
}
static void
gog_xy_dropbar_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogPlot *plot = GOG_PLOT (obj);
GogXYDropBarPlot *dropbar = GOG_XY_DROPBAR_PLOT (obj);
switch (param_id) {
case XY_DROPBAR_PROP_FILL_BEFORE_GRID:
plot->rendering_order = (g_value_get_boolean (value))?
GOG_PLOT_RENDERING_BEFORE_GRID:
GOG_PLOT_RENDERING_LAST;
break;
case XY_DROPBAR_PROP_HORIZONTAL:
dropbar->horizontal = g_value_get_boolean (value);
break;
case XY_DROPBAR_PROP_WIDTH:
dropbar->width = g_value_get_double (value);
break;
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return;
}
gog_object_emit_changed (GOG_OBJECT (obj), FALSE);
}
static void
gog_xy_dropbar_populate_editor (GogObject *obj,
GOEditor *editor,
GogDataAllocator *dalloc,
GOCmdContext *cc)
{
#ifdef GOFFICE_WITH_GTK
GogXYDropBarPlot *dropbar = GOG_XY_DROPBAR_PLOT (obj);
GtkBuilder *gui =
go_gtk_builder_load ("res:go:plot_xy/gog-xy-dropbar-prefs.ui",
GETTEXT_PACKAGE, cc);
if (gui != NULL) {
GtkWidget *w = go_gtk_builder_get_widget (gui, "before-grid");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
(GOG_PLOT (obj))->rendering_order == GOG_PLOT_RENDERING_BEFORE_GRID);
g_signal_connect (G_OBJECT (w),
"toggled",
G_CALLBACK (display_before_grid_cb), obj);
w = go_gtk_builder_get_widget (gui, "horizontal");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), dropbar->horizontal);
g_signal_connect (G_OBJECT (w),
"toggled",
G_CALLBACK (horizontal_cb), obj);
w = go_gtk_builder_get_widget (gui, "width-btn");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), dropbar->width);
g_signal_connect (G_OBJECT (w),
"value_changed",
G_CALLBACK (value_changed_cb), obj);
w = go_gtk_builder_get_widget (gui, "gog-xy-dropbar-prefs");
go_editor_add_page (editor, w, _("Properties"));
g_object_unref (gui);
}
#endif
gog_xy_dropbar_parent_klass->populate_editor (obj, editor, dalloc, cc);
};
static void
gog_xy_dropbar_view_render (GogView *view, GogViewAllocation const *bbox)
{
GogXYDropBarPlot const *model = GOG_XY_DROPBAR_PLOT (view->model);
GogPlot *plot = GOG_PLOT (model);
GogSeries const *series;
GogAxisMap *x_map, *y_map, *val_map, *index_map;
GogViewAllocation work;
double *pos_vals, *start_vals, *end_vals;
unsigned i;
GSList *ptr;
unsigned n, tmp, num_series;
GOStyle *neg_style;
for (num_series = 0, ptr = plot->series ; ptr != NULL ; ptr = ptr->next, num_series++);
if (num_series < 1)
return;
x_map = gog_axis_map_new (GOG_PLOT (model)->axis[0],
view->allocation.x, view->allocation.w);
y_map = gog_axis_map_new (GOG_PLOT (model)->axis[1], view->allocation.y + view->allocation.h,
-view->allocation.h);
if (!(gog_axis_map_is_valid (x_map) &&
gog_axis_map_is_valid (y_map))) {
gog_axis_map_free (x_map);
gog_axis_map_free (y_map);
return;
}
work.w = view->allocation.w * model->width / 100.;
for (ptr = plot->series ; ptr != NULL ; ptr = ptr->next) {
series = ptr->data;
if (!gog_series_is_valid (GOG_SERIES (series)))
continue;
neg_style = go_style_dup ((GOG_STYLED_OBJECT (series))->style);
neg_style->line.color ^= 0xffffff00;
neg_style->fill.pattern.back ^= 0xffffff00;
neg_style->fill.pattern.fore ^= 0xffffff00;
pos_vals = go_data_get_values (series->values[0].data);
n = go_data_get_vector_size (series->values[1].data);
start_vals = go_data_get_values (series->values[1].data);
tmp = go_data_get_vector_size (series->values[1].data);
if (n > tmp)
n = tmp;
end_vals = go_data_get_values (series->values[2].data);
tmp = go_data_get_vector_size (series->values[2].data);
if (n > tmp)
n = tmp;
if (model->horizontal) {
index_map = y_map;
val_map = x_map;
} else {
index_map = x_map;
val_map = y_map;
}
for (i = 0; i < n; i++) {
work.x = pos_vals[i];
work.y = start_vals[i];
work.h = end_vals[i] - work.y;
if (!gog_axis_map_finite (index_map, work.x) ||
!gog_axis_map_finite (val_map, start_vals[i]) ||
!gog_axis_map_finite (val_map, end_vals[i]))
continue;
gog_renderer_push_style (view->renderer, (start_vals[i] <= end_vals[i])?
GOG_STYLED_OBJECT (series)->style: neg_style);
barcol_draw_rect (view->renderer, model->horizontal, x_map, y_map, &work);
gog_renderer_pop_style (view->renderer);
}
g_object_unref (neg_style);
}
gog_axis_map_free (x_map);
gog_axis_map_free (y_map);
}
GtkWidget *
gog_xyz_surface_plot_pref (GogXYZPlot *plot, GogDataAllocator *dalloc, GOCmdContext *cc)
{
GogDataset *set = GOG_DATASET (plot);
XYZSurfPrefsState *state;
GtkWidget *w, *grid;
GtkBuilder *gui =
go_gtk_builder_load ("res:go:plot_surface/gog-xyz-surface-prefs.ui",
GETTEXT_PACKAGE, cc);
if (gui == NULL)
return NULL;
state = g_new (XYZSurfPrefsState, 1);
state->plot = plot;
state->x_spin = w = go_gtk_builder_get_widget (gui, "columns_spinner");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), plot->columns);
g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))),
"value_changed",
G_CALLBACK (cb_columns_changed), plot);
state->x_label = go_gtk_builder_get_widget (gui, "cols-nb-lbl");
grid = go_gtk_builder_get_widget (gui, "gog-xyz-surface-prefs");
state->x_entry = GTK_WIDGET (gog_data_allocator_editor (dalloc, set, 0, GOG_DATA_VECTOR));
gtk_widget_show_all (state->x_entry);
gtk_widget_set_margin_left (state->x_entry, 12);
gtk_grid_attach (GTK_GRID (grid), state->x_entry, 0, 2, 3, 1);
w = go_gtk_builder_get_widget (gui, "preset-cols-btn");
if (!state->plot->auto_x) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE);
gtk_widget_hide (state->x_spin);
gtk_widget_hide (state->x_label);
} else
gtk_widget_hide (state->x_entry);
w = go_gtk_builder_get_widget (gui, "calc-cols-btn");
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_cols_toggled), state);
state->y_spin = w = go_gtk_builder_get_widget (gui, "rows_spinner");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), plot->rows);
g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))),
"value_changed",
G_CALLBACK (cb_rows_changed), plot);
state->y_label = go_gtk_builder_get_widget (gui, "rows-nb-lbl");
state->y_entry = GTK_WIDGET (gog_data_allocator_editor (dalloc, set, 1, GOG_DATA_VECTOR));
gtk_widget_show_all (state->y_entry);
gtk_widget_set_margin_left (state->y_entry, 12);
gtk_grid_attach (GTK_GRID (grid), state->y_entry, 0, 5, 3, 1);
w = go_gtk_builder_get_widget (gui, "preset-rows-btn");
if (!state->plot->auto_y) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE);
gtk_widget_hide (state->y_spin);
gtk_widget_hide (state->y_label);
} else
gtk_widget_hide (state->y_entry);
w = go_gtk_builder_get_widget (gui, "calc-rows-btn");
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_rows_toggled), state);
w = go_gtk_builder_get_widget (gui, "missing-as-btn");
if (GOG_PLOT (plot)->desc.series.num_dim == 2) {
gboolean as_density;
gtk_widget_hide (w);
gtk_widget_hide (go_gtk_builder_get_widget (gui, "missing-lbl"));
w = gtk_check_button_new_with_label (_("Display population density"));
gtk_container_add (GTK_CONTAINER (grid), w);
gtk_widget_show (w);
g_object_get (plot, "as-density", &as_density, NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), as_density);
g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_as_density_toggled), state);
} else {
char const *missing;
g_object_get (plot, "missing-as", &missing, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (w), missing_as_value (missing));
g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (cb_missing_as_changed), state);
}
w = GTK_WIDGET (g_object_ref (grid));
g_object_set_data_full (G_OBJECT (w), "state", state, g_free);
g_object_unref (gui);
return w;
}
static void
gog_matrix_view_render (GogView *view, GogViewAllocation const *bbox)
{
GogXYZPlot const *plot = GOG_XYZ_PLOT (view->model);
GogSeries const *series;
GOData *x_vec = NULL, *y_vec = NULL;
GogAxisMap *x_map, *y_map, *z_map;
GogAxisColorMap const *color_map = gog_axis_get_color_map (gog_plot_get_axis (GOG_PLOT (view->model), GOG_AXIS_COLOR));
unsigned i, imax, j, jmax;
double max, *data, z;
GogRenderer *rend = view->renderer;
GOStyle *style;
gboolean xdiscrete, ydiscrete, hide_outliers = TRUE;
GogViewAllocation rect;
if (plot->base.series == NULL)
return;
series = GOG_SERIES (plot->base.series->data);
if (plot->transposed) {
imax = plot->columns;
jmax = plot->rows;
} else {
imax = plot->rows;
jmax = plot->columns;
}
if (imax == 0 || jmax == 0)
return;
if (plot->plotted_data)
data = plot->plotted_data;
else
data = GOG_XYZ_PLOT (plot)->plotted_data = gog_matrix_plot_build_matrix (GOG_XYZ_PLOT (plot), NULL);
x_map = gog_axis_map_new (plot->base.axis[0],
view->residual.x , view->residual.w);
y_map = gog_axis_map_new (plot->base.axis[1],
view->residual.y + view->residual.h,
-view->residual.h);
if (!(gog_axis_map_is_valid (x_map) &&
gog_axis_map_is_valid (y_map))) {
gog_axis_map_free (x_map);
gog_axis_map_free (y_map);
return;
}
max = gog_axis_color_map_get_max (color_map);
z_map = gog_axis_map_new (plot->base.axis[GOG_AXIS_COLOR], 0, max);
xdiscrete = gog_axis_is_discrete (plot->base.axis[0]) ||
series->values[(plot->transposed)? 1: 0].data == NULL;
if (!xdiscrete)
x_vec = gog_xyz_plot_get_x_vals (GOG_XYZ_PLOT (plot));
ydiscrete = gog_axis_is_discrete (plot->base.axis[1]) ||
series->values[(plot->transposed)? 0: 1].data == NULL;
if (!ydiscrete)
y_vec = gog_xyz_plot_get_y_vals (GOG_XYZ_PLOT (plot));
/* clip to avoid problems with logarithmic axes */
gog_renderer_push_clip_rectangle (rend, view->residual.x, view->residual.y,
view->residual.w, view->residual.h);
style = go_style_new ();
style->interesting_fields = GO_STYLE_FILL;
style->disable_theming = GO_STYLE_ALL;
style->fill.type = GO_STYLE_FILL_PATTERN;
style->fill.pattern.pattern = GO_PATTERN_SOLID;
gog_renderer_push_style (rend, style);
for (j = 0; j < jmax; j++) {
if (xdiscrete) {
rect.x = gog_axis_map_to_view (x_map, j);
rect.w = gog_axis_map_to_view (x_map, j + 1) - rect.x;
} else {
rect.x = gog_axis_map_to_view (x_map, go_data_get_vector_value (x_vec, j));
rect.w = gog_axis_map_to_view (x_map, go_data_get_vector_value (x_vec, j + 1)) - rect.x;
}
for (i = 0; i < imax; i++) {
if (ydiscrete) {
rect.y = gog_axis_map_to_view (y_map, i);
rect.h = gog_axis_map_to_view (y_map, i + 1) - rect.y;
} else {
rect.y = gog_axis_map_to_view (y_map, go_data_get_vector_value (y_vec, i));
rect.h = gog_axis_map_to_view (y_map, go_data_get_vector_value (y_vec, i + 1)) - rect.y;
}
z = data[(i) * jmax + j];
if (gog_axis_map_finite (z_map, z)) {
double zc = gog_axis_map_to_view (z_map, z);
if (hide_outliers && (zc < 0 || zc > max))
style->fill.pattern.back = 0;
else
style->fill.pattern.back = gog_axis_color_map_get_color (color_map, CLAMP (zc, 0, max));
} else
style->fill.pattern.back = 0;
gog_renderer_draw_rectangle (rend, &rect);
}
}
gog_renderer_pop_style (rend);
gog_renderer_pop_clip (rend);
g_object_unref (style);
gog_axis_map_free (x_map);
gog_axis_map_free (y_map);
gog_axis_map_free (z_map);
if (!plot->plotted_data)
g_free (data);
}
