fork download

copy

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include <cmath>
 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TCalculator *Calculator;
//---------------------------------------------------------------------------
long double fact(double N)
	{
		if(N < 0)
			return 0;
		if (N == 0)
			return 1;
		else
			return N * fact(N - 1);
	}
//---------------------------------------------------------------------------
double toRadians(double a, char units)
	{
		switch(units){
			case 'd':  return (a * M_PI) / 180;
			case 'g':  return (a * M_PI) / 200;
			default: return a;
		}
	}
 
double toDegrees(double a, char units)
	{
		switch(units) {
			case 'r':return (a * 180) / M_PI;  break;
			case 'g': return a * 9 / 10; break;
			default : return a;
        }
 
	}
 
double toGrads(double a)
	{
		return (a * 200) / M_PI;
	}
//---------------------------------------------------------------------------
__fastcall TCalculator::TCalculator(TComponent* Owner)
	: TForm(Owner)
{
	rpn_text= "";
	a = 0;
	b = 0;
	countBrackets = 0;
	d = ' ';
	units = 'd';
	checker = false;
	error = false;
	brackets = false;
	invPress = true;
	checkStatusFunction = true;
	rpn = new RPN(rpn_text.c_str());
 
	sqrtButton->Caption = L"\u221A";
	deleteButton->Caption = L"\u2190";
	PiButton->Caption = L"\u03C0";
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::zeroButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '0';
		} else {
			l += '0';
		}
 
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::oneButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '1';
		} else {
			l += '1';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::twoButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '2';
		} else {
			l += '2';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::threeButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '3';
		} else {
			l += '3';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::fourButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '4';
		} else {
			l += '4';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::fiveButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
		if(l == '0'){
			l = '5';
		} else {
			l += '5';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::sixButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '6';
		} else {
			l += '6';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::sevenButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '7';
		} else {
			l += '7';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::eightButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		if(l == '0'){
			l = '8';
		} else {
			l += '8';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::nineButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
		if(l == '0'){
			l = '9';
		} else {
			l += '9';
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::pointButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		bool checkPoint = true;
		if(checker) {
			checker = false;
			l = '0';
		} else {
			if(checkStatusFunction){
				l = Edit->Text;
			} else {
				Edit->Text = 0;
				AnsiString h = History->Text;
				h.Delete(funcPos,h.Length()-funcPos + 1);
				History->Text = h;
				checkStatusFunction = true;
			}
		}
 
		for(int i=1;i<=l.Length();i++){
			if(l[i] == '.'){
				checkPoint = false;
				break;
			}
		}
 
		if(checkPoint) {
			l += '.';
			Edit->Text = l;
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::plusButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			 if(brackets) {
				rpn_text += l;
				rpn_text += '+';
				rpn_text += '0';
				brackets = false;
			} else {
				rpn_text[rpn_text.Length() - 1] = '+';
				rpn_text[rpn_text.Length()] = '0';
				switch(d){
					case '+': case '-': case '/': case '*': h[h.Length() - 1] = '+'; break;
					case 'm': h.Delete(h.Length()-2,2); h[h.Length() - 1] = '+'; break;
					case 'r': h.Delete(h.Length() - 5,6), h += "+ "; break;
				}
			}
		}else {
			firstD = '+';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += FloatToStr(a);
				h += " + ";
				rpn_text += '+';
				rpn_text += '0';
				checker = true;
			} else {
				h += " + ";
				rpn_text += l;
				rpn_text += '+';
				rpn_text += '0';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = '+';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::minusButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			 if(brackets) {
				rpn_text += l;
				rpn_text += '-';
				rpn_text += '0';
				brackets = false;
			} else {
				rpn_text[rpn_text.Length() - 1] = '-';
				rpn_text[rpn_text.Length()] = '0';
				switch(d){
					case '+': case '-': case '/': case '*': h[h.Length() - 1] = '-'; break;
					case 'm': h.Delete(h.Length()-2,2); h[h.Length() - 1] = '-'; break;
					case 'r': h.Delete(h.Length() - 5,6), h += "- "; break;
				}
			}
		}else {
			firstD = '-';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += FloatToStr(a);
				h += " - ";
				rpn_text += '-';
				rpn_text += '0';
				checker = true;
			} else {
				h += " - ";
				rpn_text += l;
				rpn_text += '-';
				rpn_text += '0';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = '-';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::factButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "fact(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "fact(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(a >= 0) {
			b = fact(a);
			Edit->Text = FloatToStr(b);
		} else {
			Edit->Text = "Недопустимый ввод";
			error = true;
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::multiplyButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			if((firstD != '*') && (firstD != '/') && (firstD != '^') && (firstD != 'r') && (firstD != 'm')){
				AnsiString buffRPN = '(';
				AnsiString buffHistory = '(';
				int countOp = 0;
				for(int i = 1; i < rpn_text.Length()-1; i++){
					buffRPN += rpn_text[i];
					switch(rpn_text[i]){
							case '+': case '-': case '*': case '/':case 'm': case '^' :case 'r':	countOp++; break;
					}
				}
 
				for(int i = 1; i < h.Length() - 2; i++){
					buffHistory += h[i];
				}
 
				if(countOp >= 1) {
						buffRPN += ')'; buffRPN += rpn_text[rpn_text.Length()-1]; buffRPN += rpn_text[rpn_text.Length()];
						rpn_text = buffRPN;
						h = buffHistory;
						h += ") * ";
				}
				firstD = '*';
			}
			rpn_text[rpn_text.Length() - 1] = '*';
			rpn_text[rpn_text.Length()] = '1';
			switch(d){
				case '+': case '-': case '/': case '*': h[h.Length() - 1] = '*'; break;
				case 'm': h.Delete(h.Length()-2,2); h[h.Length() - 1] = '*'; break;
				case 'r': h.Delete(h.Length() - 5,6), h += "* "; break;
			}
		}else {
			firstD = '*';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += l;
				h += " * ";
				rpn_text += '*';
				rpn_text += '1';
				checker = true;
			} else {
				h += " * ";
				rpn_text += l;
				rpn_text += '*';
				rpn_text += '1';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = '*';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::divideButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
 
		if(checker) {
			if((firstD != '*') && (firstD != '/') && (firstD != '^') && (firstD != 'r') && (firstD != 'm')){
				AnsiString buffRPN = '(';
				AnsiString buffHistory = '(';
				int countOp = 0;
				for(int i = 1; i < rpn_text.Length()-1; i++){
					buffRPN += rpn_text[i];
					switch(rpn_text[i]){
							case '+': case '-': case '*': case '/':case 'm': case '^' :case 'r':	countOp++; break;
					}
				}
 
				if(countOp >= 1) {
					for(int i = 1; i < h.Length() - 2; i++){
						buffHistory += h[i];
					}
					buffRPN += ')'; buffRPN += rpn_text[rpn_text.Length()-1]; buffRPN += rpn_text[rpn_text.Length()];
					rpn_text = buffRPN;
					h = buffHistory;
					h += ") / ";
				}
				firstD = '/';
			}
			rpn_text[rpn_text.Length() - 1] = '/';
			rpn_text[rpn_text.Length()] = '1';
			switch(d){
				case '+': case '-': case '/': case '*': h[h.Length() - 1] = '/'; break;
				case 'm': h.Delete(h.Length()-2,2); h[h.Length() - 1] = '/'; break;
				case 'r': h.Delete(h.Length() - 5,6), h += "/ "; break;
			}
		}else {
			firstD = '/';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += l;
				h += " / ";
				rpn_text += '/';
				rpn_text += '1';
				checker = true;
			} else {
				h += " / ";
				rpn_text += l;
				rpn_text += '/';
				rpn_text += '1';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		if(a != 0) {
			d = '/';
			if(countBrackets == 0){
				rpn->setRPN(rpn_text.c_str());
				rpn->calculate();
			}
			History->Text = h;
			Edit->Text = FloatToStr(rpn->getResult());
		} else {
			History->Text = h;
			Edit->Text = "Недопустимый ввод";
			error = true;
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::procButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		b = a / 100;
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "proc(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "proc(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::reciprocButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "reciproc(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "reciproc(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(a != 0) {
			b = 1 / a;
			Edit->Text = FloatToStr(b);
		} else {
			Edit->Text = "Недопустимый ввод";
			error = true;
        }
 
 
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::negateButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l = Edit->Text;
		a = StrToFloat(l);
 
		if (!checkStatusFunction) {
			l = "";
			AnsiString h = History->Text;
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "negate(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		checker = false;
		b = -1 * a;
		Edit->Text = FloatToStr(b);
	}
 
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::sqrtButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "sqrt(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "sqrt(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(a >= 0) {
			b = sqrt(a);
			Edit->Text = FloatToStr(b);
		} else {
			Edit->Text = "Недопустимый ввод";
			error = true;
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::lnButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(invPress) {
				h += "ln(" + FloatToStr(a) + ")";
			} else {
				h += "powe(" + FloatToStr(a) + ")";
			}
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(invPress) {
						l+= "ln(";
					} else {
					   l+= "powe(";
                    }
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress) {
			if(a > 0) {
				b = log(a);
				Edit->Text = FloatToStr(b);
			} else {
				Edit->Text = "Недопустимый ввод";
				error = true;
			}
		} else {
			b = exp(log(M_E) * a);
			Edit->Text = FloatToStr(b);
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::sinButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			switch(units){
				case 'd': h += "sind(" + l + ")";  break;
				case 'r': h += "sinr(" + l + ")";  break;
				case 'g': h += "sing(" + l + ")";  break;
			}
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					switch(units){
						case 'd': l += "sind(";  break;
						case 'r': l += "sinr(";  break;
						case 'g': l += "sing(";  break;
					}
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			a = toRadians(a, units);
			b = sin(a);
			Edit->Text = FloatToStr(b);
		}else {
			if((a >= -1) && (a <= 1)){
				b = asin(a);
				switch(units) {
					case 'd': b = toDegrees(b,'r'); break;
					case 'g': b = toGrads(b); break;
				}
				Edit->Text = FloatToStr(b);
			} else {
				Edit->Text = "Недопустимый ввод";
				error = true;
			}
		}
 
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::sinhButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			h += "sinh(" + l + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					h += "sinh(" + l + ")";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			b = sinh(a);
		}else {
			b = log(a + sqrt(pow(a,2) + 1));
		}
 
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::cosButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			switch(units){
				case 'd': h += "cosd(" + l + ")";  break;
				case 'r': h += "cosr(" + l + ")";  break;
				case 'g': h += "cosg(" + l + ")";  break;
			}
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					switch(units){
						case 'd': l += "cosd(";  break;
						case 'r': l += "cosr(";  break;
						case 'g': l += "cosg(";  break;
					}
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			a = toRadians(a, units);
			b = cos(a);
			Edit->Text = FloatToStr(b);
		}else {
			if((a >= -1) && (a <= 1)){
				b = acos(a);
				switch(units) {
					case 'd': b = toDegrees(b,'r'); break;
					case 'g': b = toGrads(b); break;
				}
				Edit->Text = FloatToStr(b);
			} else {
				Edit->Text = "Недопустимый ввод";
				error = true;
			}
		}
 
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::coshButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			h += "cosh(" + l + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					l += "cosh(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			b = cosh(a);
			Edit->Text = FloatToStr(b);
		}else {
			if(a >= 1){
				b = log(a + sqrt(pow(a,2) - 1));
				Edit->Text = FloatToStr(b);
			} else {
				Edit->Text = "Недопустимый ввод";
				error = true;
			}
		}
 
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::tanButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			switch(units){
				case 'd': h += "tand(" + l + ")";  break;
				case 'r': h += "tanr(" + l + ")";  break;
				case 'g': h += "tang(" + l + ")";  break;
			}
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					switch(units){
						case 'd': l += "tand(";  break;
						case 'r': l += "tanr(";  break;
						case 'g': l += "tang(";  break;
					}
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			a = toDegrees(a, units);
			if(((int)a == 90) || ((int)a == 270)) {
				Edit->Text = "Недопустимый ввод";
				error = true;
			} else {
				a = toRadians(a, units);
				b = tan(a);
				Edit->Text = FloatToStr(b);
			}
		}else {
			a = toDegrees(a, units);
			if(((int)a == 0) || ((int)a == 180) || ((int)a == 360)) {
				Edit->Text = "Недопустимый ввод";
				error = true;
			} else {
				a = toRadians(a, units);
				b = atan(a);
				Edit->Text = FloatToStr(b);
			}
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::tanhButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			if(!invPress) {h += 'a';}
			h += "tanh(" + l + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					if(!invPress) {l += 'a';}
					l += "tanh(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(invPress){
			b = tanh(a);
			Edit->Text = FloatToStr(b);
		}else {
			if(a == 1) {
				Edit->Text = "Деление на ноль невозможно";
				error = true;
			}else {
				if((a > -1) &&(a < 1)) {
					b = 0.5 * log((1 + a)/(1 - a));
					Edit->Text = FloatToStr(b);
				}else {
					Edit->Text = "Недопустимый ввод";
					error = true;
                }
			}
		}
 
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::equallyButtonClick(TObject *Sender)
{
	if(!error){
		if((!checker) || (!checkStatusFunction) || (checker)){
			a = StrToFloat(Edit->Text);
			rpn_text.Delete(rpn_text.Length(),1);
			rpn_text += FloatToStr(a);
		}
 
		for(int i=1; i<= countBrackets;i++){
			rpn_text += ')';
		}
 
		rpn->setRPN(rpn_text.c_str());
		rpn->calculate();
		History->Clear();
		Edit->Text = FloatToStr(rpn->getResult());
 
		rpn_text= "";
		a = 0;
		b = 0;
		countBrackets = 0;
		d = ' ';
		checker = false;
		error = false;
		brackets = false;
		checkStatusFunction = true;
		countBracketsButton->Caption = "";
	}
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::clearButtonClick(TObject *Sender)
{
	rpn_text= "";
	a = 0;
	b = 0;
	countBrackets = 0;
	d = ' ';
	checker = false;
	error = false;
	brackets = false;
	checkStatusFunction = true;
	countBracketsButton->Caption = "";
	Edit->Text = 0;
	History->Clear();
 
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::deleteButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l = Edit->Text;
 
		if(l.Length() > 1) {
			l.Delete0(l.Length()-1,1);
			Edit->Text = l;
		} else {
		   Edit->Text = 0;
		}
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::degreesRadioButtonClick(TObject *Sender)
{
	units = 'd';
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::radiansRadioButtonClick(TObject *Sender)
{
	units = 'r';
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::gradsRadioButtonClick(TObject *Sender)
{
	units = 'g';
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::PiButtonClick(TObject *Sender)
{
	if(invPress){
		Edit->Text = FloatToStr(M_PI);
	} else {
        Edit->Text = FloatToStr(2 * M_PI);
    }
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::CEButtonClick(TObject *Sender)
{
	if(error){
		rpn_text= "";
		a = 0;
		b = 0;
		d = ' ';
		checker = false;
		error = false;
		checkStatusFunction = true;
		History->Clear();
	} else if(!checkStatusFunction){
		AnsiString h = History->Text;
		h.Delete(funcPos,h.Length()-funcPos + 1);
		History->Text = h;
		checkStatusFunction = true;
	}
	Edit->Text = '0';
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::powTenButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if(a == 0){
			b = 1;
		} else {
			if(a < 0) {
				b = (1/(exp(log(10.0) * (abs(a)))));
			} else {
				b = (exp(log(10.0) * a));
			}
		}
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "powten(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "powten(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::cuberootButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (a == 0) {
			b = 0;
		}else if (a > 0) {
			b = (exp(log(a) * 1/3));
		}else {
			b = -(exp(log(abs(a)) * 1/3));
		}
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "cuberoot(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "cuberoot(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::cubeButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (a == 0) {
			b = 0;
		}else if (a > 0) {
			b = (exp(log(a) * 3));
		}else {
			b = -(exp(log(abs(a)) * 3));
		}
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "cube(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "cube(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::sqrButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (a == 0) {
			b = 0;
		}else {
			b = (exp(log(abs(a)) * 2));
		}
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "sqr(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "sqr(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
		Edit->Text = FloatToStr(b);
	}
}
//---------------------------------------------------------------------------
 
 
void __fastcall TCalculator::logButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l;
		AnsiString h = History->Text;
		l = Edit->Text;
		a = StrToFloat(l);
 
		if (checkStatusFunction) {
			funcPos = h.Length() + 1;
			h += "log(" + FloatToStr(a) + ")";
			History->Text = h;
			checkStatusFunction = false;
			checker = false;
		} else {
			l = "";
			for (int i=1; i<=h.Length();i++){
				if(i == funcPos){
					l+= "log(";
				}
				l += h[i];
			}
			l += ")";
			History->Text = l;
		}
 
		if(a > 0) {
			b = log10(a);
			Edit->Text = FloatToStr(b);
		} else {
			Edit->Text = "Недопустимый ввод";
			error = true;
		}
	}
}
//---------------------------------------------------------------------------
 
 
void __fastcall TCalculator::invButtonClick(TObject *Sender)
{
	if(!error) {
		if(invPress) {
			sinButton->Caption = "asin";
			cosButton->Caption = "acos";
			tanButton->Caption = "atan";
			sinhButton->Caption = "asinh";
			coshButton->Caption = "acosh";
			tanhButton->Caption = "atanh";
			lnButton->Caption = "e^x";
			intButton->Caption = "Frac";
			dmsButton->Caption = "deg";
			PiButton->Caption = "2*п";
			invPress = false;
		} else {
			sinButton->Caption = "sin";
			cosButton->Caption = "cos";
			tanButton->Caption = "tan";
			sinhButton->Caption = "sinh";
			coshButton->Caption = "cosh";
			tanhButton->Caption = "tanh";
			lnButton->Caption = "ln";
			intButton->Caption = "Int";
			dmsButton->Caption = "dms";
			PiButton->Caption = "п";
			invPress = true;
		}
	}
}
//---------------------------------------------------------------------------
 
 
void __fastcall TCalculator::yPowButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			if((firstD != '*') && (firstD != '/') && (firstD != '^') && (firstD != 'r') && (firstD != 'm')){
				AnsiString buffRPN = '(';
				AnsiString buffHistory = '(';
				int countOp = 0;
				for(int i = 1; i < rpn_text.Length()-1; i++){
					buffRPN += rpn_text[i];
					switch(rpn_text[i]){
						case '+': case '-': case '*': case '/':case 'm': case '^' :case 'r': countOp++; break;
					}
				}
 
				for(int i = 1; i < h.Length() - 2; i++){
					buffHistory += h[i];
				}
 
				if(countOp >= 1) {
						buffRPN += ')'; buffRPN += rpn_text[rpn_text.Length()-1]; buffRPN += rpn_text[rpn_text.Length()];
						rpn_text = buffRPN;
						h = buffHistory;
						h += ") ^ ";
				}
				firstD = '^';
			}
			rpn_text[rpn_text.Length() - 1] = '^';
			rpn_text[rpn_text.Length()] = '1';
			switch(d){
				case '+': case '-': case '/': case '*': h[h.Length() - 1] = '^'; break;
				case 'm': h.Delete(h.Length()-2,2); h[h.Length() - 1] = '^'; break;
			}
		}else {
			firstD = '^';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += l;
				h += " ^ ";
				rpn_text += '^';
				rpn_text += '1';
				checker = true;
			} else {
				h += " ^ ";
				rpn_text += l;
				rpn_text += '^';
				rpn_text += '1';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = '^';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
 
 
 
void __fastcall TCalculator::yrootButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			if((firstD != '*') && (firstD != '/') && (firstD != '^') && (firstD != 'r') && (firstD != 'm')){
				AnsiString buffRPN = '(';
				AnsiString buffHistory = '(';
				int countOp = 0;
				for(int i = 1; i < rpn_text.Length()-1; i++){
					buffRPN += rpn_text[i];
					switch(rpn_text[i]){
							case '+': case '-': case '*': case '/':case 'm': case '^' :case 'r':	countOp++; break;
					}
				}
 
				for(int i = 1; i < h.Length() - 2; i++){
					buffHistory += h[i];
				}
 
				if(countOp >= 1) {
						buffRPN += ')'; buffRPN += rpn_text[rpn_text.Length()-1]; buffRPN += rpn_text[rpn_text.Length()];
						rpn_text = buffRPN;
						h = buffHistory;
						h += ") yroot ";
						d = 'r';
				}
				firstD = 'r';
			}
			rpn_text[rpn_text.Length() - 1] = 'r';
			rpn_text[rpn_text.Length()] = '1';
			switch(d){
				case '+': case '-': case '/': case '*': h.Delete(h.Length() - 1,2), h += "yroot "; break;
				case 'm': h.Delete(h.Length()-3,4); h += "yroot "; break;
			}
		}else {
			firstD = 'r';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += l;
				h += " yroot ";
				rpn_text += 'r';
				rpn_text += '1';
				checker = true;
			} else {
				h += " yroot ";
				rpn_text += l;
				rpn_text += 'r';
				rpn_text += '1';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = 'r';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::modButtonClick(TObject *Sender)
{
	if(!error) {
		AnsiString l = Edit->Text;
		AnsiString h = History->Text;
 
		a=StrToFloat(l);
		if(a < 0) {
			l = '(';
			l += FloatToStr(a);
			l += ')';
		} else {
			l = FloatToStr(a);
		}
 
		if(checker) {
			if((firstD != '*') && (firstD != '/') && (firstD != '^') && (firstD != 'r') && (firstD != 'm')){
				AnsiString buffRPN = '(';
				AnsiString buffHistory = '(';
				int countOp = 0;
				for(int i = 1; i < rpn_text.Length()-1; i++){
					buffRPN += rpn_text[i];
					switch(rpn_text[i]){
							case '+': case '-': case '*': case '/':case 'm': case '^' :case 'r':	countOp++; break;
					}
				}
 
				for(int i = 1; i < h.Length() - 2; i++){
					buffHistory += h[i];
				}
 
				if(countOp >= 1) {
						buffRPN += ')'; buffRPN += rpn_text[rpn_text.Length()-1]; buffRPN += rpn_text[rpn_text.Length()];
						rpn_text = buffRPN;
						h = buffHistory;
						h += ") Mod ";
						d = 'm';
				}
				firstD = 'm';
			}
			rpn_text[rpn_text.Length() - 1] = 'm';
			rpn_text[rpn_text.Length()] = '1';
			switch(d){
				case '+': case '-': case '/': case '*': case '^': h.Delete(h.Length() - 1,2), h += "Mod "; break;
				case 'r': h.Delete(h.Length() - 5,6), h += "Mod "; break;
			}
		}else {
			firstD = 'm';
			if(brackets) {
				brackets = false;
			} else {
				rpn_text.Delete(rpn_text.Length(), 1);
			}
			if(checkStatusFunction) {
				rpn_text += l;
				h += l;
				h += " Mod ";
				rpn_text += 'm';
				rpn_text += '1';
				checker = true;
			} else {
				h += " Mod ";
				rpn_text += l;
				rpn_text += 'm';
				rpn_text += '1';
				checker = true;
				checkStatusFunction = true;
			}
		}
 
		d = 'm';
		if(countBrackets == 0){
			rpn->setRPN(rpn_text.c_str());
			rpn->calculate();
		}
 
		History->Text = h;
		Edit->Text = FloatToStr(rpn->getResult());
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::intButtonClick(TObject *Sender)
{
	if(!error){
			AnsiString l;
			AnsiString h = History->Text;
			l = Edit->Text;
			a = StrToFloat(l);
 
 
 
			if (checkStatusFunction) {
				funcPos = h.Length() + 1;
				if(invPress){
					h += "Int(" + FloatToStr(a) + ")";
				} else {
					h += "frac(" + FloatToStr(a) + ")";
                }
				History->Text = h;
				checkStatusFunction = false;
				checker = false;
			} else {
				l = "";
				for (int i=1; i<=h.Length();i++){
					if(i == funcPos){
						if(invPress) {
							l+= "Int(";
						} else {
                            l+= "frac(";
                        }
					}
					l += h[i];
				}
				l += ")";
				History->Text = l;
			}
 
			if(invPress){
				b = (int)a;
			}else {
                b = a - (int)a;
            }
 
			Edit->Text = FloatToStr(b);
		}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::mPlusButtonClick(TObject *Sender)
{
	if(!error) {
		mBuff += StrToFloat(Edit->Text);
    }
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::mMinusButtonClick(TObject *Sender)
{
	if(!error) {
		mBuff -= StrToFloat(Edit->Text);
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::mRepeatButtonClick(TObject *Sender)
{
	if(!error) {
		mBuff = StrToFloat(Edit->Text);
    }
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::mWriteButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l = FloatToStr(mBuff);
		if(checker) {
			checker = false;
		} else {
			if(!checkStatusFunction){
				rpn_text= "";
				a = 0;
				b = 0;
				d = ' ';
				checker = false;
				checkStatusFunction = true;
				Edit->Text = FloatToStr(mBuff);
				History->Clear();
			}
		}
		Edit->Text = l;
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::mCEButtonClick(TObject *Sender)
{
	mBuff = 0;
}
//---------------------------------------------------------------------------
void __fastcall TCalculator::leftBracketsButtonClick(TObject *Sender)
{
	if(!error){
		AnsiString l;
		AnsiString h = History->Text;
		countBrackets++;
		countBracketsButton->Caption = "(=" + IntToStr(countBrackets);
 
		if(checker) {
			if((rpn_text[rpn_text.Length()] == '0') || (rpn_text[rpn_text.Length()] == '1')) {
				rpn_text.Delete(rpn_text.Length(),1);
				h.Delete(h.Length(),1);
			}
			rpn_text += '(';
			h += '(';
		} else {
			if(checkStatusFunction){
				if(rpn_text.Length() > 0){
					if((rpn_text[rpn_text.Length()] == '0') || (rpn_text[rpn_text.Length()] == '1')) {
						rpn_text.Delete(rpn_text.Length(),1);
						h.Delete(h.Length(),1);
					}
					rpn_text += '(';
					h+='(';
				} else {
					rpn_text += '(';
					h+='(';
				}
			} else {
				rpn_text.Delete(rpn_text.Length(),1);
				rpn_text += '(';
				h+='(';
			}
		}
		brackets = true;
		History->Text = h;
	}
}
//---------------------------------------------------------------------------
 
void __fastcall TCalculator::rightBracketsButtonClick(TObject *Sender)
{
	if(!error){
		if(countBrackets>0){
			AnsiString l;
			countBrackets--;
			if(countBrackets == 0) {
				countBracketsButton->Caption = "";
			} else {
				countBracketsButton->Caption = "(=" + IntToStr(countBrackets);
			}
			AnsiString h = History->Text;
 
			if(checker) {
				if(rpn_text[rpn_text.Length()] == '('){
					rpn_text[rpn_text.Length()] = '0';
				} else {
					rpn_text[rpn_text.Length() - 1] = ')';
					rpn_text.Delete(rpn_text.Length(),1);
					h[h.Length() - 1] = ')';
					h+= "  ";
				}
			} else {
				if(checkStatusFunction){
					if(rpn_text.Length() > 1){
						rpn_text.Delete(rpn_text.Length(), 1);
						rpn_text += Edit->Text;
						rpn_text += ')';
						h += Edit->Text;
						h += ')';
					} else {
						if(rpn_text[rpn_text.Length()] == '('){
							rpn_text[rpn_text.Length()] = '0';
							h[h.Length()] = '0';
						} else {
							rpn_text += ')';
							h += ')';
                        }
					}
				} else {
					rpn_text += Edit->Text;
					rpn_text += ')';
					h += Edit->Text;
					h += ')';
				}
			}
			rpn_text += "*1";
			d = '*';
			firstD = '*';
			brackets = false;
			checker = true;
			History->Text = h;
		}
	}
}
//---------------------------------------------------------------------------