Ticket #5203: deskcalc.patch

src/apps/deskcalc/CalcView.cpp

@@ -60 +60 @@
 
 // default calculator key pad layout
 const char *kDefaultKeypadDescription =
-    "7   8   9   (   )  \n"
-    "4   5   6   *   /  \n"
-    "1   2   3   +   -  \n"
-    "0   .   BS  =   C  \n";
+    "7   8   9   (   )  \n"
+    "4   5   6   *   /  \n"
+    "1   2   3   +   -  \n"
+    "0   .   BS  =   C  \n";
 
 
 enum {
@@ -204 +204 @@
 CalcView::AttachedToWindow()
 {
     if (be_control_look == NULL)
-        SetFont(be_bold_font);
+        SetFont(be_fixed_font);
 
     BRect frame(Frame());
     FrameResized(frame.Width(), frame.Height());
@@ -579 +579 @@
 void
 CalcView::KeyDown(const char* bytes, int32 numBytes)
 {
-    // if single byte character...
+    // if single byte character...
     if (numBytes == 1) {
 
         //printf("Key pressed: %c\n", bytes[0]);
@@ -668 +668 @@
 
     // configure expression text view font size and color
     float sizeDisp = fShowKeypad ? fHeight * kDisplayScaleY : fHeight;
-    BFont font(be_bold_font);
+    BFont font(be_fixed_font);
+    font.SetSpacing(B_FIXED_SPACING);
     font.SetSize(sizeDisp * kExpressionFontScaleY);
     fExpressionTextView->SetFontAndColor(&font, B_FONT_ALL);
 
@@ -721 +722 @@
 void
 CalcView::Cut()
 {
-    Copy(); // copy data to clipboard
+    Copy(); // copy data to clipboard
     fExpressionTextView->Clear(); // remove data
 }
 
@@ -903 +904 @@
 
     _AudioFeedback(false);
 
+    ExpressionParser parser;
+    double value = 0.0;
+    BString result;
+
     // evaluate expression
-    BString value;
-
     try {
-        ExpressionParser parser;
-        value = parser.Evaluate(expression.String());
+        value = parser.EvaluateToDouble(expression.String());
     } catch (ParseException e) {
-        BString error(e.message.String());
-        error << " at " << (e.position + 1);
-        fExpressionTextView->SetText(error.String());
+        result.SetTo("error"); // just print error
+        fExpressionTextView->SetExpression(result.String());
         return;
     }
 
-    // render new result to display
-    fExpressionTextView->SetExpression(value.String());
+    // special case for value = 0
+    if (value == 0) {
+        result.SetTo("0");
+        fExpressionTextView->SetExpression(result.String());
+        return;
+    }
+
+    // set the number of places that will fit in the display based on
+    // the expressionWidth (92px to 392px) and fontWidth (7px to 29px)
+    double expressionWidth = fExpressionTextView->Frame().Width();
+    BFont font;
+    uint32 sameProperties;
+    fExpressionTextView->GetFontAndColor(&font, &sameProperties);
+    double fontWidth = font.StringWidth("0"); // Any 1 char string will do
+    // subtract 1 for the decimal point and 1 to leave space at the end
+    int32 places = (int32)((expressionWidth / fontWidth) - 2);
+
+    if (value < 0)
+        places--; // subtract 1 place to fit the negative sign
+    if (places < 0)
+        places = 0; // minimum of 0 decimal places
+
+    // Standard Notation
+
+    result = parser.EvaluateToStandard(expression.String(), places);
+
+    // If the result is too large then converting to scientific notation
+    // will hopefully make it small enough to fit in the window by sacrificing
+    // decimal digits of precision. I cannot garentee that even with 0 decimal
+    // places the result will fit because the exponent can make the result
+    // too large to fit in the window. 
+    //
+    // The result can also get cutoff if places is too small to fit the result.
+    // For example 1E-10 (0.000000000001) requires 13 places so if places
+    // is 12 or less than the result will be 0. By converting the result
+    // to a double and comparing with the originally calculated result I can
+    // detect these errors and convert to scientific notation which will
+    // hopefully make the result fit by sacrificing precision after the
+    // decimal point.
+
+    int32 resultlen = result.Length();
+    if (result.FindFirst('.') == B_ERROR)
+        resultlen--; // subtract one for the lack of a decimal point
+    if (result.FindFirst('-') != B_ERROR)
+        resultlen--; // subtract one for the negative sign
+
+    // If result is too large to fit or got cutoff then convert to 
+    // scientific notation.
+    if ((resultlen > places) || (fabs(atof(result)) < fabs(value))) {
+        // Calculate the number of digits in the exponent
+        int32 expdigits = 1;
+        double tmpvalue = fabs(value);
+        while ((tmpvalue /= 10.0) > 1.0)
+            expdigits++;
+        expdigits = (int32)(ceil(log10(expdigits)));
+        expdigits += 1; // add one for the E
+
+        if (places >= expdigits)
+            places -= expdigits;
+        if (places < 0)
+            places = 0; // minimum of 0 decimal places
+
+        // Scientific Notation
+        result = parser.EvaluateToScientific(expression.String(), places);
+
+        // If result ends in E0 then remove it
+        if (result[result.Length() - 1] == '0'
+         && result[result.Length() - 2] == 'E')
+            result = result.Remove(result.Length() - 2, 2 * sizeof(char));
+    }
+
+    fExpressionTextView->SetExpression(result.String());
 }
 
-
 void
 CalcView::FlashKey(const char* bytes, int32 numBytes)
 {

src/kits/shared/ExpressionParser.cpp

@@ -348 +348 @@
 BString
 ExpressionParser::Evaluate(const char* expressionString)
 {
-    fTokenizer->SetTo(expressionString);
+    return EvaluateToStandard(expressionString, kMaxDecimalPlaces);
+}
 
-    MAPM value = _ParseBinary();
-    Token token = fTokenizer->NextToken();
-    if (token.type != TOKEN_END_OF_LINE)
-        throw ParseException("parse error", token.position);
 
-    if (value == 0)
-        return BString("0");
+BString
+ExpressionParser::EvaluateToStandard(const char* expressionString, 
+                                     int32 places)
+{
+    fTokenizer->SetTo(expressionString);
 
-    char* buffer = value.toFixPtStringExp(kMaxDecimalPlaces, '.', 0, 0);
-    if (buffer == NULL)
-        throw ParseException("out of memory", 0);
+    MAPM value = _ParseBinary();
+    Token token = fTokenizer->NextToken();
+    if (token.type != TOKEN_END_OF_LINE)
+        throw ParseException("parse error", token.position);
 
-    // remove surplus zeros
-    int32 lastChar = strlen(buffer) - 1;
-    if (strchr(buffer, '.')) {
-        while (buffer[lastChar] == '0')
-            lastChar--;
-        if (buffer[lastChar] == '.')
-            lastChar--;
-    }
+    if (value == 0)
+        return BString("0");
 
-    BString result(buffer, lastChar + 1);
-    free(buffer);
-    return result;
+    char* buffer = value.toFixPtStringExp(places, '.', 0, 0);
+    if (buffer == NULL)
+        throw ParseException("out of memory", 0);
+    BString result(buffer);
+    free(buffer);
+
+    // remove trailing decimal zeros
+    if (result.FindFirst('.') != B_ERROR) {
+        int32 offset = result.Length() - 1;
+        while (result[offset] == '0') {
+            result = result.Remove(offset, sizeof(char));
+            offset--;
+        }
+        if (result[offset] == '.')
+            result = result.Remove(offset, sizeof(char));
+    }
+
+    return result;
 }
 
 
+BString
+ExpressionParser::EvaluateToScientific(const char* expressionString, 
+                                       int32 places)
+{
+    fTokenizer->SetTo(expressionString);
+
+    MAPM value = _ParseBinary();
+    Token token = fTokenizer->NextToken();
+    if (token.type != TOKEN_END_OF_LINE)
+        throw ParseException("parse error", token.position);
+
+    if (value == 0)
+        return BString("0");
+
+    // max number of characters possible for 32 bits of decimal places is
+    // decimal places + 15 for -0.9999999....E+2147483647
+    // 3 + decimal digits + 2 + 10 = places + 1
+    char buffer[places + 15];
+    value.toString(buffer, places);
+    BString result(buffer, places + 15);
+
+    // remove the '+' after the 'E' (not needed)
+    int32 offset = result.FindLast('E');
+    if (offset != B_ERROR && result[offset + 1] == '+') {
+        result = result.Remove(offset + 1, sizeof(char));
+    }
+
+    // remove trailing decimal zeros
+    if (offset != B_ERROR && result.FindFirst('.') != B_ERROR) {
+        offset--;
+        while (result[offset] == '0') {
+            result = result.Remove(offset, sizeof(char));
+            offset--;
+        }
+        if (result[offset] == '.')
+            result = result.Remove(offset, sizeof(char));
+    }
+
+    return result;
+}
+
+
 int64
 ExpressionParser::EvaluateToInt64(const char* expressionString)
 {
@@ -565 +617 @@
 ExpressionParser::_ParseFunction(const Token& token)
 {
     if (strcasecmp("e", token.string.String()) == 0)
-        return MAPM(M_E);
+        return MAPM(MM_E);
     else if (strcasecmp("pi", token.string.String()) == 0)
-        return MAPM(M_PI);
+        return MAPM(MM_PI);
 
     // hard coded cases for different count of arguments
     // supports functions with 3 arguments at most
@@ -604 +656 @@
     } else if (strcasecmp("floor", token.string.String()) == 0) {
         _InitArguments(values, 1);
         return values[0].floor();
-    } else if (strcasecmp("log", token.string.String()) == 0) {
+    } else if (strcasecmp("ln", token.string.String()) == 0) {
         _InitArguments(values, 1);
         return values[0].log();
-    } else if (strcasecmp("log10", token.string.String()) == 0) {
+    } else if (strcasecmp("log", token.string.String()) == 0) {
         _InitArguments(values, 1);
         return values[0].log10();
     } else if (strcasecmp("pow", token.string.String()) == 0) {

headers/private/shared/ExpressionParser.h

@@ -29 +29 @@
     {
     }
 
-    BString message;
+    BString message;
     int32   position;
 };
 
@@ -45 +45 @@
             void                SetSupportHexInput(bool enabled);
 
             BString             Evaluate(const char* expressionString);
+            BString             EvaluateToStandard(
+                                    const char* expressionString, int32 places);
+            BString             EvaluateToScientific(
+                                    const char* expressionString, int32 places);
             int64               EvaluateToInt64(const char* expressionString);
             double              EvaluateToDouble(const char* expressionString);