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

qalculateeditvariabledialog.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.             *
 ***************************************************************************/
#include "qalculateeditvariabledialog.h"
#include "qalculate_kde_utils.h"
#include "qalculateeditnamesdialog.h"

#include <qgrid.h>
#include <klineedit.h>
#include <qpushbutton.h>
#include <kcombobox.h>
#include <qlabel.h>
#include <klocale.h>
#include <qvbox.h>
#include <qhbox.h>
#include <qcheckbox.h>
#include <kmessagebox.h>
#include <qlayout.h>
#include <kapplication.h>

extern PrintOptions printops;
extern tree_struct variable_cats;

QalculateEditVariableDialog::QalculateEditVariableDialog(QWidget *parent, const char *name) : KDialogBase(parent, name, true, i18n("Edit Variable"), Ok | Cancel | Help, Ok, true) {

      names_edit_dialog = NULL;
      edited_variable = NULL;

      setMainWidget(new QWidget(this));   
      QGridLayout *grid = new QGridLayout(mainWidget(), 6, 2, 0, spacingHint());
      
      nameLabel = new QLabel(i18n("Name:"), mainWidget());
      grid->addWidget(nameLabel, 0, 0);   
      nameEdit = new KLineEdit(mainWidget());
      grid->addWidget(nameEdit, 0, 1);
      
      QHBoxLayout *hbox = new QHBoxLayout(0, 0, spacingHint());
      grid->addMultiCellLayout(hbox, 1, 1, 0, 1);
      namesLabel = new QLabel(mainWidget());
      namesLabel->setAlignment(Qt::AlignRight);
      namesLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
      hbox->addWidget(namesLabel);
      namesButton = new QPushButton(i18n("Names Details"), mainWidget());
      hbox->addWidget(namesButton);
      
      valueLabel = new QLabel(i18n("Value:"), mainWidget());
      grid->addWidget(valueLabel, 2, 0);
      valueEdit = new KLineEdit(mainWidget());
      grid->addWidget(valueEdit, 2, 1);
      
      hbox = new QHBoxLayout(0, 0, spacingHint());
      grid->addMultiCellLayout(hbox, 3, 3, 0, 1);
      hbox->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum));
      valueExactButton = new QCheckBox(i18n("Value is exact"), mainWidget());
      hbox->addWidget(valueExactButton);
      
      grid->addWidget(new QLabel(i18n("Category:"), mainWidget()), 4, 0);
      categoryCombo = new KComboBox(mainWidget());
      grid->addWidget(categoryCombo, 4, 1);
      categoryCombo->setMaximumWidth(250);
      categoryCombo->setEditable(true);
      
      titleLabel = new QLabel(i18n("Descriptive name:"), mainWidget());
      grid->addWidget(titleLabel, 5, 0);
      titleEdit = new KLineEdit(mainWidget());
      grid->addWidget(titleEdit, 5, 1);

      connect(namesButton, SIGNAL(clicked()), this, SLOT(editNames()));
      connect(nameEdit, SIGNAL(textChanged(const QString&)), this, SLOT(nameChanged(const QString&)));
      
}

QalculateEditVariableDialog::~QalculateEditVariableDialog() {}

void QalculateEditVariableDialog::slotHelp() {
      KApplication::kApplication()->invokeHelp("qalculate-variable-creation");
}

void QalculateEditVariableDialog::slotOk() {
      string str = nameEdit->text().ascii();
      remove_blank_ends(str);
      if(str.empty() && (!names_edit_dialog || names_edit_dialog->isEmpty())) {
            //no name -- open dialog again
            KMessageBox::error(this, i18n("Empty name field"));
            return;
      }
      string str2 = valueEdit->text().ascii();
      remove_blank_ends(str2);
      if(!(init_value && force_init_value) && str2.empty()) {
            //no value -- open dialog again
            KMessageBox::error(this, i18n("Empty value field"));
            return;
      }
      //variable with the same name exists -- overwrite or open dialog again
      if((!edited_variable || !edited_variable->hasName(str)) && (!names_edit_dialog || names_edit_dialog->isEmpty()) && CALCULATOR->variableNameTaken(str, edited_variable) && KMessageBox::questionYesNo(this, i18n("An unit or variable with the same name already exists.\nDo you want to overwrite it?")) == KMessageBox::No) {
            return;
      }
      KnownVariable *v = edited_variable;
      if(!v) {
            //no need to create a new variable when a variable with the same name exists
            Variable *var = CALCULATOR->getActiveVariable(str);
            if(var && var->isLocal() && var->isKnown()) v = (KnownVariable*) var;
      }
      bool add_var = false;
      if(v) {
            //update existing variable
            v->setLocal(true);
            if(!v->isBuiltin()) {
                  if(force_init_value && init_value) {
                        v->set(*init_value);
                  } else {
                        v->set(CALCULATOR->unlocalizeExpression(valueEdit->text().ascii()));
                        v->setApproximate(!valueExactButton->isChecked());
                  }
            }
      } else {
            //new variable
            if(force_init_value && init_value) {
                  //forced value
                  v = new KnownVariable("", "", *init_value, "", true);
            } else {
                  v = new KnownVariable("", "", CALCULATOR->unlocalizeExpression(valueEdit->text().ascii()), "", true);
                  v->setApproximate(!valueExactButton->isChecked());
            }
            add_var = true;
      }
      v->setCategory(categoryCombo->lineEdit()->text().ascii());
      v->setTitle(titleEdit->text().ascii());
      if(!v->isBuiltin()) {
            if(names_edit_dialog) {
                  names_edit_dialog->saveNames(v, str.c_str());
            } else {
                  if(v->countNames() == 0) {
                        ExpressionName ename(str);
                        ename.reference = true;
                        v->setName(ename, 1);
                  } else {
                        v->setName(str, 1);
                  }
            }
      }
      if(add_var) {
            CALCULATOR->addVariable(v);
      }           
      edited_variable = v;
      accept();
}

KnownVariable *QalculateEditVariableDialog::editVariable(QString category, KnownVariable *v, MathStructure *initial_value, bool force_value) {

      nameEdit->setFocus();

      if(names_edit_dialog) {
            delete names_edit_dialog;
            names_edit_dialog = NULL;
      }
      edited_variable = v;
      if(v) {
            if(v->isLocal()) {
                  setCaption(i18n("Edit Variable"));
            } else {
                  setCaption(i18n("Edit Variable (global)"));
            }
      } else {
            setCaption(i18n("New Variable"));
      }

      actionButton(Ok)->setEnabled(true);

      namesLabel->setText("");

      //QStringList cats;
      QString catstr;
      categoryCombo->clear();
      tree_struct *item, *item2;
      variable_cats.it = variable_cats.items.begin();
      if(variable_cats.it != variable_cats.items.end()) {
            item = &*variable_cats.it;
            ++variable_cats.it;
            item->it = item->items.begin();
      } else {
            item = NULL;
      }

      catstr = "";
      while(item) {
            if(!catstr.isEmpty()) catstr += "/";
            catstr += item->item.c_str();
            categoryCombo->insertItem(catstr);
            while(item && item->it == item->items.end()) {
                  int str_i = catstr.findRev("/");
                  if(str_i < 0) {
                        catstr = "";
                  } else {
                        catstr.truncate(str_i);
                  }
                  item = item->parent;
            }
            if(item) {
                  item2 = &*item->it;
                  ++item->it;
                  item = item2;
                  item->it = item->items.begin();     
            }
      }

      if(initial_value && force_value) {
            valueEdit->hide();
            valueLabel->hide();
            namesButton->hide();
            namesLabel->hide();
            valueExactButton->hide();
      } else {
            valueEdit->show();
            valueLabel->show();
            namesButton->show();
            namesLabel->show();
            valueExactButton->show();
      }

      if(v) {
            //fill in original parameters
            set_name_label_and_entry(v, nameEdit, namesLabel);
            valueEdit->setText(get_value_string(v->get(), false, NULL));
            nameEdit->setReadOnly(v->isBuiltin());
            valueEdit->setReadOnly(v->isBuiltin());
            valueExactButton->setEnabled(!v->isBuiltin());
            categoryCombo->lineEdit()->setText(v->category().c_str());
            titleEdit->setText(v->title(false).c_str());
            valueExactButton->setChecked(!(*printops.is_approximate) && !v->isApproximate());
      } else {
            nameEdit->setReadOnly(false);
            valueEdit->setReadOnly(false);
            valueExactButton->setEnabled(true);

            //fill in default values
            nameEdit->setText(CALCULATOR->getName().c_str());
            namesLabel->setText("");
            if(initial_value && !force_value) valueEdit->setText(get_value_string(*initial_value));
            else valueEdit->setText("");
            categoryCombo->lineEdit()->setText(category);
            titleEdit->setText("");
            if(initial_value) valueExactButton->setChecked(!initial_value->isApproximate());
            else valueExactButton->setChecked(true);
            if(force_value) {
                  valueEdit->setReadOnly(true);
                  valueExactButton->setEnabled(false);
            }
      }

      init_value = initial_value;
      force_init_value = force_value;

      if(exec() == QDialog::Accepted) {
            v = edited_variable;
            edited_variable = NULL;
            return v;
      }
      edited_variable = NULL;
      return NULL;
}

void QalculateEditVariableDialog::editNames() {
      if(!names_edit_dialog) {
            names_edit_dialog = new QalculateEditNamesDialog(TYPE_VARIABLE, this);
            names_edit_dialog->setNames(edited_variable, nameEdit->text(), false);
      } else {
            names_edit_dialog->setNames(edited_variable, nameEdit->text(), true);
      }
      names_edit_dialog->exec();
      names_edit_dialog->setNamesLE(nameEdit, namesLabel);
}

void QalculateEditVariableDialog::nameChanged(const QString &name) {
      if(name.isNull()) return;
      if(!CALCULATOR->variableNameIsValid(name.ascii())) {
            nameEdit->blockSignals(true);
            nameEdit->setText(CALCULATOR->convertToValidVariableName(name.ascii()).c_str());
            nameEdit->blockSignals(false);
      }
}

#include "qalculateeditvariabledialog.moc"


Generated by  Doxygen 1.6.0   Back to index