Logo Search packages:      
Sourcecode: qalculate-kde version File versions  Download package

preferences.cpp

/***************************************************************************
 *   Copyright (C) 2005 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 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;

vector<mode_struct> modes;

/*
      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();
}

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;
      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.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;

      save_mode_as(i18n("Preset"));
      save_mode_as(i18n("Default"));
      size_t mode_index = 1;

      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 = false;
      show_history = false;
      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, 2};
      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 == "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) 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 == "spell_out_logical_operators") {
                              printops.spell_out_logical_operators = 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") {
                              printops.multiplication_sign = (MultiplicationSign) v;
                        } else if(svar == "division_sign") {
                              printops.division_sign = (DivisionSign) v;
                        } else if(svar == "close_to_systray") {
                              close_to_systray = v;
                        } else if(svar == "show_keypad") {
                              show_keypad = v;
                        } else if(svar == "show_history") {
                              show_history = 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>");
                              }
                        } 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);
                              }
                        }
                  }
            }
      } else {
            first_time = true;
      }
      
      //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_systray=%i\n", close_to_systray);
      fprintf(file, "show_keypad=%i\n", mainWin->keypadButton->isOn());
      fprintf(file, "show_history=%i\n", mainWin->historyButton->isOn());
      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, "spell_out_logical_operators=%i\n", printops.spell_out_logical_operators);
      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());
      }
      QString str = mainWin->historyBrowser->text().section("<br>", 0, 50);
      str.replace("\n", "<br>");
      fprintf(file, "history=%s\n", str.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());
            }
            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].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);
      
}

Generated by  Doxygen 1.6.0   Back to index