apps/plugins/calculator.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 Pengxuan Liu (Isaac)
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /*
  23    00 01    21 22 23    43 44 45    65 66 67    87 88 89    109110111
  24 00 |-----------|-----------|-----------|-----------|-----------|
  25 01 |           |           |           |           |           |
  26    |***********|***********|***********|***********|***********|
  27    |***********|***********|***********|***********|***********|
  28 11 |           |           |           |           |           |
  29 12 |-----------|-----------|-----------|-----------|-----------|
  30 13 |-----------|-----------|-----------|-----------|-----------| y1
  31 14 |           |           |           |           |           |
  32    |           |           |           |           |           |
  33 22 |           |           |           |           |           |
  34 23 |-----------|-----------|-----------|-----------|-----------| y2
  35 24 |           |           |           |           |           |
  36    |           |           |           |           |           |
  37 32 |           |           |           |           |           |
  38 33 |-----------|-----------|-----------|-----------|-----------| y3
  39 34 |           |           |           |           |           |
  40    |           |           |           |           |           |
  41 42 |           |           |           |           |           |
  42 43 |-----------|-----------|-----------|-----------|-----------| y4
  43 44 |           |           |           |           |           |
  44    |           |           |           |           |           |
  45 52 |           |           |           |           |           |
  46 53 |-----------|-----------|-----------|-----------|-----------| y5
  47 54 |           |           |           |           |           |
  48    |           |           |           |           |           |
  49 62 |           |           |           |           |           |
  50 63 |-----------|-----------|-----------|-----------|-----------| y6
  51    x0          x1          x2          x3          x4          x5
  52 */
  53
  54 /*---------------------------------------------------------------------------
  55 Features:
  56 - Scientific number format core code.  Support range 10^-999 ~ 10^999
  57 - Number of significant figures up to 10
  58
  59 Limitations:
  60 - Right now, only accept "num, operator (+,-,*,/), num, =" input sequence.
  61   Input "3, +, 5, -, 2, =", the calculator will only do 5-2 and result = 3
  62   You have to input "3, +, 5, =, -, 2, =" to get 3+5-2 = 6
  63
  64 - "*,/" have no priority.  Actually you can't input 3+5*2 yet.
  65
  66 User Instructions:
  67 use arrow button to move cursor, "play" button to select, "off" button to exit
  68 F1: if typing numbers, it's equal to "Del"; otherwise, equal to "C"
  69 F2: circle input "+, -, *, /"
  70 F3: equal to "="
  71
  72 "MR"  :  load temp memory
  73 "M+"  :  add currently display to temp memory
  74 "C"   :  reset calculator
  75 ---------------------------------------------------------------------------*/
  76
  77 #include "plugin.h"
  78
  79 #include "math.h"
  80
  81
  82
  83
  84 #define M_TWOPI         (M_PI * 2.0)
  85
  86 #define BUTTON_ROWS 5
  87 #define BUTTON_COLS 5
  88
  89 #define REC_HEIGHT (int)(LCD_HEIGHT / (BUTTON_ROWS + 1))
  90 #define REC_WIDTH (int)(LCD_WIDTH / BUTTON_COLS)
  91
  92 #define Y_6_POS (LCD_HEIGHT)       /* Leave room for the border */
  93 #define Y_5_POS (Y_6_POS - REC_HEIGHT) /* y5 = 53 */
  94 #define Y_4_POS (Y_5_POS - REC_HEIGHT) /* y4 = 43 */
  95 #define Y_3_POS (Y_4_POS - REC_HEIGHT) /* y3 = 33 */
  96 #define Y_2_POS (Y_3_POS - REC_HEIGHT) /* y2 = 23 */
  97 #define Y_1_POS (Y_2_POS - REC_HEIGHT) /* y1 = 13 */
  98 #define Y_0_POS 0                      /* y0 = 0  */
  99
 100 #define X_0_POS 0                      /* x0 = 0  */
 101 #define X_1_POS (X_0_POS + REC_WIDTH)  /* x1 = 22 */
 102 #define X_2_POS (X_1_POS + REC_WIDTH)  /* x2 = 44 */
 103 #define X_3_POS (X_2_POS + REC_WIDTH)  /* x3 = 66 */
 104 #define X_4_POS (X_3_POS + REC_WIDTH)  /* x4 = 88 */
 105 #define X_5_POS (X_4_POS + REC_WIDTH)  /* x5 = 110, column 111 left blank */
 106
 107 #define SIGN(x) ((x)<0?-1:1)
 108 #ifndef ABS
 109 #define ABS(a) (((a) < 0) ? -(a) : (a))
 110 #endif
 111
 112 /* variable button definitions */
 113 #if CONFIG_KEYPAD == RECORDER_PAD
 114 #define CALCULATOR_LEFT BUTTON_LEFT
 115 #define CALCULATOR_RIGHT BUTTON_RIGHT
 116 #define CALCULATOR_UP   BUTTON_UP
 117 #define CALCULATOR_DOWN BUTTON_DOWN
 118 #define CALCULATOR_QUIT BUTTON_OFF
 119 #define CALCULATOR_INPUT BUTTON_PLAY
 120 #define CALCULATOR_CALC BUTTON_F3
 121 #define CALCULATOR_OPERATORS BUTTON_F2
 122 #define CALCULATOR_CLEAR BUTTON_F1
 123
 124 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
 125 #define CALCULATOR_LEFT BUTTON_LEFT
 126 #define CALCULATOR_RIGHT BUTTON_RIGHT
 127 #define CALCULATOR_UP   BUTTON_UP
 128 #define CALCULATOR_DOWN BUTTON_DOWN
 129 #define CALCULATOR_QUIT BUTTON_OFF
 130 #define CALCULATOR_INPUT BUTTON_SELECT
 131 #define CALCULATOR_CALC BUTTON_F3
 132 #define CALCULATOR_OPERATORS BUTTON_F2
 133 #define CALCULATOR_CLEAR BUTTON_F1
 134
 135 #elif CONFIG_KEYPAD == ONDIO_PAD
 136 #define CALCULATOR_LEFT BUTTON_LEFT
 137 #define CALCULATOR_RIGHT BUTTON_RIGHT
 138 #define CALCULATOR_UP   BUTTON_UP
 139 #define CALCULATOR_DOWN BUTTON_DOWN
 140 #define CALCULATOR_QUIT BUTTON_OFF
 141 #define CALCULATOR_INPUT_CALC_PRE BUTTON_MENU
 142 #define CALCULATOR_INPUT (BUTTON_MENU | BUTTON_REL)
 143 #define CALCULATOR_CALC (BUTTON_MENU | BUTTON_REPEAT)
 144
 145 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
 146       (CONFIG_KEYPAD == IRIVER_H300_PAD)
 147 #define CALCULATOR_LEFT BUTTON_LEFT
 148 #define CALCULATOR_RIGHT BUTTON_RIGHT
 149 #define CALCULATOR_UP   BUTTON_UP
 150 #define CALCULATOR_DOWN BUTTON_DOWN
 151 #define CALCULATOR_QUIT BUTTON_OFF
 152 #define CALCULATOR_INPUT BUTTON_SELECT
 153 #define CALCULATOR_CALC BUTTON_ON
 154 #define CALCULATOR_OPERATORS BUTTON_MODE
 155 #define CALCULATOR_CLEAR BUTTON_REC
 156
 157 #define CALCULATOR_RC_QUIT BUTTON_RC_STOP
 158
 159 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
 160       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 161       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 162
 163 #define CALCULATOR_LEFT BUTTON_LEFT
 164 #define CALCULATOR_RIGHT        BUTTON_RIGHT
 165 #define CALCULATOR_UP_W_SHIFT   BUTTON_SCROLL_BACK
 166 #define CALCULATOR_DOWN_W_SHIFT BUTTON_SCROLL_FWD
 167 #define CALCULATOR_QUIT         BUTTON_MENU
 168 #define CALCULATOR_INPUT        BUTTON_SELECT
 169 #define CALCULATOR_CALC         BUTTON_PLAY
 170
 171 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
 172
 173 #define CALCULATOR_LEFT  BUTTON_LEFT
 174 #define CALCULATOR_RIGHT BUTTON_RIGHT
 175 #define CALCULATOR_UP    BUTTON_UP
 176 #define CALCULATOR_DOWN  BUTTON_DOWN
 177 #define CALCULATOR_QUIT  BUTTON_POWER
 178 #define CALCULATOR_INPUT BUTTON_SELECT
 179 #define CALCULATOR_CALC  BUTTON_PLAY
 180 #define CALCULATOR_CLEAR BUTTON_REC
 181
 182 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
 183
 184 #define CALCULATOR_LEFT BUTTON_LEFT
 185 #define CALCULATOR_RIGHT BUTTON_RIGHT
 186 #define CALCULATOR_UP   BUTTON_UP
 187 #define CALCULATOR_DOWN BUTTON_DOWN
 188 #define CALCULATOR_QUIT BUTTON_POWER
 189 #define CALCULATOR_INPUT BUTTON_SELECT
 190 #define CALCULATOR_CALC BUTTON_MENU
 191 #define CALCULATOR_CLEAR BUTTON_A
 192
 193 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
 194 #define CALCULATOR_LEFT      BUTTON_LEFT
 195 #define CALCULATOR_RIGHT     BUTTON_RIGHT
 196 #define CALCULATOR_UP        BUTTON_UP
 197 #define CALCULATOR_DOWN      BUTTON_DOWN
 198 #define CALCULATOR_UP_W_SHIFT   BUTTON_SCROLL_BACK
 199 #define CALCULATOR_DOWN_W_SHIFT BUTTON_SCROLL_FWD
 200 #define CALCULATOR_QUIT      BUTTON_POWER
 201 #define CALCULATOR_INPUT_CALC_PRE BUTTON_SELECT
 202 #define CALCULATOR_INPUT     (BUTTON_SELECT|BUTTON_REL)
 203 #define CALCULATOR_CALC      (BUTTON_SELECT|BUTTON_REPEAT)
 204 #define CALCULATOR_CLEAR     BUTTON_REC
 205
 206 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
 207 #define CALCULATOR_LEFT      BUTTON_LEFT
 208 #define CALCULATOR_RIGHT     BUTTON_RIGHT
 209 #define CALCULATOR_UP        BUTTON_UP
 210 #define CALCULATOR_DOWN      BUTTON_DOWN
 211 #define CALCULATOR_QUIT      BUTTON_POWER
 212 #define CALCULATOR_INPUT_CALC_PRE BUTTON_SELECT
 213 #define CALCULATOR_INPUT     (BUTTON_SELECT|BUTTON_REL)
 214 #define CALCULATOR_CALC      (BUTTON_SELECT|BUTTON_REPEAT)
 215
 216 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
 217 #define CALCULATOR_LEFT      BUTTON_LEFT
 218 #define CALCULATOR_RIGHT     BUTTON_RIGHT
 219 #define CALCULATOR_UP        BUTTON_UP
 220 #define CALCULATOR_DOWN      BUTTON_DOWN
 221 #define CALCULATOR_UP_W_SHIFT   BUTTON_SCROLL_BACK
 222 #define CALCULATOR_DOWN_W_SHIFT BUTTON_SCROLL_FWD
 223 #define CALCULATOR_QUIT      (BUTTON_HOME|BUTTON_REPEAT)
 224 #define CALCULATOR_INPUT_CALC_PRE BUTTON_SELECT
 225 #define CALCULATOR_INPUT     (BUTTON_SELECT|BUTTON_REL)
 226 #define CALCULATOR_CALC      (BUTTON_SELECT|BUTTON_REPEAT)
 227 #define CALCULATOR_CLEAR     BUTTON_HOME
 228
 229
 230 #elif (CONFIG_KEYPAD == SANSA_CLIP_PAD)
 231 #define CALCULATOR_LEFT      BUTTON_LEFT
 232 #define CALCULATOR_RIGHT     BUTTON_RIGHT
 233 #define CALCULATOR_UP        BUTTON_UP
 234 #define CALCULATOR_DOWN      BUTTON_DOWN
 235 #define CALCULATOR_QUIT      BUTTON_POWER
 236 #define CALCULATOR_INPUT_CALC_PRE BUTTON_SELECT
 237 #define CALCULATOR_INPUT     (BUTTON_SELECT|BUTTON_REL)
 238 #define CALCULATOR_CALC      (BUTTON_SELECT|BUTTON_REPEAT)
 239 #define CALCULATOR_CLEAR     BUTTON_HOME
 240
 241 #elif (CONFIG_KEYPAD == SANSA_M200_PAD)
 242 #define CALCULATOR_LEFT      BUTTON_LEFT
 243 #define CALCULATOR_RIGHT     BUTTON_RIGHT
 244 #define CALCULATOR_UP        BUTTON_UP
 245 #define CALCULATOR_DOWN      BUTTON_DOWN
 246 #define CALCULATOR_QUIT      BUTTON_POWER
 247 #define CALCULATOR_INPUT_CALC_PRE BUTTON_SELECT
 248 #define CALCULATOR_INPUT     (BUTTON_SELECT|BUTTON_REL)
 249 #define CALCULATOR_CALC      (BUTTON_SELECT|BUTTON_REPEAT)
 250 #define CALCULATOR_CLEAR     (BUTTON_SELECT|BUTTON_UP)
 251
 252 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
 253
 254 #define CALCULATOR_LEFT BUTTON_LEFT
 255 #define CALCULATOR_RIGHT          BUTTON_RIGHT
 256 #define CALCULATOR_UP             BUTTON_SCROLL_UP
 257 #define CALCULATOR_DOWN           BUTTON_SCROLL_DOWN
 258 #define CALCULATOR_QUIT           BUTTON_POWER
 259 #define CALCULATOR_INPUT_CALC_PRE BUTTON_PLAY
 260 #define CALCULATOR_INPUT          (BUTTON_PLAY | BUTTON_REL)
 261 #define CALCULATOR_CALC           (BUTTON_PLAY | BUTTON_REPEAT)
 262 #define CALCULATOR_CLEAR          BUTTON_REW
 263
 264 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 265
 266 #define CALCULATOR_LEFT  BUTTON_LEFT
 267 #define CALCULATOR_RIGHT BUTTON_RIGHT
 268 #define CALCULATOR_UP    BUTTON_UP
 269 #define CALCULATOR_DOWN  BUTTON_DOWN
 270 #define CALCULATOR_QUIT  BUTTON_BACK
 271 #define CALCULATOR_INPUT BUTTON_SELECT
 272 #define CALCULATOR_CALC  BUTTON_MENU
 273 #define CALCULATOR_CLEAR BUTTON_PLAY
 274
 275 #elif (CONFIG_KEYPAD == MROBE100_PAD)
 276
 277 #define CALCULATOR_LEFT BUTTON_LEFT
 278 #define CALCULATOR_RIGHT BUTTON_RIGHT
 279 #define CALCULATOR_UP   BUTTON_UP
 280 #define CALCULATOR_DOWN BUTTON_DOWN
 281 #define CALCULATOR_QUIT BUTTON_POWER
 282 #define CALCULATOR_INPUT BUTTON_SELECT
 283 #define CALCULATOR_CALC BUTTON_MENU
 284 #define CALCULATOR_CLEAR BUTTON_DISPLAY
 285
 286 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 287
 288 #define CALCULATOR_LEFT BUTTON_RC_REW
 289 #define CALCULATOR_RIGHT BUTTON_RC_FF
 290 #define CALCULATOR_UP   BUTTON_RC_VOL_UP
 291 #define CALCULATOR_DOWN BUTTON_RC_VOL_DOWN
 292 #define CALCULATOR_QUIT BUTTON_RC_REC
 293 #define CALCULATOR_INPUT BUTTON_RC_PLAY
 294 #define CALCULATOR_CALC BUTTON_RC_MODE
 295 #define CALCULATOR_CLEAR BUTTON_RC_MENU
 296
 297 #define CALCULATOR_RC_QUIT BUTTON_REC
 298
 299 #elif (CONFIG_KEYPAD == COWON_D2_PAD)
 300
 301 #define CALCULATOR_QUIT           BUTTON_POWER
 302 #define CALCULATOR_CLEAR          BUTTON_MENU
 303
 304 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 305
 306 #define CALCULATOR_LEFT BUTTON_LEFT
 307 #define CALCULATOR_RIGHT BUTTON_RIGHT
 308 #define CALCULATOR_UP   BUTTON_VOLUP
 309 #define CALCULATOR_DOWN BUTTON_VOLDOWN
 310 #define CALCULATOR_QUIT BUTTON_POWER
 311 #define CALCULATOR_INPUT BUTTON_PLAY
 312 #define CALCULATOR_CALC BUTTON_MENU
 313 #define CALCULATOR_CLEAR BUTTON_STOP
 314
 315 #define CALCULATOR_RC_QUIT (BUTTON_MENU|BUTTON_PLAY)
 316
 317 #elif (CONFIG_KEYPAD == CREATIVEZVM_PAD)
 318
 319 #define CALCULATOR_LEFT  BUTTON_LEFT
 320 #define CALCULATOR_RIGHT BUTTON_RIGHT
 321 #define CALCULATOR_UP    BUTTON_UP
 322 #define CALCULATOR_DOWN  BUTTON_DOWN
 323 #define CALCULATOR_QUIT  BUTTON_BACK
 324 #define CALCULATOR_INPUT BUTTON_SELECT
 325 #define CALCULATOR_CALC  BUTTON_MENU
 326 #define CALCULATOR_CLEAR BUTTON_PLAY
 327
 328 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 329
 330 #define CALCULATOR_LEFT  BUTTON_LEFT
 331 #define CALCULATOR_RIGHT BUTTON_RIGHT
 332 #define CALCULATOR_UP    BUTTON_UP
 333 #define CALCULATOR_DOWN  BUTTON_DOWN
 334 #define CALCULATOR_QUIT  BUTTON_POWER
 335 #define CALCULATOR_INPUT BUTTON_SELECT
 336 #define CALCULATOR_CALC  BUTTON_MENU
 337 #define CALCULATOR_CLEAR BUTTON_VIEW
 338
 339 #elif CONFIG_KEYPAD == PHILIPS_HDD6330_PAD
 340
 341 #define CALCULATOR_LEFT  BUTTON_PREV
 342 #define CALCULATOR_RIGHT BUTTON_NEXT
 343 #define CALCULATOR_UP    BUTTON_UP
 344 #define CALCULATOR_DOWN  BUTTON_DOWN
 345 #define CALCULATOR_QUIT  BUTTON_POWER
 346 #define CALCULATOR_INPUT BUTTON_PLAY
 347 #define CALCULATOR_CALC  BUTTON_MENU
 348 #define CALCULATOR_CLEAR BUTTON_RIGHT
 349
 350 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
 351
 352 #define CALCULATOR_LEFT  BUTTON_PREV
 353 #define CALCULATOR_RIGHT BUTTON_NEXT
 354 #define CALCULATOR_UP    BUTTON_UP
 355 #define CALCULATOR_DOWN  BUTTON_DOWN
 356 #define CALCULATOR_QUIT  BUTTON_POWER
 357 #define CALCULATOR_INPUT BUTTON_PLAY
 358 #define CALCULATOR_CALC  BUTTON_MENU
 359 #define CALCULATOR_CLEAR BUTTON_RIGHT
 360
 361 #elif (CONFIG_KEYPAD == ONDAVX747_PAD)
 362
 363 #define CALCULATOR_QUIT           BUTTON_POWER
 364 #define CALCULATOR_CLEAR          BUTTON_MENU
 365
 366 #elif (CONFIG_KEYPAD == ONDAVX777_PAD)
 367 #define CALCULATOR_QUIT           BUTTON_POWER
 368
 369 #elif CONFIG_KEYPAD == MROBE500_PAD
 370 #define CALCULATOR_QUIT           BUTTON_POWER
 371
 372 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 373
 374 #define CALCULATOR_LEFT  BUTTON_LEFT
 375 #define CALCULATOR_RIGHT BUTTON_RIGHT
 376 #define CALCULATOR_UP    BUTTON_UP
 377 #define CALCULATOR_DOWN  BUTTON_DOWN
 378 #define CALCULATOR_QUIT  BUTTON_REC
 379 #define CALCULATOR_INPUT BUTTON_PLAY
 380 #define CALCULATOR_CALC  BUTTON_FFWD
 381 #define CALCULATOR_CLEAR BUTTON_REW
 382
 383 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
 384
 385 #define CALCULATOR_LEFT  BUTTON_PREV
 386 #define CALCULATOR_RIGHT BUTTON_NEXT
 387 #define CALCULATOR_UP    BUTTON_UP
 388 #define CALCULATOR_DOWN  BUTTON_DOWN
 389 #define CALCULATOR_QUIT  BUTTON_REC
 390 #define CALCULATOR_INPUT BUTTON_OK
 391 #define CALCULATOR_CALC  BUTTON_PLAY
 392 #define CALCULATOR_CLEAR BUTTON_CANCEL
 393
 394 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
 395 #define CALCULATOR_LEFT  BUTTON_REW
 396 #define CALCULATOR_RIGHT BUTTON_FF
 397 #define CALCULATOR_QUIT  (BUTTON_REC|BUTTON_PLAY)
 398 #define CALCULATOR_INPUT BUTTON_FUNC
 399 #define CALCULATOR_CALC  BUTTON_PLAY
 400
 401 #elif CONFIG_KEYPAD == MPIO_HD300_PAD
 402 #define CALCULATOR_LEFT  BUTTON_REW
 403 #define CALCULATOR_RIGHT BUTTON_FF
 404 #define CALCULATOR_UP    BUTTON_UP
 405 #define CALCULATOR_DOWN  BUTTON_DOWN
 406 #define CALCULATOR_QUIT  (BUTTON_REC|BUTTON_REPEAT)
 407 #define CALCULATOR_INPUT BUTTON_ENTER
 408 #define CALCULATOR_CALC  BUTTON_PLAY
 409 #define CALCULATOR_CLEAR BUTTON_MENU
 410
 411 #else
 412 #error No keymap defined!
 413 #endif
 414
 415 #ifdef HAVE_TOUCHSCREEN
 416 #ifndef CALCULATOR_LEFT
 417 #define CALCULATOR_LEFT           BUTTON_MIDLEFT
 418 #endif
 419 #ifndef CALCULATOR_RIGHT
 420 #define CALCULATOR_RIGHT          BUTTON_MIDRIGHT
 421 #endif
 422 #ifndef CALCULATOR_UP
 423 #define CALCULATOR_UP             BUTTON_TOPMIDDLE
 424 #endif
 425 #ifndef CALCULATOR_DOWN
 426 #define CALCULATOR_DOWN           BUTTON_BOTTOMMIDDLE
 427 #endif
 428 #ifndef CALCULATOR_CALC
 429 #define CALCULATOR_CALC           BUTTON_BOTTOMRIGHT
 430 #endif
 431 #ifndef CALCULATOR_INPUT
 432 #define CALCULATOR_INPUT          BUTTON_CENTER
 433 #endif
 434 #ifndef CALCULATOR_CLEAR
 435 #define CALCULATOR_CLEAR          BUTTON_TOPRIGHT
 436 #endif
 437
 438 #include "lib/pluginlib_touchscreen.h"
 439 static struct ts_raster calc_raster = { X_0_POS, Y_1_POS,
 440     BUTTON_COLS*REC_WIDTH, BUTTON_ROWS*REC_HEIGHT, REC_WIDTH, REC_HEIGHT };
 441 #endif
 442
 443 enum {
 444     basicButtons,
 445     sciButtons
 446 } buttonGroup;
 447
 448 unsigned char* buttonChar[2][5][5] = {
 449     { { "MR" , "M+" , "2nd" , "CE"   , "C"   },
 450       { "7"  , "8"  , "9"   , "/"    , "sqr" },
 451       { "4"  , "5"  , "6"   , "*"    , "x^2" },
 452       { "1"  , "2"  , "3"   , "-"    , "1/x" },
 453       { "0"  , "+/-", "."   , "+"    , "="   }  },
 454
 455     { { "n!" , "PI" , "1st" , "sin"  , "asi" },
 456       { "7"  , "8"  , "9"   , "cos"  , "aco" },
 457       { "4"  , "5"  , "6"   , "tan"  , "ata" },
 458       { "1"  , "2"  , "3"   , "ln"   , "e^x" },
 459       { "0"  , "+/-", "."   , "log"  , "x^y" }  }
 460 };
 461
 462 enum { btn_MR , btn_M    , btn_bas , btn_CE    , btn_C      ,
 463        btn_7  , btn_8    , btn_9   , btn_div   , btn_sqr    ,
 464        btn_4  , btn_5    , btn_6   , btn_time  , btn_square ,
 465        btn_1  , btn_2    , btn_3   , btn_minus , btn_rec    ,
 466        btn_0  , btn_sign , btn_dot , btn_add   , btn_equal
 467      };
 468
 469 enum { sci_fac, sci_pi   , sci_sci , sci_sin   , sci_asin   ,
 470        sci_7  , sci_8    , sci_9   , sci_cos   , sci_acos    ,
 471        sci_4  , sci_5    , sci_6   , sci_tan   , sci_atan    ,
 472        sci_1  , sci_2    , sci_3   , sci_ln    , sci_exp    ,
 473        sci_0  , sci_sign , sci_dot , sci_log   , sci_xy
 474      };
 475
 476 #define MINIMUM 0.000000000001   /* e-12 */
 477               /*  ^   ^    ^    ^       */
 478               /*  123456789abcdef       */
 479
 480 #define DIGITLEN 10  /* must <= 10 */
 481 #define SCIENTIFIC_FORMAT ( power < -(DIGITLEN-3) || power > (DIGITLEN))
 482            /*          0.000 00000 0001         */
 483            /*          ^   ^ ^   ^ ^   ^        */
 484            /* DIGITLEN 12345 6789a bcdef        */
 485            /* power       12 34567 89abc def    */
 486            /* 10^-       123 45678 9abcd ef     */
 487
 488 unsigned char buf[19];/* 18 bytes of output line,
 489                          buf[0] is operator
 490                          buf[1] = 'M' if memTemp is not 0
 491                          buf[2] = ' '
 492
 493                          if SCIENTIFIC_FORMAT
 494                              buf[2]-buf[12] or buf[3]-buf[13] = result;
 495                              format X.XXXXXXXX
 496                              buf[13] or buf[14] -buf[17] = power;
 497                              format eXXX or e-XXX
 498                          else
 499                              buf[3]-buf[6] = ' ';
 500                              buf[7]-buf[17] = result;
 501
 502                          buf[18] = '\0'                    */
 503
 504 unsigned char typingbuf[DIGITLEN+2];/* byte 0 is sign or ' ',
 505                                        byte 1~DIGITLEN are num and '.'
 506                                        byte (DIGITLEN+1) is '\0' */
 507 unsigned char* typingbufPointer = typingbuf;
 508
 509 double result = 0;          /*  main operand, format 0.xxxxx     */
 510 int power = 0;              /*  10^power                         */
 511 double modifier = 0.1;      /*  position of next input           */
 512 double operand = 0;         /*  second operand, format 0.xxxxx   */
 513 int operandPower = 0;       /*  10^power of second operand       */
 514 char oper = ' ';            /*  operators: + - * /               */
 515 bool operInputted = false;  /*  false: do calculation first and
 516                                        replace current oper
 517                                 true:  just replace current oper */
 518
 519 double memTemp = 0;         /* temp memory                       */
 520 int memTempPower = 0;       /* 10^^power of memTemp              */
 521
 522 int btn_row, btn_col;       /* current position index for button */
 523 int prev_btn_row, prev_btn_col; /* previous cursor position      */
 524 #define CAL_BUTTON (btn_row*5+btn_col)
 525
 526 int btn = BUTTON_NONE;
 527 int lastbtn = BUTTON_NONE;
 528
 529 /* Status of calculator */
 530 enum {cal_normal,  /* 0, normal status, display result */
 531       cal_typing,  /* 1, currently typing, dot hasn't been typed */
 532       cal_dotted,  /* 2, currently typing, dot already has been typed. */
 533       cal_error,
 534       cal_exit,
 535       cal_toDo
 536 } calStatus;
 537
 538 /* constant table for CORDIC algorithm */
 539 double cordicTable[51][2]= {
 540  /* pow(2,0) - pow(2,-50)             atan(pow(2,0) - atan(pow(2,-50) */
 541     {1e+00,                                    7.853981633974483e-01},
 542     {5e-01,                                    4.636476090008061e-01},
 543     {2.5e-01,                                  2.449786631268641e-01},
 544     {1.25e-01,                                 1.243549945467614e-01},
 545     {6.25e-02,                                 6.241880999595735e-02},
 546     {3.125e-02,                                3.123983343026828e-02},
 547     {1.5625e-02,                               1.562372862047683e-02},
 548     {7.8125e-03,                               7.812341060101111e-03},
 549     {3.90625e-03,                              3.906230131966972e-03},
 550     {1.953125e-03,                             1.953122516478819e-03},
 551     {9.765625e-04,                             9.765621895593195e-04},
 552     {4.8828125e-04,                            4.882812111948983e-04},
 553     {2.44140625e-04,                           2.441406201493618e-04},
 554     {1.220703125e-04,                          1.220703118936702e-04},
 555     {6.103515625e-05,                          6.103515617420877e-05},
 556     {3.0517578125e-05,                         3.051757811552610e-05},
 557     {1.52587890625e-05,                        1.525878906131576e-05},
 558     {7.62939453125e-06,                        7.629394531101970e-06},
 559     {3.814697265625e-06,                       3.814697265606496e-06},
 560     {1.9073486328125e-06,                      1.907348632810187e-06},
 561     {9.5367431640625e-07,                      9.536743164059608e-07},
 562     {4.76837158203125e-07,                     4.768371582030888e-07},
 563     {2.384185791015625e-07,                    2.384185791015580e-07},
 564     {1.1920928955078125e-07,                   1.192092895507807e-07},
 565     {5.9604644775390625e-08,                   5.960464477539055e-08},
 566     {2.98023223876953125e-08,                  2.980232238769530e-08},
 567     {1.490116119384765625e-08,                 1.490116119384765e-08},
 568     {7.450580596923828125e-09,                 7.450580596923828e-09},
 569     {3.7252902984619140625e-09,                3.725290298461914e-09},
 570     {1.86264514923095703125e-09,               1.862645149230957e-09},
 571     {9.31322574615478515625e-10,               9.313225746154785e-10},
 572     {4.656612873077392578125e-10,              4.656612873077393e-10},
 573     {2.3283064365386962890625e-10,             2.328306436538696e-10},
 574     {1.16415321826934814453125e-10,            1.164153218269348e-10},
 575     {5.82076609134674072265625e-11,            5.820766091346741e-11},
 576     {2.910383045673370361328125e-11,           2.910383045673370e-11},
 577     {1.4551915228366851806640625e-11,          1.455191522836685e-11},
 578     {7.2759576141834259033203125e-12,          7.275957614183426e-12},
 579     {3.63797880709171295166015625e-12,         3.637978807091713e-12},
 580     {1.818989403545856475830078125e-12,        1.818989403545856e-12},
 581     {9.094947017729282379150390625e-13,        9.094947017729282e-13},
 582     {4.5474735088646411895751953125e-13,       4.547473508864641e-13},
 583     {2.27373675443232059478759765625e-13,      2.273736754432321e-13},
 584     {1.136868377216160297393798828125e-13,     1.136868377216160e-13},
 585     {5.684341886080801486968994140625e-14,     5.684341886080801e-14},
 586     {2.8421709430404007434844970703125e-14,    2.842170943040401e-14},
 587     {1.42108547152020037174224853515625e-14,   1.421085471520200e-14},
 588     {7.10542735760100185871124267578125e-15,   7.105427357601002e-15},
 589     {3.552713678800500929355621337890625e-15,  3.552713678800501e-15},
 590     {1.7763568394002504646778106689453125e-15, 1.776356839400250e-15},
 591     {8.8817841970012523233890533447265625e-16, 8.881784197001252e-16}
 592 };
 593
 594 void doMultiple(double* operandOne, int* powerOne,
 595                 double  operandTwo, int  powerTwo);
 596 void doAdd (double* operandOne, int* powerOne,
 597             double  operandTwo, int  powerTwo);
 598 void printResult(void);
 599 void formatResult(void);
 600 void oneOperand(void);
 601
 602 void drawLines(void);
 603 void drawButtons(int group);
 604
 605 /* -----------------------------------------------------------------------
 606 Handy funtions
 607 ----------------------------------------------------------------------- */
 608 void cleartypingbuf(void)
 609 {
 610     int k;
 611     for( k=1; k<=(DIGITLEN+1); k++)
 612         typingbuf[k] = 0;
 613     typingbuf[0] = ' ';
 614     typingbufPointer = typingbuf+1;
 615 }
 616 void clearbuf(void)
 617 {
 618     int k;
 619     for(k=0;k<18;k++)
 620         buf[k]=' ';
 621     buf[18] = 0;
 622 }
 623 void clearResult(void)
 624 {
 625     result = 0;
 626     power = 0;
 627     modifier = 0.1;
 628 }
 629
 630 void clearInput(void)
 631 {
 632     calStatus = cal_normal;
 633     clearResult();
 634     cleartypingbuf();
 635     rb->lcd_clear_display();
 636     drawButtons(buttonGroup);
 637     drawLines();
 638 }
 639
 640 void clearOperand(void)
 641 {
 642     operand = 0;
 643     operandPower = 0;
 644 }
 645
 646 void clearMemTemp(void)
 647 {
 648     memTemp = 0;
 649     memTempPower = 0;
 650 }
 651
 652 void clearOper(void)
 653 {
 654     oper = ' ';
 655     operInputted = false;
 656 }
 657
 658 void clearMem(void)
 659 {
 660     clearInput();
 661     clearMemTemp();
 662     clearOperand();
 663     clearOper();
 664     btn = BUTTON_NONE;
 665 }
 666
 667 void switchOperands(void)
 668 {
 669     double tempr = operand;
 670     int tempp = operandPower;
 671     operand = result;
 672     operandPower = power;
 673     result = tempr;
 674     power = tempp;
 675 }
 676
 677 void drawLines(void)
 678 {
 679     int i;
 680     rb->lcd_hline(0, LCD_WIDTH, Y_1_POS-1);
 681     for (i = 0; i < 5 ; i++)
 682         rb->lcd_hline(0, LCD_WIDTH, Y_1_POS+i*REC_HEIGHT);
 683     for (i = 0; i < 4 ; i++)
 684         rb->lcd_vline(X_1_POS+i*REC_WIDTH, Y_1_POS, LCD_HEIGHT);
 685 }
 686
 687 void drawButtons(int group)
 688 {
 689     int i, j, w, h;
 690     for (i = 0; i <= 4; i++){
 691         for (j = 0; j <= 4; j++){
 692             rb->lcd_getstringsize( buttonChar[group][i][j],&w,&h);
 693             if (i == btn_row && j == btn_col) /* selected item */
 694                 rb->lcd_set_drawmode(DRMODE_SOLID);
 695             else
 696                 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 697             rb->lcd_fillrect( X_0_POS + j*REC_WIDTH,
 698                               Y_1_POS + i*REC_HEIGHT,
 699                               REC_WIDTH, REC_HEIGHT+1);
 700             if (i == btn_row && j == btn_col) /* selected item */
 701                 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 702             else
 703                 rb->lcd_set_drawmode(DRMODE_SOLID);
 704             rb->lcd_putsxy( X_0_POS + j*REC_WIDTH + (REC_WIDTH - w)/2,
 705                             Y_1_POS + i*REC_HEIGHT + (REC_HEIGHT - h)/2 + 1,
 706                             buttonChar[group][i][j] );
 707         }
 708     }
 709     rb->lcd_set_drawmode(DRMODE_SOLID);
 710 }
 711
 712 /* -----------------------------------------------------------------------
 713 Initiate calculator
 714 ----------------------------------------------------------------------- */
 715 void cal_initial (void)
 716 {
 717     int w,h;
 718
 719     rb->lcd_getstringsize("2nd",&w,&h);
 720     if (w > REC_WIDTH || h > REC_HEIGHT)
 721         rb->lcd_setfont(FONT_SYSFIXED);
 722
 723     rb->lcd_clear_display();
 724
 725 #ifdef CALCULATOR_OPERATORS
 726     /* basic operators are available through separate button */
 727     buttonGroup = sciButtons;
 728 #else
 729     buttonGroup = basicButtons;
 730 #endif
 731
 732     /* initially, invert button "5" */
 733     btn_row = 2;
 734     btn_col = 1;
 735     prev_btn_row = btn_row;
 736     prev_btn_col = btn_col;
 737     drawButtons(buttonGroup);
 738     drawLines();
 739     rb->lcd_update();
 740
 741     /* initial mem and output display*/
 742     clearMem();
 743     printResult();
 744
 745     /* clear button queue */
 746     rb->button_clear_queue();
 747 }
 748
 749 /* -----------------------------------------------------------------------
 750    mySqrt uses Heron's algorithm, which is the Newtone-Raphson algorhitm
 751    in it's private case for sqrt.
 752    Thanks BlueChip for his intro text and Dave Straayer for the actual name.
 753    ----------------------------------------------------------------------- */
 754 double mySqrt(double square)
 755 {
 756     int k = 0;
 757     double temp = 0;
 758     double root= ABS(square+1)/2;
 759
 760     while( ABS(root - temp) > MINIMUM ){
 761         temp = root;
 762         root = (square/temp + temp)/2;
 763         k++;
 764         if (k>10000) return 0;
 765     }
 766
 767     return root;
 768 }
 769 /* -----------------------------------------------------------------------
 770    transcendFunc uses CORDIC (COordinate Rotation DIgital Computer) method
 771    transcendFunc can do sin,cos,log,exp
 772    input parameter is angle
 773 ----------------------------------------------------------------------- */
 774 void transcendFunc(char* func, double* tt, int* ttPower)
 775 {
 776     double t = (*tt)*M_PI/180; int tPower = *ttPower;
 777     int sign = 1;
 778     int n = 50; /* n <=50, tables are all <= 50 */
 779     int j;
 780     double x,y,z,xt,yt,zt;
 781
 782     if (tPower < -998) {
 783         calStatus = cal_normal;
 784         return;
 785     }
 786     if (tPower > 8) {
 787         calStatus = cal_error;
 788         return;
 789     }
 790     *ttPower = 0;
 791     calStatus = cal_normal;
 792
 793     if( func[0] =='s' || func[0] =='S'|| func[0] =='t' || func[0] =='T')
 794         sign = SIGN(t);
 795     else {
 796         /* if( func[0] =='c' || func[0] =='C') */
 797         sign = 1;
 798     }
 799     t = ABS(t);
 800
 801     while (tPower > 0){
 802         t *= 10;
 803         tPower--;
 804     }
 805     while (tPower < 0) {
 806         t /= 10;
 807         tPower++;
 808     }
 809     j = 0;
 810     while (t > j*M_TWOPI) {j++;}
 811     t -= (j-1)*M_TWOPI;
 812     if (M_PI_2 < t && t < 3*M_PI_2){
 813         t = M_PI - t;
 814         if (func[0] =='c' || func[0] =='C')
 815             sign = -1;
 816         else if (func[0] =='t' || func[0] =='T')
 817             t*=-1;
 818     }
 819     else if ( 3*M_PI_2 <= t && t <= M_TWOPI)
 820         t -= M_TWOPI;
 821
 822     x = 0.60725293500888;  y = 0;  z = t;
 823     for (j=1;j<n+2;j++){
 824         xt = x - SIGN(z) * y*cordicTable[j-1][0];
 825         yt = y + SIGN(z) * x*cordicTable[j-1][0];
 826         zt = z - SIGN(z) * cordicTable[j-1][1];
 827         x = xt;
 828         y=yt;
 829         z=zt;
 830     }
 831     if( func[0] =='s' || func[0] =='S') {
 832         *tt = sign*y;
 833         return;
 834     }
 835     else if( func[0] =='c' || func[0] =='C') {
 836         *tt = sign*x;
 837         return;
 838     }
 839     else /*if( func[0] =='t' || func[0] =='T')*/ {
 840         if(t==M_PI_2||t==-M_PI_2){
 841             calStatus = cal_error;
 842             return;
 843         }
 844         else{
 845             *tt = sign*(y/x);
 846             return;
 847         }
 848     }
 849
 850 }
 851 /* -----------------------------------------------------------------------
 852    add in scientific number format
 853 ----------------------------------------------------------------------- */
 854 void doAdd (double* operandOne, int* powerOne,
 855             double  operandTwo, int  powerTwo)
 856 {
 857     if ( *powerOne >= powerTwo ){
 858         if (*powerOne - powerTwo <= DIGITLEN+1){
 859             while (powerTwo < *powerOne){
 860                 operandTwo /=10;
 861                 powerTwo++;
 862             }
 863             *operandOne += operandTwo;
 864         }
 865         /*do nothing if operandTwo is too small*/
 866     }
 867     else{
 868         if (powerTwo - *powerOne <= DIGITLEN+1){
 869             while(powerTwo > *powerOne){
 870                 *operandOne /=10;
 871                 (*powerOne)++;
 872             }
 873             (*operandOne) += operandTwo;
 874         }
 875         else{/* simply copy operandTwo if operandOne is too small */
 876             *operandOne = operandTwo;
 877             *powerOne = powerTwo;
 878         }
 879     }
 880 }
 881 /* -----------------------------------------------------------------------
 882 multiple in scientific number format
 883 ----------------------------------------------------------------------- */
 884 void doMultiple(double* operandOne, int* powerOne,
 885                 double  operandTwo, int  powerTwo)
 886 {
 887     (*operandOne) *= operandTwo;
 888     (*powerOne) += powerTwo;
 889 }
 890
 891 /* -----------------------------------------------------------------------
 892 Handles all one operand calculations
 893 ----------------------------------------------------------------------- */
 894 void oneOperand(void)
 895 {
 896     int k = 0;
 897     if (buttonGroup == basicButtons){
 898         switch(CAL_BUTTON){
 899             case btn_sqr:
 900                 if (result<0)
 901                     calStatus = cal_error;
 902                 else{
 903                     if (power%2 == 1){
 904                         result = (mySqrt(result*10))/10;
 905                         power = (power+1) / 2;
 906                     }
 907                     else{
 908                         result = mySqrt(result);
 909                         power = power / 2;
 910                     }
 911                     calStatus = cal_normal;
 912                 }
 913                 break;
 914             case btn_square:
 915                 power *= 2;
 916                 result *= result;
 917                 calStatus = cal_normal;
 918                 break;
 919
 920             case btn_rec:
 921                 if (result==0)
 922                     calStatus = cal_error;
 923                 else{
 924                     power = -power;
 925                     result = 1/result;
 926                     calStatus = cal_normal;
 927                 }
 928                 break;
 929             default:
 930                 calStatus = cal_toDo;
 931                 break; /* just for the safety */
 932         }
 933     }
 934     else{ /* sciButtons */
 935         switch(CAL_BUTTON){
 936             case sci_sin:
 937                 transcendFunc("sin", &result, &power);
 938                 break;
 939             case sci_cos:
 940                 transcendFunc("cos", &result, &power);
 941                 break;
 942             case sci_tan:
 943                 transcendFunc("tan", &result, &power);
 944                 break;
 945             case sci_fac:
 946                 if (power<0 || power>8 || result<0 )
 947                     calStatus = cal_error;
 948                 else if(result == 0) {
 949                     result = 1;
 950                     power = 0;
 951                 }
 952                 else{
 953                     while(power > 0) {
 954                         result *= 10;
 955                         power--;
 956                     }
 957                     if ( ( result - (int)result) > MINIMUM )
 958                         calStatus = cal_error;
 959                     else {
 960                         k = result; result = 1;
 961                         while (k > 1){
 962                             doMultiple(&result, &power, k, 0);
 963                             formatResult();
 964                             k--;
 965                         }
 966                         calStatus = cal_normal;
 967                     }
 968                 }
 969                 break;
 970             default:
 971                 calStatus = cal_toDo;
 972                 break; /* just for the safety */
 973         }
 974     }
 975 }
 976
 977
 978 /* -----------------------------------------------------------------------
 979 Handles all two operands calculations
 980 ----------------------------------------------------------------------- */
 981 void twoOperands(void)
 982 {
 983     switch(oper){
 984         case '-':
 985             doAdd(&operand, &operandPower, -result, power);
 986             break;
 987         case '+':
 988             doAdd(&operand, &operandPower, result, power);
 989             break;
 990         case '*':
 991             doMultiple(&operand, &operandPower, result, power);
 992             break;
 993         case '/':
 994             if ( ABS(result) > MINIMUM ){
 995                 doMultiple(&operand, &operandPower, 1/result, -power);
 996             }
 997             else
 998                 calStatus = cal_error;
 999             break;
1000         default: /* ' ' */
1001             switchOperands(); /* counter switchOperands() below */
1002             break;
1003     } /* switch(oper) */
1004     switchOperands();
1005     clearOper();
1006 }
1007
1008 /* First, increases *dimen1 by dimen1_delta modulo dimen1_modulo.
1009    If dimen1 wraps, increases *dimen2 by dimen2_delta modulo dimen2_modulo.
1010 */
1011 static void move_with_wrap_and_shift(
1012     int *dimen1, int dimen1_delta, int dimen1_modulo,
1013     int *dimen2, int dimen2_delta, int dimen2_modulo)
1014 {
1015     bool wrapped = false;
1016
1017     *dimen1 += dimen1_delta;
1018     if (*dimen1 < 0)
1019     {
1020         *dimen1 = dimen1_modulo - 1;
1021         wrapped = true;
1022     }
1023     else if (*dimen1 >= dimen1_modulo)
1024     {
1025         *dimen1 = 0;
1026         wrapped = true;
1027     }
1028
1029     if (wrapped)
1030     {
1031         /* Make the dividend always positive to be sure about the result.
1032            Adding dimen2_modulo does not change it since we do it modulo. */
1033         *dimen2 = (*dimen2 + dimen2_modulo + dimen2_delta) % dimen2_modulo;
1034     }
1035 }
1036
1037 /* -----------------------------------------------------------------------
1038 Print buttons when switching 1st and 2nd
1039 int group = {basicButtons, sciButtons}
1040 ----------------------------------------------------------------------- */
1041 void printButtonGroups(int group)
1042 {
1043     drawButtons(group);
1044     drawLines();
1045     rb->lcd_update();
1046 }
1047 /* -----------------------------------------------------------------------
1048 flash the currently marked button
1049 ----------------------------------------------------------------------- */
1050 void flashButton(void)
1051 {
1052     int k, w, h;
1053     for (k=2;k>0;k--)
1054     {
1055         rb->lcd_getstringsize( buttonChar[buttonGroup][btn_row][btn_col],&w,&h);
1056         rb->lcd_set_drawmode(DRMODE_SOLID|(k==1) ? 0 : DRMODE_INVERSEVID);
1057         rb->lcd_fillrect( X_0_POS + btn_col*REC_WIDTH + 1,
1058                           Y_1_POS + btn_row*REC_HEIGHT + 1,
1059                           REC_WIDTH - 1, REC_HEIGHT - 1);
1060         rb->lcd_putsxy( X_0_POS + btn_col*REC_WIDTH + (REC_WIDTH - w)/2,
1061                         Y_1_POS + btn_row*REC_HEIGHT + (REC_HEIGHT - h)/2 +1,
1062                         buttonChar[buttonGroup][btn_row][btn_col] );
1063         rb->lcd_update_rect( X_0_POS + btn_col*REC_WIDTH + 1,
1064                             Y_1_POS + btn_row*REC_HEIGHT + 1,
1065                             REC_WIDTH - 1, REC_HEIGHT - 1);
1066
1067         if (k!= 1)
1068             rb->sleep(HZ/22);
1069
1070     }
1071 }
1072
1073 /* -----------------------------------------------------------------------
1074 pos is the position that needs animation. pos = [1~18]
1075 ----------------------------------------------------------------------- */
1076 void deleteAnimation(int pos)
1077 {
1078     int k, w, h, x;
1079     if (pos<1 || pos >18)
1080         return;
1081
1082     rb->lcd_getstringsize("0", &w, &h);
1083     x = (pos==1? 4: LCD_WIDTH - 4 - w);
1084
1085     for (k=0;k<4;k++){
1086         rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
1087         rb->lcd_fillrect(x, Y_1_POS - h -1, w, h);
1088         rb->lcd_set_drawmode(DRMODE_SOLID);
1089         rb->lcd_fillrect(x + (w*k)/8, Y_1_POS - h -1 + (h*k)/8,
1090                          (w*(4-k))/4, (h*(4-k))/4);
1091         rb->lcd_update_rect(x, Y_1_POS - h -1, w, h);
1092         rb->sleep(HZ/32);
1093     }
1094 }
1095
1096 /* -----------------------------------------------------------------------
1097 result may be one of these formats:
1098 0
1099 xxxx.xxxx
1100 0.xxxx
1101 0.0000xxxx
1102
1103 formatResult() change result to standard format: 0.xxxx
1104 if result is close to 0, let it be 0;
1105 if result is close to 1, let it be 0.1 and power++;
1106 ----------------------------------------------------------------------- */
1107 void formatResult(void)
1108 {
1109     int resultsign = SIGN(result);
1110     result = ABS(result);
1111     if(result > MINIMUM ){ /* doesn't check power, might have problem
1112                               input wouldn't,
1113                               + - * / of two formatted number wouldn't.
1114                               only a calculation that makes a formatted
1115                               number (0.xxxx) less than MINIMUM in only
1116                               one operation  */
1117
1118         if (result<1){
1119             while( (int)(result*10) == 0 ){
1120                 result *= 10;
1121                 power--;
1122                 modifier *= 10;
1123             }
1124         }
1125         else{ /* result >= 1 */
1126             while( (int)result != 0 ){
1127                 result /= 10;
1128                 power++;
1129                 modifier /= 10;
1130             }
1131         } /* if result<1 */
1132
1133         if (result > (1-MINIMUM)){
1134             result = 0.1;
1135             power++;
1136             modifier /= 10;
1137         }
1138         result *= resultsign;
1139     }
1140     else {
1141         result = 0;
1142         power = 0;
1143         modifier = 0.1;
1144     }
1145 }
1146
1147 /* -----------------------------------------------------------------------
1148 result2typingbuf() outputs standard format result to typingbuf.
1149 case SCIENTIFIC_FORMAT, let temppower = 1;
1150 case temppower >  0:  print '.' in the middle
1151 case temppower <= 0:  print '.' in the begining
1152 ----------------------------------------------------------------------- */
1153 void result2typingbuf(void)
1154 {
1155     bool haveDot = false;
1156     char tempchar = 0;
1157     int k;
1158     double tempresult = ABS(result); /* positive num makes things simple */
1159
1160     int temppower;
1161     double tempmodifier = 1;
1162     int count;
1163
1164     if(SCIENTIFIC_FORMAT)
1165         temppower = 1; /* output x.xxxx format */
1166     else
1167         temppower = power;
1168
1169     cleartypingbuf();
1170
1171     if(tempresult < MINIMUM){ /* if 0,faster display and avoid complication*/
1172         typingbuf[0] = ' ';
1173         typingbuf[1] = '0';
1174     }
1175     else{ /* tempresult > 0 */
1176         typingbuf[0] = (SIGN(result)<0)?'-':' ';
1177
1178         typingbufPointer = typingbuf;
1179         if(temppower > 0){
1180             for (k = 0; k<DIGITLEN+1 ; k++){
1181                 typingbufPointer++;
1182                 if(temppower || *(typingbufPointer-1) == '.'){
1183                     count = 0;
1184                     tempmodifier = tempmodifier/10;
1185                     while( (tempresult-tempmodifier*count) >
1186                            (tempmodifier-MINIMUM)){
1187                         count++;
1188                     }
1189                     tempresult -= tempmodifier*count;
1190                     tempresult = ABS(tempresult);
1191                     temppower-- ;
1192                     *typingbufPointer = count + '0';
1193                 }
1194                 else{ /* temppower == 0 */
1195                     *typingbufPointer = '.';
1196                     haveDot = true;
1197                 }
1198             } /* for */
1199         }
1200         else{
1201             haveDot = true;
1202             typingbufPointer++;  *typingbufPointer = '0';
1203             typingbufPointer++;  *typingbufPointer = '.';
1204             for (k = 2; k<DIGITLEN+1 ; k++){
1205                 typingbufPointer++;
1206                 count = 0;
1207                 if ( (-temppower) < (k-1)){
1208                     tempmodifier = tempmodifier/10;
1209                     while((tempresult-tempmodifier*count)>(tempmodifier-MINIMUM)){
1210                         count++;
1211
1212                     }
1213                     tempresult -= tempmodifier*count;
1214                     tempresult = ABS(tempresult);
1215                     temppower-- ;
1216                 }
1217                 *typingbufPointer = count + '0';
1218             }
1219         }
1220         /* now, typingbufPointer = typingbuf + 16 */
1221         /* backward strip off 0 and '.' */
1222         if (haveDot){
1223             while( (*typingbufPointer == '0') || (*typingbufPointer == '.')){
1224                 tempchar = *typingbufPointer;
1225                 *typingbufPointer = 0;
1226                 typingbufPointer--;
1227                 if (tempchar == '.') break;
1228             }
1229         }
1230         typingbuf[DIGITLEN+1] = 0;
1231     } /* else tempresult > 0 */
1232 }
1233
1234 /* -----------------------------------------------------------------------
1235 printResult() generates LCD display.
1236 ----------------------------------------------------------------------- */
1237 void printResult(void)
1238 {
1239     int k, w, h;
1240
1241     char operbuf[3] = {0, 0, 0};
1242
1243     switch_Status:
1244     switch(calStatus){
1245         case cal_exit:
1246             rb->lcd_clear_display();
1247             rb->splash(HZ/3, "Bye now!");
1248             break;
1249         case cal_error:
1250             clearbuf();
1251             rb->snprintf(buf, 19, "%18s","Error");
1252             break;
1253         case cal_toDo:
1254             clearbuf();
1255             rb->snprintf(buf, 19, "%18s","Coming soon ^_* ");
1256             break;
1257
1258         case cal_normal:
1259             formatResult();
1260
1261             if( power > 1000 ){  /* power -1 > 999  */
1262                 calStatus = cal_error;
1263                 goto switch_Status;
1264             }
1265             if (power < -998 )   /* power -1 < -999 */
1266                 clearResult();   /* too small, let it be 0 */
1267
1268             result2typingbuf();
1269             clearbuf();
1270
1271             operbuf[0] = oper;
1272             operbuf[1] = ( ABS(memTemp) > MINIMUM )?'M':' ';
1273             operbuf[2] = '\0';
1274
1275             if(SCIENTIFIC_FORMAT){
1276                 /* output format: X.XXXX eXXX */
1277                 if(power > -98){ /* power-1 >= -99, eXXX or e-XX */
1278                     rb->snprintf(buf, 12, "%11s",typingbuf);
1279                     for(k=11;k<=14;k++) buf[k] = ' ';
1280                     cleartypingbuf();
1281                     rb->snprintf(typingbuf, 5, "e%d",power-1);
1282                     rb->snprintf(buf+11, 5, "%4s",typingbuf);
1283                 }
1284                 else{  /* power-1 <= -100, e-XXX */
1285                     rb->snprintf(buf, 12, "%11s",typingbuf);
1286                     rb->snprintf(buf+11, 6, "e%d",power-1);
1287                 }
1288             }
1289             else{
1290                 rb->snprintf(buf, 12, "%11s",typingbuf);
1291             } /* if SCIENTIFIC_FORMAT */
1292             break;
1293         case cal_typing:
1294         case cal_dotted:
1295             clearbuf();
1296             operbuf[0] = oper;
1297             operbuf[1] = ( ABS(memTemp) > MINIMUM )?'M':' ';
1298             rb->snprintf(buf, 12, "%11s",typingbuf);
1299             break;
1300
1301     }
1302
1303     rb->lcd_getstringsize(buf, &w, &h);
1304     rb->screen_clear_area(rb->screens[0], 0, 0, LCD_WIDTH, Y_1_POS - 1);
1305     rb->lcd_putsxy(4, Y_1_POS - h -1, operbuf);
1306     rb->lcd_putsxy(LCD_WIDTH - w - 4, Y_1_POS - h -1, buf);
1307     rb->lcd_update_rect(0, 1, LCD_WIDTH, Y_1_POS);
1308 }
1309
1310 /* -----------------------------------------------------------------------
1311 Process typing buttons: 1-9, '.', sign
1312 main operand "result" and typingbuf are processed seperately here.
1313 ----------------------------------------------------------------------- */
1314 void typingProcess(void){
1315     switch( CAL_BUTTON ){
1316         case btn_sign:
1317             if (calStatus == cal_typing ||
1318                 calStatus == cal_dotted)
1319                 typingbuf[0] = (typingbuf[0]=='-')?' ':'-';
1320             result = -result;
1321             break;
1322         case btn_dot:
1323             operInputted = false;
1324             switch(calStatus){
1325                 case cal_normal:
1326                     clearInput();
1327                     *typingbufPointer = '0';
1328                     typingbufPointer++;
1329                 case cal_typing:
1330                     calStatus = cal_dotted;
1331                     *typingbufPointer = '.';
1332                     if (typingbufPointer != typingbuf+DIGITLEN+1)
1333                         typingbufPointer++;
1334                     break;
1335                 default:  /* cal_dotted */
1336                     break;
1337             }
1338             break;
1339         default:  /* 0-9 */
1340             operInputted = false;
1341             /* normal,0; normal,1-9; typing,0; typing,1-9 */
1342             switch(calStatus){
1343                 case cal_normal:
1344                     if(CAL_BUTTON == btn_0 )
1345                         break;   /* first input is 0, ignore */
1346                     clearInput();
1347                     /*no operator means start a new calculation*/
1348                     if (oper ==' ')
1349                         clearOperand();
1350                     calStatus = cal_typing;
1351                     /* go on typing, no break */
1352                 case cal_typing:
1353                 case cal_dotted:
1354                     switch(CAL_BUTTON){
1355                         case btn_0:
1356                             *typingbufPointer = '0';
1357                             break;
1358                         default:
1359                             *typingbufPointer=(7+btn_col-3*(btn_row-1))+ '0';
1360                             break;
1361                     }
1362                     if (typingbufPointer!=typingbuf+DIGITLEN+1){
1363                         typingbufPointer++;
1364
1365                         {/* result processing */
1366                          if (calStatus == cal_typing) power++;
1367                          if (CAL_BUTTON != btn_0)
1368                              result= result +
1369                                      SIGN(result)*
1370                                      (7+btn_col-3*(btn_row-1))*modifier;
1371                          modifier /= 10;
1372                         }
1373                     }
1374                     else /* last byte always '\0' */
1375                         *typingbufPointer = 0;
1376                     break;
1377                 default: /* cal_error, cal_exit */
1378                     break;
1379             }
1380             break; /* default, 0-9 */
1381     } /* switch( CAL_BUTTON ) */
1382 }
1383
1384 /* -----------------------------------------------------------------------
1385 Handle delete operation
1386 main operand "result" and typingbuf are processed seperately here.
1387 ----------------------------------------------------------------------- */
1388 void doDelete(void){
1389     deleteAnimation(18);
1390     switch(calStatus){
1391         case cal_dotted:
1392             if (*(typingbufPointer-1) == '.'){
1393                 /* if dotted and deleting '.',
1394                    change status and delete '.' below */
1395                 calStatus = cal_typing;
1396             }
1397             else{ /* if dotted and not deleting '.',
1398                      power stays */
1399                 power++; /* counter "power--;" below */
1400             }
1401         case cal_typing:
1402             typingbufPointer--;
1403
1404             {/* result processing */   /* 0-9, '.' */
1405              /* if deleting '.', do nothing */
1406              if ( *typingbufPointer != '.'){
1407                 power--;
1408                 modifier *= 10;
1409                 result = result - SIGN(result)*
1410                     ((*typingbufPointer)- '0')*modifier;
1411              }
1412             }
1413
1414             *typingbufPointer = 0;
1415
1416             /* if (only one digit left and it's 0)
1417                or  no digit left, change status*/
1418             if ( typingbufPointer == typingbuf+1 ||
1419                  ( typingbufPointer == typingbuf+2 &&
1420                    *(typingbufPointer-1) == '0' ))
1421                 calStatus = cal_normal;
1422             break;
1423         default: /* normal, error, exit */
1424             break;
1425     }
1426 }
1427 /* -----------------------------------------------------------------------
1428 Handle buttons on basic screen
1429 ----------------------------------------------------------------------- */
1430 void basicButtonsProcess(void){
1431     switch (btn) {
1432         case CALCULATOR_INPUT:
1433             if (calStatus == cal_error && (CAL_BUTTON != btn_C) ) break;
1434             flashButton();
1435             switch( CAL_BUTTON ){
1436                 case btn_MR:
1437                     operInputted = false;
1438                     result = memTemp; power = memTempPower;
1439                     calStatus = cal_normal;
1440                     break;
1441                 case btn_M:
1442                     formatResult();
1443                     if (memTemp > MINIMUM)
1444                         doAdd(&memTemp, &memTempPower, result, power);
1445                     else {
1446                         /* if result is too small and memTemp = 0,
1447                            doAdd will not add */
1448                         memTemp = result;
1449                         memTempPower = power;
1450                     }
1451                     calStatus = cal_normal;
1452                     break;
1453
1454                 case btn_C:    clearMem();        break;
1455                 case btn_CE:   clearInput();      break;
1456
1457                 case btn_bas:
1458                     buttonGroup = sciButtons;
1459                     printButtonGroups(buttonGroup);
1460                     break;
1461
1462                 /* one operand calculation, may be changed to
1463                    like sin, cos, log, etc */
1464                 case btn_sqr:
1465                 case btn_square:
1466                 case btn_rec:
1467                     formatResult(); /* not necessary, just for safty */
1468                     oneOperand();
1469                     break;
1470
1471                 case_btn_equal:  /* F3 shortkey entrance */
1472                 case btn_equal:
1473                     formatResult();
1474                     calStatus = cal_normal;
1475                     operInputted = false;
1476                     if (oper != ' ') twoOperands();
1477                     break;
1478
1479                 case btn_div:
1480                 case btn_time:
1481                 case btn_minus:
1482                 case btn_add:
1483                     if(!operInputted) {twoOperands(); operInputted = true;}
1484                     oper = buttonChar[basicButtons][btn_row][btn_col][0];
1485 #ifdef CALCULATOR_OPERATORS
1486                     case_cycle_operators:  /* F2 shortkey entrance */
1487 #endif
1488                     calStatus = cal_normal;
1489                     formatResult();
1490                     operand = result;
1491                     operandPower = power;
1492
1493                     break;
1494
1495                 case btn_sign:
1496                 case btn_dot:
1497                 default:  /* 0-9 */
1498                     typingProcess();
1499                     break;
1500             } /* switch (CAL_BUTTON) */
1501             break;
1502
1503 #ifdef CALCULATOR_OPERATORS
1504         case CALCULATOR_OPERATORS:
1505             if (calStatus == cal_error) break;
1506             if (!operInputted) {twoOperands(); operInputted = true;}
1507             switch (oper){
1508                 case ' ':
1509                 case '/':  oper = '+';  flashButton();    break;
1510                 case '+':  oper = '-';  flashButton();  break;
1511                 case '-':  oper = '*';  flashButton();   break;
1512                 case '*':  oper = '/';  flashButton();    break;
1513             }
1514             goto case_cycle_operators;
1515             break;
1516 #endif
1517
1518         case CALCULATOR_CALC:
1519             if (calStatus == cal_error) break;
1520             flashButton();
1521             goto case_btn_equal;
1522             break;
1523         default: break;
1524     }
1525     printResult();
1526 }
1527
1528 /* -----------------------------------------------------------------------
1529 Handle buttons on scientific screen
1530 ----------------------------------------------------------------------- */
1531 void sciButtonsProcess(void){
1532     switch (btn) {
1533         case CALCULATOR_INPUT:
1534             if (calStatus == cal_error && (CAL_BUTTON != sci_sci) ) break;
1535             flashButton();
1536             switch( CAL_BUTTON ){
1537
1538                 case sci_pi:
1539                     result = M_PI;  power = 0;
1540                     calStatus = cal_normal;
1541                     break;
1542
1543                 case sci_xy:  break;
1544
1545                 case sci_sci:
1546                     buttonGroup = basicButtons;
1547                     printButtonGroups(basicButtons);
1548                     break;
1549
1550                 case sci_fac:
1551                 case sci_sin:
1552                 case sci_asin:
1553                 case sci_cos:
1554                 case sci_acos:
1555                 case sci_tan:
1556                 case sci_atan:
1557                 case sci_ln:
1558                 case sci_exp:
1559                 case sci_log:
1560                     formatResult(); /* not necessary, just for safty */
1561                     oneOperand();
1562                     break;
1563
1564                 case btn_sign:
1565                 case btn_dot:
1566                 default:  /* 0-9 */
1567                     typingProcess();
1568                     break;
1569             } /* switch (CAL_BUTTON) */
1570             break;
1571
1572 #ifdef CALCULATOR_OPERATORS
1573         case CALCULATOR_OPERATORS:
1574             if (calStatus == cal_error) break;
1575             if (!operInputted) {twoOperands(); operInputted = true;}
1576             switch (oper){
1577                 case ' ':  oper = '+'; break;
1578                 case '/':  oper = '+'; deleteAnimation(1);  break;
1579                 case '+':  oper = '-'; deleteAnimation(1);  break;
1580                 case '-':  oper = '*'; deleteAnimation(1);  break;
1581                 case '*':  oper = '/'; deleteAnimation(1);  break;
1582             }
1583             calStatus = cal_normal;
1584             formatResult();
1585             operand = result;
1586             operandPower = power;
1587             break;
1588 #endif
1589
1590         case CALCULATOR_CALC:
1591             if (calStatus == cal_error) break;
1592             formatResult();
1593             calStatus = cal_normal;
1594             operInputted = false;
1595             if (oper != ' ') twoOperands();
1596             break;
1597         default: break;
1598     }
1599     printResult();
1600 }
1601
1602 /* -----------------------------------------------------------------------
1603 move button index
1604 Invert display new button, invert back previous button
1605 ----------------------------------------------------------------------- */
1606 int handleButton(int button){
1607     switch(button)
1608     {
1609         case CALCULATOR_INPUT:
1610         case CALCULATOR_CALC:
1611 #ifdef CALCULATOR_INPUT_CALC_PRE
1612             if (lastbtn != CALCULATOR_INPUT_CALC_PRE)
1613                 break;
1614             /* no unconditional break; here! */
1615 #endif
1616 #ifdef CALCULATOR_OPERATORS
1617         case CALCULATOR_OPERATORS:
1618 #endif
1619             switch(buttonGroup){
1620                 case basicButtons:
1621                     basicButtonsProcess();
1622                     break;
1623                 case sciButtons:
1624                     sciButtonsProcess();
1625                     break;
1626             }
1627             break;
1628
1629 #ifdef CALCULATOR_CLEAR
1630         case CALCULATOR_CLEAR:
1631             switch(calStatus){
1632                 case cal_typing:
1633                 case cal_dotted:
1634                     doDelete();
1635                     break;
1636                 default: /* cal_normal, cal_error, cal_exit */
1637                     clearMem();
1638                     break;
1639             }
1640             printResult();
1641             break;
1642 #endif
1643         case CALCULATOR_LEFT:
1644         case CALCULATOR_LEFT | BUTTON_REPEAT:
1645             move_with_wrap_and_shift(
1646                 &btn_col, -1, BUTTON_COLS,
1647                 &btn_row,  0, BUTTON_ROWS);
1648             break;
1649
1650         case CALCULATOR_RIGHT:
1651         case CALCULATOR_RIGHT | BUTTON_REPEAT:
1652             move_with_wrap_and_shift(
1653                 &btn_col,  1, BUTTON_COLS,
1654                 &btn_row,  0, BUTTON_ROWS);
1655             break;
1656
1657 #ifdef CALCULATOR_UP
1658         case CALCULATOR_UP:
1659         case CALCULATOR_UP | BUTTON_REPEAT:
1660             move_with_wrap_and_shift(
1661                 &btn_row, -1, BUTTON_ROWS,
1662                 &btn_col,  0, BUTTON_COLS);
1663             break;
1664 #endif
1665 #ifdef CALCULATOR_DOWN
1666         case CALCULATOR_DOWN:
1667         case CALCULATOR_DOWN | BUTTON_REPEAT:
1668             move_with_wrap_and_shift(
1669                 &btn_row,  1, BUTTON_ROWS,
1670                 &btn_col,  0, BUTTON_COLS);
1671             break;
1672 #endif
1673
1674 #ifdef CALCULATOR_UP_W_SHIFT
1675         case CALCULATOR_UP_W_SHIFT:
1676         case CALCULATOR_UP_W_SHIFT | BUTTON_REPEAT:
1677             move_with_wrap_and_shift(
1678                 &btn_row, -1, BUTTON_ROWS,
1679                 &btn_col, -1, BUTTON_COLS);
1680             break;
1681 #endif
1682 #ifdef CALCULATOR_DOWN_W_SHIFT
1683         case CALCULATOR_DOWN_W_SHIFT:
1684         case CALCULATOR_DOWN_W_SHIFT | BUTTON_REPEAT:
1685             move_with_wrap_and_shift(
1686                 &btn_row,  1, BUTTON_ROWS,
1687                 &btn_col,  1, BUTTON_COLS);
1688             break;
1689 #endif
1690 #ifdef CALCULATOR_LEFT_W_SHIFT
1691         case CALCULATOR_LEFT_W_SHIFT:
1692         case CALCULATOR_LEFT_W_SHIFT | BUTTON_REPEAT:
1693             move_with_wrap_and_shift(
1694                 &btn_col, -1, BUTTON_COLS,
1695                 &btn_row, -1, BUTTON_ROWS);
1696             break;
1697 #endif
1698 #ifdef CALCULATOR_RIGHT_W_SHIFT
1699         case CALCULATOR_RIGHT_W_SHIFT:
1700         case CALCULATOR_RIGHT_W_SHIFT | BUTTON_REPEAT:
1701             move_with_wrap_and_shift(
1702                 &btn_col,  1, BUTTON_COLS,
1703                 &btn_row,  1, BUTTON_ROWS);
1704             break;
1705 #endif
1706 #ifdef CALCULATOR_RC_QUIT
1707         case CALCULATOR_RC_QUIT:
1708 #endif
1709         case CALCULATOR_QUIT:
1710             return -1;
1711     }
1712
1713     return 0;
1714
1715     prev_btn_row = btn_row;
1716     prev_btn_col = btn_col;
1717 }
1718
1719 /* -----------------------------------------------------------------------
1720 Main();
1721 ----------------------------------------------------------------------- */
1722 enum plugin_status plugin_start(const void* parameter)
1723 {
1724     (void)parameter;
1725
1726     /* now go ahead and have fun! */
1727
1728 #ifdef HAVE_TOUCHSCREEN
1729     rb->touchscreen_set_mode(TOUCHSCREEN_POINT);
1730 #endif
1731
1732     cal_initial();
1733
1734     while (calStatus != cal_exit ) {
1735         btn = rb->button_get_w_tmo(HZ/2);
1736 #ifdef HAVE_TOUCHSCREEN
1737         if(btn & BUTTON_TOUCHSCREEN)
1738         {
1739             struct ts_raster_result res;
1740             if(touchscreen_map_raster(&calc_raster, rb->button_get_data() >> 16,
1741                                       rb->button_get_data() & 0xffff, &res) == 1)
1742             {
1743                 btn_row = res.y;
1744                 btn_col = res.x;
1745                 drawButtons(buttonGroup);
1746                 drawLines();
1747
1748                 rb->lcd_update();
1749
1750                 prev_btn_row = btn_row;
1751                 prev_btn_col = btn_col;
1752                 if(btn & BUTTON_REL)
1753                 {
1754                     btn = CALCULATOR_INPUT;
1755                     switch(buttonGroup){
1756                         case basicButtons:
1757                             basicButtonsProcess();
1758                             break;
1759                         case sciButtons:
1760                             sciButtonsProcess();
1761                             break;
1762                     }
1763                     btn = BUTTON_TOUCHSCREEN;
1764                 }
1765             }
1766         }
1767 #endif
1768         if (handleButton(btn) == -1)
1769         {
1770             calStatus = cal_exit;
1771             printResult();
1772         }
1773         else
1774         {
1775             drawButtons(buttonGroup);
1776             drawLines();
1777         }
1778
1779         rb->lcd_update();
1780
1781         if(rb->default_event_handler(btn) == SYS_USB_CONNECTED)
1782             return PLUGIN_USB_CONNECTED;
1783
1784         if (btn != BUTTON_NONE)
1785             lastbtn = btn;
1786     } /* while (calStatus != cal_exit ) */
1787
1788     rb->button_clear_queue();
1789     return PLUGIN_OK;
1790 }