From 84da08d7b7fcda12c85caeb5a10b4903770a6f69 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeaddons@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kicker-applets/math/Makefile.am | 19 + kicker-applets/math/mathapplet.cpp | 285 ++++++++++++ kicker-applets/math/mathapplet.desktop | 114 +++++ kicker-applets/math/mathapplet.h | 74 +++ kicker-applets/math/parser.cpp | 813 +++++++++++++++++++++++++++++++++ kicker-applets/math/parser.h | 241 ++++++++++ 6 files changed, 1546 insertions(+) create mode 100644 kicker-applets/math/Makefile.am create mode 100644 kicker-applets/math/mathapplet.cpp create mode 100644 kicker-applets/math/mathapplet.desktop create mode 100644 kicker-applets/math/mathapplet.h create mode 100644 kicker-applets/math/parser.cpp create mode 100644 kicker-applets/math/parser.h (limited to 'kicker-applets/math') diff --git a/kicker-applets/math/Makefile.am b/kicker-applets/math/Makefile.am new file mode 100644 index 0000000..da94ffb --- /dev/null +++ b/kicker-applets/math/Makefile.am @@ -0,0 +1,19 @@ +INCLUDES = $(all_includes) + +kde_module_LTLIBRARIES = math_panelapplet.la + +math_panelapplet_la_SOURCES = mathapplet.cpp parser.cpp + +METASOURCES = mathapplet.moc +noinst_HEADERS = mathapplet.h parser.h + +lnkdir = $(kde_datadir)/kicker/applets +lnk_DATA = mathapplet.desktop + +EXTRA_DIST = $(lnk_DATA) + +math_panelapplet_la_LDFLAGS = -module $(KDE_PLUGIN) $(all_libraries) +math_panelapplet_la_LIBADD = $(LIB_KSYCOCA) $(LIB_KDEUI) + +messages: + $(XGETTEXT) *.cpp *.h -o $(podir)/kmathapplet.pot diff --git a/kicker-applets/math/mathapplet.cpp b/kicker-applets/math/mathapplet.cpp new file mode 100644 index 0000000..b4966b2 --- /dev/null +++ b/kicker-applets/math/mathapplet.cpp @@ -0,0 +1,285 @@ +/***************************************************************** + +Based on code 'Run' applet code, copyright (c) 2000 Matthias Elter + +Modifications made by Andrew Coles, 2004 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +******************************************************************/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "parser.h" + + + +#include "mathapplet.h" +#include "mathapplet.moc" + +extern "C" +{ + KDE_EXPORT KPanelApplet* init(QWidget *parent, const QString& configFile) + { + KGlobal::locale()->insertCatalogue("kmathapplet"); + return new MathApplet(configFile, KPanelApplet::Stretch, 0, parent, "kmathapplet"); + } +} + +MathApplet::MathApplet(const QString& configFile, Type type, int actions, + QWidget *parent, const char *name) + : KPanelApplet(configFile, type, actions, parent, name), + m_hasFocus(false) +{ + // setBackgroundMode(X11ParentRelative); + setBackgroundOrigin( AncestorOrigin ); + // setup label + _label = new QLabel(i18n("Evaluate:"), this); + QFont f(_label->font()); + f.setPixelSize(12); +// _label->setBackgroundMode(X11ParentRelative); + _label->setBackgroundOrigin( AncestorOrigin ); + _label->setFixedHeight(14); + _label->setFont(f); + + // setup popup button + _btn = new QPushButton(this); + f = _btn->font(); + f.setPixelSize(12); + _btn->setFont(f); + connect(_btn, SIGNAL(clicked()), SLOT(popup_combo())); + + // setup history combo + _input = new KHistoryCombo(this); + _input->setFocus(); + _input->clearEdit(); + watchForFocus(_input->lineEdit()); + connect(_input, SIGNAL(activated(const QString&)), + SLOT(evaluate(const QString&))); + + initContextMenu(); + useDegrees(); + + KConfig *c = config(); + c->setGroup("General"); + + + // restore history and completion list + QStringList list = c->readListEntry("Completion list"); + _input->completionObject()->setItems(list); + list = c->readListEntry("History list"); + _input->setHistoryItems(list); + int mode = c->readNumEntry( "CompletionMode", KGlobalSettings::completionMode() ); + _input->setCompletionMode( (KGlobalSettings::Completion) mode ); + + _hbox = new QHBox( 0, 0, WStyle_Customize | WType_Popup ); + _hbox->setFixedSize(120, 22); + + +} + +void MathApplet::initContextMenu() +{ + mContextMenu = new KPopupMenu(this); + mContextMenu->setCheckable(true); + mContextMenu->insertItem(i18n("Use &Degrees"), this, SLOT(useDegrees()), 0, 0, 0); + mContextMenu->insertItem(i18n("Use &Radians"), this, SLOT(useRadians()), 0, 1, 1); + setCustomMenu(mContextMenu); +} + + +MathApplet::~MathApplet() +{ + KConfig *c = config(); + c->setGroup("General"); + + // save history and completion list + QStringList list = _input->completionObject()->items(); + c->writeEntry("Completion list", list); + list = _input->historyItems(); + c->writeEntry("History list", list); + c->writeEntry( "CompletionMode", (int) _input->completionMode() ); + c->sync(); + + KGlobal::locale()->removeCatalogue("kmathapplet"); +} + +void MathApplet::useDegrees() { + + mContextMenu->setItemChecked(0, true); + mContextMenu->setItemChecked(1, false); + Parser dummy; + dummy.setAngleMode(1); +} + +void MathApplet::useRadians() { + mContextMenu->setItemChecked(0, false); + mContextMenu->setItemChecked(1, true); + Parser dummy; + dummy.setAngleMode(0); +} + +void MathApplet::resizeEvent(QResizeEvent*) +{ + if(orientation() == Horizontal) + { + _btn->hide(); + _input->reparent(this, QPoint(0,0), true); + _label->setGeometry(0,0, width(), _label->height()); + + if(height() >= _input->sizeHint().height() + _label->height()) + { + int inputVOffset = height() - _input->sizeHint().height() - 2; + int labelHeight = _label->sizeHint().height(); + _label->setGeometry(0, inputVOffset - labelHeight, + width(), labelHeight); + _input->setGeometry(0, inputVOffset, + width(), _input->sizeHint().height()); + _label->show(); + } + else + { + _label->hide(); + + // make it as high as the combobox naturally wants to be + // but no taller than the panel is! + // don't forget to center it vertically either. + int newHeight = _input->sizeHint().height(); + if (newHeight > height()) + newHeight = height(); + _input->setGeometry(0, (height() - newHeight) / 2, + width(), newHeight); + } + } + else + { + _btn->show(); + _btn->setFixedSize(width(), 22); + _input->reparent( _hbox, QPoint(0, 0), false); + _label->hide(); + } + setButtonText(); +} + +void MathApplet::positionChange(KPanelApplet::Position) +{ + setButtonText(); +} + +void MathApplet::setButtonText() +{ + QString t; + + if (position() == pLeft) + { + if (width() >= 42) + t = i18n("< Eval"); + else + t = "<"; + } + else + { + if(width() >= 42) + t = i18n("Eval >"); + else + t = ">"; + } + + _btn->setText(t); +} + +int MathApplet::widthForHeight(int ) const +{ + return 110; +} + +int MathApplet::heightForWidth(int ) const +{ + return 22; +} + +void MathApplet::popup_combo() +{ + QPoint p; + if (position() == pLeft) + p = mapToGlobal(QPoint(-_input->width()-1, 0)); + else + p = mapToGlobal(QPoint(width()+1, 0)); + _hbox->move(p); + _hbox->show(); + _input->setFocus(); +} + +void MathApplet::evaluate(const QString& command) +{ + QString exec; + + Parser evaluator; + + kapp->propagateSessionManager(); + + _input->addToHistory(command); + + + QString cmd = command; + + // Nothing interesting. Quit! + if ( cmd.isEmpty() ){ + KMessageBox::sorry(0L, i18n("You have to enter an expression to be evaluated first.")); + needsFocus(true); + } else { + double answer = evaluator.eval(command); + if (evaluator.errmsg() == 0) { + QString ansAsString = QString::number(answer); + _input->clearEdit(); + _input->setEditText(ansAsString); + } else { + _input->removeFromHistory(_input->currentText()); + needsFocus(true); + } + } + + if (orientation() == Vertical) + _hbox->hide(); +} + +void MathApplet::mousePressEvent(QMouseEvent *e) +{ + if ( e->button() != RightButton ) + { + KPanelApplet::mousePressEvent( e ); + return; + } + + mContextMenu->exec(e->globalPos()); +} diff --git a/kicker-applets/math/mathapplet.desktop b/kicker-applets/math/mathapplet.desktop new file mode 100644 index 0000000..9aba622 --- /dev/null +++ b/kicker-applets/math/mathapplet.desktop @@ -0,0 +1,114 @@ +[Desktop Entry] +Type=Plugin +Name=Math Expression Evaluator +Name[bg]=Математически изрази +Name[bs]=Procjena matematičkih izraza +Name[ca]=Avaluador d'expressions matemàtiques +Name[cs]=Vyhodnocení matematického výrazu +Name[da]=Evaluering af matematiske udtryk +Name[de]=Auswertung mathematischer Ausdrücke +Name[el]=Ελεγκτής εγκυρότητας μαθηματικής έκφρασης +Name[en_GB]=Maths Expression Evaluator +Name[eo]=Matematikesprima interpretilo +Name[es]=Evaluador de expresiones matemáticas +Name[et]=Matemaatikaavaldiste kontrollija +Name[eu]=Espresio matematikoen balidatzailea +Name[fa]=ارزیاب عبارت ریاضی +Name[fi]=Matemaattisen lausekkeen laskija +Name[fr]=Interpréteur d'expressions mathématique +Name[fy]=Lytse rekkenmachine +Name[ga]=Luachálaí Slonn Matamaiticiúil +Name[gl]=Avaliación de Expresións Matemáticas +Name[he]=מפענח נוסחאות מתמטיות +Name[hi]=मैथ एक्सप्रेशन इवेल्यूएटर्स +Name[hr]=Ocjena matematičkih izraza +Name[hu]=Kifejezéskiértékelő +Name[is]=Algebrureiknivél +Name[it]=Disegnatore di funzioni matematiche +Name[ja]=数学的表現の評価者 +Name[ka]=მათემატიკური გამოსახულებების გამომთვლელი +Name[kk]=Математикалық өрнегін есептеу +Name[km]=កម្មវិធី​វាយ​តម្លៃ​កន្សោម​ពិជគណិត +Name[lt]=Matematinių išraiškų vertinimo priemonė +Name[mk]=Пресметувач на математички изрази +Name[ms]=Penilaian Ungkapan Matematik +Name[nb]=Matematikkberegner +Name[nds]=Mathemaatsche Utdrück utreken +Name[ne]=गणित अभिव्यक्ति मुल्याङ्कनकर्ता +Name[nl]=Kleine rekenmachine +Name[nn]=Matteuttrykkevaluerar +Name[pl]=Program wyliczający wyrażenia matematyczne +Name[pt]=Avaliação de Expressões Matemáticas +Name[pt_BR]=Validador de Expressões Matemáticas +Name[ru]=Вычисление математических выражений +Name[sk]=Vyhodnotenie matematického výrazu +Name[sl]=Vrednotenje matematičnih izrazov +Name[sr]=Рачунар математичких израза +Name[sr@Latn]=Računar matematičkih izraza +Name[sv]=Utvärdering av matematiska uttryck +Name[ta]=கணிதத் தொடர் மதிப்பிடு +Name[tg]=Тафтиши ифодаҳои математикӣ +Name[tr]=Matematiksel İşlem Değerlendiricisi +Name[uk]=Перевірка математичних виразів +Name[uz]=Matematik ifodalarni hisoblagich +Name[uz@cyrillic]=Математик ифодаларни ҳисоблагич +Name[vi]=Bộ định giá biểu thức toán học +Name[zh_CN]=数学表达式计算器 +Name[zh_TW]=數學運算模擬器 +Comment=A mathematical expression evaluator +Comment[bg]=Изчисление на математически изрази +Comment[bs]=Procjena matematičkih izraza +Comment[ca]=Un avaluador d'expressions matemàtiques +Comment[cs]=Program pro vyhodnocování matematických výrazů +Comment[da]=Til evaluering af matematiske udtryk +Comment[de]=Auswerten von mathematischen Ausdrücken +Comment[el]=Ένας ελεγκτής εγκυρότητας μαθηματικών εκφράσεων +Comment[eo]=Matematikesprima interpretilo +Comment[es]=Un evaluador de expresiones matemáticas +Comment[et]=Matemaatikaavaldiste kontrollija +Comment[eu]=Espresio matematikoen ebaluatzailea +Comment[fa]=ارزیاب عبارتهای ریاضی +Comment[fi]=Matemaattisen lausekkeen laskija +Comment[fr]=Un interpréteur d'expressions mathématiques +Comment[fy]=In applet om wiskundige útdrukkingen te evaluearjen +Comment[ga]=Luachálaí slonn matamaiticiúil +Comment[gl]=Un avaliador de expresións matemáticas +Comment[he]=מפענח נוסחאות מתמטיות +Comment[hi]=एक मैथमेटिकल एक्सप्रेशन इवेल्यूएटर +Comment[hr]=Ocjenjivanje matematičkih izraza +Comment[hu]=Matematikai kifejezések kiszámítására alkalmas program +Comment[is]=Algebrureiknivél +Comment[it]=Uno strumento per disegnare funzioni matematiche +Comment[ja]=数学的表現の評価者 +Comment[ka]=მათემატიკური გამოსახულებების გამომთვლელი +Comment[kk]=Математикалық өрнекті есептеп шығару +Comment[km]=កម្មវិធី​វាយ​តម្លៃ​កន្សោម​ពិជ​គណិត +Comment[lt]=Matematinių išraiškų vertinimo priemonė +Comment[mk]=Пресметување математички изрази +Comment[ms]=Penilai ungkapan matematik +Comment[nb]=En beregner for matematiske uttrykk +Comment[nds]=Utreken vun mathemaatsche Utdrück +Comment[ne]=एउटा गणितिय अभिव्यक्ति मुल्याङ्कनकर्ता +Comment[nl]=Een applet waarmee u wiskundige uitdrukkingen kunt evalueren +Comment[nn]=Ein utreknar for matematiske uttrykk +Comment[pl]=Program wyliczający wyrażenia matematyczne +Comment[pt]=Um avaliador de expressões matemáticas +Comment[pt_BR]=Um validador de expressões +Comment[ru]=Вычисление математических выражений +Comment[sk]=Program pre vyhodnotenie matematických výrazov +Comment[sl]=Vrednotenje matematičnih izrazov +Comment[sr]=Израчунава задате математичке изразе +Comment[sr@Latn]=Izračunava zadate matematičke izraze +Comment[sv]=Ett verktyg för utvärdering av matematiska uttryck +Comment[ta]=கணிதத் தொடர் மதிப்பிடு +Comment[tg]=Тафтиши ифодаҳои математикӣ +Comment[tr]=Matematiksel işlem değerlendirici +Comment[uk]=Перевірка математичних виразів +Comment[uz]=Matematik ifodalarni hisoblagich +Comment[uz@cyrillic]=Математик ифодаларни ҳисоблагич +Comment[vi]=Bộ định giá biểu thức toán học +Comment[zh_CN]=数学表达式计算器 +Comment[zh_TW]=數學運算模擬器 +Icon=math_int +X-KDE-Library=math_panelapplet +X-KDE-UniqueApplet=true diff --git a/kicker-applets/math/mathapplet.h b/kicker-applets/math/mathapplet.h new file mode 100644 index 0000000..1a918c3 --- /dev/null +++ b/kicker-applets/math/mathapplet.h @@ -0,0 +1,74 @@ +/***************************************************************** + +Based on code 'Run' applet code, copyright (c) 2000 Matthias Elter + +Modifications made by Andrew Coles, 2004 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +******************************************************************/ + +#ifndef __mathapplet_h__ +#define __mathapplet_h__ + +#include +#include + +class QLabel; +class QHBox; +class QPushButton; +class KHistoryCombo; +class KPopupMenu; + +class MathApplet : public KPanelApplet +{ + Q_OBJECT + +public: + MathApplet(const QString& configFile, Type t = Stretch, int actions = 0, + QWidget *parent = 0, const char *name = 0); + virtual ~MathApplet(); + + int widthForHeight(int height) const; + int heightForWidth(int width) const; + +protected: + void resizeEvent(QResizeEvent*); + void positionChange(KPanelApplet::Position); + +protected slots: + void evaluate(const QString&); + void popup_combo(); + void setButtonText(); + void useDegrees(); + void useRadians(); + +private: + + void initContextMenu(); + void mousePressEvent(QMouseEvent *e); + + KHistoryCombo *_input; + QLabel *_label; + QPushButton *_btn; + QHBox *_hbox; + KPopupMenu *mContextMenu; + bool m_hasFocus; +}; + +#endif diff --git a/kicker-applets/math/parser.cpp b/kicker-applets/math/parser.cpp new file mode 100644 index 0000000..7d99c87 --- /dev/null +++ b/kicker-applets/math/parser.cpp @@ -0,0 +1,813 @@ +/* +* Code based on parser from KmPlot - a math. function plotter for the KDE-Desktop +* +* Original code +* Copyright (C) 1998, 1999 Klaus-Dieter Mller +* 2000, 2002 kd.moeller@t-online.de +* +* Modifications: 2004 Andrew Coles (andrew_coles@yahoo.co.uk) +* +* This file is part of the KDE Project. +* KmPlot is part of the KDE-EDU Project. +* +* 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., 675 Mass Ave, Cambridge, MA 02139, USA. +* +*/ + +// standard c(++) includes +#include +#include +#include + +//KDE includes +#include +#include +#include + +// local includes +#include "parser.h" +//#include "settings.h" +//#include "xparser.h" + +double Parser::m_anglemode = 0; + +/// List of predefined functions. +Parser::Mfkt Parser::mfkttab[ FANZ ]= +{ + {"tanh", ltanh}, // Tangens hyperbolicus + {"tan", ltan}, // Tangens + {"sqrt", sqrt}, // Square root + {"sqr", sqr}, // Square + {"sinh", lsinh}, // Sinus hyperbolicus + {"sin", lsin}, // Sinus + {"sign", sign}, // Signum + {"sech", sech}, // Secans hyperbolicus + {"sec", sec}, // Secans + {"log", log10}, // Logarithm base 10 + {"ln", log}, // Logarithm base e + {"exp", exp}, // Exponential function base e + {"coth", coth}, // Co-Tangens hyperbolicus + {"cot", cot}, // Co-Tangens = 1/tan + {"cosh", lcosh}, // Cosinus hyperbolicus + {"cosech", cosech}, // Co-Secans hyperbolicus + {"cosec", cosec}, // Co-Secans + {"cos", lcos}, // Cosinus + {"artanh", artanh}, // Area-tangens hyperbolicus = inverse of tanh + {"arsinh", arsinh}, // Area-sinus hyperbolicus = inverse of sinh + {"arsech", arsech}, // Area-secans hyperbolicus = invers of sech + {"arctan", arctan}, // Arcus tangens = inverse of tan + {"arcsin", arcsin}, // Arcus sinus = inverse of sin + {"arcsec", arcsec}, // Arcus secans = inverse of sec + {"arcoth", arcoth}, // Area-co-tangens hyperbolicus = inverse of coth + {"arcosh", arcosh}, // Area-cosinus hyperbolicus = inverse of cosh + {"arcosech", arcosech}, // Area-co-secans hyperbolicus = inverse of cosech + {"arccot", arccot}, // Arcus co-tangens = inverse of cotan + {"arccosec", arccosec}, // Arcus co-secans = inverse of cosec + {"arccos", arccos}, // Arcus cosinus = inverse of cos + {"abs", fabs} // Absolute value +}; + + +Parser::Parser() +{ ps_init( UFANZ, MEMSIZE, STACKSIZE ); +} + + +Parser::Parser( int anz, int m_size, int s_size ) +{ ps_init( anz, m_size, s_size ); +} + + +void Parser::ps_init(int anz, int m_size, int s_size) +{ int ix; + + ufanz=anz; + memsize=m_size; + stacksize=s_size; + ufkt=new Ufkt[ufanz]; + evalflg=ixa=0; + for(ix=0; ixfkt(*stkptr); + mptr=(unsigned char*)puf; + break; + + case ENDE: erg=*stkptr; + delete [] stack; + return erg; + } + } +} + +int Parser::getNextIndex() +{ + int ix = 0; + while( ( ix < ufanz ) && !ufkt[ ix ].fname.isEmpty() ) ix++; + if( ix == ufanz ) ix = -1; + return ix; +} + +int Parser::addfkt(QString str) +{ + int ix; + + stkptr=stack=0; + err=0; + errpos=1; + str.remove(" " ); + const int p1=str.find('('); + int p2=str.find(','); + const int p3=str.find(")="); + + //insert '*' when it is needed + for(int i=p1+3; i < (int) str.length();i++) + { + if( (str.at(i).isNumber() || str.at(i).category()==QChar::Letter_Uppercase )&& ( str.at(i-1).isLetter() || str.at(i-1) == ')' ) ) + { + str.insert(i,'*'); + } + else if( (str.at(i).isNumber() || str.at(i) == ')' || str.at(i).category()==QChar::Letter_Uppercase) && ( str.at(i+1).isLetter() || str.at(i+1) == '(' ) ) + { + str.insert(i+1,'*'); + i++; + } + } + + if(p1==-1 || p3==-1 || p1>p3) + { err=4; + return -1; + } + if ( p3+2 == (int) str.length()) //empty function + { err=11; + return -1; + } + if(p2==-1 || p2>p3) p2=p3; + if(getfix(str.left(p1))!=-1) + { err=8; + return -1; + } + else err=0; + + if (str.mid(p1+1, p2-p1-1) == "e") + { err=4; + return -1; + } + + for(ix=0; ix=ufanz) return -1; // ungltiger Index + + ufkt[ix].fname=""; //.resize(1); // Name l�chen + return ix; +} + + +double Parser::fkt(QString name, double x) +{ int ix; + + ix=getfix(name); + if(ix==-1) return 0.; + + return ufkt[ix].fkt(x); +} + + +void Parser::heir1() +{ char c; + + heir2(); + if(err!=0) return ; + + while(1) + { switch(c=*lptr) + { default: return ; + + case ' ': ++lptr; + continue; + + case '+': + case '-': ++lptr; + addtoken(PUSH); + heir2(); + if(err!=0) return ; + } + + switch(c) + { case '+': addtoken(PLUS); + break; + + case '-': addtoken(MINUS); + } + } +} + + +void Parser::heir2() +{ if(match("-")) + { heir2(); + if(err!=0) return; + + addtoken(NEG); + } + + else heir3(); +} + + +void Parser::heir3() +{ char c; + + heir4(); + if(err!=0) return; + + while(1) + { switch(c=*lptr) + { default: return ; + + case ' ': ++lptr; + continue; + + case '*': + case '/': ++lptr; + addtoken(PUSH); + heir4(); + if(err!=0) return ; + } + + switch(c) + { case '*': addtoken(MULT); + break; + + case '/': addtoken(DIV); + } + } +} + + +void Parser::heir4() +{ primary(); + if(err!=0) return; + + while(match("^")) + { addtoken(PUSH); + primary(); + if(err!=0) return; + addtoken(POW); + } +} + + +void Parser::primary() +{ char *p; + int i; + double w; + + if(match("(")) + { heir1(); + if(match(")")==0) err=2; // fehlende Klammer + return; + } + + for(i=0; i='A' && lptr[0]<='Z' ) + { char tmp[2]; + tmp[1] = '\0'; + for( int i = 0; i< (int)constant.size();i++) + { + tmp[0] = constant[i].constant; + if ( match( tmp) ) + { + addtoken(KONST); + addwert(constant[i].value); + return; + } + + } + err = 10; + return; + } + + + if(match("pi")) + { addtoken(KONST); + addwert(M_PI); + return; + } + + if(match("e")) + { addtoken(KONST); + addwert(M_E); + return; + } + + if(match(ufkt[ixa].fvar.latin1())) + { addtoken(XWERT); + return; + } + + if(match("y")) + { addtoken(YWERT); + return; + } + + if(match(ufkt[ixa].fpar.latin1())) + { addtoken(KWERT); + return; + } + + w=strtod(lptr, &p); + if(lptr!=p) + { lptr=p; + addtoken(KONST); + addwert(w); + } + else err=1; // Syntax-Fehler +} + + +int Parser::match(const char *lit) +{ const char *p; + + if(*lit==0) return 0; + + while(*lptr==' ') ++lptr; + p=lptr; + while(*lit) + { if(*lit++!=*p++) return 0; + } + lptr=p; + return 1; +} + + +void Parser::addtoken(unsigned char token) +{ if(stkptr>=stack+stacksize-1) + { err=7; + return; + } + + if(evalflg==0) + { if(mptr>=&mem[memsize-10]) err=6; + else *mptr++=token; + + switch(token) + { case PUSH: ++stkptr; + break; + + case PLUS: + case MINUS: + case MULT: + case DIV: + case POW: --stkptr; + } + } + else switch(token) + { case PUSH: ++stkptr; + break; + + case PLUS: stkptr[-1]+=*stkptr; + --stkptr; + break; + + case MINUS: stkptr[-1]-=*stkptr; + --stkptr; + break; + + case MULT: stkptr[-1]*=*stkptr; + --stkptr; + break; + + case DIV: if(*stkptr==0.) *(--stkptr)=HUGE_VAL; + else + { stkptr[-1]/=*stkptr; + --stkptr; + } + break; + + case POW: stkptr[-1]=pow(*(stkptr-1), *stkptr); + --stkptr; + break; + case NEG: *stkptr=-*stkptr; + } +} + + +void Parser::addwert(double x) +{ double *pd=(double*)mptr; + + if(evalflg==0) + { if(mptr>=&mem[memsize-10]) err=6; + else + { *pd++=x; + mptr=(unsigned char*)pd; + } + } + else *stkptr=x; +} + + +void Parser::addfptr(double(*fadr)(double)) +{ double (**pf)(double)=(double(**)(double))mptr; + + if(evalflg==0) + { if(mptr>=&mem[memsize-10]) err=6; + else + { *pf++=fadr; + mptr=(unsigned char*)pf; + } + } + else *stkptr=(*fadr)(*stkptr); +} + + +void Parser::addfptr(Ufkt *adr) +{ Ufkt **p=(Ufkt**)mptr; + + if(evalflg==0) + { if(mptr>=&mem[memsize-10]) err=6; + else + { *p++=adr; + mptr=(unsigned char*)p; + } + } + else *stkptr=adr->fkt(*stkptr); +} + + +int Parser::chkfix(int ix) +{ if(ix<0 || ix>=ufanz) return -1; // ungltiger Index + if(ufkt[ix].fname.isEmpty()) return -1; // keine Funktion + return ix; +} + + +int Parser::getfkt(int ix, QString& name, QString& str) +{ if(ix<0 || ix>=ufanz) return -1; // ungltiger Index + if(ufkt[ix].fname.isEmpty()) return -1; // keine Funktion + name=ufkt[ix].fname.copy(); + str=ufkt[ix].fstr.copy(); + return ix; +} + + +int Parser::getfix(QString name) +{ int ix; + + err=0; + for(ix=0; ix0.) return 1.; + return 0.; +} + +double sqr(double x) +{ return x*x; +} + +double arsinh(double x) +{ return log(x+sqrt(x*x+1)); +} + + +double arcosh(double x) +{ return log(x+sqrt(x*x-1)); +} + + +double artanh(double x) +{ return log((1+x)/(1-x))/2; +} + +// sec, cosec, cot and their inverses + +double sec(double x) +{ return (1 / cos(x*Parser::anglemode())); +} + +double cosec(double x) +{ return (1 / sin(x*Parser::anglemode())); +} + +double cot(double x) +{ return (1 / tan(x*Parser::anglemode())); +} + +double arcsec(double x) +{ if ( !Parser::anglemode() ) return ( 1/acos(x)* 180/M_PI ); + else return acos(1/x); +} + +double arccosec(double x) +{ return asin(1/x)* 1/Parser::anglemode(); +} + +double arccot(double x) +{ return atan(1/x)* 1/Parser::anglemode(); +} + +// sech, cosech, coth and their inverses + + +double sech(double x) +{ return (1 / cosh(x*Parser::anglemode())); +} + +double cosech(double x) +{ return (1 / sinh(x*Parser::anglemode())); +} + +double coth(double x) +{ return (1 / tanh(x*Parser::anglemode())); +} + +double arsech(double x) +{ return arcosh(1/x)* 1/Parser::anglemode(); +} + +double arcosech(double x) +{ return arsinh(1/x)* 1/Parser::anglemode(); +} + +double arcoth(double x) +{ return artanh(1/x)* 1/Parser::anglemode(); +} + +//basic trigonometry functions + +double lcos(double x) +{ return cos(x*Parser::anglemode()); +} +double lsin(double x) +{ return sin(x*Parser::anglemode()); +} +double ltan(double x) +{ return tan(x*Parser::anglemode()); +} + +double lcosh(double x) +{ return cosh(x*Parser::anglemode()); +} +double lsinh(double x) +{ return sinh(x*Parser::anglemode()); +} +double ltanh(double x) +{ return tanh(x*Parser::anglemode()); +} + +double arccos(double x) +{ return acos(x) * 1/Parser::anglemode(); +} +double arcsin(double x) +{ return asin(x)* 1/Parser::anglemode(); +} + +double arctan(double x) +{ return atan(x)* 1/Parser::anglemode(); +} diff --git a/kicker-applets/math/parser.h b/kicker-applets/math/parser.h new file mode 100644 index 0000000..44e82ba --- /dev/null +++ b/kicker-applets/math/parser.h @@ -0,0 +1,241 @@ +/* +* Code based on parser from KmPlot - a math. function plotter for the KDE-Desktop +* +* Original code +* Copyright (C) 1998, 1999 Klaus-Dieter Mller +* 2000, 2002 kd.moeller@t-online.de +* +* Modifications: 2004 Andrew Coles (andrew_coles@yahoo.co.uk) +* +* This file is part of the KDE Project. +* KmPlot is part of the KDE-EDU Project. +* +* 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., 675 Mass Ave, Cambridge, MA 02139, USA. +* +*/ + +/** @file parser.h + * \brief Contains the parser core class Parser. */ + +// Qt includes +#include +#include + +#ifndef parser_included +#define parser_included + +// Voreinstellungen bei Verwendung des Standardkonstruktors : + + +#define UFANZ 10 ///< max. count of user defined functions +#define MEMSIZE 200 ///< memory size for tokens +#define STACKSIZE 50 ///< stack depth + +//@{ +/** Token type. */ +#define KONST 0 // double value follows +#define XWERT 1 // get x value +#define KWERT 2 // get function parameter +#define PUSH 3 // push value to stack +#define PLUS 4 // add +#define MINUS 5 // subtract +#define MULT 6 // multiply +#define DIV 7 // divide +#define POW 8 // exponentiate +#define NEG 9 // negate +#define FKT 10 // address to function followes +#define UFKT 11 // address to user defined function follows +#define ENDE 12 // end of function +#define YWERT 13 // get y value +#define FANZ 31 // number of mathematical functions in mfkttab[] +//@} + +//@{ +/** Predefined mathematical function. */ +double sign(double x); +double sqr(double x); +double arsinh(double x); +double arcosh(double x); +double artanh(double x); + +double sec(double x); +double cosec(double x); +double cot(double x); +double arcsec(double x); +double arccosec(double x); +double arccot(double x); + +double sech(double x); +double cosech(double x); +double coth(double x); +double arsech(double x); +double arcosech(double x); +double arcoth(double x); + +double lcos(double x); +double lsin(double x); +double ltan(double x); + +double lcosh(double x); +double lsinh(double x); +double ltanh(double x); + +double arccos(double x); +double arcsin(double x); +double arctan(double x); + +//@} + +class Constant +{ +public: + Constant( char c='A', double v=0) + { + constant = c; + value = v; + } + + char constant; + double value; +}; + +/** @short Parser. + * + * Tokenizes a function equation to be evaluated. + */ +class Parser +{ +public: + + Parser(); + Parser(int, int, int); + + ~Parser(); + + /// Evaluates the given expression. + double eval(QString); + /// Evaluates the function with the given name at the position. + double fkt(QString, double); + /// Evaluates the function with the given index at the position. + double fkt(int ix, double x) {return ufkt[ix].fkt(x);} + /// Adds a user defined function with the given equation. + int addfkt(QString); + /// Removes the function with the given name. + int delfkt(QString); + /// Removes the function with the given index. + int delfkt(int); + /// Returns name and expression of the function with the given index. + int getfkt(int, QString&, QString&); + /// Checks, if at the given index a function is stored. + int chkfix(int); + /// Returns the index of the function with the given name. + int getfix(QString); + /// Returns the lowest index in the array of user defined functions which is empty, + /// or -1, if the array is full. + int getNextIndex(); + /// Shows an error message box. + int errmsg(); + /// ? + void setparameter(int ix, double k) {ufkt[ix].k=k;} + /// return the angletype + static double anglemode(); + /// sets the angletype. TRUE is radians and FALSE degrees + void setAngleMode(int); + + QValueVector constant; + + /// Error codes. + /** + * The values have following meanings: + * \li 0 => parse success + * \li 1 => syntax error + * \li 2 => missing bracket + * \li 3 => function unknown + * \li 4 => function variable not valid + * \li 5 => too much functions + * \li 6 => memory overflow + * \li 7 => stack overflow + * \li 8 => function name allready used + * \li 9 => recursive function call + * \li 10 => didn't found the wanted constant + * \li 11 => emtpy function + */ + int err, + errpos, ///< Position where the error occured. + ufanz; ///< Max. count of user defined functions. + + + /** User function. */ + class Ufkt + { + public: + Ufkt(); + ~Ufkt(); + double fkt(double); ///< User defined function. + + unsigned char *mem; ///< Pointer to the allocated memory for the tokens. + unsigned char *mptr; ///< Pointer to the token. + QString fname; ///< Name of the function. + QString fvar; ///< Dummy variable. + QString fpar; ///< Parameter. + QString fstr; ///< Function expression. + int memsize; ///< Size of token memory + int stacksize; ///< Size of the stack. + double k, ///< Function parameter. + oldy; ///< The last y-value needed for Euler's method + } + *ufkt; ///< Points to the array of user defined functions. + +protected: + /** Mathematical function. */ + struct Mfkt + { + const char *mfstr; + double (*mfadr)(double); + }; + static Mfkt mfkttab[FANZ]; + +//private: +public: + + void ps_init(int, int, int), + heir1(), + heir2(), + heir3(), + heir4(), + primary(), + addtoken(unsigned char), + addwert(double), + addfptr(double(*)(double)), + addfptr(Ufkt*); + int match(const char*); + + unsigned + char evalflg, // 0 => String wird tokenisiert + // 1 => String wird direkt ausgewertet + *mem, // Zeiger auf Speicher fr Token + *mptr; // Zeiger fr Token + const + char *lptr; // Zeiger fr Funktions-String + int memsize, // Gr�e des Tokenspeichers + stacksize, // Gr�e des Stack + ixa; // Index der aktuellen Funktion + double *stack, // Zeiger auf Stackanfang + *stkptr; // Stackpointer + static double m_anglemode; + +}; + +#endif // parser_included -- cgit v1.2.3