static Boolean AppHandleEvent(EventPtr event){
FormPtr pfrm;
Boolean handled = false;
switch (event->eType){
case frmLoadEvent:
prevFormId = formId;
formId = event->data.frmLoad.formID;
pfrm = FrmInitForm(formId);
FrmSetActiveForm(pfrm);
switch (formId){
case GraffitiForm:
FrmSetEventHandler(pfrm, GraffitiFormHandleEvent);
handled = true;
break;
case HelpForm:
offset = 0;
FrmSetEventHandler(pfrm, HelpFormHandleEvent);
handled = true;
break;
case WinForm:
FrmSetEventHandler(pfrm, WinFormHandleEvent);
handled = true;
break;
case GraffitiHelpForm:
FrmSetEventHandler(pfrm, GraffitiHelpFormHandleEvent);
handled = true;
break;
default:
break;
}
break;
case menuEvent:
MenuEraseStatus(NULL);
switch (event->data.menu.itemID) {
case MainMenuGraffitiHelpCmd:
FrmGotoForm(GraffitiHelpForm);
handled = true;
break;
case MainMenuRestartCmd:
FrmGotoForm(HelpForm);
handled = true;
break;
default:
break;
}
break;
case keyDownEvent:
if (event->data.keyDown.chr == vchrHardPower){
FrmGotoForm(HelpForm);
}
break;
default:
break;
}
return handled;
}
static Boolean AppHandleEvent(EventPtr event)
{
FormPtr frm;
Int32 formId;
Boolean handled;
handled = false;
if (event->eType == frmLoadEvent)
{
formId = event->data.frmLoad.formID;
frm = FrmInitForm(formId);
FrmSetActiveForm(frm);
switch (formId)
{
case FlopForm:
FrmSetEventHandler(frm, FlopFormHandleEvent);
handled = true;
break;
default:
break;
}
}
return handled;
}
static Boolean AppHandleEvent(EventPtr eventP) {
Boolean handled = false;
FormType *frmP;
if (eventP->eType == frmLoadEvent) { /* Initialize and activate the form resource. */
frmP = FrmInitForm(eventP->data.frmLoad.formID);
FrmSetActiveForm(frmP);
if (eventP->data.frmLoad.formID == MainForm) {
dynInputOnMainFormLoad(frmP);
FrmSetEventHandler(frmP, MainFormHandleEvent);
}
handled = true;
} else if (eventP->eType == frmOpenEvent) { /* Load the form resource. */
frmP = FrmGetActiveForm();
FrmDrawForm(frmP);
handled = true;
} else if (eventP->eType == appStopEvent) { /* Unload the form resource. */
frmP = FrmGetActiveForm();
FrmEraseForm(frmP);
FrmDeleteForm(frmP);
handled = true;
}
return(handled);
}
/*********************************************************************
* Function: ApplicationHandleEvent
* Description: this is the event handler that we use to
* set up forms on frmLoadEvents. It sets the event handlers
* for every other non modal form in the program
* *******************************************************************/
static Boolean
ApplicationHandleEvent (EventType *event)
{
FormType *frm;
Int16 formId;
Boolean handled = false;
if (event->eType == frmLoadEvent)
{
// load and activate the requested form
formId = event->data.frmLoad.formID;
frm = FrmInitForm (formId);
FrmSetActiveForm (frm);
// set an event handler
switch (formId)
{
case PasswordForm:
FrmSetEventHandler (frm, PasswordHandleEvent);
break;
}
handled = true;
}
return handled;
}
static Boolean ApplicationHandleEvent( EventPtr event )
{
FormPtr frm;
FieldPtr fld;
FieldAttrType fldattr;
Int formId;
Boolean handled = false;
if( event->eType == frmLoadEvent ) {
formId = event->data.frmLoad.formID;
frm = FrmInitForm( formId );
FrmSetActiveForm( frm );
switch( formId ) {
case mainFormID:
FrmSetEventHandler( frm, MyMainFormHandleEvent );
fld = FrmGetObjectPtr( frm, FrmGetObjectIndex( frm,
dataFieldID ) );
FldGetAttributes( fld, &fldattr );
fldattr.hasScrollBar=true;
FldSetAttributes( fld, &fldattr );
break;
default:
break;
}
handled = true;
}
return handled;
}
Boolean Application_EventHandler(EventPtr event)
{
FormPtr frm;
int formId;
Boolean handled = false;
switch (event->eType) {
case frmLoadEvent :
{
formId = event->data.frmLoad.formID;
frm = FrmInitForm(formId);
FrmSetActiveForm(frm);
switch(formId) {
case _GmF:
FrmSetEventHandler(frm, GmF_EventHandler);
break;
}
handled = true;
}
case menuEvent :
{
switch (event->data.menu.itemID) {
}
handled = true;
}
default:
break;
}
return handled;
}
static Boolean
ApplicationHandleEvent (EventPtr event)
{
Word formId;
FormPtr frm;
if (event->eType == frmLoadEvent)
{
// Load the form resource.
formId = event->data.frmLoad.formID;
frm = FrmInitForm (formId);
if (frm)
{
switch (formId) {
case mainForm:
mainFrm = frm;
FrmSetEventHandler (frm, MainFormHandleEvent);
break;
}
FrmSetActiveForm (frm);
}
// Set the event handler for the form. The handler of the currently
// active form is called by FrmHandleEvent each time is receives an
// event.
return (true);
}
return (false);
}
/***********************************************************************
*
* FUNCTION: AppHandleEvent
*
* DESCRIPTION: This routine loads form resources and set the event
* handler for the form loaded.
*
* PARAMETERS: event - a pointer to an EventType structure
*
* RETURNED: true if the event has handle and should not be passed
* to a higher level handler.
*
* REVISION HISTORY:
*
*
***********************************************************************/
static Boolean AppHandleEvent(EventPtr eventP)
{
UInt16 formId;
FormPtr frmP;
if (eventP->eType == frmLoadEvent)
{
// Load the form resource.
formId = eventP->data.frmLoad.formID;
frmP = FrmInitForm(formId);
FrmSetActiveForm(frmP);
// Set the event handler for the form. The handler of the currently
// active form is called by FrmHandleEvent each time is receives an
// event.
switch (formId)
{
case MainForm:
FrmSetEventHandler(frmP, MainFormHandleEvent);
break;
default:
// ErrFatalDisplay("Invalid Form Load Event");
break;
}
return true;
}
return false;
}
bool wxTopLevelWindowPalm::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// this is a check for limitation mentioned before FrameFormHandleEvent() code
if(wxTopLevelWindows.GetCount()>0)
return false;
ActiveParentFrame=NULL;
wxTopLevelWindows.Append(this);
if ( parent )
parent->AddChild(this);
SetId( id == wxID_ANY ? NewControlId() : id );
WinConstraintsType constraints;
memset(&constraints, 0, sizeof(WinConstraintsType));
// position
constraints.x_pos = ( pos.x == wxDefaultCoord ) ? winUndefConstraint : pos.x;
constraints.y_pos = ( pos.y == wxDefaultCoord ) ? winUndefConstraint : pos.y;
// size
constraints.x_min = winUndefConstraint;
constraints.x_max = winMaxConstraint;
constraints.x_pref = ( size.x == wxDefaultCoord ) ? winUndefConstraint : size.x;
constraints.y_min = winUndefConstraint;
constraints.y_max = winMaxConstraint;
constraints.y_pref = ( size.y == wxDefaultCoord ) ? winUndefConstraint : size.y;
FrameForm = FrmNewFormWithConstraints(
GetId(),
title.c_str(),
winFlagBackBuffer,
&constraints,
0,
NULL,
0,
NULL,
0
);
if(FrameForm==NULL)
return false;
FrmSetEventHandler(FrameForm,FrameFormHandleEvent);
FrmSetActiveForm(FrameForm);
ActiveParentFrame=this;
return true;
}
// Show a registration dialog where a user enters registration code.
// if fDeleteAfterCancel is set to true, we'll remove the registration code
// from preferences. We want this behavior if "re-enter registration code" was
// pressed after registration process failed (this was an invalid registration code
// so we don't want the client to send it to the server -> so we erase it).
// If this dialog was brought by "Register" menu item, then we don't want to
// touch the registration code (we assume it's correct)
// TODO: maybe if we're called from "Register" menu and registartion code
// is already present (i.e. valid) we should make it harder to edit it by accident
// (e.g. make it read only until user makes some action like pressing a "edit" button)
static void MainFormHandleRegister(AppContext* appContext, bool fDeleteAfterCancel)
{
FormType* form=FrmInitForm(formRegistration);
if (!form)
{
FrmAlert(alertMemError);
return;
}
DefaultFormInit(appContext, form);
FrmSetEventHandler(form, RegistrationFormHandleEvent);
UInt16 button=FrmDoDialog(form);
if (buttonRegister!=button)
{
if (fDeleteAfterCancel)
{
appContext->prefs.regCode[0] = '\0';
SavePreferencesInoah(appContext);
}
goto Exit;
}
UInt16 index=FrmGetObjectIndex(form, fieldRegCode);
Assert(frmInvalidObjectId!=index);
const FieldType* field=static_cast<FieldType*>(FrmGetObjectPtr(form, index));
Assert(field);
const char* regCode=FldGetTextPtr(field);
int regCodeLen = (int)FldGetTextLength(field);
if ( (NULL != regCode) && (regCodeLen>0) )
{
// save the registration code in preferences so that we can
// send it in all requests
if (regCodeLen>MAX_REG_CODE_LENGTH)
{
// this is laziness: reg code longer than MAX_REG_CODE_LENGTH
// is invalid for sure so we should just display such message
// but we'll just use truncated version and go on with normal
// processing
regCodeLen=MAX_REG_CODE_LENGTH;
}
SafeStrNCopy((char*)appContext->prefs.regCode, sizeof(appContext->prefs.regCode), regCode, regCodeLen);
RemoveNonDigits( (char*)appContext->prefs.regCode );
// save preferences just for sure - so that we don't loose regCode
// in case of a crash
SavePreferencesInoah(appContext);
// send a registration query to the server so that the user
// knows if he registered correctly
// it doesn't really matter, in the long run, because every time
// we send a request, we also send the registration code and
// if it's not correct, we'll reject the query
StartRegistration(appContext, (const char*)appContext->prefs.regCode);
}
Exit:
FrmDeleteForm(form);
}
static void
EventLoop (void)
{
short err;
int fid;
FormPtr form;
EventType event;
do
{
EvtGetEvent(&event, 200);
// let the system handle it's own events
if (SysHandleEvent(&event)) continue;
// same for menu events
if (MenuHandleEvent((void *)0, &event, &err)) continue;
// set up our handler when our main form is loaded
if (event.eType == frmLoadEvent) {
fid = event.data.frmLoad.formID;
form = FrmInitForm(fid);
FrmSetActiveForm(form);
switch (fid) {
case fid_kartrando:
FrmSetEventHandler(form, mainEventHandler);
break;
case fid_prefs:
FrmSetEventHandler(form, prefsEventHandler);
break;
}
}
FrmDispatchEvent(&event);
} while (event.eType != appStopEvent);
}
static Boolean AppHandleEvent(EventType *eventP)
{
UInt16 formId;
FormType *frmP;
if (eventP->eType == frmLoadEvent) {
/* Load the form resource. */
formId = eventP->data.frmLoad.formID;
frmP = FrmInitForm(formId);
FrmSetActiveForm(frmP);
/*
* Set the event handler for the form. The handler of the
* currently active form is called by FrmHandleEvent each
* time is receives an event.
*/
switch (formId) {
case kMainForm:
FrmSetEventHandler(frmP, MainFormHandleEvent);
FrmSetGadgetHandler(frmP, FrmGetObjectIndex(frmP, kTabGadget), TabGadgetHandler);
break;
case kURLForm:
FrmSetEventHandler(frmP, URLFormHandleEvent);
break;
case kPrivacyForm:
FrmSetEventHandler(frmP, PrivacyFormHandleEvent);
break;
case kPrefsForm:
FrmSetEventHandler(frmP, PrefsFormHandleEvent);
FrmSetGadgetHandler(frmP, FrmGetObjectIndex(frmP, kPrefsTabGadget), TabGadgetHandler);
break;
}
return true;
}
return false;
}
int event_loop(void) {
UInt16 error;
EventType event;
FormPtr form;
int form_id;
Regiondesc rd;
do {
EvtGetEvent(&event, 0); // No timeout - return immediately
if (!SysHandleEvent(&event))
if (!MenuHandleEvent(NULL, &event, &error))
if (event.eType == frmLoadEvent) {
// Load and activate form.
form_id = event.data.frmLoad.formID;
form = FrmInitForm(form_id);
FrmSetActiveForm(form);
switch (form_id) {
case formID_main_ri_sim: FrmSetEventHandler(form, (FormEventHandlerPtr) ri_sim_event); break;
case formID_sys_info: FrmSetEventHandler(form, (FormEventHandlerPtr) sys_info_event); break;
}
} else
FrmDispatchEvent(&event);
} while (event.eType != appStopEvent);
}
static Boolean ApplicationHandleEvent(EventPtr e)
{
FormPtr frm;
UInt16 formId;
Boolean handled = false;
if (e->eType == frmLoadEvent) {
formId = e->data.frmLoad.formID;
frm = FrmInitForm(formId);
FrmSetActiveForm(frm);
switch(formId) {
case MainForm:
FrmSetEventHandler(frm, MainFormHandleEvent);
break;
case PrefForm:
FrmSetEventHandler(frm, PrefFormHandleEvent);
break;
}
handled = true;
}
return handled;
}
Err PopupResidentBrowseForm(AppContext* appContext)
{
Err error=errNone;
FormType* form=FrmInitForm(formResidentBrowse);
UInt16 buttonId=0;
Assert(form);
error=DefaultFormInit(appContext, form);
if (error)
goto OnError;
FrmSetEventHandler(form, ResidentBrowseFormHandleEvent);
buttonId=FrmDoDialog(form);
Assert(!buttonId || buttonCancel==buttonId);
OnError:
FrmDeleteForm(form);
return error;
}
static Err UserCredentialsFormInit(FormType* form, const FlickrPrefs& prefs)
{
FieldType* field;
MemHandle handle;
MemHandle newText;
UInt16 len;
FrmSetEventHandler(form, UserCredentialsFormHandleEvent);
field = (FieldType*)FrmGetObjectPtr(form, FrmGetObjectIndex(form, emailField));
assert(field != NULL);
// FldSetMaxVisibleLines(field, 2);
if (0 != (len = StrLen(prefs.email)))
{
newText = StrCopyToHandle(prefs.email, len);
if (NULL == newText)
return exgMemError;
handle = FldGetTextHandle(field);
if (NULL != handle)
MemHandleFree(handle);
FldSetTextHandle(field, newText);
FldSetSelection(field, 0, len);
FldRecalculateField(field, false);
}
if (0 != (len = StrLen(prefs.password)))
{
field = (FieldType*)FrmGetObjectPtr(form, FrmGetObjectIndex(form, passwordField));
assert(field != NULL);
newText = StrCopyToHandle(prefs.password, len);
if (NULL == newText)
return exgMemError;
handle = FldGetTextHandle(field);
if (NULL != handle)
MemHandleFree(handle);
FldSetTextHandle(field, newText);
FldSetSelection(field, 0, len);
FldRecalculateField(field, false);
}
return errNone;
}
UInt16 DisplayDialog( UInt16 formID, FormEventHandlerPtr handler )
{
FormPtr active = FrmGetActiveForm();
UInt16 activeID = ( active != NULL ) ? FrmGetFormId( active ) : 0;
FormPtr dialog = FrmInitForm( formID );
UInt16 buttonPressed = 0;
FrmSetActiveForm( dialog );
if( handler ){
FrmSetEventHandler( dialog, handler );
}
FrmPopupForm( formID );
buttonPressed = FrmDoDialog( dialog );
FrmReturnToForm( activeID );
return buttonPressed;
}
Err BookmarksFormLoad(AppContext* appContext)
{
Err error=errNone;
FormType* form=FrmInitForm(formBookmarks);
if (!form)
{
error=memErrNotEnoughSpace;
goto OnError;
}
error=DefaultFormInit(appContext, form);
if (!error)
{
FrmSetActiveForm(form);
FrmSetEventHandler(form, BookmarksFormHandleEvent);
}
else
FrmDeleteForm(form);
OnError:
return error;
}
/* This routine handles the loading of forms */
static void HandleFormLoad
(
EventType* event
)
{
FormType* form;
UInt16 formID;
formID = event->data.frmLoad.formID;
form = FrmInitForm( formID );
FrmSetActiveForm( form );
switch( formID ) {
case frmMain:
FrmSetEventHandler( form, FormHandleEvent );
break;
default:
ErrFatalDisplay( "Unknown form ID" );
break;
}
}
static Boolean
RulesFormHandleEvent(EventPtr event)
{
Boolean handled = false;
switch (event->eType) {
case ctlRepeatEvent:
switch (event->data.ctlRepeat.controlID) {
case rulesScrollUp:
RulesScroll (winUp, false);
break;
case rulesScrollDown:
RulesScroll (winDown, false);
break;
}
break;
case ctlSelectEvent:
switch (event->data.ctlSelect.controlID) {
case rulesScrollUp:
RulesScroll (winUp, false);
break;
case rulesScrollDown:
RulesScroll (winDown, false);
break;
}
break;
case keyDownEvent:
switch (event->data.keyDown.chr) {
case pageDownChr:
RulesScroll (winDown, true);
handled = true;
break;
case pageUpChr:
RulesScroll (winUp, true);
handled = true;
break;
}
break;
default:
}
return handled;
}
void
Rules (void)
{
FieldPtr field;
VoidHand rulesH;
rulesH = DmGetResource ('tSTR', ricochetRulesText);
if (rulesH)
{
rulesFrm = FrmInitForm (rulesForm);
field = FrmGetObjectPtr (rulesFrm,
FrmGetObjectIndex (rulesFrm, rulesText));
FldSetInsPtPosition (field, 0);
FldSetTextHandle (field, (Handle) rulesH);
RulesSetScrolling ();
FrmSetEventHandler (rulesFrm, RulesFormHandleEvent);
FrmDoDialog (rulesFrm);
FldSetTextHandle (field, 0);
DmReleaseResource (rulesH);
FrmDeleteForm (rulesFrm);
}
}
/***********************************************************************
* chooses an displays the requested form
***********************************************************************/
static Boolean
AppHandleEvent( EventPtr eventP)
{
UInt16 formId;
FormPtr frmP;
switch (eventP->eType) {
case frmLoadEvent:
// Load the form resource.
formId = eventP->data.frmLoad.formID;
frmP = FrmInitForm(formId);
FrmSetActiveForm(frmP);
// Set the event handler for the form. The handler of the currently
// active form is called by FrmHandleEvent each time is receives an
// event.
switch (formId) {
case FORM_main:
FrmSetEventHandler(frmP, MainFormHandleEvent);
break;
case FORM_courselist:
FrmSetEventHandler(frmP, CourseListHandleEvent);
break;
case FORM_evt_det:
FrmSetEventHandler(frmP, EditTimeFormHandleEvent);
break;
case FORM_course_det:
FrmSetEventHandler(frmP, EditCourseFormHandleEvent);
break;
case FORM_settings:
FrmSetEventHandler(frmP, SettingsFormHandleEvent);
break;
case FORM_coursetypes:
FrmSetEventHandler(frmP, CourseTypeFormHandleEvent);
break;
case FORM_exams:
FrmSetEventHandler(frmP, ExamsFormHandleEvent);
break;
case FORM_exam_details:
FrmSetEventHandler(frmP, ExamDetailsFormHandleEvent);
break;
case NewNoteView:
FrmSetEventHandler(frmP, NoteViewHandleEvent);
break;
case FORM_alarm_sets:
FrmSetEventHandler(frmP, AlarmFormHandleEvent);
break;
default:
ErrNonFatalDisplay("Invalid Form Load Event");
break;
}
break;
default:
return false;
}
return true;
}
void DialogNewGame() {
FormPtr prevForm, frm;
UInt16 hitButton;
Char tmpString[5];
Char *text;
UInt16 x;
UInt16 num;
// Save previous form
prevForm = FrmGetActiveForm();
FrmSetFocus( prevForm, noFocus );
// Init new form
frm = FrmInitForm( frmNewGame );
// Set it
FrmSetActiveForm(frm);
FrmDrawForm(frm);
for( x = 0; x < MaxPlayers; x++ )
{
tmppref[x].type = GetPlayerType( x );
StrCopy( tmppref[x].hname, pref.player[x].hname );
StrCopy( tmppref[x].aname, pref.player[x].aname );
DrawUserType( x, tmppref[x].type );
NewGameSetPlayerName( fldNGname0+x, x );
}
// Fill in WinScore with previous value.
if ( pref.winscore > 9999 ) { // Sanity check...
pref.winscore = DEFAULT_WINSCORE;
}
StrIToA( tmpString, pref.winscore );
SetFieldTextFromStr( fld_winscore, tmpString );
// Fill in Opening Roll with previous value.
if ( pref.openingroll > pref.winscore || pref.openingroll <= 0 ) {
// Sanity check...
pref.openingroll = DEFAULT_OPENINGROLL;
}
StrIToA( tmpString, pref.openingroll );
SetFieldTextFromStr( fld_openingroll, tmpString );
SetFocus( fld_openingroll );
// Set the handler
FrmSetEventHandler(frm, DialogNewGameHandleEvent);
hitButton = FrmDoDialog(frm);
FrmSetFocus( frm, noFocus );
if ( hitButton == btn_OK_frmNewGame ) {
/* Get the score needed to win */
pref.winscore = DEFAULT_WINSCORE;
text = FldGetTextPtr( GetObjectPtr( fld_winscore ) );
if ( text != NULL ) {
num = StrAToI( text );
if( num <= 9999 && num >= 50 ) {
pref.winscore = num;
}
}
/* Get the score needed to open game */
pref.openingroll = DEFAULT_OPENINGROLL;
text = FldGetTextPtr( GetObjectPtr( fld_openingroll ) );
if ( text != NULL ) {
num = StrAToI( text );
if( num <= pref.winscore && num >= 0 ) {
pref.openingroll = num;
}
}
pref.totalplayers = 0;
for( x = 0; x < MaxPlayers; x++ )
{
pref.player[x].type = tmppref[x].type;
NewGameGetPlayerName( fldNGname0 + x, x );
StrCopy( pref.player[x].hname,
tmppref[x].hname );
StrCopy( pref.player[x].aname,
tmppref[x].aname );
if( tmppref[x].type != PlayerNone )
{
pref.totalplayers++;
}
}
if( pref.totalplayers > 0 )
{
NewGame();
}
}
// Delete the form, we're not using it
FrmDeleteForm(frm);
// Restore previous form.
if (prevForm) {
FrmSetActiveForm(prevForm);
}
DrawState();
}
void DialogVarients() {
FormPtr prevForm, frm;
Word hitButton;
Word fldIndex;
Char tmpString[3];
CharPtr text;
// Save previous form
prevForm = FrmGetActiveForm();
// Init new form
frm = FrmInitForm( frmVariants );
// Set it
FrmSetActiveForm(frm);
FrmDrawForm(frm);
// Set Controls
CtlSetValue( GetObjectPtr(check_Bump ), stor.flags & flag_Bump );
CtlSetValue( GetObjectPtr(check_Eclipse ), stor.flags & flag_Eclipse );
CtlSetValue( GetObjectPtr(check_Sampler ), stor.flags & flag_Sampler );
CtlSetValue( GetObjectPtr(check_nTW ), stor.flags & flag_nTW );
CtlSetValue( GetObjectPtr(check_FullHouse), stor.flags & flag_FullHouse );
CtlSetValue( GetObjectPtr(check_Suspend ), stor.flags & flag_Suspend );
// Fill in WinScore with previous value.
StrIToA( tmpString, stor.nTrainWrecks );
SetFieldTextFromStr( fldnTrainWrecks, tmpString );
StrIToA( tmpString, stor.nSuspend );
SetFieldTextFromStr( fldnSuspend, tmpString );
// Set the focus to this field so the user can just start typing.
fldIndex = FrmGetObjectIndex(frm, fldnTrainWrecks);
FrmSetFocus( frm, fldIndex );
// Set the handler
FrmSetEventHandler(frm, DialogVariantsHandleEvent);
hitButton = FrmDoDialog(frm);
// Get Controls
text = FldGetTextPtr( FrmGetObjectPtr( frm, fldIndex ) );
if( text != NULL ) {
stor.nTrainWrecks = StrAToI( text );
} else {
stor.nTrainWrecks = 3;
}
fldIndex = FrmGetObjectIndex(frm, fldnSuspend);
text = FldGetTextPtr( FrmGetObjectPtr( frm, fldIndex ) );
if( text != NULL ) {
stor.nSuspend = StrAToI( text );
} else {
stor.nSuspend = 10;
}
// Delete the form, we're not using it
FrmDeleteForm(frm);
// Restore previous form.
if (prevForm) {
FrmSetActiveForm(prevForm);
}
}
void DialogNewGame() {
FormPtr prevForm, frm;
Word hitButton;
Char tmpString[5];
CharPtr text;
Word fldIndex;
Int x;
// Save previous form
prevForm = FrmGetActiveForm();
// Init new form
frm = FrmInitForm( frmNewGame );
// Set it
FrmSetActiveForm(frm);
FrmDrawForm(frm);
// Set Controls
// cbtnVal & pbtnVal
stor.tmpplayers = stor.numplayers;
stor.tmpcomputers = stor.numcomputers;
if ( stor.numplayers > 0 ) {
x = stor.numplayers;
} else {
x = 1;
}
CtlSetValue( GetObjectPtr( pbtnVal[x - 1] ), true );
if ( stor.numcomputers > 0 ) {
x = stor.numcomputers;
} else {
x = 0;
}
CtlSetValue( GetObjectPtr( cbtnVal[x] ), true );
// Fill in WinScore with previous value.
if ( stor.winscore > 9999 ) { // Sanity check...
stor.winscore = 300;
}
StrIToA( tmpString, stor.winscore );
SetFieldTextFromStr( fld_winscore, tmpString );
// Set the focus to this field so the user can just start typing.
fldIndex = FrmGetObjectIndex(frm, fld_winscore);
FrmSetFocus( frm, fldIndex );
// Set the handler
FrmSetEventHandler(frm, DialogNewGameHandleEvent);
hitButton = FrmDoDialog(frm);
if ( hitButton == btn_OK_frmNewGame ) {
text = FldGetTextPtr( FrmGetObjectPtr (frm, fldIndex) );
if ( text != NULL ) {
stor.winscore = StrAToI( text );
} else {
stor.winscore = 300;
}
stor.numplayers = stor.tmpplayers;
stor.numcomputers = stor.tmpcomputers;
}
// Delete the form, we're not using it
FrmDeleteForm(frm);
// Restore previous form.
if (prevForm) {
FrmSetActiveForm(prevForm);
}
if ( hitButton == btn_OK_frmNewGame ) {
NewGame();
}
DrawState();
}
