static void
paste_cell_with_operation (Sheet *dst_sheet,
int target_col, int target_row,
GnmExprRelocateInfo const *rinfo,
GnmCellCopy const *src,
int paste_flags)
{
GnmCell *dst;
GnmExprOp op;
if (src->texpr == NULL &&
!VALUE_IS_EMPTY (src->val) &&
!VALUE_IS_NUMBER (src->val))
return;
dst = sheet_cell_fetch (dst_sheet, target_col, target_row);
if (!cell_has_expr_or_number_or_blank (dst))
return;
op = paste_op_to_expr_op (paste_flags);
/* FIXME : This does not handle arrays, linked cells, ranges, etc. */
if ((paste_flags & PASTE_CONTENTS) &&
(NULL != src->texpr || gnm_cell_has_expr (dst))) {
GnmExpr const *old_expr = contents_as_expr (dst->base.texpr, dst->value);
GnmExpr const *copied_expr = contents_as_expr (src->texpr, src->val);
GnmExprTop const *res = gnm_expr_top_new (gnm_expr_new_binary (old_expr, op, copied_expr));
GnmExprTop const *relo = gnm_expr_top_relocate (res, rinfo, FALSE);
if (relo) {
gnm_cell_set_expr (dst, relo);
gnm_expr_top_unref (relo);
} else
gnm_cell_set_expr (dst, res);
gnm_expr_top_unref (res);
} else {
GnmValue *value;
GnmEvalPos pos;
GnmExpr const *expr = gnm_expr_new_binary (
gnm_expr_new_constant (value_dup (dst->value)),
op,
gnm_expr_new_constant (value_dup (src->val)));
GnmExprTop const *texpr = gnm_expr_top_new (expr);
eval_pos_init_cell (&pos, dst);
pos.dep = NULL; /* no dynamic deps */
value = gnm_expr_top_eval (texpr, &pos,
GNM_EXPR_EVAL_SCALAR_NON_EMPTY);
gnm_expr_top_unref (texpr);
gnm_cell_set_value (dst, value);
}
}
static void
wb_create_name (WorkbookControl *wbc, char const *text, GnmParsePos *pp)
{
GnmRange const *r;
GnmCellRef a, b;
GnmExpr const *target_range;
r = selection_first_range (wb_control_cur_sheet_view (wbc),
GO_CMD_CONTEXT (wbc), _("Define Name"));
if (r != NULL) {
a.sheet = b.sheet = wb_control_cur_sheet (wbc);
a.col = r->start.col;
a.row = r->start.row;
b.col = r->end.col;
b.row = r->end.row;
a.col_relative = a.row_relative = b.col_relative = b.row_relative = FALSE;
pp->sheet = NULL; /* make it a global name */
if (gnm_cellref_equal (&a, &b))
target_range = gnm_expr_new_cellref (&a);
else
target_range = gnm_expr_new_constant (
value_new_cellrange_unsafe (&a, &b));
cmd_define_name (wbc, text, pp, gnm_expr_top_new (target_range), NULL);
}
}
int gnumeric_sheet_set_cell(GnumericSheetPtr sheet, int x, int y,
GSheetCellPtr cell) {
if (!cell->is_url) {
if (cell->all) {
gnumeric_sheet_set_cell_as_string(sheet,x,y,cell->all);
return 0;
}
gnumeric_sheet_remove_cell(sheet,x,y);
return 0;
}
if (cell->url&&cell->txt) {
GnmFunc *func = gnm_func_lookup("hyperlink",((Sheet *)sheet)->workbook);
if (!func) {
fprintf(stderr,"hyperlink unknown\n");
exit(1);
}
GnmExpr const *expr =
gnm_expr_new_funcall2(func,
gnm_expr_new_constant(value_new_string(cell->url)),
gnm_expr_new_constant(value_new_string(cell->txt)));
GnmExprTop const *texpr = gnm_expr_top_new(expr);
GnmCell *cell2 = sheet_cell_get((Sheet*)sheet,x,y);
if (cell2==NULL) {
cell2 = sheet_cell_create((Sheet*)sheet,x,y);
}
GnmValue *val = value_new_string(cell->txt);
//sheet_cell_set_value(cell2,val);
gnm_cell_set_expr_and_value(cell2,texpr,val,0);
}
return 0;
}
/**
* paste_cell:
* @target_col: Column to put the cell into
* @target_row: Row to put the cell into.
* @src: A #GnmCelCopy with the content to paste
* @paste_flags: Bit mask that describes the paste options.
*
* Pastes a cell in the spreadsheet.
*/
static void
paste_cell (int target_col, int target_row,
GnmCellCopy const *src,
const struct paste_cell_data *dat)
{
Sheet *dst_sheet = dat->pt->sheet;
int paste_flags = dat->pt->paste_flags;
if (paste_flags & PASTE_OPER_MASK)
paste_cell_with_operation (dst_sheet, target_col, target_row,
&dat->rinfo, src, paste_flags);
else {
GnmCell *dst = sheet_cell_fetch (dst_sheet, target_col, target_row);
if (NULL != src->texpr && (paste_flags & PASTE_CONTENTS)) {
GnmExprTop const *relo = gnm_expr_top_relocate (
src->texpr, &dat->rinfo, FALSE);
if (paste_flags & PASTE_TRANSPOSE) {
GnmExprTop const *trelo =
gnm_expr_top_transpose (relo ? relo : src->texpr);
if (trelo) {
if (relo)
gnm_expr_top_unref (relo);
relo = trelo;
}
} else if (!relo && gnm_expr_top_is_array_corner (src->texpr)) {
/* We must not share array expressions. */
relo = gnm_expr_top_new (gnm_expr_copy (src->texpr->expr));
}
gnm_cell_set_expr_and_value (dst, relo ? relo : src->texpr,
value_dup (src->val), TRUE);
if (NULL != relo)
gnm_expr_top_unref (relo);
} else {
GnmValue *newval = NULL;
GnmValue const *oldval = src->val;
if (dat->translate_dates && oldval && VALUE_IS_FLOAT (oldval)) {
GOFormat const *fmt = VALUE_FMT (oldval)
? VALUE_FMT (oldval)
: gnm_style_get_format (gnm_cell_get_style (dst));
if (go_format_is_date (fmt) > 0) {
gnm_float fnew = go_date_conv_translate
(value_get_as_float (oldval),
dat->cr->date_conv,
workbook_date_conv (dst_sheet->workbook));
newval = value_new_float (fnew);
value_set_fmt (newval, VALUE_FMT (oldval));
}
}
if (!newval)
newval = value_dup (src->val);
gnm_cell_set_value (dst, newval);
}
}
}
static GnmExprTop const *
expr_new_from_formula (const psiconv_sheet_cell psi_cell,
const psiconv_formula_list psi_formulas)
{
psiconv_formula formula = psiconv_get_formula (psi_formulas, psi_cell->ref_formula);
if (NULL != formula) {
GnmExpr const *expr = parse_subexpr (formula);
if (NULL != expr)
return gnm_expr_top_new (expr);
}
return NULL;
}
/* NOTE : Make sure to set up any merged regions in the target range BEFORE
* this is called.
*/
static void
paste_link (GnmPasteTarget const *pt, int top, int left,
GnmCellRegion const *cr)
{
GnmCellPos pos;
GnmCellRef source_cell_ref;
int x, y;
/* Not possible to link to arbitrary (non gnumeric) sources yet. */
/* TODO : eventually support interprocess gnumeric links */
if (cr->origin_sheet == NULL)
return;
/* TODO : support relative links ? */
source_cell_ref.col_relative = 0;
source_cell_ref.row_relative = 0;
source_cell_ref.sheet = (cr->origin_sheet != pt->sheet)
? cr->origin_sheet : NULL;
pos.col = left;
for (x = 0 ; x < cr->cols ; x++, pos.col++) {
source_cell_ref.col = cr->base.col + x;
pos.row = top;
for (y = 0 ; y < cr->rows ; y++, pos.row++) {
GnmExprTop const *texpr;
GnmCell *cell =
sheet_cell_fetch (pt->sheet, pos.col, pos.row);
/* This could easily be made smarter */
if (!gnm_cell_is_merged (cell) &&
gnm_sheet_merge_contains_pos (pt->sheet, &pos))
continue;
source_cell_ref.row = cr->base.row + y;
texpr = gnm_expr_top_new (gnm_expr_new_cellref (&source_cell_ref));
gnm_cell_set_expr (cell, texpr);
gnm_expr_top_unref (texpr);
}
}
}
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;
}
/**
* gnm_validation_eval:
* @wbc:
* @mstyle:
* @sheet:
*
* validation set in the GnmStyle if applicable.
**/
ValidationStatus
gnm_validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
Sheet *sheet, GnmCellPos const *pos, gboolean *showed_dialog)
{
GnmValidation const *v;
GnmCell *cell;
GnmValue *val;
gnm_float x;
int nok, i;
GnmEvalPos ep;
if (showed_dialog) *showed_dialog = FALSE;
v = gnm_style_get_validation (mstyle);
if (v == NULL)
return GNM_VALIDATION_STATUS_VALID;
if (v->type == GNM_VALIDATION_TYPE_ANY)
return GNM_VALIDATION_STATUS_VALID;
cell = sheet_cell_get (sheet, pos->col, pos->row);
if (cell != NULL)
gnm_cell_eval (cell);
if (gnm_cell_is_empty (cell)) {
if (v->allow_blank)
return GNM_VALIDATION_STATUS_VALID;
BARF (g_strdup_printf (_("Cell %s is not permitted to be blank"),
cell_name (cell)));
}
val = cell->value;
switch (val->type) {
case VALUE_ERROR:
if (typeinfo[v->type].errors_not_allowed)
BARF (g_strdup_printf (_("Cell %s is not permitted to contain error values"),
cell_name (cell)));
break;
case VALUE_BOOLEAN:
if (typeinfo[v->type].bool_always_ok)
return GNM_VALIDATION_STATUS_VALID;
break;
case VALUE_STRING:
if (typeinfo[v->type].strings_not_allowed)
BARF (g_strdup_printf (_("Cell %s is not permitted to contain strings"),
cell_name (cell)));
break;
default:
break;
}
eval_pos_init_cell (&ep, cell);
switch (v->type) {
case GNM_VALIDATION_TYPE_AS_INT:
x = value_get_as_float (val);
if (gnm_fake_floor (x) == gnm_fake_ceil (x))
break;
else
BARF (g_strdup_printf (_("'%s' is not an integer"),
value_peek_string (val)));
case GNM_VALIDATION_TYPE_AS_NUMBER:
x = value_get_as_float (val);
break;
case GNM_VALIDATION_TYPE_AS_DATE: /* What the hell does this do? */
x = value_get_as_float (val);
if (x < 0)
BARF (g_strdup_printf (_("'%s' is not a valid date"),
value_peek_string (val)));
break;
case GNM_VALIDATION_TYPE_AS_TIME: /* What the hell does this do? */
x = value_get_as_float (val);
break;
case GNM_VALIDATION_TYPE_IN_LIST: {
GnmExprTop const *texpr = v->deps[0].texpr;
if (texpr) {
GnmValue *list = gnm_expr_top_eval
(texpr, &ep,
GNM_EXPR_EVAL_PERMIT_NON_SCALAR | GNM_EXPR_EVAL_PERMIT_EMPTY);
GnmValue *res = value_area_foreach (list, &ep, CELL_ITER_IGNORE_BLANK,
(GnmValueIterFunc) cb_validate_custom, val);
value_release (list);
if (res == NULL) {
GnmParsePos pp;
char *expr_str = gnm_expr_top_as_string
(texpr,
parse_pos_init_evalpos (&pp, &ep),
ep.sheet->convs);
char *msg = g_strdup_printf (_("%s does not contain the new value."), expr_str);
g_free (expr_str);
BARF (msg);
}
}
return GNM_VALIDATION_STATUS_VALID;
}
case GNM_VALIDATION_TYPE_TEXT_LENGTH:
/* XL appears to use a very basic value->string mapping that
* ignores formatting.
* eg len (12/13/01) == len (37238) = 5
* This seems wrong for
*/
x = g_utf8_strlen (value_peek_string (val), -1);
break;
case GNM_VALIDATION_TYPE_CUSTOM: {
gboolean valid;
GnmExprTop const *texpr = v->deps[0].texpr;
if (!texpr)
return GNM_VALIDATION_STATUS_VALID;
val = gnm_expr_top_eval (texpr, &ep, GNM_EXPR_EVAL_SCALAR_NON_EMPTY);
valid = value_get_as_bool (val, NULL);
value_release (val);
if (valid)
return GNM_VALIDATION_STATUS_VALID;
else {
GnmParsePos pp;
char *expr_str = gnm_expr_top_as_string
(texpr,
parse_pos_init_evalpos (&pp, &ep),
ep.sheet->convs);
char *msg = g_strdup_printf (_("%s is not true."), expr_str);
g_free (expr_str);
BARF (msg);
}
}
default:
g_assert_not_reached ();
return GNM_VALIDATION_STATUS_VALID;
}
if (v->op == GNM_VALIDATION_OP_NONE)
return GNM_VALIDATION_STATUS_VALID;
nok = 0;
for (i = 0; i < opinfo[v->op].nops; i++) {
GnmExprTop const *texpr_i = v->deps[i].texpr;
GnmExprTop const *texpr;
GnmValue *cres;
if (!texpr_i) {
nok++;
continue;
}
texpr = gnm_expr_top_new
(gnm_expr_new_binary
(gnm_expr_new_constant (value_new_float (x)),
opinfo[v->op].ops[i],
gnm_expr_copy (texpr_i->expr)));
cres = gnm_expr_top_eval
(texpr, &ep, GNM_EXPR_EVAL_SCALAR_NON_EMPTY);
if (value_get_as_bool (cres, NULL))
nok++;
value_release (cres);
gnm_expr_top_unref (texpr);
}
if (nok < opinfo[v->op].ntrue)
BARF (g_strdup_printf (_("%s is out of permitted range"),
value_peek_string (val)));
return GNM_VALIDATION_STATUS_VALID;
}
