hello.c

PALM程序设计入门

                 speedx=event->data.sclRepeat.newValue;
                 FrmCopyLabel(frm, Labelbar, StrIToA(s,speedx));
              }
              if (direction == 2)
              {
                 speedy=event->data.sclRepeat.newValue;
                 FrmCopyLabel(frm, Labelbar, StrIToA(s,speedy));
              }
              if (direction == 3)
              {
                 speedz=event->data.sclRepeat.newValue;
                 FrmCopyLabel(frm, Labelbar, StrIToA(s,speedz));
              }
              FrmShowObject(frm,FrmGetObjectIndex(frm,Labelbar));
           }
           handled=true;
           break;

		case frmOpenEvent:
           
         FrmDrawForm(FrmGetActiveForm());

         SysSetAutoOffTime(0);

         wr5(0x0124);
         command(0x3b);  
         XYZUOutValue=0x1111;
	    	XOut(2,1);                  
         ZOut(0,0);

         CncSetup();
      
			handled = true;
			break;
	}
	return (handled);
}

static Boolean FieldEventHandler(EventPtr event)
{
	Boolean handled = false;

	switch (event->eType) 
   {
 		case ctlSelectEvent:
           if (event->data.ctlSelect.controlID==ButtonList)
           {
              Err err =DmCreateDatabase(0, DBNAME, CREATORID, DBTYPE, false);
              CharPtr fieldstring;
              
              StrCopy(fieldstring, "The coordinates are : \n");

              if ( err == 0)
              {  
                    UInt  mode = dmModeReadWrite;
                    UInt at=0; // 0:beginning , end:dmMaxRecordIndex

                    long *mem,value;
                    VoidHand h;

                    dbRef = DmOpenDatabaseByTypeCreator(DBTYPE,CREATORID,mode);
         
                    value=0;

                    h=DmNewRecord(dbRef, &at, sizeof(value));

                    mem=(long *)MemHandleLock(h);

                    DmWrite(mem,0,&value,sizeof(value));

                    MemHandleUnlock(h);
                    DmReleaseRecord(dbRef, at, true); // clears busy bit
                     
                    DmCloseDatabase(dbRef); 
              }
              
              if ( err == dmErrAlreadyExists)
              { 
                    UInt  mode = dmModeReadWrite;
                    UInt at=0; // 0:beginning , end:dmMaxRecordIndex

                    long *mem,i,value;
                    VoidHand h;
                    char s[5];
                    
                    
                    dbRef = DmOpenDatabaseByTypeCreator(DBTYPE,CREATORID,mode);
                    
                    h=DmQueryRecord(dbRef,at);
                    mem=(long *)MemHandleLock(h);
                    value=*mem;
                    MemHandleUnlock(h); 
                    
                    StrIToA(s,value);
                    
                    StrCat(fieldstring,s );
                    
                    StrCat(fieldstring, " set of coordinates.");

                    for (i=0; i<value; i++)
                    {
                        fieldstring=StrCat(fieldstring, "\n");
                        fieldstring=StrCat(fieldstring, StrIToA(s,(i+1)));

                        fieldstring=StrCat(fieldstring, " ");
                        h=DmQueryRecord(dbRef,(value-i)*3);
                        mem=(long *)MemHandleLock(h);
                        fieldstring=StrCat(fieldstring, "x=");
                        fieldstring=StrCat(fieldstring, StrIToA(s,*mem));
                        fieldstring=StrCat(fieldstring, " ");
                        MemHandleUnlock(h);    
 
                        h=DmQueryRecord(dbRef,(value-i)*3-1);
                        mem=(long *)MemHandleLock(h);
                        fieldstring=StrCat(fieldstring, "y=");
                        fieldstring=StrCat(fieldstring, StrIToA(s,*mem));
                        fieldstring=StrCat(fieldstring, " ");
                        MemHandleUnlock(h);  
  
                        h=DmQueryRecord(dbRef,(value-i)*3-2);
                        mem=(long *)MemHandleLock(h);
                        fieldstring=StrCat(fieldstring, "z=");
                        fieldstring=StrCat(fieldstring, StrIToA(s,*mem));
                        fieldstring=StrCat(fieldstring, " ");
                        MemHandleUnlock(h);     
                        
                    }
                    DmCloseDatabase(dbRef);                                         
              }

              StrCat(fieldstring, "\n- end -");
              
              StrCat(fieldstring, "\0");

              SetFieldTextFromStr(Field, fieldstring);
           }
           handled=true;
           break;

      case sclExitEvent:
          
           handled=true;
           break;

		case frmOpenEvent:
           FrmDrawForm(FrmGetActiveForm());
           handled = true;
			  break;

      case sclRepeatEvent:
         ScrollLines(event->data.sclRepeat.newValue -
                          event->data.sclRepeat.value, false);
         handled = true;
         break;

     case fldChangedEvent:
         UpdateScrollbar();
         handled=true;
         break;

     case ctlRepeatEvent:
         if (event->data.ctlRepeat.controlID == UpRepeatButton)
         {
            PageScroll(up);
            handled=true;
         } 
         else if (event->data.ctlRepeat.controlID == DownRepeatButton)
         {
            PageScroll(down);
            handled=true;
         }
         break;
	}
	return (handled);
}

static Boolean ApplicationHandleEvent(EventPtr event)
{
	FormPtr form;
	Word    formID;
	Boolean handled = false;

	if (event->eType == frmLoadEvent) 
   {
		formID = event->data.frmLoad.formID;
		form   = FrmInitForm(formID);

		FrmSetActiveForm(form);

		switch (formID)  
      {
			case formID_hello:
				FrmSetEventHandler(form, HelloFormEventHandler);
				break;
		}
		handled = true;
	}
	return (handled);
}

static Boolean FieldHandleEvent(EventPtr event)
{
	FormPtr form;
	Word    formID;
	Boolean handled = false;

	if (event->eType == frmLoadEvent)
   {
		formID = event->data.frmLoad.formID;
		form   = FrmInitForm(formID);

		FrmSetActiveForm(form);

		switch (formID)
      {
			case Formfield:
				FrmSetEventHandler(form, FieldEventHandler);
				break;
		}
		handled = true;
	}
	return (handled);
}


static Boolean StartApplication()
{
   Err err;

   err = SysLibFind ("Serial Library", &gSerialRefNum);
   ErrNonFatalDisplayIf(err !=0, "Can't find serial library");

   err = SerOpen(gSerialRefNum, 0, 57600);
   if (err != 0)
   {
      if (err == serErrAlreadyOpen)
      {
         FrmAlert(ErrorAlert);
         SerClose(gSerialRefNum);
      }
      else
      {
        FrmAlert(ErrorAlert);
      }

      FrmGotoForm(formID_hello);
      return False;
   }
   
   err = SerSetReceiveBuffer(gSerialRefNum, gSerialBuffer, 
                              sizeof(gSerialBuffer));
   FrmAlert(SerialOK);
   FrmGotoForm(formID_hello);
   return True;
}

static void EventLoop(void)
{
	short			err;
	int			formID;
	FormPtr		form;
	EventType		event;

	do
   {
		EvtGetEvent(&event, evtWaitForever);
		if (SysHandleEvent(&event)) continue;
		if (MenuHandleEvent(NULL, &event, &err))	continue;
		if (ApplicationHandleEvent(&event)) continue;
		FrmDispatchEvent(&event);
	} while (event.eType != appStopEvent);
}

static void FieldEventLoop(void)
{
	short			err;
	int			formID;
	FormPtr		form;
	EventType		event;

	do
   {
		EvtGetEvent(&event, evtWaitForever);
		if (SysHandleEvent(&event)) continue;
		if (MenuHandleEvent(NULL, &event, &err))	continue;
		if (FieldHandleEvent(&event)) continue;
		FrmDispatchEvent(&event);
	} while (event.eType != appStopEvent && event.data.ctlSelect.controlID!=ButtonLeave );
}

static void StopApplication(void)
{
   // restore the default buffer before closing the serial port
   SerSetReceiveBuffer(gSerialRefNum, NULL, 0);
   SerClose(gSerialRefNum);
	FrmCloseAllForms();
}

DWord PilotMain (Word cmd, Ptr cmdPBP, Word launchFlags)
{
	if (cmd ==  sysAppLaunchCmdNormalLaunch)
   {
		StartApplication();
		EventLoop();
		StopApplication();
	}
	return (0);
}

Word formsave(void)
{
      FormPtr previousForm=FrmGetActiveForm();
      FormPtr frm = FrmInitForm(Formsave);
      Word hitButton;
      char str[10];

      FrmSetActiveForm(frm);

      RdXYZP(&Xabs,&Yabs,&Zabs);              
 
      StrPrintF(str,"x=%ld",Xabs);
      FrmHideObject(frm,FrmGetObjectIndex(frm,Labelx));
      FrmCopyLabel(frm, Labelx, str);
      FrmShowObject(frm,FrmGetObjectIndex(frm,Labelx));

      StrPrintF(str,"y=%ld",Yabs);
      FrmHideObject(frm,FrmGetObjectIndex(frm,Labely));
      FrmCopyLabel(frm, Labely, str);
      FrmShowObject(frm,FrmGetObjectIndex(frm,Labely));
      
      StrPrintF(str,"z=%ld",Zabs);
      FrmHideObject(frm,FrmGetObjectIndex(frm,Labelz));
      FrmCopyLabel(frm, Labelz, str);
      FrmShowObject(frm,FrmGetObjectIndex(frm,Labelz));
 
      hitButton=FrmDoDialog(frm);
      
      if (previousForm)
              FrmSetActiveForm(previousForm);
      FrmDeleteForm(frm);
      return hitButton;
}

Word formfield(void)
{
      FormPtr previousForm=FrmGetActiveForm();
      Word hitButton;

      FrmGotoForm(Formfield);
      FieldEventLoop();

      FrmGotoForm(formID_hello);
      hitButton=ButtonLeave;
      
      return hitButton;
}

int ReadABuffer(char *lpBuf,DWord dwToRead)
{
    ULong numBytesPending;
    Err err;
    char theData[90];
    ULong numBytes;

    err=SerReceiveWait(gSerialRefNum, sizeof(theData)-1,2);
	 numBytes = SerReceive(gSerialRefNum, lpBuf, dwToRead, 0,  &err);
    return numBytes;
}

int WriteABuffer(char *lpBuf,DWord dwToWrite)
{
    Err errp=false;

    SerSend(gSerialRefNum, lpBuf, dwToWrite, &errp);
    if ( errp != 0)
    {
       FrmAlert(ErrorAlert);
    }
}


//--------------------------------------------------------------
void CheckMessage()
{
}

float Distance(long x1,long y1,long x2,long y2)
{
	float len;
	len=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
	return len;
}
int CountCheckSum1(int FuncNum,long para)
{
   int	checksum;

   checksum=FuncNum + para+ (para>>8) + (para>>16) + (para>>24);
   checksum=checksum & 0xff;
   return checksum;
}

//--------------------------------------------------------------
// WREG1
//--------------------------------------------------------------
Boolean xwreg1(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(XWREG1,para);
   Buf[2]=XWREG1;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  return False;
      i++;
      if( i>10 && data!=(char)0xf0) 
			return False;
   } while(data!=(char)0xf0);
   return True;
}
//-----------------------------------------
Boolean ywreg1(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(YWREG1,para);
   Buf[2]=YWREG1;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  
			return False;
      i++;
      if( i>10 && (char)data!=(char)0xf0) 
			return False;
   } while(data!=(char)0xf0);
   return True;

}
//-----------------------------------------
Boolean zwreg1(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(ZWREG1,para);
   Buf[2]=ZWREG1;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  return False;
      i++;
      if( i>10 && (char)data!=(char)0xf0) return False;
   } while(data!=(char)0xf0);
   return True;

}
//--------------------------------------------------------------
//   WREG2
//--------------------------------------------------------------
Boolean xwreg2(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(XWREG2,para);
   Buf[2]=XWREG2;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  return False;
      i++;
      if( i>10 && (char)data!=(char)0xf0) return False;
   } while(data!=(char)0xf0);
   return True;

}
//-----------------------------------------
Boolean ywreg2(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(YWREG2,para);
   Buf[2]=YWREG2;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  return False;
      i++;
      if( i>10 && (char)data!=(char)0xf0) return False;
   } while(data!=(char)0xf0);
   return True;

}
//-----------------------------------------
Boolean zwreg2(int para)
{
   char Buf[5];
   char data,i=0;

   Buf[0]=0xff;
   Buf[1]=CountCheckSum1(ZWREG2,para);
   Buf[2]=ZWREG2;
   Buf[3]=(para>>8) & 0xff;
   Buf[4]=para & 0xff;
 do{
      WriteABuffer(Buf,5);
      if( !ReadABuffer(&data,(DWord)1) )  return False;
      i++;
      if( i>10 && (char)data!=(char)0xf0) return False;
   } while(data!=(char)0xf0);
   return True;