static void
gog_trend_line_init_style (GogStyledObject *gso, GOStyle *style)
{
style->interesting_fields = GO_STYLE_LINE;
gog_theme_fillin_style (gog_object_get_theme (GOG_OBJECT (gso)),
style, GOG_OBJECT (gso), 0, FALSE);
}
static void
gog_chart_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogChart *chart = GOG_CHART (obj);
char **str_doubles;
char const *str;
gboolean changed = FALSE;
switch (param_id) {
case CHART_PROP_PLOT_AREA:
str = g_value_get_string (value);
str_doubles = g_strsplit (str, " ", 4);
if (g_strv_length (str_doubles) != 4) {
g_strfreev (str_doubles);
break;
}
chart->plot_area.x = g_ascii_strtod (str_doubles[0], NULL);
chart->plot_area.y = g_ascii_strtod (str_doubles[1], NULL);
chart->plot_area.w = g_ascii_strtod (str_doubles[2], NULL);
chart->plot_area.h = g_ascii_strtod (str_doubles[3], NULL);
g_strfreev (str_doubles);
break;
case CHART_PROP_PLOT_AREA_IS_MANUAL:
chart->is_plot_area_manual = g_value_get_boolean (value);
break;
case CHART_PROP_X_POS:
chart->x_pos = g_value_get_int (value);
changed = TRUE;
break;
case CHART_PROP_Y_POS:
chart->y_pos = g_value_get_int (value);
changed = TRUE;
break;
case CHART_PROP_COLUMNS:
chart->cols = g_value_get_int (value);
changed = TRUE;
break;
case CHART_PROP_ROWS:
chart->rows = g_value_get_int (value);
changed = TRUE;
break;
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return; /* NOTE : RETURN */
}
if (changed) {
gog_graph_validate_chart_layout (GOG_GRAPH (GOG_OBJECT (chart)->parent));
gog_object_emit_changed (GOG_OBJECT (obj), TRUE);
}
}
static void
gog_pie_series_update (GogObject *obj)
{
double *vals = NULL, total;
int len = 0;
GogPieSeries *series = GOG_PIE_SERIES (obj);
unsigned old_num = series->base.num_elements;
GogShowNegsMode mode = GOG_PIE_PLOT (series->base.plot)->show_negatives;
if (series->base.values[1].data != NULL) {
vals = go_data_get_values (series->base.values[1].data);
len = go_data_get_vector_size (series->base.values[1].data);
}
series->base.num_elements = len;
for (total = 0. ; len-- > 0 ;) {
double val = vals[len];
if (go_finite (val)) {
if (val < 0)
val = (mode == GOG_SHOW_NEGS_SKIP)? 0.: -val;
total += val;
}
}
series->total = total;
/* queue plot for redraw */
gog_object_request_update (GOG_OBJECT (series->base.plot));
if (old_num != series->base.num_elements)
gog_plot_request_cardinality_update (series->base.plot);
if (series_parent_klass->update)
series_parent_klass->update (obj);
}
static void
gog_smoothed_curve_dataset_dim_changed (GogDataset *set, int dim_i)
{
GogSmoothedCurveClass *klass = (GogSmoothedCurveClass *) G_OBJECT_GET_CLASS (set);
g_return_if_fail (dim_i >= -1 && dim_i <= klass->max_dim);
{
GogSmoothedCurve const *sc = GOG_SMOOTHED_CURVE (set);
if (dim_i == -1) {
GOData *name_src = sc->name->data;
char *name = (name_src != NULL)
? go_data_get_scalar_string (name_src) : NULL;
gog_object_set_name (GOG_OBJECT (set), name, NULL);
} else
gog_object_request_update (GOG_OBJECT (set));
}
}
/**
* gog_chart_get_axes:
* @chart: #GogChart
* @target: #GogAxisType
*
* Returns: (element-type GogAxis) (transfer container): a list which the
* caller must free of all axis of type @target
* associated with @chart.
**/
GSList *
gog_chart_get_axes (GogChart const *chart, GogAxisType target)
{
GSList *ptr, *res = NULL;
GogAxis *axis;
int type;
g_return_val_if_fail (GOG_IS_CHART (chart), NULL);
for (ptr = GOG_OBJECT (chart)->children ; ptr != NULL ; ptr = ptr->next) {
axis = ptr->data;
if (GOG_IS_AXIS (axis)) {
type = -1;
g_object_get (G_OBJECT (axis), "type", &type, NULL);
if (type < 0 || type >= GOG_AXIS_TYPES) {
g_warning ("Invalid axis");
continue;
}
if (type == target)
res = g_slist_prepend (res, axis);
}
}
return res;
}
static void
graph_setup_chart (GogGraph *graph, CutRunContext *run_context)
{
GogChart *chart;
GogPlot *pie;
GOData *data;
GogSeries *series;
gchar **legends;
double *values;
gint n = 0;
chart = GOG_CHART(gog_object_get_child_by_name(GOG_OBJECT(graph), "Chart"));
pie = gog_plot_new_by_name("GogPiePlot");
gog_object_add_by_name(GOG_OBJECT(chart), "Plot", GOG_OBJECT(pie));
legends = g_new0(gchar *, CUT_TEST_RESULT_LAST);
values = g_new0(double, CUT_TEST_RESULT_LAST);
#define STATUS(status) (CUT_TEST_RESULT_ ## status)
#define SET_DATA(status, n_statuses) G_STMT_START \
{ \
const gchar *name; \
name = cut_test_result_status_to_signal_name(STATUS(status)); \
legends[STATUS(status)] = g_strdup(name); \
values[STATUS(status)] = \
cut_run_context_get_n_ ## n_statuses(run_context); \
n++; \
} G_STMT_END \
SET_DATA(SUCCESS, successes);
SET_DATA(NOTIFICATION, notifications);
SET_DATA(OMISSION, omissions);
SET_DATA(PENDING, pendings);
SET_DATA(FAILURE, failures);
SET_DATA(ERROR, errors);
#undef STATUS
#undef SET_DATA
series = gog_plot_new_series(pie);
data = go_data_vector_str_new((const gchar * const *)legends, n,
(GDestroyNotify)g_strfreev);
gog_series_set_dim(series, 0, data, NULL);
data = go_data_vector_val_new(values, n, g_free);
gog_series_set_dim(series, 1, data, NULL);
gog_object_add_by_name(GOG_OBJECT(chart), "Legend", NULL);
}
static void
graph_setup_title (GogGraph *graph, const gchar *title)
{
GogLabel *label;
GOData *data;
GOStyle *style;
PangoFontDescription *desc;
label = g_object_new(GOG_TYPE_LABEL, NULL);
data = go_data_scalar_str_new(title, FALSE);
gog_dataset_set_dim(GOG_DATASET(label), 0, data, NULL);
gog_object_add_by_name(GOG_OBJECT(graph), "Title", GOG_OBJECT(label));
style = go_styled_object_get_style(GO_STYLED_OBJECT(label));
desc = pango_font_description_from_string("Sans bold 16");
go_style_set_font_desc(style, desc);
}
static void
gog_pie_plot_set_default_separation (GogPiePlot *pie, double separation)
{
g_return_if_fail (GOG_PIE_PLOT (pie) != NULL);
pie->default_separation = CLAMP (separation, 0.0, 5.0);
gog_object_emit_changed (GOG_OBJECT (pie), FALSE);
}
/**
* gog_chart_set_position:
* @chart: #GogChart
* @x:
* @y:
* @cols:
* @rows:
*
**/
void
gog_chart_set_position (GogChart *chart,
unsigned int x, unsigned int y, unsigned int cols, unsigned int rows)
{
g_return_if_fail (GOG_IS_CHART (chart));
if (chart->x_pos == x && chart->y_pos == y &&
chart->cols == cols && chart->rows == rows)
return;
chart->x_pos = x;
chart->y_pos = y;
chart->cols = cols;
chart->rows = rows;
gog_graph_validate_chart_layout (GOG_GRAPH (GOG_OBJECT (chart)->parent));
gog_object_emit_changed (GOG_OBJECT (chart), TRUE);
}
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);
}
void
gog_chart_request_cardinality_update (GogChart *chart)
{
g_return_if_fail (GOG_IS_CHART (chart));
if (chart->cardinality_valid) {
chart->cardinality_valid = FALSE;
gog_object_request_update (GOG_OBJECT (chart));
}
}
static void
color_scale_pre_remove (GogObject *parent, GogObject *scale)
{
/* Unlink the color scale */
GSList const *l = gog_axis_contributors (gog_color_scale_get_axis (GOG_COLOR_SCALE (scale)));
gog_color_scale_set_axis (GOG_COLOR_SCALE (scale), NULL);
for (; l; l = l->next)
gog_object_request_update (GOG_OBJECT (l->data));
gog_chart_request_cardinality_update (GOG_CHART (parent));
}
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);
}
/**
* gog_chart_set_plot_area:
* @chart: #GogChart
* @plot_area: #GogViewAllocation
*
* If plot_area != NULL, sets plot area size and location, in fraction
* of chart size, and sets GogChart::is_plot_area_manual flag to TRUE.
* If plot_area == NULL, sets GogChart::is_plot_area_manual to FALSE.
**/
void
gog_chart_set_plot_area (GogChart *chart, GogViewAllocation const *plot_area)
{
if (plot_area == NULL) {
chart->is_plot_area_manual = FALSE;
} else {
chart->plot_area = *plot_area;
chart->is_plot_area_manual = TRUE;
}
gog_object_emit_changed (GOG_OBJECT (chart), TRUE);
}
static void
gog_tool_move_pie_double_click (GogToolAction *action)
{
MovePieData *data = action->data;
GogPieSeries *series;
GogObject *obj;
unsigned int index;
if (!find_element (action->view, data->x, data->y,
action->start_x, action->start_y,
&index, &series))
return;
obj = GOG_OBJECT (gog_series_get_element (GOG_SERIES (series), index));
if (obj == NULL) {
obj = g_object_new (gog_pie_series_element_get_type (),
"index", index, NULL);
gog_object_add_by_name (GOG_OBJECT (series), "Point", obj);
}
}
static void
gog_chart_add_axis (GogChart *chart, GogAxisType type)
{
unsigned i = G_N_ELEMENTS (roles);
while (i-- > 0)
if (roles[i].user.i == (int)type) {
gog_object_add_by_role (GOG_OBJECT (chart), roles + i, NULL);
return;
}
g_warning ("unknown axis type %d", type);
}
gboolean
gog_chart_axis_set_assign (GogChart *chart, GogAxisSet axis_set)
{
GogAxis *axis;
GSList *ptr;
GogAxisType type;
g_return_val_if_fail (GOG_IS_CHART (chart), FALSE);
if (chart->axis_set == axis_set)
return TRUE;
chart->axis_set = axis_set;
if (axis_set == GOG_AXIS_SET_UNKNOWN)
return TRUE;
/* Add at least 1 instance of any required axis */
for (type = 0 ; type < GOG_AXIS_TYPES ; type++)
if ((axis_set & (1 << type))) {
GSList *tmp = gog_chart_get_axes (chart, type);
if (tmp == NULL)
gog_chart_add_axis (chart, type);
else
g_slist_free (tmp);
}
/* link the plots */
for (ptr = chart->plots ; ptr != NULL ; ptr = ptr->next)
if (!gog_plot_axis_set_assign (ptr->data, axis_set))
return FALSE;
/* add any existing axis that do not fit this scheme to the set */
for (ptr = GOG_OBJECT (chart)->children ; ptr != NULL ; ) {
axis = ptr->data;
ptr = ptr->next; /* list may change under us */
if (GOG_IS_AXIS (axis)) {
type = -1;
g_object_get (G_OBJECT (axis), "type", &type, NULL);
if (type < 0 || type >= GOG_AXIS_TYPES) {
g_warning ("Invalid axis");
continue;
}
if (0 == (axis_set & (1 << type))) {
/* We used to delete those axes but if the first plot use a
restricted set, all other axes are lost, see #708292 */
chart->axis_set |= 1 << type;
}
}
}
return TRUE;
}
static GogGraph *
graph_new (const gchar *title, CutRunContext *run_context)
{
GogGraph *graph;
graph = g_object_new(GOG_TYPE_GRAPH, NULL);
gog_object_add_by_name(GOG_OBJECT(graph), "Chart", NULL);
graph_setup_title(graph, title);
graph_setup_chart(graph, run_context);
return graph;
}
static GogPlot *
setup_page (GtkNotebook *notebook, const gchar *service_id)
{
GtkWidget *child, *w;
GogChart *chart;
GogGraph *graph;
GogLabel *label;
GogPlot *plot;
GOData *data;
GOStyle *style;
PangoFontDescription *desc;
child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (notebook, child, gtk_label_new (service_id));
/* Create a graph widget and add it to the GtkVBox */
w = go_graph_widget_new (NULL);
gtk_box_pack_end (GTK_BOX (child), w, TRUE, TRUE, 0);
/* Get the embedded graph */
graph = go_graph_widget_get_graph (GO_GRAPH_WIDGET (w));
/* Add a title */
label = (GogLabel *) g_object_new (GOG_TYPE_LABEL, NULL);
data = go_data_scalar_str_new (service_id, FALSE);
gog_dataset_set_dim (GOG_DATASET (label), 0, data, NULL);
gog_object_add_by_name (GOG_OBJECT (graph), "Title", GOG_OBJECT (label));
/* Change the title font */
style = go_styled_object_get_style (GO_STYLED_OBJECT (label));
desc = pango_font_description_from_string ("Sans bold 16");
go_style_set_font_desc (style, desc);
/* Get the chart created by the widget initialization */
chart = go_graph_widget_get_chart (GO_GRAPH_WIDGET (w));
/* Create a plot and add it to the chart */
plot = (GogPlot *) gog_plot_new_by_name (service_id);
gog_object_add_by_name (GOG_OBJECT (chart), "Plot", GOG_OBJECT (plot));
/* Add a legend to the chart */
gog_object_add_by_name (GOG_OBJECT (chart), "Legend", NULL);
return plot;
}
static void
gog_trend_line_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
gboolean b_tmp;
switch (param_id) {
case TREND_LINE_PROP_HAS_LEGEND :
b_tmp = g_value_get_boolean (value);
if (GPOINTER_TO_INT (g_object_get_data (obj, "has-legend")) ^ b_tmp) {
GogSeries *series = GOG_SERIES (gog_object_get_parent (GOG_OBJECT (obj)));
g_object_set_data (obj, "has-legend", GINT_TO_POINTER (b_tmp));
if (series->plot != NULL)
gog_plot_request_cardinality_update (series->plot);
}
break;
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return; /* NOTE : RETURN */
}
gog_object_emit_changed (GOG_OBJECT (obj), FALSE);
}
static void
gog_smoothed_curve_view_render (GogView *view, GogViewAllocation const *bbox)
{
GogSmoothedCurve *curve = GOG_SMOOTHED_CURVE (view->model);
GogSeries *series = GOG_SERIES ((GOG_OBJECT (curve))->parent);
GogPlot *plot = series->plot;
GogChart *chart = GOG_CHART (GOG_OBJECT (plot)->parent);
GogChartMap *chart_map;
GOStyle *style;
GOPath *path;
if (curve->nb == 0 || curve->x == NULL || curve->y == NULL)
return;
chart_map = gog_chart_map_new (chart, &view->residual,
plot->axis[GOG_AXIS_X],
plot->axis[GOG_AXIS_Y],
NULL, FALSE);
if (!gog_chart_map_is_valid (chart_map)) {
gog_chart_map_free (chart_map);
return;
}
gog_renderer_push_clip_rectangle (view->renderer, view->residual.x, view->residual.y,
view->residual.w, view->residual.h);
path = gog_chart_map_make_path (chart_map, curve->x, curve->y, curve->nb, GO_LINE_INTERPOLATION_LINEAR, FALSE, NULL);
style = GOG_STYLED_OBJECT (curve)->style;
gog_renderer_push_style (view->renderer, style);
gog_renderer_stroke_serie (view->renderer, path);
gog_renderer_pop_style (view->renderer);
go_path_free (path);
gog_renderer_pop_clip (view->renderer);
gog_chart_map_free (chart_map);
}
static void
gog_xy_dropbar_series_update (GogObject *obj)
{
const double *x_vals, *y_vals, *z_vals;
GogSeries *series = GOG_SERIES (obj);
unsigned old_num = series->num_elements;
series->num_elements = gog_series_get_xyz_data (series,
&x_vals, &y_vals, &z_vals);
/* queue plot for redraw */
gog_object_request_update (GOG_OBJECT (series->plot));
if (old_num != series->num_elements)
gog_plot_request_cardinality_update (series->plot);
if (series_parent_klass->update)
series_parent_klass->update (obj);
}
static void
gog_pie_series_element_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogPieSeriesElement *pse = GOG_PIE_SERIES_ELEMENT (obj);
switch (param_id) {
case ELEMENT_SEPARATION:
pse->separation = g_value_get_double (value);
break;
default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, param_id, pspec);
return; /* NOTE : RETURN */
}
gog_object_emit_changed (GOG_OBJECT (obj), FALSE);
}
static void
gog_ring_plot_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogRingPlot *ring = GOG_RING_PLOT (obj);
switch (param_id) {
case RING_PLOT_PROP_CENTER_SIZE:
ring->center_size = g_value_get_double (value);
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_pie_series_set_property (GObject *obj, guint param_id,
GValue const *value, GParamSpec *pspec)
{
GogPieSeries *pie = GOG_PIE_SERIES (obj);
switch (param_id) {
case SERIES_PROP_INITIAL_ANGLE:
pie->initial_angle = g_value_get_double (value);
break;
case SERIES_PROP_SEPARATION:
pie->separation = g_value_get_double (value);
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 gboolean
gog_tool_move_pie_point (GogView *view, double x, double y, GogObject **gobj)
{
GogPieSeries *series;
double r = view->allocation.h, cx, cy;
unsigned int index;
if (r > view->allocation.w)
r = view->allocation.w;
r /= 2.;
cx = view->allocation.x + view->allocation.w/2.;
cy = view->allocation.y + view->allocation.h/2.;
if (hypot (x - cx, y - cy) > fabs (r))
return FALSE;
if (find_element (view, cx, cy, x, y, &index, &series))
*gobj = GOG_OBJECT (gog_series_get_element (GOG_SERIES (series), index));
return TRUE;
}
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
color_scale_post_add (GogObject *parent, GogObject *child)
{
/* Link the color scale to an axis without a preexisting color scale */
GogChart *chart = GOG_CHART (parent);
GSList *ptr;
GogAxis *axis;
GogAxisType type;
GSList const *l;
for (ptr = chart->axes; ptr && ptr->data; ptr = ptr->next) {
axis = GOG_AXIS (ptr->data);
type = gog_axis_get_atype (axis);
if ((type == GOG_AXIS_COLOR || type == GOG_AXIS_PSEUDO_3D)
&& gog_axis_get_color_scale (axis) == NULL) {
gog_color_scale_set_axis (GOG_COLOR_SCALE (child), axis);
for (l = gog_axis_contributors (axis); l; l = l->next)
gog_object_request_update (GOG_OBJECT (l->data));
break;
}
}
gog_chart_request_cardinality_update (chart);
}
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 gboolean
analysis_tool_normality_engine_run (data_analysis_output_t *dao,
analysis_tools_data_normality_t *info)
{
guint col;
GSList *data = info->base.input;
GnmFunc *fd;
GnmFunc *fd_if;
char const *fdname;
char const *testname;
char const *n_comment;
GogGraph *graph = NULL;
GogPlot *plot = NULL;
SheetObject *so;
switch (info->type) {
case normality_test_type_andersondarling:
fdname = "ADTEST";
testname = N_("Anderson-Darling Test");
n_comment = N_("For the Anderson-Darling Test\n"
"the sample size must be at\n"
"least 8.");
break;
case normality_test_type_cramervonmises:
fdname = "CVMTEST";
testname = N_("Cram\xc3\xa9r-von Mises Test");
n_comment = N_("For the Cram\xc3\xa9r-von Mises Test\n"
"the sample size must be at\n"
"least 8.");
break;
case normality_test_type_lilliefors:
fdname = "LKSTEST";
testname = N_("Lilliefors (Kolmogorov-Smirnov) Test");
n_comment = N_("For the Lilliefors (Kolmogorov-Smirnov) Test\n"
"the sample size must be at least 5.");
break;
case normality_test_type_shapirofrancia:
fdname = "SFTEST";
testname = N_("Shapiro-Francia Test");
n_comment = N_("For the Shapiro-Francia Test\n"
"the sample size must be at\n"
"least 5 and at most 5000.");
break;
default:
g_assert_not_reached();
}
fd = gnm_func_lookup_or_add_placeholder (fdname);
gnm_func_ref (fd);
fd_if = gnm_func_lookup_or_add_placeholder ("IF");
gnm_func_ref (fd_if);
dao_set_italic (dao, 0, 0, 0, 5);
dao_set_cell (dao, 0, 0, _(testname));
if (info->graph) {
GogChart *chart;
graph = g_object_new (GOG_TYPE_GRAPH, NULL);
chart = GOG_CHART (gog_object_add_by_name (
GOG_OBJECT (graph), "Chart", NULL));
plot = gog_plot_new_by_name ("GogProbabilityPlot");
go_object_set_property (G_OBJECT (plot), "distribution",
"Distribution", "GODistNormal",
NULL, NULL);
gog_object_add_by_name (GOG_OBJECT (chart),
"Plot", GOG_OBJECT (plot));
}
/* xgettext:
* Note to translators: in the following string and others like it,
* the "/" is a separator character that can be changed to anything
* if the translation needs the slash; just use, say, "|" instead.
*
* The items are bundled like this to increase translation context.
*/
set_cell_text_col (dao, 0, 1, _("/Alpha"
"/p-Value"
"/Statistic"
"/N"
"/Conclusion"));
dao_set_cell_comment (dao, 0, 4, _(n_comment));
for (col = 1; data != NULL; data = data->next, col++) {
GnmValue *val_org = value_dup (data->data);
/* Note that analysis_tools_write_label may modify val_org */
dao_set_italic (dao, col, 0, col, 0);
analysis_tools_write_label (val_org, dao, &info->base,
col, 0, col);
if (info->graph) {
GogSeries *series;
series = gog_plot_new_series (plot);
gog_series_set_dim (series, 0,
gnm_go_data_vector_new_expr
(val_org->v_range.cell.a.sheet,
gnm_expr_top_new (gnm_expr_new_constant (value_dup (val_org)))),
NULL);
}
if (col == 1)
dao_set_cell_float (dao, col, 1, info->alpha);
else
dao_set_cell_expr (dao, col, 1,
make_cellref (1 - col, 0));
dao_set_array_expr (dao, col, 2, 1, 3,
gnm_expr_new_funcall1 (fd, gnm_expr_new_constant (val_org)));
dao_set_cell_expr (dao, col, 5,
gnm_expr_new_funcall3
(fd_if, gnm_expr_new_binary
(make_cellref (0, -4),
GNM_EXPR_OP_GTE,
make_cellref (0, -3)),
gnm_expr_new_constant (value_new_string (_("Not normal"))),
gnm_expr_new_constant (value_new_string (_("Possibly normal")))));
}
if (info->graph) {
so = sheet_object_graph_new (graph);
g_object_unref (graph);
dao_set_sheet_object (dao, 0, 1, so);
}
gnm_func_unref (fd);
gnm_func_unref (fd_if);
dao_redraw_respan (dao);
return 0;
}
