void show_stats_t(int y, int x, char *header, stats_t *data, char abbreviate) { if (data -> valid) { char *cur_str = format_value(data -> cur, 6, 2, abbreviate); char *min_str = format_value(data -> min, 6, 2, abbreviate); char *avg_str = format_value(data -> avg / (double)data -> n, 6, 2, abbreviate); char *max_str = format_value(data -> max, 6, 2, abbreviate); char *sd_str = format_value(calc_sd(data), 6, 2, abbreviate); myprintloc(w_stats, y, x, "%s: %s %s %s %s %s", header, data -> cur_valid ? cur_str : gettext(" n/a"), min_str, avg_str, max_str, sd_str); free(sd_str); free(max_str); free(avg_str); free(min_str); free(cur_str); } else { myprintloc(w_stats, y, x, gettext("%s: n/a"), header); } }
static char const * xlsx_write_pivot_cache_definition (XLSXWriteState *state, GsfOutfile *wb_part, GODataCache const *cache, unsigned int cache_def_num) { GsfXMLOut *xml; int i, n; char const *record_id; char *name = g_strdup_printf ("pivotCacheDefinition%u.xml", cache_def_num); GsfOutput *cache_def_part = gsf_outfile_new_child_full (state->pivotCache.dir, name, FALSE, "content-type", "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml", NULL); char const *cache_def_id = gsf_outfile_open_pkg_relate (GSF_OUTFILE_OPEN_PKG (cache_def_part), GSF_OUTFILE_OPEN_PKG (wb_part), "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition"); record_id = xlsx_write_pivot_cache_records (state, cache, cache_def_part, cache_def_num); xml = gsf_xml_out_new (cache_def_part); gsf_xml_out_start_element (xml, "pivotCacheDefinition"); gsf_xml_out_add_cstr_unchecked (xml, "xmlns", ns_ss); gsf_xml_out_add_cstr_unchecked (xml, "xmlns:r", ns_rel); gsf_xml_out_add_cstr (xml, "r:id", record_id); if (cache->refreshed_by) gsf_xml_out_add_cstr (xml, "refreshedBy", cache->refreshed_by); if (cache->refreshed_on) { if (state->version == ECMA_376_2006) gsf_xml_out_add_float (xml, "refreshedDate", go_val_as_float (cache->refreshed_on), -1); else { GOFormat const *format = go_format_new_from_XL ("yyyy-mm-dd\"T\"hh:mm:ss"); gchar *date = format_value (format, cache->refreshed_on, NULL, -1, NULL); gsf_xml_out_add_cstr_unchecked (xml, "refreshedDateIso", date); g_free (date); go_format_unref (format); } } gsf_xml_out_add_int (xml, "createdVersion", cache->XL_created_ver); gsf_xml_out_add_int (xml, "refreshedVersion", cache->XL_refresh_ver); gsf_xml_out_add_uint (xml, "recordCount", go_data_cache_num_items (cache)); xlsx_add_bool (xml, "upgradeOnRefresh", cache->refresh_upgrades); xlsx_write_pivot_cache_source (state, xml, cache); gsf_xml_out_start_element (xml, "cacheFields"); n = go_data_cache_num_fields (cache); gsf_xml_out_add_uint (xml, "count", n); for (i = 0 ; i < n ; i++) xlsx_write_pivot_cache_field (state, xml, go_data_cache_get_field (cache, i)); gsf_xml_out_end_element (xml); /* </cacheFields> */ gsf_xml_out_end_element (xml); /* </pivotCacheDefinition> */ g_object_unref (xml); gsf_output_close (cache_def_part); g_object_unref (cache_def_part); g_free (name); return cache_def_id; }
static GnmValue * cb_collect_unique (GnmValueIter const *iter, UniqueCollection *uc) { GOFormat const *fmt = (NULL != iter->cell_iter) ? gnm_cell_get_format (iter->cell_iter->cell) : NULL; g_hash_table_replace (uc->hash, value_dup (iter->v), format_value (fmt, iter->v, -1, uc->date_conv)); return NULL; }
static void xlsx_write_date (XLSXWriteState *state, GsfXMLOut *xml, char const *id, gnm_float v) { GOVal *tmp = go_val_new_float (v); char *d = format_value (state->date_fmt, tmp, NULL, -1, workbook_date_conv (state->base.wb)); gsf_xml_out_add_cstr_unchecked (xml, id, d); g_free (d); go_val_free (tmp); }
static char * try_auto_date (GnmValue *value, const GOFormat *format, GODateConventions const *date_conv) { gnm_float v, vr, vs; GOFormat *actual; char *res; gboolean needs_date, needs_time, needs_frac_sec; gboolean is_date; int is_time; GString *xlfmt; GDate date; format = gnm_format_specialize (format, value); is_date = go_format_is_date (format) > 0; is_time = go_format_is_time (format); if (!is_date && is_time <= 0) return NULL; /* We don't want to coerce strings. */ if (!VALUE_IS_FLOAT (value)) return NULL; /* Verify that the date is valid. */ if (!datetime_value_to_g (&date, value, date_conv)) return NULL; v = value_get_as_float (value); vr = gnm_fake_round (v); vs = (24 * 60 * 60) * gnm_abs (v - vr); needs_date = is_time < 2 && (is_date || gnm_abs (v) >= 1); needs_time = is_time > 0 || gnm_abs (v - vr) > 1e-9; needs_frac_sec = needs_time && gnm_abs (vs - gnm_fake_round (vs)) >= 0.5e-3; xlfmt = g_string_new (NULL); if (needs_date) g_string_append (xlfmt, "yyyy/mm/dd"); if (needs_time) { if (needs_date) g_string_append_c (xlfmt, ' '); if (is_time == 2) g_string_append (xlfmt, "[h]:mm:ss"); else g_string_append (xlfmt, "hh:mm:ss"); if (needs_frac_sec) g_string_append (xlfmt, ".000"); } actual = go_format_new_from_XL (xlfmt->str); g_string_free (xlfmt, TRUE); res = format_value (actual, value, -1, date_conv); go_format_unref (actual); return res; }
/* * write_row: * * @output: the stream * @sheet: the gnumeric sheet * @row: the row number * */ static void write_row (GsfOutput *output, Sheet *sheet, gint row, GnmRange *range) { char const *text = NULL; char *formatted_string = NULL; GnmCell *cell; GnmStyle const *style; GODateConventions const *date_conv = sheet->workbook ? workbook_date_conv (sheet->workbook) : NULL; gint col; for (col = range->start.col; col <= range->end.col; col++) { GnmRange const *merge_range; GnmCellPos pos; pos.col = col; pos.row = row; merge_range = gnm_sheet_merge_contains_pos (sheet, &pos); if (merge_range != NULL) { /* If cell is inside a merged region, we use the corner cell of the merged region: */ cell = sheet_cell_get (sheet, merge_range->start.col, merge_range->start.row); } else { cell = sheet_cell_get (sheet, col, row); } if (cell != NULL && cell->value) { text = value_peek_string (cell->value); pwcsv_print_encoded (output, text); style = sheet_style_get (sheet, col, row); GOFormat const *format = gnm_style_get_format (style); // set col_width to 16-something. This works around gnumeric quirk // where, in wider cells, it formats 9,3 as 9,300000000000001 formatted_string = format_value (format, cell->value, 16, date_conv); pwcsv_print_encoded (output, formatted_string); html_write_cell_content (output, cell, style, formatted_string); g_free (formatted_string); /* Without this, we're accumulating lots of heap memory on big spreadsheets. */ gnm_cell_unrender(cell); } else { gsf_output_puts (output, ",,,"); } } gsf_output_puts (output, "\n"); }
EnumMapper::EnumMapper(const EnumAssoc* m, bool ignore_case) { if (!m) return; while (m->name) { std::string name = m->name; if (!val2name.insert(std::pair<int, std::string>(m->value, name)).second) throw std::runtime_error("Multiple names for value "+format_value(m->value)); if (!name2val.insert(std::pair<std::string, int>(ignore_case ? ascii_tolower(name) : name, m->value)).second) throw std::runtime_error("Multiple values for name '"+name+"'"); ++m; } }
static void compute_slider(Slider s, int *ny, int *vx, int *vy, int *lx, int *ly, int *sx, int *sy, int *hx, int *hy) { int hv = (s->show_value == ON ? valInt(getHeightFont(s->value_font)) : 0); int hl, hm; compute_label_slider(s, vx, &hl); hm = max(hl, max(hv, SLIDER_HEIGHT)); *ny = (hm - hl) / 2; *sy = (hm - SLIDER_HEIGHT) / 2; *vy = *ly = *hy = (hm - hv) / 2; if ( s->show_value == ON ) { int shw, slw, sh, cw = 4, tw; char buf[100]; string str; buf[0] = '['; format_value(s, &buf[1], s->high); strcat(buf, "]"); str_set_ascii(&str, buf); str_size(&str, s->value_font, &shw, &sh); format_value(s, buf, s->low); str_set_ascii(&str, buf); str_size(&str, s->value_font, &slw, &sh); if ( convert_value(s->low) < 0.0 && (tw = (c_width('-', s->value_font) + slw)) > shw ) shw = tw; *lx = *vx + shw + cw; *sx = *lx + slw + cw; *hx = *sx + valInt(s->width) + cw; } else { *lx = *sx = *vx; *hx = *sx + valInt(s->width); } }
/* * * DO * NOT * COMPILE * DIRECTLY * * DO * NOT * COMPILE * DIRECTLY * * DO * NOT * COMPILE * DIRECTLY * * * included via xlsx-write.c **/ static void xlsx_write_pivot_val (XLSXWriteState *state, GsfXMLOut *xml, GOVal const *v) { switch (v->type) { case VALUE_CELLRANGE: case VALUE_ARRAY: g_warning ("REMOVE THIS CODE WHEN WE MOVE TO GOFFICE"); break; case VALUE_EMPTY: gsf_xml_out_simple_element (xml, "m", NULL); break; case VALUE_BOOLEAN: gsf_xml_out_start_element (xml, "b"); xlsx_add_bool (xml, "v", v->v_bool.val); gsf_xml_out_end_element (xml); break; case VALUE_FLOAT: { GOFormat const *fmt = go_val_get_fmt (v); if (NULL != fmt && go_format_is_date (fmt)) { char *d = format_value (state->date_fmt, v, NULL, -1, workbook_date_conv (state->base.wb)); gsf_xml_out_start_element (xml, "d"); gsf_xml_out_add_cstr_unchecked (xml, "v", d); gsf_xml_out_end_element (xml); } else { gsf_xml_out_start_element (xml, "n"); gsf_xml_out_add_float (xml, "v", v->v_float.val, -1); gsf_xml_out_end_element (xml); } break; } case VALUE_ERROR : gsf_xml_out_start_element (xml, "e"); gsf_xml_out_add_cstr (xml, "v", v->v_err.mesg->str); gsf_xml_out_end_element (xml); break; case VALUE_STRING : gsf_xml_out_start_element (xml, "s"); gsf_xml_out_add_cstr (xml, "v", v->v_str.val->str); gsf_xml_out_end_element (xml); break; } }
static void print_rusage(struct kinfo_proc *kipp) { long *lp; unsigned int i; char *field, *threadid; print_prefix(kipp); xo_emit("{d:resource/%-14s} {d:usage/%29s}{P: }\n", "user time", format_time(&kipp->ki_rusage.ru_utime)); print_prefix(kipp); xo_emit("{d:resource/%-14s} {d:usage/%29s}{P: }\n", "system time", format_time(&kipp->ki_rusage.ru_stime)); if (Hflag) { asprintf(&threadid, "%d", kipp->ki_tid); if (threadid == NULL) xo_errc(1, ENOMEM, "Failed to allocate memory in print_rusage()"); xo_open_container(threadid); xo_emit("{e:thread_id/%d}", kipp->ki_tid); } else { xo_emit("{e:process_id/%d}", kipp->ki_pid); xo_emit("{e:command/%s}", kipp->ki_comm); } xo_emit("{e:user time/%s}", format_time(&kipp->ki_rusage.ru_utime)); xo_emit("{e:system time/%s}", format_time(&kipp->ki_rusage.ru_stime)); lp = &kipp->ki_rusage.ru_maxrss; for (i = 0; i < nitems(rusage_info); i++) { print_prefix(kipp); asprintf(&field, "{e:%s/%%D}", rusage_info[i].ri_name); if (field == NULL) xo_errc(1, ENOMEM, "Failed to allocate memory in print_rusage()"); xo_emit(field, *lp); free(field); xo_emit("{d:resource/%-32s} {d:usage/%14s}\n", rusage_info[i].ri_name, format_value(*lp, rusage_info[i].ri_humanize, rusage_info[i].ri_scale)); lp++; } if (Hflag) { xo_close_container(threadid); free(threadid); } }
static GnmValue * cb_collect_content (GnmCellIter const *iter, UniqueCollection *uc) { GnmCell const *cell = (iter->pp.sheet == uc->src_sheet) ? iter->cell : sheet_cell_get (uc->src_sheet, iter->pp.eval.col, iter->pp.eval.row); if (gnm_cell_is_blank (cell)) uc->has_blank = TRUE; else { GOFormat const *fmt = gnm_cell_get_format (cell); GnmValue const *v = cell->value; g_hash_table_replace (uc->hash, value_dup (v), format_value (fmt, v, -1, uc->date_conv)); } return NULL; }
static char * try_auto_float (GnmValue *value, const GOFormat *format, GODateConventions const *date_conv) { gboolean is_date; int is_time; if (!VALUE_IS_FLOAT (value)) return NULL; format = gnm_format_specialize (format, value); is_date = go_format_is_date (format) > 0; is_time = go_format_is_time (format); if (is_date || is_time > 0) return NULL; return format_value (go_format_general (), value, -1, date_conv); }
int main(int argc, char *argv[]) { char *typearg; char *valarg; struct t_value value; int type = -1; int i; if (argc < 3) { fprintf(stderr, "Usage: format_value TYPE VALUE\n"); exit(2); } typearg = argv[1]; for (i=0; i < value_types_len; i++) { if (strcmp(typearg, value_types[i]) == 0) { type = i; break; } } if (type < 0) { fprintf(stderr, "Unknown type: %s\n", typearg); exit(2); } valarg = argv[2]; value_init(&value, type); if (type == VAL_INT) { value.intval = atoi(valarg); } else if (type == VAL_STRING) { value.stringval = valarg; value.len = strlen(valarg); } else { fprintf(stderr, "format_value does not support VAL_%s\n", typearg); exit(2); } printf("value: %s\n", format_value(&value)); exit(0); }
/* * Figure out whether the format engine in goffice allows negative values * or (as XL) considers them errors. */ gboolean gnm_datetime_allow_negative (void) { static int allow = -1; if (allow == -1) { GOFormat *fmt = go_format_new_from_XL ("yyyy-mm-dd"); GnmValue *v = value_new_int (-42); GODateConventions const *conv = go_date_conv_from_str ("Lotus:1900"); char *text = format_value (fmt, v, NULL, -1, conv); allow = (strcmp (text, "1899-11-19") == 0); value_release (v); go_format_unref (fmt); g_free (text); } return (gboolean)allow; }
static void print_rusage(struct kinfo_proc *kipp) { long *lp; unsigned int i; print_prefix(kipp); printf("%-14s %32s\n", "user time", format_time(&kipp->ki_rusage.ru_utime)); print_prefix(kipp); printf("%-14s %32s\n", "system time", format_time(&kipp->ki_rusage.ru_stime)); lp = &kipp->ki_rusage.ru_maxrss; for (i = 0; i < nitems(rusage_info); i++) { print_prefix(kipp); printf("%-32s %14s\n", rusage_info[i].ri_name, format_value(*lp, rusage_info[i].ri_humanize, rusage_info[i].ri_scale)); lp++; } }
static GnmValue * cb_get_content (GnmCellIter const *iter, GsfOutput *buf) { GnmCell *cell; if (NULL != (cell = iter->cell)) { char *tmp; if (gnm_cell_has_expr (cell)) tmp = gnm_expr_top_as_string (cell->base.texpr, &iter->pp, iter->pp.sheet->convs); else if (VALUE_FMT (cell->value) != NULL) tmp = format_value (NULL, cell->value, -1, workbook_date_conv (iter->pp.wb)); else tmp = value_get_as_string (cell->value); gsf_output_write (buf, strlen (tmp), tmp); g_free (tmp); } gsf_output_write (buf, 1, "\n"); return NULL; }
GString * format_ipv (guint id, guint pos, guint val) { GString *buf = g_string_sized_new(1); GString *vec_buf = g_string_sized_new(1); XmlSettings *xml = get_xml_settings(id, pos); GString *val_buf; if (!xml) { g_warning("Failed to find xml settings for position %d id %d.", id, pos); g_string_printf(buf, "%s", "error"); return buf; } val_buf = format_value(xml, val); g_string_printf(vec_buf, "(%d, %d, %d)", pos, id, val); g_string_printf(buf, "%-16s %s: %s: %s", vec_buf->str, get_position(pos), xml->label, val_buf->str); g_string_free(vec_buf, TRUE); g_string_free(val_buf, TRUE); return buf; }
/** * cb_dialog_apply_clicked: * @button: * @state: * * Close (destroy) the dialog **/ static void cb_dialog_apply_clicked (G_GNUC_UNUSED GtkWidget *button, GoalSeekState *state) { char *status_str; GoalSeekStatus status; GnmValue *target; GnmRangeRef const *r; GOFormat *format; if (state->warning_dialog != NULL) gtk_widget_destroy (state->warning_dialog); /* set up source */ target = gnm_expr_entry_parse_as_value (state->set_cell_entry, state->sheet); if (target == NULL) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("You should introduce a valid cell " "name in 'Set Cell:'!")); gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE); return; } r = &target->v_range.cell; state->set_cell = sheet_cell_get (r->a.sheet, r->a.col, r->a.row); value_release (target); if (state->set_cell == NULL || !gnm_cell_has_expr (state->set_cell)) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The cell named in 'Set Cell:' " "must contain a formula!")); gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE); return; } /* set up source */ target = gnm_expr_entry_parse_as_value (state->change_cell_entry, state->sheet); if (target == NULL) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("You should introduce a valid cell " "name in 'By Changing Cell:'!")); gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE); return; } r = &target->v_range.cell; state->change_cell = sheet_cell_fetch (r->a.sheet, r->a.col, r->a.row); value_release (target); if (gnm_cell_has_expr (state->change_cell)) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The cell named in 'By changing cell' " "must not contain a formula.")); gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE); return; } format = gnm_style_get_format (gnm_cell_get_style (state->set_cell)); if (entry_to_float_with_format (GTK_ENTRY(state->to_value_entry), &state->target_value, TRUE, format)){ go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, _("The value given in 'To Value:' " "is not valid.")); focus_on_entry (GTK_ENTRY(state->to_value_entry)); return; } format = gnm_style_get_format (gnm_cell_get_style (state->change_cell)); if (entry_to_float_with_format (GTK_ENTRY(state->at_least_entry), &state->xmin, TRUE, format)) { state->xmin = -max_range_val; gtk_entry_set_text (GTK_ENTRY (state->at_least_entry), ""); } if (entry_to_float_with_format (GTK_ENTRY(state->at_most_entry), &state->xmax, TRUE, format)) { state->xmax = +max_range_val; gtk_entry_set_text (GTK_ENTRY (state->at_most_entry), ""); } if ((state->old_cell != NULL) && (state->old_value != NULL)) { sheet_cell_set_value (state->old_cell, state->old_value); workbook_recalc (state->wb); state->old_value = NULL; } state->old_cell = state->change_cell; state->old_value = value_dup (state->change_cell->value); status = gnumeric_goal_seek (state); switch (status) { case GOAL_SEEK_OK: { const char *actual_str; const char *solution_str; GOFormat *format = go_format_general (); GnmValue *error_value = value_new_float (state->target_value - value_get_as_float (state->set_cell->value)); char *target_str = format_value (format, error_value, NULL, -1, workbook_date_conv (state->wb)); gtk_label_set_text (GTK_LABEL (state->target_value_label), target_str); g_free (target_str); value_release (error_value); status_str = g_strdup_printf (_("Goal seeking with cell %s found a solution."), cell_name (state->set_cell)); gtk_label_set_text (GTK_LABEL (state->result_label), status_str); g_free (status_str); /* FIXME? Do a format? */ actual_str = state->set_cell->value ? value_peek_string (state->set_cell->value) : ""; gtk_label_set_text (GTK_LABEL (state->current_value_label), actual_str); solution_str = state->change_cell->value ? value_peek_string (state->change_cell->value) : ""; gtk_label_set_text (GTK_LABEL (state->solution_label), solution_str); break; } default: status_str = g_strdup_printf (_("Goal seeking with cell %s did not find a solution."), cell_name (state->set_cell)); gtk_label_set_text (GTK_LABEL (state->result_label), status_str); g_free (status_str); gtk_label_set_text (GTK_LABEL (state->current_value_label), ""); gtk_label_set_text (GTK_LABEL (state->solution_label), ""); gtk_label_set_text (GTK_LABEL (state->target_value_label), ""); break; } state->cancelled = FALSE; gtk_widget_show (state->result_table); return; }
struct t_value * exec_i_fcall(struct t_exec *exec, struct t_icode *fcall) { struct list a, args; int i; struct t_value *ret = &nullvalue; struct t_func * func; struct t_value *opnd; struct item *item; int current_addr; int offset; debug(3, "%s(): Stack size at line %d: %d\n", __FUNCTION__, __LINE__, exec->stack.size); debug(3, "%s(): Top of stack at line %d: %s\n", __FUNCTION__, __LINE__, format_value(list_last(&exec->stack))); func = exec_funcbyname(exec, fcall->operand->name); if (!func) { fprintf(stderr, "Error: Function %s() is not defined, on Line %d.\n", fcall->operand->name, fcall->token->row+1); return NULL; } /* Prepare the arguments */ list_init(&a); list_init(&args); for (i=0; i < fcall->operand->argc; i++) { list_push(&a, list_pop(&exec->stack)); } for (i=0; i < fcall->operand->argc; i++) { list_push(&args, list_pop(&a)); } if (func->invoke) { DBG(2, "Calling C function"); ret = calloc(1, sizeof(struct t_value)); list_push(&exec->values, ret); if (func->invoke(func, &args, ret) < 0) { fprintf(stderr, "(TODO) Error in native function: %s()\n", func->name); return NULL; } list_push(&exec->stack, ret); } else { DBG(2, "Calling local function"); // Calculate the offset offset = 0; item = exec->parser.output.first; printf("func start: %d\n", func->start); current_addr = 0; while (item != exec->current) { item = item->next; current_addr++; if (item == exec->current) { printf("Found current\n"); } } offset = (func->start + 1) - current_addr; opnd = create_num_from_int(offset); list_push(&exec->stack, opnd); exec_i_jst(exec, NULL); } return ret; }
string format_value(const DistributedType *dtype, const string &packed) { ostringstream ss; format_value(dtype, packed, ss); return ss.str(); }
void base_node_state::on_list(clsm::ev_cmd< list_cmd > const& cmd) { auto const& editor = context< paramtree_editor >(); auto acc = editor.acc; qualified_path path; param_tree::param_data pd; if(cmd.nav) { path = nav_cmd_path(*cmd.nav); if(!path) { return;// todo: false; } pd = acc.find_param(path); } else { path = acc.where(); pd = acc.param_here(); } auto node = acc.node_at(path); unsigned int depth = 0; unsigned int max_depth = cmd.depth ? cmd.depth->value : 1u; unsigned int indent = 0; auto pre_op = [&](param_tree::tree_t::node_descriptor n) { if(depth <= max_depth) { auto& pt = editor.ptree; auto& tree = pt.tree(); std::stringstream output; for(unsigned int i = 0; i < indent; ++i) { output << " "; } auto sibling_idx = tree.position_in_siblings(n); if(depth == 1) { // Index immediate children output << (sibling_idx + 1) << ". "; indent += 3; } output << tree[n].name; auto in = tree.in_edge(n).first; if(tree[in].repeat_idx) { output << " /" << (sibling_idx + 1); } output << ": "; if(is_leaf_type(tree[n].type)) { output << format_value(*tree[n].value); } if(cmd.type_info) { output << " "; output << format_type_info(tree[n]); output << " "; auto path = pt.node_qpath(n); auto acc_copy = acc; acc_copy.move_to(path); output << format_constraints((*editor.provider)[path.unindexed()](acc_copy)); } editor.output(output.str()); } ++depth; indent += 2; }; auto post_op = [&](param_tree::tree_t::node_descriptor n) { --depth; indent -= 2; if(depth == 1) { indent -= 3; } }; wb::gtree::depth_first_traversal( editor.ptree.tree(), node, pre_op, wb::gtree::null_op{}, post_op ); }
static void format_northing(double north, char *buf, int projection) { format_value(G_format_northing, north, buf, projection); }
void update_stats(stats_t *resolve, stats_t *connect, stats_t *request, stats_t *total, stats_t *ssl_setup, int n_ok, int n_fail, const char *last_connect_str, const char *fp, char use_tfo, char dg, stats_t *st_to, stats_t *tcp_rtt_stats, int re_tx, int pmtu, int tos, stats_t *close_st, stats_t *t_write, int n_cookies, char abbreviate, stats_t *stats_header_size) { double k = 0.0; char force_redraw = 0; struct pollfd p = { 0, POLLIN, 0 }; werase(w_stats); if (n_ok) { char buffer[4096] = { 0 }, *scc_str = NULL, *kalman_str = NULL; int buflen = 0; myprintloc(w_stats, 0, 0, " %6s %6s %6s %6s %6s", gettext("latest"), gettext("min"), gettext("avg"), gettext("max"), gettext("sd")); show_stats_t(1, 0, gettext("resolve"), resolve, abbreviate); show_stats_t(2, 0, gettext("connect"), connect, abbreviate); show_stats_t(3, 0, gettext("ssl "), ssl_setup, abbreviate); show_stats_t(4, 0, gettext("send "), t_write, abbreviate); show_stats_t(5, 0, gettext("request"), request, abbreviate); show_stats_t(6, 0, gettext("close "), close_st, abbreviate); show_stats_t(7, 0, gettext("total "), total, abbreviate); scc_str = format_value(get_cur_scc(), 5, 3, abbreviate); kalman_str = format_value(kalman_do(total -> cur), 5, 3, abbreviate); myprintloc(w_stats, 8, 0, gettext("ok: %3d, fail: %3d%s, scc: %s, kalman: %s"), n_ok, n_fail, use_tfo ? gettext(", with TFO") : "", scc_str, kalman_str); free(kalman_str); free(scc_str); if (max_x >= 44 * 2 + 1) { double trend = calc_trend(); char trend_dir = ' '; myprintloc(w_stats, 0, 45, " %6s %6s %6s %6s %6s", gettext("cur"), gettext("min"), gettext("avg"), gettext("max"), gettext("sd")); show_stats_t(1, 45, gettext("t offst"), st_to, abbreviate); #if defined(linux) || defined(__FreeBSD__) show_stats_t(2, 45, gettext("tcp rtt"), tcp_rtt_stats, abbreviate); #endif show_stats_t(3, 45, gettext("headers"), stats_header_size, abbreviate); if (trend < 0) trend_dir = '-'; else if (trend > 0) trend_dir = '+'; myprintloc(w_stats, 8, 48, gettext("# cookies: %d"), n_cookies); #ifdef linux myprintloc(w_stats, 9, 48, gettext("trend: %c%6.2f%%, re-tx: %2d, pmtu: %5d, TOS: %02x"), trend_dir, fabs(trend), re_tx, pmtu, tos); #else myprintloc(w_stats, 9, 48, gettext("trend: %c%6.2f%%, TOS: %02x"), trend_dir, fabs(trend), tos); #endif } buflen = snprintf(buffer, sizeof buffer, gettext("HTTP rc: %s, SSL fp: %s"), last_connect_str, fp ? fp : gettext("n/a")); if (buflen <= max_x) myprintloc(w_stats, 9, 0, "%s", buffer); else { static char prev_sf[48] = { 0 }; myprintloc(w_stats, 9, 0, gettext("http result code: %s"), last_connect_str); if (fp && strcmp(prev_sf, fp)) { slow_log(gettext("\nSSL fingerprint: %s"), fp); memcpy(prev_sf, fp, 47); } } } memmove(&history[1], &history[0], (history_n - 1) * sizeof(double)); memmove(&history_set[1], &history_set[0], (history_n - 1) * sizeof(char)); history[0]= total -> cur; history_set[0] = 1; if (poll(&p, 1, 0) == 1 && p.revents == POLLIN) { int c = getch(); if (c == 12) /* ^L */ force_redraw = 1; if (c == 'H') pause_graphs = !pause_graphs; if (c == 'q') stop = 1; } if (dg && !pause_graphs) { draw_graph(k); #ifdef FW draw_fft(); #endif } wnoutrefresh(w_stats); if (win_resize || force_redraw) recreate_terminal(); }
static status RedrawAreaSlider(Slider s, Area a) { int x, y, w, h; int ny, vx, vy, lx, ly, sx, sy, hx, hy; int vv; int bw = (s->look == NAME_x ? BAR_WIDTH : OL_BOX_WIDTH); float lv = convert_value(s->low); float hv = convert_value(s->high); float dv = convert_value(s->displayed_value); int lflags = (s->active == ON ? 0 : LABEL_INACTIVE); if ( dv < lv ) dv = lv; else if ( dv > hv ) dv = hv; if ( hv > lv ) vv = rfloat(((float) (valInt(s->width) - bw) * (dv - lv)) / (hv - lv)); else vv = 0; initialiseDeviceGraphical(s, &x, &y, &w, &h); NormaliseArea(x, y, w, h); r_thickness(valInt(s->pen)); r_dash(s->texture); compute_slider(s, &ny, &vx, &vy, &lx, &ly, &sx, &sy, &hx, &hy); r_clear(x, y, w, h); if ( s->show_label == ON ) { int ex = valInt(getExFont(s->label_font)); RedrawLabelDialogItem(s, accelerator_code(s->accelerator), x, y+ny, vx-ex, 0, s->label_format, NAME_top, lflags); } if ( s->look == NAME_motif ) { int by = y+sy+(SLIDER_HEIGHT-OL_BAR_HEIGHT)/2; int ex = x + sx + valInt(s->width); Elevation z = getClassVariableValueObject(s, NAME_elevation); r_3d_box(x+sx, by, vv, OL_BAR_HEIGHT, 0, z, FALSE); r_3d_box(x+sx+vv+bw, by, ex-(x+sx+vv+bw), OL_BAR_HEIGHT, 0, z, FALSE); r_3d_box(x+sx+vv, y+sy, bw, SLIDER_HEIGHT, 0, z, TRUE); } else if ( s->look == NAME_openLook ) { int by = y+sy+(SLIDER_HEIGHT-OL_BAR_HEIGHT)/2; int ly2 = by+OL_BAR_HEIGHT-1; int ex = x + sx + valInt(s->width); r_fill(x+sx, by+1, 1, OL_BAR_HEIGHT-2, BLACK_IMAGE); r_fill(x+sx+1, by, vv-2, OL_BAR_HEIGHT, BLACK_IMAGE); r_line(x+sx+1+vv+bw, by, ex-2, by); r_line(x+sx+1+vv+bw, ly2, ex-2, ly2); r_line(ex-1, by+1, ex-1, ly2-1); r_shadow_box(x+sx+vv, y+sy, bw, SLIDER_HEIGHT, 0, 1, NIL); } else { r_fill(x+sx, y+sy, vv, SLIDER_HEIGHT, GREY50_IMAGE); r_box(x+sx, y+sy, valInt(s->width), SLIDER_HEIGHT, 0, NIL); r_fill(x+sx+vv, y+sy, bw, SLIDER_HEIGHT, BLACK_IMAGE); } if ( s->show_value == ON ) { char buf[100]; string str; buf[0] = '['; format_value(s, &buf[1], s->displayed_value); strcat(buf, "]"); str_set_ascii(&str, buf); str_label(&str, 0, s->value_font, x+vx, y+vy, 0, 0, NAME_left, NAME_top, lflags); format_value(s, buf, s->low); str_set_ascii(&str, buf); str_label(&str, 0, s->value_font, x+lx, y+ly, 0, 0, NAME_left, NAME_top, lflags); format_value(s, buf, s->high); str_set_ascii(&str, buf); str_label(&str, 0, s->value_font, x+hx, y+hy, 0, 0, NAME_left, NAME_top, lflags); } return RedrawAreaGraphical(s, a); }
static void format_resolution(double res, char *buf, int projection) { format_value(G_format_resolution, res, buf, projection); }
static void format_easting(double east, char *buf, int projection) { format_value(G_format_easting, east, buf, projection); }