calculator.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        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.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include "3d.h"
#include "input.h"
#include "controlEngine.h"
#include "calculator.h"

extern ControlEngine ce;

Opperation::Opperation()
{
        number = 0;
        op=Op_Null;
}

void Opperation::operator=(Opperation &src)
{
        number=src.number;
        op=src.op;
}

void Opperation::GetText(MyString &result)
{
        switch (op)
        {
        case Op_Null: result="Null"; break;
        case Op_Add: result="+"; break;
        case Op_Sub: result="-"; break;
        case Op_Mult: result="*"; break;
        case Op_Div: result="/"; break;
        default: result="Error";
        }
}

double Opperation::Compute(double param1,TOpperation op,double param2)
{
        switch (op)
        {
        case Op_Null: return param1;
        case Op_Add: return param1+param2;
        case Op_Sub: return param1-param2;
        case Op_Mult: return param1*param2;
        case Op_Div: return !param2?-1:param1/param2;
        default: return -1;
        }
}

// *********************************************************************

Calculator::Calculator()
{
        lineCur="0";
        txtResult=lineCur;
        txtResult.text.SetAlign(align_begin,align_begin);

        title="Calc";
        title.useMax=FALSE;

        // gestion evenement de touche
        onControl.key.down.connect(this,OnKey);
        client.onControl.key.down.connect(this,OnKey);
        for (int i=0;i<10;i++) btnNumbers[i].onControl.key.down.connect(this,OnKey);
        btnAdd.onControl.key.down.connect(this,OnKey);
        btnSub.onControl.key.down.connect(this,OnKey);
        btnDiv.onControl.key.down.connect(this,OnKey);
        btnMult.onControl.key.down.connect(this,OnKey);
        btnEqual.onControl.key.down.connect(this,OnKey);
        btnDot.onControl.key.down.connect(this,OnKey);
        btnEqual.onControl.key.down.connect(this,OnKey);

        // config des trouches numerique
        btnNumbers[0]="0";
        btnNumbers[0].onButton.click.connect(this,OnNum0);
        btnNumbers[1]="1";
        btnNumbers[1].onButton.click.connect(this,OnNum1);
        btnNumbers[2]="2";
        btnNumbers[2].onButton.click.connect(this,OnNum2);
        btnNumbers[3]="3";
        btnNumbers[3].onButton.click.connect(this,OnNum3);
        btnNumbers[4]="4";
        btnNumbers[4].onButton.click.connect(this,OnNum4);
        btnNumbers[5]="5";
        btnNumbers[5].onButton.click.connect(this,OnNum5);
        btnNumbers[6]="6";
        btnNumbers[6].onButton.click.connect(this,OnNum6);
        btnNumbers[7]="7";
        btnNumbers[7].onButton.click.connect(this,OnNum7);
        btnNumbers[8]="8";
        btnNumbers[8].onButton.click.connect(this,OnNum8);
        btnNumbers[9]="9";
        btnNumbers[9].onButton.click.connect(this,OnNum9);

        // config touche operation
        btnEqual="=";
        btnEqual.onButton.click.connect(this,OnEqual);
        btnAdd="+";
        btnAdd.onButton.click.connect(this,OnAdd);
        btnSub="-";
        btnSub.onButton.click.connect(this,OnSub);
        btnMult="*";
        btnMult.onButton.click.connect(this,OnMult);
        btnDiv="/";
        btnDiv.onButton.click.connect(this,OnDiv);
        btnDot=".";
        btnDot.onButton.click.connect(this,OnDot);
        btnClear="C";
        btnClear.onButton.click.connect(this,OnClear);
}

void Calculator::Create()
{
        ce.Push(ce.univers);
        Window::Create();
        canResize=FALSE;
        textureIcon.FromBitmap("calculator icon","texture/control/calculator icon.bmp");
        title.btnIcon.faceNode->Elems(FACE_FRONT)->texture=&textureIcon;

        ce.Push(&client);
        ce.primitive.GoTo(FACE_FRONT); // a l'avant

        // text resultat
        txtResult.Create();
        txtResult.XDockCenter(2,0);
        txtResult.YDockTop(2,80);

        int posX=2,posY=84;
        int dx=20,dy=20;
        btnClear.Create();
        btnClear.XDockLeft(posX,dx);
        btnClear.YDockTop(posY,dy);
        btnDiv.Create();
        btnDiv.XDockLeft(posX+dx+2,dx);
        btnDiv.YDockTop(posY,dy);
        btnMult.Create();
        btnMult.XDockLeft(posX+(dx+2)*2,dx);
        btnMult.YDockTop(posY,dy);
        btnSub.Create();
        btnSub.XDockLeft(posX+(dx+2)*3,dx);
        btnSub.YDockTop(posY,dy);

        posY+=22;
        btnNumbers[7].Create();
        btnNumbers[7].XDockLeft(posX+(dx+2)*0,dx);
        btnNumbers[7].YDockTop(posY,dy);
        btnNumbers[8].Create();
        btnNumbers[8].XDockLeft(posX+(dx+2)*1,dx);
        btnNumbers[8].YDockTop(posY,dy);
        btnNumbers[9].Create();
        btnNumbers[9].XDockLeft(posX+(dx+2)*2,dx);
        btnNumbers[9].YDockTop(posY,dy);
        btnAdd.Create();
        btnAdd.XDockLeft(posX+(dx+2)*3,dx);
        btnAdd.YDockTop(posY,dy*2+2);

        posY+=22;
        btnNumbers[4].Create();
        btnNumbers[4].XDockLeft(posX+(dx+2)*0,dx);
        btnNumbers[4].YDockTop(posY,dy);
        btnNumbers[5].Create();
        btnNumbers[5].XDockLeft(posX+(dx+2)*1,dx);
        btnNumbers[5].YDockTop(posY,dy);
        btnNumbers[6].Create();
        btnNumbers[6].XDockLeft(posX+(dx+2)*2,dx);
        btnNumbers[6].YDockTop(posY,dy);

        posY+=22;
        btnNumbers[1].Create();
        btnNumbers[1].XDockLeft(posX+(dx+2)*0,dx);
        btnNumbers[1].YDockTop(posY,dy);
        btnNumbers[2].Create();
        btnNumbers[2].XDockLeft(posX+(dx+2)*1,dx);
        btnNumbers[2].YDockTop(posY,dy);
        btnNumbers[3].Create();
        btnNumbers[3].XDockLeft(posX+(dx+2)*2,dx);
        btnNumbers[3].YDockTop(posY,dy);
        btnEqual.Create();
        btnEqual.XDockLeft(posX+(dx+2)*3,dx);
        btnEqual.YDockTop(posY,dy*2+2);

        posY+=22;
        btnNumbers[0].Create();
        btnNumbers[0].XDockLeft(posX+(dx+2)*0,dx*2+2);
        btnNumbers[0].YDockTop(posY,dy);
        btnDot.Create();
        btnDot.XDockLeft(posX+(dx+2)*2,dx);
        btnDot.YDockTop(posY,dy);
        ce.Pop();

        //affichage arriere:
        ce.Push(this);
        ce.primitive.GoTo(FACE_BACK);
        txtResultBase.Create();
        txtResultBase.XDockCenter(2,2);
        txtResultBase.YDockCenter(2,2);
        txtResultBase.faceNode->elem->angle.z=180;
        txtResultBase.text.SetAlign(align_begin,align_center);
        ce.Pop();
        ce.Pop();
}

void Calculator::MajResult()
{
        MyString text,txtOp;
        for (lOpperation.i=0;lOpperation.i.More();lOpperation.i++)
        {
                Opperation *oppCur = lOpperation.i.GetElemPtr();
                oppCur->GetText(txtOp);
                text<<oppCur->number<<" "<<txtOp<<"\n";
        }
        text<<lineCur;
        txtResult=text;
}

void Calculator::Compute()
{
        double result=0;
        double value;
        TOpperation oldOp=Op_Null;
        BOOL isFirst=TRUE;

        for (lOpperation.i=0;lOpperation.i.More();lOpperation.i++)
        {
                Opperation *oppCur = lOpperation.i.GetElemPtr();
                if (isFirst) { result=oppCur->number; isFirst=FALSE; }
                else result = Opperation::Compute(result,oldOp,oppCur->number);
                oldOp=oppCur->op;
        }
        sscanf(lineCur,"%lf",&value);
        result = Opperation::Compute(result,oldOp,value);
        lineCur.Format("%lf",result);
        lOpperation.i.SuprAll();
        MyString str(result);
        txtResult=str;

        MyString resultBase;
        str="";
        str<<"Hexa:\n";
        resultBase.EnterHexaNumber((int)result);
        str<<resultBase<<"\n";
        str<<"Bin:\n";
        resultBase.EnterBinNumber((int)result);
        str<<resultBase;
        txtResultBase=str;      
}

int Calculator::OnKey(StateKey *key,int face)
{
        switch (key->code)
        {
        case VK_NUMPAD0: 
        case VK_NUMPAD1: 
        case VK_NUMPAD2: 
        case VK_NUMPAD3: 
        case VK_NUMPAD4: 
        case VK_NUMPAD5: 
        case VK_NUMPAD6: 
        case VK_NUMPAD7: 
        case VK_NUMPAD8: 
        case VK_NUMPAD9: OnNum(key->code-VK_NUMPAD0); return 1;
        case VK_DECIMAL: OnDot(); return 1;;
        case VK_ADD: OnAdd(); return 1;
        case VK_SUBTRACT: OnSub(); return 1;
        case VK_DIVIDE: OnDiv(); return 1;
        case VK_MULTIPLY: OnMult(); return 1;
        case VK_RETURN: OnEqual(); return 1;
        case VK_DELETE: OnClear(); return 1;
        case VK_ESCAPE: Delete(); return 1;
        }
        return 1;
}

void Calculator::OnNum(int num)
{
        if (lineCur=="0") lineCur="";
        lineCur<<(char)('0'+num);
        MajResult();

}
int Calculator::OnNum0() { OnNum(0); return 0;}
int Calculator::OnNum1() { OnNum(1); return 0;}
int Calculator::OnNum2() { OnNum(2); return 0;}
int Calculator::OnNum3() { OnNum(3); return 0;}
int Calculator::OnNum4() { OnNum(4); return 0;}
int Calculator::OnNum5() { OnNum(5); return 0;}
int Calculator::OnNum6() { OnNum(6); return 0;}
int Calculator::OnNum7() { OnNum(7); return 0;}
int Calculator::OnNum8() { OnNum(8); return 0;}
int Calculator::OnNum9() { OnNum(9); return 0;}

int Calculator::OnDot()
{
        lineCur<<'.';
        MajResult();
        return 1;
}

int Calculator::OnClear()
{
        lineCur="0";
        lOpperation.i.SuprAll();
        MajResult();
        return 1;
}

int Calculator::OnEqual()
{
        Compute();
        return 1;
}

int Calculator::OnAdd()
{
        double result;
        sscanf(lineCur,"%lf",&result);
        Opperation op;
        op.number=result;
        op.op=Op_Add;
        lOpperation.i+=op;
        lineCur="0";
        MajResult();
        return 1;
}

int Calculator::OnSub()
{
        if (lineCur=="0") lineCur="-";
        else if (lineCur=="-") lineCur="0";
        else 
        {
                double result;
                sscanf(lineCur,"%lf",&result);
                Opperation op;
                op.number=result;
                op.op=Op_Sub;
                lOpperation.i+=op;
                lineCur="0";
        }
        MajResult();
        return 1;
}

int Calculator::OnMult()
{
        double result;
        sscanf(lineCur,"%lf",&result);
        Opperation op;
        op.number=result;
        op.op=Op_Mult;
        lOpperation.i+=op;
        lineCur="0";
        MajResult();
        return 1;
}

int Calculator::OnDiv()
{
        double result;
        sscanf(lineCur,"%lf",&result);
        Opperation op;
        op.number=result;
        op.op=Op_Div;
        lOpperation.i+=op;
        lineCur="0";
        MajResult();
        return 1;
}

int Calculator::OnOk()
{
        OnClose();
        return 1;
}

---