/**
* dialog_goal_seek:
* @wbcg:
* @sheet:
*
* Create the dialog (guru).
*
**/
void
dialog_goal_seek (WBCGtk *wbcg, Sheet *sheet)
{
GoalSeekState *state;
GladeXML *gui;
g_return_if_fail (IS_SHEET (sheet));
/* Testing hook. */
if (wbcg == NULL) {
GnmRangeRef *range =
g_object_get_data (G_OBJECT (sheet), "ssconvert-goal-seek");
if (range) {
Sheet *start_sheet, *end_sheet;
GnmEvalPos ep;
GnmRange r;
gnm_rangeref_normalize (range,
eval_pos_init_sheet (&ep, sheet),
&start_sheet, &end_sheet,
&r);
g_return_if_fail (start_sheet == sheet);
dialog_goal_seek_test (sheet, &r);
return;
}
}
g_return_if_fail (wbcg != NULL);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, GOALSEEK_KEY))
return;
gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg),
"goalseek.glade", NULL, NULL);
if (gui == NULL)
return;
state = g_new (GoalSeekState, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg));
state->sheet = sheet;
state->gui = gui;
state->warning_dialog = NULL;
state->cancelled = TRUE;
if (dialog_init (state)) {
go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR,
_("Could not create the Goal-Seek dialog."));
g_free (state);
return;
}
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
GOALSEEK_KEY);
gtk_widget_show (state->dialog);
}
/**
* value_area_foreach:
* @v: const #GnmValue
* @ep: const #GnmEvalPos
* @flags: #CellIterFlags
* @func: (scope call): #GnmValueIterFunc
* @user_data:
*
* For each existing element in an array or range , invoke the
* callback routine.
*
* Returns: (transfer none):
* non-NULL on error, or VALUE_TERMINATE if some invoked routine requested
* to stop (by returning non-NULL).
**/
GnmValue *
value_area_foreach (GnmValue const *v, GnmEvalPos const *ep,
CellIterFlags flags,
GnmValueIterFunc func,
gpointer user_data)
{
GnmValueIter v_iter;
GnmValue *tmp;
g_return_val_if_fail (func != NULL, NULL);
if (VALUE_IS_CELLRANGE (v)) {
WrapperClosure wrap;
GnmRange r;
Sheet *start_sheet, *end_sheet;
gnm_rangeref_normalize (&v->v_range.cell, ep, &start_sheet, &end_sheet, &r);
wrap.v_iter.ep = ep;
wrap.v_iter.region = v;
wrap.func = func;
wrap.user_data = user_data;
wrap.base_col = r.start.col;
wrap.base_row = r.start.row;
return workbook_foreach_cell_in_range (ep, v, flags,
(CellIterFunc) cb_wrapper_foreach_cell_in_area, &wrap);
}
v_iter.ep = ep;
v_iter.region = v;
v_iter.cell_iter = NULL;
/* If not an array, apply func to singleton */
if (!VALUE_IS_ARRAY (v)) {
v_iter.x = v_iter.y = 0;
v_iter.v = v;
return (*func) (&v_iter, user_data);
}
for (v_iter.x = v->v_array.x; v_iter.x-- > 0;)
for (v_iter.y = v->v_array.y; v_iter.y-- > 0;) {
v_iter.v = v->v_array.vals [v_iter.x][v_iter.y];
if ((tmp = (*func)(&v_iter, user_data)) != NULL)
return tmp;
}
return NULL;
}
int
value_area_get_width (GnmValue const *v, GnmEvalPos const *ep)
{
g_return_val_if_fail (v, 0);
if (VALUE_IS_CELLRANGE (v)) {
GnmRange r;
Sheet *start_sheet, *end_sheet;
g_return_val_if_fail (ep, 0);
gnm_rangeref_normalize (&v->v_range.cell, ep, &start_sheet, &end_sheet, &r);
return range_width (&r);
} else if (VALUE_IS_ARRAY (v))
return v->v_array.x;
return 1;
}
/**
* stf_export_sheet:
* @stfe: an export options struct
* @sheet: the sheet to export
*
* Writes the @sheet to the callback function
*
* Return value: returns TRUE on success, FALSE otherwise
**/
static gboolean
stf_export_sheet (GnmStfExport *stfe, Sheet *sheet)
{
int col, row;
GnmRange r;
GnmRangeRef *range;
g_return_val_if_fail (stfe != NULL, FALSE);
g_return_val_if_fail (IS_SHEET (sheet), FALSE);
range = g_object_get_data (G_OBJECT (sheet->workbook), "ssconvert-range");
if (range) {
Sheet *start_sheet, *end_sheet;
GnmEvalPos ep;
gnm_rangeref_normalize (range,
eval_pos_init_sheet (&ep, sheet),
&start_sheet, &end_sheet,
&r);
if (start_sheet != sheet)
return TRUE;
} else
r = sheet_get_extent (sheet, FALSE, TRUE);
for (row = r.start.row; row <= r.end.row; row++) {
for (col = r.start.col; col <= r.end.col; col++) {
GnmCell *cell = sheet_cell_get (sheet, col, row);
if (!stf_export_cell (stfe, cell))
return FALSE;
}
if (!gsf_output_csv_write_eol (GSF_OUTPUT_CSV (stfe)))
return FALSE;
}
return TRUE;
}
static GnmValue *
get_single_cache_key_from_value (GnmValue const *r, GnmEvalPos const *ep)
{
GnmValue *key;
GnmSheetRange sr;
GnmRangeRef const *rr;
Sheet *end_sheet;
int h, w;
const int min_size = 25;
rr = value_get_rangeref (r);
gnm_rangeref_normalize (rr, ep, &sr.sheet, &end_sheet, &sr.range);
if (sr.sheet != end_sheet)
return NULL; /* 3D */
h = range_height (&sr.range);
w = range_width (&sr.range);
if (h < min_size && w < min_size && h * w < min_size)
return NULL;
key = value_new_cellrange_r (sr.sheet, &sr.range);
return key;
}
static void
copy_construct_xloper_from_gnm_value (XLOPER*out, const GnmValue*in,
GnmFuncEvalInfo *ei)
{
g_return_if_fail (NULL != out);
out->xltype = xltypeMissing;
out->val.num = 0;
if (NULL != in) {
switch (in->type) {
case VALUE_EMPTY:
out->xltype = xltypeNil;
break;
case VALUE_BOOLEAN:
out->xltype = xltypeBool;
out->val.boolean = (WORD)in->v_bool.val;
break;
case VALUE_FLOAT:
out->xltype = xltypeNum;
out->val.num = in->v_float.val;
break;
case VALUE_ERROR:
out->xltype = xltypeErr;
out->val.err = xloper_error_code_from_gnm_value (in);
break;
case VALUE_STRING:
out->xltype = xltypeStr;
out->val.str = pascal_string_from_c_string (in->v_str.val->str);
break;
case VALUE_CELLRANGE: {
GnmSheetRange sr;
GnmRangeRef const *rr = value_get_rangeref (in);
Sheet *end_sheet = NULL;
GnmValue *cell_value;
GnmCell *cell;
gnm_rangeref_normalize (rr, ei->pos, &sr.sheet, &end_sheet, &sr.range);
if (sr.sheet != end_sheet) {
/* We don't attempt to flatten a 3D range to an array. */
g_warning (_("Cannot convert 3D cell range to XLOPER."));
} else {
int m = sr.range.end.col-sr.range.start.col+1;
int n = sr.range.end.row-sr.range.start.row+1;
int i, j;
out->xltype = xltypeMulti;
out->val.array.lparray = ALLOC_ARRAY (XLOPER,m*n);
out->val.array.columns = m;
out->val.array.rows = n;
for (i = 0; i < m; ++i) {
for (j = 0;j<n; ++j) {
cell = sheet_cell_get (sr.sheet,sr.range.start.col+i,sr.range.start.row+j);
cell_value = NULL;
if (NULL != cell) {
gnm_cell_eval (cell);
cell_value=cell->value;
}
copy_construct_xloper_from_gnm_value (out->val.array.lparray+i+j*m,cell_value,ei);
}
}
}
break;
}
case VALUE_ARRAY: {
int m = in->v_array.x;
int n = in->v_array.y;
int i, j;
out->xltype = xltypeMulti;
out->val.array.lparray = ALLOC_ARRAY (XLOPER,m*n);
out->val.array.columns = m;
out->val.array.rows = n;
for (i = 0; i < m; ++i) {
for (j = 0;j < n; ++j) {
copy_construct_xloper_from_gnm_value (out->val.array.lparray+i+j*m,in->v_array.vals[i][j],ei);
}
}
break;
}
default:;
g_warning (_("Unsupported GnmValue type (%d)"),in->type);
}
}
}
