diff options
Diffstat (limited to 'src/preferences.cpp')
| -rw-r--r-- | src/preferences.cpp | 865 |
1 files changed, 865 insertions, 0 deletions
diff --git a/src/preferences.cpp b/src/preferences.cpp new file mode 100644 index 0000000..658e5ec --- /dev/null +++ b/src/preferences.cpp @@ -0,0 +1,865 @@ +/*************************************************************************** + * Copyright (C) 2005-2007 by Niklas Knutsson * + * nq@altern.org * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include "preferences.h" +#include "kqalculate.h" +#include "qalculate_kde_utils.h" +#include "qalculateexpressionedit.h" +#include <sys/stat.h> +#include <unistd.h> +#include <dirent.h> +#include <stdio.h> +#include <klocale.h> +#include <qstringlist.h> +#include <ktextbrowser.h> +#include <qwidgetstack.h> +#include <qpushbutton.h> +#include <qvaluevector.h> + +PrintOptions printops; +EvaluationOptions evalops; +bool rpn_mode; +bool rpn_keypad_only; +bool load_global_defs, fetch_exchange_rates_at_startup, first_time, first_qalculate_run, save_mode_on_exit, save_defs_on_exit; +bool use_custom_result_font, use_custom_expression_font, use_custom_status_font; +int use_icon_buttons; +QString custom_result_font, custom_expression_font, custom_status_font; +QColor status_warning_color, status_error_color; + +bool display_expression_status; +bool close_to_systray; +bool enable_expression_completion; + +PlotLegendPlacement default_plot_legend_placement; +bool default_plot_display_grid; +bool default_plot_full_border; +QString default_plot_min; +QString default_plot_max; +QString default_plot_step; +int default_plot_sampling_rate; +bool default_plot_use_sampling_rate; +bool default_plot_rows; +int default_plot_type; +PlotStyle default_plot_style; +PlotSmoothing default_plot_smoothing; +QString default_plot_variable; +bool default_plot_color; +bool enable_plot_expression_completion; + +bool canplot; + +QString initial_history; + +extern vector<MathFunction*> recent_functions; +extern vector<Variable*> recent_variables; +extern vector<Unit*> recent_units; +QValueVector<QString> recent_functions_pre; +QValueVector<QString> recent_variables_pre; +QValueVector<QString> recent_units_pre; + +extern QWidget *expressionWidget; +extern KQalculate *mainWin; +QStringList expression_history; + +bool show_keypad, show_history, show_stack; + +vector<mode_struct> modes; + +QValueVector<QString> inhistory; +QValueVector<int> inhistory_type; +QValueVector<int> inhistory_id; +int inhistory_current_id; + +/* + save mode to file +*/ +void save_mode() { + return save_preferences(true); +} + +/* + remember current mode +*/ +void set_saved_mode() { + modes[1].precision = CALCULATOR->getPrecision(); + modes[1].po = printops; + modes[1].po.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); + modes[1].eo = evalops; + modes[1].at = CALCULATOR->defaultAssumptions()->type(); + modes[1].as = CALCULATOR->defaultAssumptions()->sign(); + modes[1].rpn_mode = rpn_mode; +} + +size_t save_mode_as(QString name, bool *new_mode) { + name = name.stripWhiteSpace(); + size_t index = 0; + for(; index < modes.size(); index++) { + if(modes[index].name == name) { + if(new_mode) *new_mode = false; + break; + } + } + if(index >= modes.size()) { + modes.resize(modes.size() + 1); + index = modes.size() - 1; + if(new_mode) *new_mode = true; + } + modes[index].po = printops; + modes[index].po.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); + modes[index].eo = evalops; + modes[index].precision = CALCULATOR->getPrecision(); + modes[index].at = CALCULATOR->defaultAssumptions()->type(); + modes[index].as = CALCULATOR->defaultAssumptions()->sign(); + modes[index].name = name; + modes[index].rpn_mode = rpn_mode; + return index; +} + +void load_preferences() { + + default_plot_legend_placement = PLOT_LEGEND_TOP_RIGHT; + default_plot_display_grid = true; + default_plot_full_border = false; + default_plot_min = "0"; + default_plot_max = "10"; + default_plot_step = "1"; + default_plot_sampling_rate = 100; + default_plot_rows = false; + default_plot_type = 0; + default_plot_style = PLOT_STYLE_LINES; + default_plot_smoothing = PLOT_SMOOTHING_NONE; + default_plot_variable = "x"; + default_plot_color = true; + default_plot_use_sampling_rate = true; + + printops.is_approximate = new bool(false); + printops.prefix = NULL; + printops.use_min_decimals = false; + printops.use_denominator_prefix = true; + printops.min_decimals = 0; + printops.use_max_decimals = false; + printops.max_decimals = 2; + printops.base = 10; + printops.min_exp = EXP_PRECISION; + printops.negative_exponents = false; + printops.sort_options.minus_last = true; + printops.indicate_infinite_series = false; + printops.show_ending_zeroes = false; + printops.round_halfway_to_even = false; + printops.number_fraction_format = FRACTION_DECIMAL; + printops.abbreviate_names = true; + printops.use_unicode_signs = true; + printops.use_unit_prefixes = true; + printops.spacious = true; + printops.short_multiplication = true; + printops.limit_implicit_multiplication = false; + printops.place_units_separately = true; + printops.use_all_prefixes = false; + printops.excessive_parenthesis = false; + printops.allow_non_usable = false; + printops.lower_case_numbers = false; + printops.lower_case_e = false; + printops.base_display = BASE_DISPLAY_NORMAL; + printops.division_sign = DIVISION_SIGN_DIVISION_SLASH; + printops.multiplication_sign = MULTIPLICATION_SIGN_DOT; + printops.can_display_unicode_string_function = &can_display_unicode_string_function; + printops.allow_factorization = false; + printops.spell_out_logical_operators = true; + + evalops.parse_options.limit_implicit_multiplication = false; + evalops.approximation = APPROXIMATION_TRY_EXACT; + evalops.sync_units = true; + evalops.structuring = STRUCTURING_SIMPLIFY; + evalops.parse_options.unknowns_enabled = false; + evalops.parse_options.read_precision = DONT_READ_PRECISION; + evalops.parse_options.base = BASE_DECIMAL; + evalops.allow_complex = true; + evalops.allow_infinite = true; + evalops.auto_post_conversion = POST_CONVERSION_NONE; + evalops.assume_denominators_nonzero = true; + evalops.warn_about_denominators_assumed_nonzero = true; + evalops.parse_options.angle_unit = ANGLE_UNIT_RADIANS; + evalops.parse_options.dot_as_separator = KGlobal::locale()->thousandsSeparator() == "."; + + rpn_mode = false; + rpn_keypad_only = true; + + save_mode_as(i18n("Preset")); + save_mode_as(i18n("Default")); + size_t mode_index = 1; + + inhistory_current_id = 0; + + status_warning_color.setNamedColor("blue"); + status_error_color.setNamedColor("red"); + use_icon_buttons = 1; + enable_expression_completion = true; + enable_plot_expression_completion = true; + close_to_systray = false; + show_keypad = true; + show_history = false; + show_stack = true; + display_expression_status = true; + save_mode_on_exit = true; + save_defs_on_exit = true; + use_custom_result_font = false; + use_custom_expression_font = false; + use_custom_status_font = false; + custom_result_font = ""; + custom_expression_font = ""; + custom_status_font = ""; + load_global_defs = true; + fetch_exchange_rates_at_startup = false; + first_time = false; + string filename = getLocalDir(); + DIR *dir = opendir(filename.c_str()); + if(!dir) { + first_qalculate_run = true; + first_time = true; + set_saved_mode(); + return; + } else { + first_qalculate_run = false; + closedir(dir); + } + + int version_numbers[] = {0, 9, 6}; + FILE *file = NULL; + filename += "qalculate-kde.cfg"; + file = fopen(filename.c_str(), "r"); + if(file) { + char line[10000]; + QString stmp, svalue, svar; + int i; + int v; + while(true) { + if(fgets(line, 10000, file) == NULL) + break; + stmp = line; + stmp = stmp.stripWhiteSpace(); + if((i = stmp.find("=")) >= 0) { + svar = stmp; + svar.truncate(i); + svar = svar.stripWhiteSpace(); + svalue = stmp; + svalue.remove(0, i + 1); + svalue = svalue.stripWhiteSpace(); + v = svalue.toInt(); + if(svar == "version") { + parse_qalculate_version(svalue.ascii(), version_numbers); + } else if(svar == "shortcut") { + if(mode_index != 1) modes[mode_index].shortcut.init(svalue); + } else if(svar == "save_mode_on_exit") { + save_mode_on_exit = v; + } else if(svar == "save_definitions_on_exit") { + save_defs_on_exit = v; + } else if(svar == "fetch_exchange_rates_at_startup") { + fetch_exchange_rates_at_startup = v; + } else if(svar == "min_deci") { + if(mode_index == 1) printops.min_decimals = v; + else modes[mode_index].po.min_decimals = v; + } else if(svar == "use_min_deci") { + if(mode_index == 1) printops.use_min_decimals = v; + else modes[mode_index].po.use_min_decimals = v; + } else if(svar == "max_deci") { + if(mode_index == 1) printops.max_decimals = v; + else modes[mode_index].po.max_decimals = v; + } else if(svar == "use_max_deci") { + if(mode_index == 1) printops.use_max_decimals = v; + else modes[mode_index].po.use_max_decimals = v; + } else if(svar == "precision") { + if(mode_index == 1) CALCULATOR->setPrecision(v); + else modes[mode_index].precision = v; + } else if(svar == "min_exp") { + if(mode_index == 1) printops.min_exp = v; + else modes[mode_index].po.min_exp = v; + } else if(svar == "negative_exponents") { + if(mode_index == 1) printops.negative_exponents = v; + else modes[mode_index].po.negative_exponents = v; + } else if(svar == "sort_minus_last") { + if(mode_index == 1) printops.sort_options.minus_last = v; + else modes[mode_index].po.sort_options.minus_last = v; + } else if(svar == "place_units_separately") { + if(mode_index == 1) printops.place_units_separately = v; + else modes[mode_index].po.place_units_separately = v; + } else if(svar == "use_prefixes") { + if(mode_index == 1) printops.use_unit_prefixes = v; + else modes[mode_index].po.use_unit_prefixes = v; + } else if(svar == "number_fraction_format") { + if(v >= FRACTION_DECIMAL && v <= FRACTION_COMBINED) { + if(mode_index == 1) printops.number_fraction_format = (NumberFractionFormat) v; + else modes[mode_index].po.number_fraction_format = (NumberFractionFormat) v; + } + } else if(svar == "number_base") { + if(mode_index == 1) printops.base = v; + else modes[mode_index].po.base = v; + } else if(svar == "number_base_expression") { + if(mode_index == 1) evalops.parse_options.base = v; + else modes[mode_index].eo.parse_options.base = v; + } else if(svar == "read_precision") { + if(v >= DONT_READ_PRECISION && v <= READ_PRECISION_WHEN_DECIMALS) { + if(mode_index == 1) evalops.parse_options.read_precision = (ReadPrecisionMode) v; + else modes[mode_index].eo.parse_options.read_precision = (ReadPrecisionMode) v; + } + } else if(svar == "assume_denominators_nonzero") { + if(version_numbers[0] == 0 && (version_numbers[1] < 9 || (version_numbers[1] == 9 && version_numbers[2] == 0))) { + v = true; + } + if(mode_index == 1) evalops.assume_denominators_nonzero = v; + else modes[mode_index].eo.assume_denominators_nonzero = v; + } else if(svar == "warn_about_denominators_assumed_nonzero") { + if(mode_index == 1) evalops.warn_about_denominators_assumed_nonzero = v; + else modes[mode_index].eo.warn_about_denominators_assumed_nonzero = v; + } else if(svar == "structuring") { + if(v >= STRUCTURING_NONE && v <= STRUCTURING_FACTORIZE) { + if(mode_index == 1) { + evalops.structuring = (StructuringMode) v; + printops.allow_factorization = (evalops.structuring == STRUCTURING_FACTORIZE); + } else { + modes[mode_index].eo.structuring = (StructuringMode) v; + modes[mode_index].po.allow_factorization = (modes[mode_index].eo.structuring == STRUCTURING_FACTORIZE); + } + } + } else if(svar == "angle_unit") { + if(v >= ANGLE_UNIT_NONE && v <= ANGLE_UNIT_GRADIANS) { + if(mode_index == 1) evalops.parse_options.angle_unit = (AngleUnit) v; + else modes[mode_index].eo.parse_options.angle_unit = (AngleUnit) v; + } + } else if(svar == "functions_enabled") { + if(mode_index == 1) evalops.parse_options.functions_enabled = v; + else modes[mode_index].eo.parse_options.functions_enabled = v; + } else if(svar == "variables_enabled") { + if(mode_index == 1) evalops.parse_options.variables_enabled = v; + else modes[mode_index].eo.parse_options.variables_enabled = v; + } else if(svar == "calculate_variables") { + if(mode_index == 1) evalops.calculate_variables = v; + else modes[mode_index].eo.calculate_variables = v; + } else if(svar == "calculate_functions") { + if(mode_index == 1) evalops.calculate_functions = v; + else modes[mode_index].eo.calculate_functions = v; + } else if(svar == "sync_units") { + if(mode_index == 1) evalops.sync_units = v; + else modes[mode_index].eo.sync_units = v; + } else if(svar == "unknownvariables_enabled") { + if(mode_index == 1) evalops.parse_options.unknowns_enabled = v; + else modes[mode_index].eo.parse_options.unknowns_enabled = v; + } else if(svar == "units_enabled") { + if(mode_index == 1) evalops.parse_options.units_enabled = v; + else modes[mode_index].eo.parse_options.units_enabled = v; + } else if(svar == "allow_complex") { + if(mode_index == 1) evalops.allow_complex = v; + else modes[mode_index].eo.allow_complex = v; + } else if(svar == "allow_infinite") { + if(mode_index == 1) evalops.allow_infinite = v; + else modes[mode_index].eo.allow_infinite = v; + } else if(svar == "use_short_units") { + if(mode_index == 1) printops.abbreviate_names = v; + else modes[mode_index].po.abbreviate_names = v; + } else if(svar == "abbreviate_names") { + if(mode_index == 1) printops.abbreviate_names = v; + else modes[mode_index].po.abbreviate_names = v; + } else if(svar == "all_prefixes_enabled") { + if(mode_index == 1) printops.use_all_prefixes = v; + else modes[mode_index].po.use_all_prefixes = v; + } else if(svar == "denominator_prefix_enabled") { + if(mode_index == 1) printops.use_denominator_prefix = v; + else modes[mode_index].po.use_denominator_prefix = v; + } else if(svar == "auto_post_conversion") { + if(v >= POST_CONVERSION_NONE && v <= POST_CONVERSION_BASE) { + if(mode_index == 1) evalops.auto_post_conversion = (AutoPostConversion) v; + else modes[mode_index].eo.auto_post_conversion = (AutoPostConversion) v; + } + } else if(svar == "indicate_infinite_series") { + if(mode_index == 1) printops.indicate_infinite_series = v; + else modes[mode_index].po.indicate_infinite_series = v; + } else if(svar == "show_ending_zeroes") { + if(mode_index == 1) printops.show_ending_zeroes = v; + else modes[mode_index].po.show_ending_zeroes = v; + } else if(svar == "round_halfway_to_even") { + if(mode_index == 1) printops.round_halfway_to_even = v; + else modes[mode_index].po.round_halfway_to_even = v; + } else if(svar == "approximation") { + if(v >= APPROXIMATION_EXACT && v <= APPROXIMATION_APPROXIMATE) { + if(mode_index == 1) evalops.approximation = (ApproximationMode) v; + else modes[mode_index].eo.approximation = (ApproximationMode) v; + } + } else if(svar == "in_rpn_mode") { + if(mode_index == 1) rpn_mode = v; + else modes[mode_index].rpn_mode = v; + } else if(svar == "rpn_keypad_only") { + rpn_keypad_only = v; + } else if(svar == "rpn_syntax") { + if(mode_index == 1) evalops.parse_options.rpn = v; + else modes[mode_index].eo.parse_options.rpn = v; + } else if(svar == "limit_implicit_multiplication") { + if(mode_index == 1) { + evalops.parse_options.limit_implicit_multiplication = v; + printops.limit_implicit_multiplication = v; + } else { + modes[mode_index].eo.parse_options.limit_implicit_multiplication = v; + modes[mode_index].po.limit_implicit_multiplication = v; + } + } else if(svar == "default_assumption_type") { + if(v >= ASSUMPTION_TYPE_NONE && v <= ASSUMPTION_TYPE_INTEGER) { + if(v == ASSUMPTION_TYPE_NONE && version_numbers[0] == 0 && (version_numbers[1] < 9 || (version_numbers[1] == 9 && version_numbers[2] == 0))) { + v = ASSUMPTION_TYPE_NONMATRIX; + } + if(mode_index == 1) CALCULATOR->defaultAssumptions()->setType((AssumptionType) v); + else modes[mode_index].at = (AssumptionType) v; + } + } else if(svar == "default_assumption_sign") { + if(v >= ASSUMPTION_SIGN_UNKNOWN && v <= ASSUMPTION_SIGN_NONZERO) { + if(v == ASSUMPTION_SIGN_NONZERO && version_numbers[0] == 0 && (version_numbers[1] < 9 || (version_numbers[1] == 9 && version_numbers[2] == 0))) { + v = ASSUMPTION_SIGN_UNKNOWN; + } + if(mode_index == 1) CALCULATOR->defaultAssumptions()->setSign((AssumptionSign) v); + else modes[mode_index].as = (AssumptionSign) v; + } + } else if(svar == "spacious") { + if(mode_index == 1) printops.spacious = v; + else modes[mode_index].po.spacious = v; + } else if(svar == "excessive_parenthesis") { + if(mode_index == 1) printops.excessive_parenthesis = v; + else modes[mode_index].po.excessive_parenthesis = v; + } else if(svar == "short_multiplication") { + if(mode_index == 1) printops.short_multiplication = v; + else modes[mode_index].po.short_multiplication = v; + } else if(svar == "use_unicode_signs") { + printops.use_unicode_signs = v; + } else if(svar == "lower_case_numbers") { + printops.lower_case_numbers = v; + } else if(svar == "lower_case_e") { + printops.lower_case_e = v; + } else if(svar == "base_display") { + if(v >= BASE_DISPLAY_NONE && v <= BASE_DISPLAY_ALTERNATIVE) printops.base_display = (BaseDisplay) v; + } else if(svar == "spell_out_logical_operators") { + printops.spell_out_logical_operators = v; + } else if(svar == "dot_as_separator") { + evalops.parse_options.dot_as_separator = v; + } else if(svar == "use_custom_result_font") { + use_custom_result_font = v; + } else if(svar == "use_custom_expression_font") { + use_custom_expression_font = v; + } else if(svar == "use_custom_status_font") { + use_custom_status_font = v; + } else if(svar == "custom_result_font") { + custom_result_font = svalue; + } else if(svar == "custom_expression_font") { + custom_expression_font = svalue; + } else if(svar == "custom_status_font") { + custom_status_font = svalue; + } else if(svar == "status_error_color") { + status_error_color.setNamedColor(svalue); + } else if(svar == "status_warning_color") { + status_warning_color.setNamedColor(svalue); + } else if(svar == "multiplication_sign") { + if(v >= MULTIPLICATION_SIGN_ASTERISK && v <= MULTIPLICATION_SIGN_X) printops.multiplication_sign = (MultiplicationSign) v; + } else if(svar == "division_sign") { + if(v >= DIVISION_SIGN_SLASH && v <= DIVISION_SIGN_DIVISION) printops.division_sign = (DivisionSign) v; + } else if(svar == "close_to_system_tray") { + close_to_systray = v; + } else if(svar == "show_keypad") { + show_keypad = v; + } else if(svar == "show_history") { + show_history = v; + } else if(svar == "show_stack") { + show_stack = v; + } else if(svar == "display_expression_status") { + display_expression_status = v; + } else if(svar == "enable_expression_completion") { + enable_expression_completion = v; + } else if(svar == "use_icon_buttons") { + use_icon_buttons = v; + } else if(svar == "plot_legend_placement") { + if(v >= PLOT_LEGEND_NONE && v <= PLOT_LEGEND_OUTSIDE) default_plot_legend_placement = (PlotLegendPlacement) v; + } else if(svar == "plot_style") { + if(v >= PLOT_STYLE_LINES && v <= PLOT_STYLE_DOTS) default_plot_style = (PlotStyle) v; + } else if(svar == "plot_smoothing") { + if(v >= PLOT_SMOOTHING_NONE && v <= PLOT_SMOOTHING_SBEZIER) default_plot_smoothing = (PlotSmoothing) v; + } else if(svar == "plot_display_grid") { + default_plot_display_grid = v; + } else if(svar == "plot_full_border") { + default_plot_full_border = v; + } else if(svar == "plot_min") { + default_plot_min = svalue; + } else if(svar == "plot_max") { + default_plot_max = svalue; + } else if(svar == "plot_step") { + default_plot_step = svalue; + } else if(svar == "plot_sampling_rate") { + default_plot_sampling_rate = v; + } else if(svar == "plot_use_sampling_rate") { + default_plot_use_sampling_rate = v; + } else if(svar == "plot_variable") { + default_plot_variable = svalue; + } else if(svar == "plot_rows") { + default_plot_rows = v; + } else if(svar == "plot_type") { + default_plot_type = v; + } else if(svar == "plot_color") { + default_plot_color = v; + } else if(svar == "enable_plot_expression_completion") { + enable_plot_expression_completion = v; + } else if(svar == "expression_history") { + expression_history.push_back(svalue); + } else if(svar == "history") { + initial_history = svalue; + if(version_numbers[1] < 9) { + initial_history.replace("<br><br>", "<br><hr>"); + } + inhistory.push_back(initial_history); + inhistory_type.push_back(QALCULATE_HISTORY_OLD); + } else if(svar == "history_old") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_OLD); + } else if(svar == "history_expression") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_EXPRESSION); + } else if(svar == "history_transformation") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_TRANSFORMATION); + } else if(svar == "history_result") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_RESULT); + } else if(svar == "history_result_approximate") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_RESULT_APPROXIMATE); + } else if(svar == "history_parse") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_PARSE); + } else if(svar == "history_parse_approximate") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_PARSE_APPROXIMATE); + } else if(svar == "history_register_moved") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_REGISTER_MOVED); + } else if(svar == "history_warning") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_WARNING); + } else if(svar == "history_error") { + inhistory.push_back(svalue); + inhistory_type.push_back(QALCULATE_HISTORY_ERROR); + } else if(svar == "history_continued") { + if(inhistory.size() > 0) { + inhistory[inhistory.size() - 1] += "<br>"; + inhistory[inhistory.size() - 1] += svalue; + } + } else if(svar == "recent_functions") { + int v_i = 0; + while(true) { + v_i = svalue.find(','); + if(v_i < 0) { + svar = svalue.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_functions_pre.push_back(svar); + } + break; + } else { + svar = svalue; + svar.truncate(v_i); + svalue.remove(0, v_i + 1); + svar = svar.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_functions_pre.push_back(svar); + } + } + } + } else if(svar == "recent_variables") { + int v_i = 0; + while(true) { + v_i = svalue.find(','); + if(v_i < 0) { + svar = svalue.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_variables_pre.push_back(svar); + } + break; + } else { + svar = svalue; + svar.truncate(v_i); + svalue.remove(0, v_i + 1); + svar = svar.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_variables_pre.push_back(svar); + } + } + } + } else if(svar == "recent_units") { + int v_i = 0; + while(true) { + v_i = svalue.find(','); + if(v_i < 0) { + svar = svalue.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_units_pre.push_back(svar); + } + break; + } else { + svar = svalue; + svar.truncate(v_i); + svalue.remove(0, v_i + 1); + svar = svar.stripWhiteSpace(); + if(!svar.isEmpty()) { + recent_units_pre.push_back(svar); + } + } + } + } + } else if(stmp.length() > 2 && stmp[0] == '[' && stmp[stmp.length() - 1] == ']') { + stmp.truncate(stmp.length() - 1); + stmp.remove(0, 1); + stmp = stmp.stripWhiteSpace(); + if(stmp == "Mode") { + mode_index = 1; + } else if(stmp.length() > 5) { + QString svar = stmp; + svar.truncate(4); + if(svar == "Mode") { + stmp.remove(0, 5); + mode_index = save_mode_as(stmp); + } + } + } + } + inhistory_current_id = (int) inhistory.size(); + int id = inhistory_current_id; + id--; + for(QValueVector<QString>::size_type i = 0; i < inhistory.size(); i++) { + inhistory_id.push_back(id); + id--; + } + } else { + first_time = true; + } + if(show_keypad) show_history = false; + //remember start mode for when we save preferences + set_saved_mode(); + +} + +void save_preferences(bool mode) { + + FILE *file = NULL; + string filename = getLocalDir(); + mkdir(filename.c_str(), S_IRWXU); + filename += "qalculate-kde.cfg"; + file = fopen(filename.c_str(), "w+"); + if(file == NULL) { + fprintf(stderr, i18n("Couldn't write preferences to\n%s"), filename.c_str()); + return; + } + fprintf(file, "\n[General]\n"); + fprintf(file, "version=%s\n", VERSION); + fprintf(file, "save_mode_on_exit=%i\n", save_mode_on_exit); + fprintf(file, "save_definitions_on_exit=%i\n", save_defs_on_exit); + fprintf(file, "load_global_definitions=%i\n", load_global_defs); + fprintf(file, "fetch_exchange_rates_at_startup=%i\n", fetch_exchange_rates_at_startup); + fprintf(file, "close_to_system_tray=%i\n", close_to_systray); + fprintf(file, "show_keypad=%i\n", mainWin->keypadButton->isOn() || (rpn_mode && show_keypad && mainWin->stackButton->isOn())); + fprintf(file, "show_history=%i\n", mainWin->historyButton->isOn() || (rpn_mode && show_history && mainWin->stackButton->isOn())); + fprintf(file, "show_stack=%i\n", rpn_mode ? mainWin->stackButton->isOn() : show_stack); + fprintf(file, "rpn_keypad_only=%i\n", rpn_keypad_only); + fprintf(file, "display_expression_status=%i\n", display_expression_status); + fprintf(file, "enable_expression_completion=%i\n", ((QalculateExpressionEdit*) expressionWidget)->completionEnabled()); + if(use_icon_buttons >= 0) fprintf(file, "use_icon_buttons=%i\n", use_icon_buttons); + fprintf(file, "use_unicode_signs=%i\n", printops.use_unicode_signs); + fprintf(file, "lower_case_numbers=%i\n", printops.lower_case_numbers); + fprintf(file, "lower_case_e=%i\n", printops.lower_case_e); + fprintf(file, "base_display=%i\n", printops.base_display); + fprintf(file, "spell_out_logical_operators=%i\n", printops.spell_out_logical_operators); + fprintf(file, "dot_as_separator=%i\n", evalops.parse_options.dot_as_separator); + fprintf(file, "use_custom_result_font=%i\n", use_custom_result_font); + fprintf(file, "use_custom_expression_font=%i\n", use_custom_expression_font); + fprintf(file, "use_custom_status_font=%i\n", use_custom_status_font); + fprintf(file, "custom_result_font=%s\n", custom_result_font.ascii()); + fprintf(file, "custom_expression_font=%s\n", custom_expression_font.ascii()); + fprintf(file, "custom_status_font=%s\n", custom_status_font.ascii()); + if(status_error_color != QColor("red")) fprintf(file, "status_error_color=%s\n", status_error_color.name().ascii()); + if(status_warning_color != QColor("blue")) fprintf(file, "status_warning_color=%s\n", status_warning_color.name().ascii()); + fprintf(file, "multiplication_sign=%i\n", printops.multiplication_sign); + fprintf(file, "division_sign=%i\n", printops.division_sign); + for (QStringList::Iterator it = ((QalculateExpressionEdit*) expressionWidget)->expression_history.begin(); it != ((QalculateExpressionEdit*) expressionWidget)->expression_history.end(); ++it) { + fprintf(file, "expression_history=%s\n", (*it).ascii()); + } + int lines = 50; + bool end_after_result = false; + bool doend = false; + for(QValueVector<QString>::size_type i = 0; i < inhistory.size() && !doend; i++) { + switch(inhistory_type[i]) { + case QALCULATE_HISTORY_EXPRESSION: { + fprintf(file, "history_expression="); + break; + } + case QALCULATE_HISTORY_TRANSFORMATION: { + fprintf(file, "history_transformation="); + break; + } + case QALCULATE_HISTORY_RESULT: { + fprintf(file, "history_result="); + lines--; + if(end_after_result) doend = true; + break; + } + case QALCULATE_HISTORY_RESULT_APPROXIMATE: { + fprintf(file, "history_result_approximate="); + lines--; + if(end_after_result) doend = true; + break; + } + case QALCULATE_HISTORY_PARSE: { + fprintf(file, "history_parse="); + lines--; + if(lines < 0) end_after_result = true; + break; + } + case QALCULATE_HISTORY_PARSE_APPROXIMATE: { + fprintf(file, "history_parse_approximate="); + lines--; + if(lines < 0) end_after_result = true; + break; + } + case QALCULATE_HISTORY_REGISTER_MOVED: { + fprintf(file, "history_register_moved="); + break; + } + case QALCULATE_HISTORY_WARNING: { + fprintf(file, "history_warning="); + lines--; + break; + } + case QALCULATE_HISTORY_ERROR: { + fprintf(file, "history_error="); + lines--; + break; + } + case QALCULATE_HISTORY_OLD: { + fprintf(file, "history_old="); + lines--; + if(lines < 0) doend = true; + break; + } + } + if(inhistory[i].find("<br>") < 0) { + fprintf(file, "%s\n", inhistory[i].ascii()); + } else { + QStringList slist = QStringList::split("<br>", inhistory[i], true); + for(QStringList::size_type i2 = 0; i2 < slist.size(); i2++) { + if(i2 == 0) fprintf(file, "%s\n", slist[i2].ascii()); + else fprintf(file, "history_continued=%s\n", slist[i2].ascii()); + } + } + } + fprintf(file, "recent_functions="); + for(int i = (int) (recent_functions.size()) - 1; i >= 0; i--) { + fprintf(file, "%s", recent_functions[i]->referenceName().c_str()); + if(i != 0) fprintf(file, ","); + } + fprintf(file, "\n"); + fprintf(file, "recent_variables="); + for(int i = (int) (recent_variables.size()) - 1; i >= 0; i--) { + fprintf(file, "%s", recent_variables[i]->referenceName().c_str()); + if(i != 0) fprintf(file, ","); + } + fprintf(file, "\n"); + fprintf(file, "recent_units="); + for(int i = (int) (recent_units.size()) - 1; i >= 0; i--) { + fprintf(file, "%s", recent_units[i]->referenceName().c_str()); + if(i != 0) fprintf(file, ","); + } + fprintf(file, "\n"); + if(mode) + set_saved_mode(); + for(size_t i = 1; i < modes.size(); i++) { + if(i == 1) { + fprintf(file, "\n[Mode]\n"); + } else { + fprintf(file, "\n[Mode %s]\n", modes[i].name.ascii()); + if(!modes[i].shortcut.toString().isNull()) fprintf(file, "shortcut=%s\n", modes[i].shortcut.toString().ascii()); + } + fprintf(file, "min_deci=%i\n", modes[i].po.min_decimals); + fprintf(file, "use_min_deci=%i\n", modes[i].po.use_min_decimals); + fprintf(file, "max_deci=%i\n", modes[i].po.max_decimals); + fprintf(file, "use_max_deci=%i\n", modes[i].po.use_max_decimals); + fprintf(file, "precision=%i\n", modes[i].precision); + fprintf(file, "min_exp=%i\n", modes[i].po.min_exp); + fprintf(file, "negative_exponents=%i\n", modes[i].po.negative_exponents); + fprintf(file, "sort_minus_last=%i\n", modes[i].po.sort_options.minus_last); + fprintf(file, "number_fraction_format=%i\n", modes[i].po.number_fraction_format); + fprintf(file, "use_prefixes=%i\n", modes[i].po.use_unit_prefixes); + fprintf(file, "abbreviate_names=%i\n", modes[i].po.abbreviate_names); + fprintf(file, "all_prefixes_enabled=%i\n", modes[i].po.use_all_prefixes); + fprintf(file, "denominator_prefix_enabled=%i\n", modes[i].po.use_denominator_prefix); + fprintf(file, "place_units_separately=%i\n", modes[i].po.place_units_separately); + fprintf(file, "auto_post_conversion=%i\n", modes[i].eo.auto_post_conversion); + fprintf(file, "number_base=%i\n", modes[i].po.base); + fprintf(file, "number_base_expression=%i\n", modes[i].eo.parse_options.base); + fprintf(file, "read_precision=%i\n", modes[i].eo.parse_options.read_precision); + fprintf(file, "assume_denominators_nonzero=%i\n", modes[i].eo.assume_denominators_nonzero); + fprintf(file, "warn_about_denominators_assumed_nonzero=%i\n", modes[i].eo.warn_about_denominators_assumed_nonzero); + fprintf(file, "structuring=%i\n", modes[i].eo.structuring); + fprintf(file, "angle_unit=%i\n", modes[i].eo.parse_options.angle_unit); + fprintf(file, "functions_enabled=%i\n", modes[i].eo.parse_options.functions_enabled); + fprintf(file, "variables_enabled=%i\n", modes[i].eo.parse_options.variables_enabled); + fprintf(file, "calculate_functions=%i\n", modes[i].eo.calculate_functions); + fprintf(file, "calculate_variables=%i\n", modes[i].eo.calculate_variables); + fprintf(file, "sync_units=%i\n", modes[i].eo.sync_units); + fprintf(file, "unknownvariables_enabled=%i\n", modes[i].eo.parse_options.unknowns_enabled); + fprintf(file, "units_enabled=%i\n", modes[i].eo.parse_options.units_enabled); + fprintf(file, "allow_complex=%i\n", modes[i].eo.allow_complex); + fprintf(file, "allow_infinite=%i\n", modes[i].eo.allow_infinite); + fprintf(file, "indicate_infinite_series=%i\n", modes[i].po.indicate_infinite_series); + fprintf(file, "show_ending_zeroes=%i\n", modes[i].po.show_ending_zeroes); + fprintf(file, "round_halfway_to_even=%i\n", modes[i].po.round_halfway_to_even); + fprintf(file, "approximation=%i\n", modes[i].eo.approximation); + fprintf(file, "in_rpn_mode=%i\n", modes[i].rpn_mode); + fprintf(file, "rpn_syntax=%i\n", modes[i].eo.parse_options.rpn); + fprintf(file, "limit_implicit_multiplication=%i\n", modes[i].eo.parse_options.limit_implicit_multiplication); + fprintf(file, "spacious=%i\n", modes[i].po.spacious); + fprintf(file, "excessive_parenthesis=%i\n", modes[i].po.excessive_parenthesis); + fprintf(file, "short_multiplication=%i\n", modes[i].po.short_multiplication); + fprintf(file, "default_assumption_type=%i\n", modes[i].at); + fprintf(file, "default_assumption_sign=%i\n", modes[i].as); + } + + fprintf(file, "\n[Plotting]\n"); + fprintf(file, "plot_legend_placement=%i\n", default_plot_legend_placement); + fprintf(file, "plot_style=%i\n", default_plot_style); + fprintf(file, "plot_smoothing=%i\n", default_plot_smoothing); + fprintf(file, "plot_display_grid=%i\n", default_plot_display_grid); + fprintf(file, "plot_full_border=%i\n", default_plot_full_border); + fprintf(file, "plot_min=%s\n", default_plot_min.ascii()); + fprintf(file, "plot_max=%s\n", default_plot_max.ascii()); + fprintf(file, "plot_step=%s\n", default_plot_step.ascii()); + fprintf(file, "plot_sampling_rate=%i\n", default_plot_sampling_rate); + fprintf(file, "plot_use_sampling_rate=%i\n", default_plot_use_sampling_rate); + fprintf(file, "plot_variable=%s\n", default_plot_variable.ascii()); + fprintf(file, "plot_rows=%i\n", default_plot_rows); + fprintf(file, "plot_type=%i\n", default_plot_type); + fprintf(file, "plot_color=%i\n", default_plot_color); + fprintf(file, "enable_plot_expression_completion=%i\n", enable_plot_expression_completion); + + + fclose(file); + +} |