/**************************************************************************\
*** SCICALC Scientific Calculator for Windows 3.00.12
*** By Kraig Brockschmidt, Microsoft Co-op, Contractor, 1988-1989
*** (c)1989 Microsoft Corporation. All Rights Reserved.
***
*** scimain.c
***
*** Definitions of all globals, WinMain procedure
***
*** Last modification
*** Fri 22-Nov-1996
***
*** -by- Jonathan Parati. [jonpa] 22-Nov-1996
*** Converted Calc from floating point to infinite precision.
*** The new math engine is in ..\ratpak
***
***
*** -by- Amit Chatterjee. [amitc] 05-Jan-1990.
*** Calc did not have a floating point exception signal handler. This
*** would cause CALC to be forced to exit on a FP exception as that's
*** the default.
*** The signal handler is defined in SCIFUNC.C, in WinMain we hook the
*** the signal.
\**************************************************************************/
#include "scicalc.h"
#include "calchelp.h"
#include "signal.h"
#include "unifunc.h"
#include "input.h"
#include "scidisp.h"
#define BOOLIFY(x) ((x)?1:0)
/**************************************************************************/
/*** Global variable declarations and initializations ***/
/**************************************************************************/
int nCalc=0; /* 0=Scientific, 1=Simple. */
BOOL gbUseSep=FALSE; /* display the number with a separator */
ANGLE_TYPE nDecMode=ANGLE_DEG; /* Holder for last used Deg/Rad/Grad mode. */
UINT gnDecGrouping=0x03; /* Holds the decimal digit grouping number */
int nHexMode=0; /* Holder for last used Dword/Word/Byte mode. */
int nTempCom=0, /* Holding place for the last command. */
nParNum=0, /* Number of parenthases. */
nOpCode=0, /* ID value of operation. */
nOp[25], /* Holding array for parenthasis operations. */
nPrecOp[25], /* Holding array for precedence operations. */
nPrecNum=0, /* Current number of precedence ops in holding. */
gcIntDigits; /* Number of digits allowed in the current base */
eNUMOBJ_FMT nFE = FMT_FLOAT; /* Scientific notation conversion flag. */
HWND g_hwndDlg=0, /* Global handle to main window. */
hEdit=0, /* Handle to Clibboard I/O edit control */
hStatBox=0, /* Global handle to statistics box. */
hListBox=0; /* Global handle for statistics list box. */
HMENU g_hHexMenu=NULL; // Global handle for hex menu
HMENU g_hDecMenu=NULL; // Global handle for dec menu
HANDLE hAccel; // Accelerator handle.
HINSTANCE hInst; // Global instance.
BOOL bHyp=FALSE, // Hyperbolic on/off flag.
bInv=FALSE, // Inverse on/off flag.
bError=FALSE, // Error flag.
bColor=TRUE; // Flag indicating if color is available.
HNUMOBJ ghnoNum=NULL, // Currently displayed number used everywhere.
ghnoParNum[25], // Holding array for parenthasis values.
ghnoPrecNum[25], // Holding array for precedence values.
ghnoMem=NULL, // Current memory value.
ghnoLastNum = NULL; // Number before operation (left operand).
LONG nPrecision = 32, // number of digits to use in decimal mode
nDecimalPlaces = 10, // number of decimal places to show
nRadix=10, // the current base (2, 8, 10, or 16)
dwWordBitWidth = 64; // # of bits in currently selected word size
BOOL g_fHighContrast = FALSE; // Are we in High Contrast mode?
HNUMOBJ g_ahnoChopNumbers[4]; // word size inforcement
BOOL bFarEast; // true if we need to use Far East localization
#ifdef USE_MIRRORING
BOOL g_fLayoutRTL = FALSE;
#endif
extern CALCINPUTOBJ gcio;
extern BOOL gbRecord;
/* DO NOT LOCALIZE THESE STRINGS. */
TCHAR szAppName[10]=TEXT("SciCalc"), /* Application name. */
szDec[5]=TEXT("."), /* Default decimal character */
gszSep[5]=TEXT(","), /* Default thousand seperator */
szBlank[6]=TEXT(""); /* Blank space. */
LPTSTR gpszNum = NULL;
static TCHAR szInitNum[] = TEXT("0"); // text to init gpszNum with
/* END WARNING */
/* rgpsz[] is an array of pointers to strings in a locally allocated */
/* memory block. This block is fixed such that LocalLock does not need */
/* to be called to use a string. */
TCHAR *rgpsz[CSTRINGS];
RECT rcDeg[6];
void ParseCmdLine( LPSTR pszCmdA );
BOOL InitializeWindowClass( HINSTANCE hPrevInstance );
void InitialOneTimeOnlySetup();
void EverythingResettingNumberSetup();
extern WNDPROC fpOrgDispEditProc;
LRESULT CALLBACK SubDispEditProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
/**************************************************************************/
/*** Main Window Procedure. ***/
/*** ***/
/*** Important functions: ***/
/*** 1) Gets text dimensions and sets conversion units correctly. ***/
/*** ***/
/*** 2) Checks the display device driver for color capability. ***/
/*** If only 2 colors are available (mono, cga), bColor is ***/
/*** set to FALSE, and the background brush is gray. If ***/
/*** color is available, the background brush colors are read ***/
/*** from WIN.INI and the brush is created. ***/
/*** ***/
/*** 3) Window and hidden edit control are created. ***/
/*** ***/
/*** 4) Contains message loop and deletes the brushes used. ***/
/*** ***/
/**************************************************************************/
int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
INT nx;
LPTSTR psz;
int cch = 0, cchTotal = 0;
TCHAR szTempString[100] = {0};
#ifdef USE_MIRRORING
DWORD dwLayout;
#endif
// A bunch of sanity checks to ensure nobody is violating any of the
// bazillion
// assumptions calc makes about the order of controls. Of course these
// asserts
// wouldn't prevent a really dedicated person from messing things up but they
// should help guide a rational person who might not be aware of calc's
// idiosyncrasies.
// Anyone who modifies the resource file should hit these asserts which
// will then
// alert them to the consequences of their actions.
// IDC_0 to IDC_F must be in sequential increasing order
ASSERT( 15 == (IDC_F - IDC_0) );
// Binary operators IDC_AND through IDC_PWR must be in order
ASSERT( (95-86) == (IDC_PWR - IDC_AND) );
// Unary operators IDC_CHOP through IDC_EQU must be in order
ASSERT( (112-96) == (IDC_EQU - IDC_CHOP) );
// menu item id's must be in order
ASSERT( 5 == (IDM_LASTMENU - IDM_FIRSTMENU) );
#ifdef USE_MIRRORING
if (GetProcessDefaultLayout(&dwLayout) && (dwLayout & LAYOUT_RTL))
{
SetProcessDefaultLayout(dwLayout & ~LAYOUT_RTL);
g_fLayoutRTL = TRUE;
}
#endif
ParseCmdLine( lpCmdLine );
hInst = hInstance;
if ( !InitializeWindowClass( hPrevInstance ) )
return FALSE;
// Read strings for keys, errors, trig types, etc.
// These will be copied from the resources to local memory. A larger
// than needed block is allocated first and then reallocated once we
// know how much is actually used.
try
{
psz = (LPTSTR) LocalAlloc(LPTR, ByteCountOf(CCHSTRINGSMAX));
if (!psz)
throw;
int cchResourceBuffer = CCHSTRINGSMAX, cchLeftInBuffer;
// build up an offset array in rgpsz
for (nx = 0; nx <= CSTRINGS; nx++)
{
INT_PTR iOffset;
Retry:
cchLeftInBuffer = cchResourceBuffer - cchTotal;
cch = 1 + LoadString(hInstance, (UINT)(IDS_FIRSTKEY + nx), psz + cchTotal, cchLeftInBuffer);
if (cch == (cchResourceBuffer - cchTotal)) // woops: buffer was too small
{
LPTSTR pszTmp = (LPTSTR)LocalReAlloc(psz, ByteCountOf(cchResourceBuffer + CCHSTRINGSMAX), LMEM_MOVEABLE);
if (!pszTmp)
throw;
psz = pszTmp;
cchResourceBuffer += CCHSTRINGSMAX;
goto Retry;
}
iOffset = (INT_PTR)cchTotal;
rgpsz[nx] = (LPTSTR)iOffset; // first pass is offset array
cchTotal += cch;
}
LPTSTR pszTmp = (LPTSTR)LocalReAlloc(psz, ByteCountOf(cchTotal), LMEM_MOVEABLE);
if (!pszTmp)
throw;
psz = pszTmp;
// convert the array of offsets into an array of pointers
for (nx = 0 ; nx <= CSTRINGS ; nx++)
rgpsz[nx] = psz + (INT_PTR)rgpsz[nx];
}
catch ( ... )
{
if (psz)
LocalFree(psz);
if (LoadString(hInst, IDS_NOMEM, szTempString, CharSizeOf(szTempString)))
{
MessageBox((HWND) NULL, szTempString, NULL, MB_OK | MB_ICONHAND);
}
return FALSE;
}
// The display in calc isn't really an edit control so we use this edit
// control to simplify cutting to the clipboard
hEdit = CreateWindow( TEXT("EDIT"), TEXT("CalcMsgPumpWnd"),
WS_OVERLAPPED | WS_VISIBLE,
CW_USEDEFAULT,0,CW_USEDEFAULT,0,
NULL, NULL, hInst, NULL );
// This initializes things that only need to be set up once, including a
// call to ratpak so that ratpak can create any constants it needs
InitialOneTimeOnlySetup();
// we store in the win.ini file our desired display mode, Scientific
// or Standard
nCalc = (INT)GetProfileInt(szAppName, TEXT("layout"), 1);
gbUseSep = (INT)GetProfileInt(szAppName, TEXT("UseSep"), 0);
// InitSciCalc creates a dialog based on what the value of nCalc is.
// A handle to the window that is created is stored in g_hwndDlg
InitSciCalc(TRUE);
hAccel = LoadAccelerators(hInst, MAKEINTRESOURCE(IDA_ACCELTABLE));
while (GetMessage(&msg, NULL, 0, 0))
{
if (!hStatBox || !IsDialogMessage(hStatBox, &msg))
{
if ( ((msg.hwnd == g_hwndDlg)||IsChild(g_hwndDlg, msg.hwnd)) && TranslateAccelerator (g_hwndDlg, (HACCEL)hAccel, &msg))
continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
LocalFree(psz);
return (DWORD)msg.wParam;
}
/**************************************************************************\
*
* Command Line processing routines
*
* History
* 22-Nov-1996 JonPa Wrote it
*
\**************************************************************************/
#define IsWhiteSpace( ch ) ((ch) == TEXT(' ') || (ch) == TEXT('\t'))
#define IsDigit( ch ) ((ch) >= TEXT('0') && (ch) <= TEXT('9'))
LPTSTR TtoL( LPTSTR psz, LONG *pl ) {
LONG l = 0;
while( IsDigit( *psz ) ) {
l = l * 10 + (*psz - TEXT('0'));
psz = CharNext( psz );
}
*pl = l;
return psz;
}
void ParseCmdLine( LPSTR pszCmdA ) {
BOOL fInQuote;
LPTSTR pszCmdT = GetCommandLine();
// parse cmd line
// usage: -p:## -r:## -w:## -e -x -i
// -e, -x, and -i currently do nothing.
// Skip app name
while( *pszCmdT && IsWhiteSpace( *pszCmdT )) {
pszCmdT = CharNext( pszCmdT );
}
fInQuote = FALSE;
while( *pszCmdT && (fInQuote || !IsWhiteSpace(*pszCmdT)) ) {
if (*pszCmdT == TEXT('\"'))
fInQuote = !fInQuote;
pszCmdT = CharNext( pszCmdT );
}
while( *pszCmdT )
{
switch( *pszCmdT )
{
case TEXT('p'):
case TEXT('P'):
// -p:## precision
pszCmdT = CharNext(pszCmdT);
// Skip ':' and white space
while( *pszCmdT && (*pszCmdT == TEXT(':') || IsWhiteSpace(*pszCmdT)) ) {
pszCmdT = CharNext(pszCmdT);
}
pszCmdT = TtoL( pszCmdT, &nPrecision );
// a percision > C_NUM_MAX_DIGITS will allow a string too long for it's buffer
if ( nPrecision > C_NUM_MAX_DIGITS)
{
ASSERT( nPrecision <= C_NUM_MAX_DIGITS );
nPrecision = C_NUM_MAX_DIGITS;
}
// NOTE: this code assumes there MUST be a space after the number
break;
case TEXT('r'):
case TEXT('R'):
// -r:## Radix
pszCmdT = CharNext(pszCmdT);
// Skip ':' and white space
while( *pszCmdT && (*pszCmdT == TEXT(':') || IsWhiteSpace(*pszCmdT)) ) {
pszCmdT = CharNext(pszCmdT);
}
pszCmdT = TtoL( pszCmdT, &nRadix );
// since the UI only has 16 keys for digit input, we only allow upto base 16
if (nRadix > 16)
{
ASSERT( nRadix <= 16 );
nRadix = 16;
}
else if (nRadix < 2) // you know some fool would try for base zero if you let them
{
ASSERT( nRadix >= 2 );
nRadix = 2;
}
// NOTE: this code assumes there MUST be a space after the number
break;
case TEXT('e'):
case TEXT('E'):
// -e extended mode
break;
case TEXT('w'):
case TEXT('W'):
// -w:## Word size in bits
pszCmdT = CharNext(pszCmdT);
// Skip ':' and white space
while( *pszCmdT && (*pszCmdT == TEXT(':') || IsWhiteSpace(*pszCmdT)) ) {
pszCmdT = CharNext(pszCmdT);
}
// Set bit count
pszCmdT = TtoL( pszCmdT, &dwWordBitWidth );
// NOTE: this code assumes there MUST be a space after the number
break;
}
pszCmdT = CharNext( pszCmdT );
}
}
//////////////////////////////////////////////////
//
// InitalizeWindowClass
//
//////////////////////////////////////////////////
BOOL InitializeWindowClass( HINSTANCE hPrevInstance )
{
WNDCLASSEX wndclass;
if (!hPrevInstance)
{
wndclass.cbSize = sizeof(wndclass);
wndclass.style = 0;
wndclass.lpfnWndProc = CalcWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = DLGWINDOWEXTRA;
wndclass.hInstance = hInst;
wndclass.hIcon = LoadIcon(hInst, TEXT("SC"));
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
wndclass.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
wndclass.lpszMenuName = MAKEINTRESOURCE(IDM_CALCMENU);
wndclass.lpszClassName = szAppName;
wndclass.hIconSm = NULL;
if (!RegisterClassEx(&wndclass))
return FALSE;
}
return TRUE;
}
//////////////////////////////////////////////////
//
// InitialOneTimeOnlyNumberSetup
//
//////////////////////////////////////////////////
void InitialOneTimeOnlySetup()
{
// Initialize the decimal input code. This ends up getting called twice
// but it's quick so that shouldn't be a problem. Needs to be done before
// SetRadix is called.
CIO_vClear( &gcio );
gbRecord = TRUE;
// we must now setup all the ratpak constants and our arrayed pointers
// to these constants.
BaseOrPrecisionChanged();
// these rat numbers are set only once and then never change regardless of
// base or precision changes
g_ahnoChopNumbers[0] = rat_qword;
g_ahnoChopNumbers[1] = rat_dword;
g_ahnoChopNumbers[2] = rat_word;
g_ahnoChopNumbers[3] = rat_byte;
// we can't call this until after we have set the radix (and thus called
// ChangeConstants) so we do it last.
EverythingResettingNumberSetup();
NumObjAssign( &ghnoMem, HNO_ZERO );
}
//////////////////////////////////////////////////
//
// EverythingResettingNumberSetup
//
//////////////////////////////////////////////////
void EverythingResettingNumberSetup()
{
int i;
// Initialize the decimal input code.
CIO_vClear( &gcio );
gbRecord = TRUE;
NumObjAssign( &ghnoNum, HNO_ZERO );
NumObjAssign( &ghnoLastNum, HNO_ZERO );
// REVIEW: is it just me, or do we speew major memory wheneven this method
// executes?
// array used to handle ( and )
for( i = 0; i < ARRAYSIZE(ghnoParNum); i++ )
ghnoParNum[i] = NULL;
// array used to handle order of operations
for( i = 0; i < ARRAYSIZE(ghnoPrecNum); i++ )
ghnoPrecNum[i] = NULL;
gpszNum = (LPTSTR)NumObjAllocMem( sizeof(szInitNum) );
if (gpszNum)
{
lstrcpy( gpszNum, szInitNum );
}
}
//////////////////////////////////////////////////
//
// InitSciCalc
//
//////////////////////////////////////////////////
VOID APIENTRY InitSciCalc(BOOL bViewChange)
{
TCHAR chLastDec;
TCHAR chLastSep;
int nLastSepLen;
UINT nLastDecGrouping;
HMENU hMenu;
HWND hDispEdit;
BOOL bRepaint=FALSE;
RECT rect = {0,0,0,0};
TCHAR szGrouping[32];
EverythingResettingNumberSetup();
// when we switch modes, we need to remind the ui that we are no longer
// inputing the number we were inputting before we switched modes.
gbRecord = FALSE; // REVIEW: This should not be needed with the new initialization
chLastDec = szDec[0];
chLastSep = gszSep[0];
nLastDecGrouping=gnDecGrouping;
GetProfileString(TEXT("intl"), TEXT("sDecimal"), TEXT("."),
szDec, CharSizeOf(szDec));
GetProfileString(TEXT("intl"), TEXT("sThousand"), TEXT(","),
gszSep, CharSizeOf(gszSep));
ZeroMemory(szGrouping,sizeof(szGrouping));
GetProfileString(TEXT("intl"), TEXT("sGrouping"), TEXT("3;0"),
szGrouping, CharSizeOf(szGrouping));
gnDecGrouping=DigitGroupingStringToGroupingNum(szGrouping);
// if the grouping pattern changed we always do the following things
if (gnDecGrouping != nLastDecGrouping)
{
nLastDecGrouping=gnDecGrouping;
bRepaint=TRUE;
}
// if the thousands symbol has changed we always do the following things
if ( gszSep[0] != chLastSep )
{
chLastSep = gszSep[0];
bRepaint = TRUE;
}
// if the decimal symbol has changed we always do the following things
if ( szDec[0] != chLastDec )
{
chLastDec = szDec[0];
// Re-initialize input string's decimal point.
CIO_vUpdateDecimalSymbol(&gcio, chLastDec);
// put the new decimal symbol into the table used to draw the decimal
// key
*(rgpsz[IDS_DECIMAL]) = chLastDec;
// we need to redraw to update the decimal point button
bRepaint = TRUE;
}
{
HIGHCONTRAST hc;
hc.cbSize = sizeof(hc);
if ( SystemParametersInfo(SPI_GETHIGHCONTRAST, sizeof(hc), &hc, 0) )
{
if ( BOOLIFY(hc.dwFlags & HCF_HIGHCONTRASTON) != g_fHighContrast )
{
g_fHighContrast = BOOLIFY(hc.dwFlags & HCF_HIGHCONTRASTON);
bRepaint = TRUE;
}
}
}
if ( bViewChange )
{
BOOL bUseOldPos = FALSE;
// if we are changing views we destory the old window and create
// a new window
if ( g_hwndDlg )
{
SetMenu(g_hwndDlg, g_hDecMenu);
bUseOldPos = TRUE;
GetWindowRect( g_hwndDlg, &rect );
DestroyWindow( g_hwndDlg );
DestroyMenu(g_hHexMenu);
g_hHexMenu=NULL;
}
// create the correct window for the mode we're currently in
if ( nCalc )
{
// switch to standard mode
g_hwndDlg = CreateDialog(hInst, MAKEINTRESOURCE(IDD_STANDARD), 0,
NULL);
g_hDecMenu=GetMenu(g_hwndDlg);
#ifdef USE_MIRRORING
if (g_fLayoutRTL)
{
SetWindowLong(g_hwndDlg,
GWL_EXSTYLE,
GetWindowLong(g_hwndDlg,GWL_EXSTYLE) | \
WS_EX_LAYOUTRTL | WS_EX_NOINHERITLAYOUT);
}
#endif
}
else
{
// switch to scientific mode
g_hwndDlg = CreateDialog(hInst, MAKEINTRESOURCE(IDD_SCIENTIFIC),
0, NULL);
g_hDecMenu=GetMenu(g_hwndDlg);
g_hHexMenu=LoadMenu(hInst, MAKEINTRESOURCE(IDM_HEXCALCMENU));
#ifdef USE_MIRRORING
if (g_fLayoutRTL)
{
SetWindowLong(g_hwndDlg,
GWL_EXSTYLE,
GetWindowLong(g_hwndDlg,GWL_EXSTYLE) | WS_EX_LAYOUTRTL | WS_EX_NOINHERITLAYOUT);
}
#endif
// Stat box is initially off, disable stat buttons.
for ( int iID = IDC_AVE; iID <= IDC_DATA; iID++ )
EnableWindow( GetDlgItem( g_hwndDlg, iID ), FALSE );
SwitchModes(10, nDecMode, nHexMode);
// If precision won't fit in display, then resize it
if (nPrecision > 32)
{
HWND hwndDisplay;
RECT rc, rcMain;
hwndDisplay=GetDlgItem( g_hwndDlg, IDC_DISPLAY );
GetWindowRect( hwndDisplay, &rc );
GetClientRect( g_hwndDlg, &rcMain );
MapWindowPoints( g_hwndDlg, NULL, (LPPOINT)&rcMain, 2);
rc.left = rcMain.left + (rcMain.right - rc.right);
OffsetRect( &rc, -(rcMain.left), -(rcMain.top) );
SetWindowPos(hwndDisplay, NULL,
rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOZORDER );
}
}
if (hDispEdit = GetDlgItem(g_hwndDlg, IDC_DISPLAY))
{
// subclass the Edit Control hide caret and filter out mouse msg
fpOrgDispEditProc = (WNDPROC)GetWindowLongPtr(hDispEdit, GWLP_WNDPROC);
if (fpOrgDispEditProc)
SetWindowLongPtr(hDispEdit, GWLP_WNDPROC, (LONG_PTR)(WNDPROC)SubDispEditProc);
}
// keep calc in the same place it was before
if ( bUseOldPos )
{
SetWindowPos( g_hwndDlg, NULL, rect.left, rect.top, 0,0,
SWP_NOZORDER | SWP_NOSIZE );
}
// ensure the menu items for Scientific and Standard are set correctly
CheckMenuRadioItem(g_hDecMenu, IDM_SC, IDM_SSC,
(nCalc == 0 ? IDM_SC : IDM_SSC), MF_BYCOMMAND);
CheckMenuItem(g_hDecMenu, IDM_USE_SEPARATOR,
MF_BYCOMMAND | (gbUseSep ? MF_CHECKED : MF_UNCHECKED));
if (g_hHexMenu)
{
CheckMenuRadioItem(g_hHexMenu, IDM_SC, IDM_SSC,
(nCalc == 0 ? IDM_SC : IDM_SSC), MF_BYCOMMAND);
CheckMenuItem(g_hHexMenu, IDM_USE_SEPARATOR,
MF_BYCOMMAND | (gbUseSep ? MF_CHECKED:MF_UNCHECKED));
}
// To ensure that the call to SetRadix correctly update the active
// state of the buttons on
// SciCalc we must tell it to forget the previous Radix
{
extern long oldRadix;
oldRadix = (unsigned)-1;
}
// this will set the correct buttons on the UI
SetRadix(10);
SetDlgItemText(g_hwndDlg, IDC_MEMTEXT,
NumObjIsZero(ghnoMem) ? (szBlank) : (TEXT(" M")) );
SendMessage(g_hwndDlg, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0);
ShowWindow( g_hwndDlg, SW_SHOW );
UpdateWindow(g_hwndDlg);
} // END if ( bViewChanged )
else if ( bRepaint )
{
// no need to repaint if we just changed views
InvalidateRect( g_hwndDlg, NULL, TRUE );
}
}