Example #1
0
void
osip_usleep (int useconds)
{
#if defined(__PALMOS__) && (__PALMOS__ >= 0x06000000)
  /* This bit will work for the Protein API, but not the Palm 68K API */
  nsecs_t nanoseconds = useconds * 1000;

  SysThreadDelay (nanoseconds, P_ABSOLUTE_TIMEOUT);
#elif defined(__PALMOS__) && (__PALMOS__ < 0x06000000)
  UInt32 stoptime = TimGetTicks () + (useconds / 1000000) * SysTicksPerSecond ();

  while (stoptime > TimGetTicks ())
    /* I wish there was some type of yield function here */
    ;
#elif defined(WIN32)
  Sleep (useconds / 1000);
#else
  struct timeval delay;
  int sec;

  sec = (int) useconds / 1000000;
  if (sec > 0)
    {
      delay.tv_sec = sec;
      delay.tv_usec = 0;
  } else
    {
      delay.tv_sec = 0;
      delay.tv_usec = useconds;
    }
  select (0, 0, 0, 0, &delay);
#endif
}
Example #2
0
static void
EventLoop (void)
{
    EventType	event;
    SDWord	timeout;
    UInt32	timer_next;
    Word	error;

    do
    {
        timeout = evtWaitForever;
        timer_next = 0;
        if (needRedisplay)
            timeout = 0;
        else if (game.timer_running)
        {
            UInt32  now = TimGetTicks ();
            int	    sec = (now - game.timer_start) / sysTicksPerSecond;

            timer_next = ((sec + 1) * sysTicksPerSecond + game.timer_start);
            timeout = timer_next - now;
        }
        EvtGetEvent (&event, timeout);
        DIAG (("Event %d\n", event.eType));
        if (timer_next && TimGetTicks () <= timer_next)
            DamageCount ();
        if (needRedisplay && event.eType == nilEvent)
            FrmUpdateForm (mainForm, frmRedrawUpdateCode);
        if (event.eType == nilEvent)
            continue;

        /* Give the system a chance to handle the event. */
        if (! SysHandleEvent (&event))
        {
            if (!MenuHandleEvent (0, &event, &error))
            {
                /* Give the application a chance to handle the event. */
                if (!ApplicationHandleEvent (&event))
                {
                    /* Let the form object provide default handling of the event. */
                    FrmDispatchEvent (&event);
                }
            }
        }
    }
    while (event.eType != appStopEvent);
    // ** SPECIAL NOTE **
    // In order for the Emulator to exit
    // cleanly when the File|Quit menu option is
    // selected, the running application
    // must exit.  The emulator will generate an
    // ÒappStopEventÓ when Quit is selected.
}
Example #3
0
void PediaMainForm::handleControlSelect(const EventType& event)
{
    LookupManager* lookupManager = app().getLookupManager();
    if (NULL != lookupManager && lookupManager->lookupInProgress())
        return;
        
    bool fFullText = false;
    switch (event.data.ctlSelect.controlID)
    {
        case searchButton:
            // If button held for more than ~300msec, perform full text search.
            if (TimGetTicks() - lastPenDownTimestamp_ > app().ticksPerSecond()/3)
                fFullText = true;
            search(fFullText);
            break;
            
        case backButton:
            moveHistory(false);
            break;
        
        case forwardButton:
            moveHistory(true);
            break;
        
        default:
            assert(false);
    }
}
Example #4
0
int scGeneralGetRandStr( BYTE *data, int len )
{
#if defined(HAVE_LIBCRYPT)
	cryptGetRandom( data, len );
#elif defined(__palmos__)
	SysRandom( TimGetTicks() );

	while( len-- ){
		*data++ = SysRandom(0) & 0xFF;
	}
#elif defined(__linux__)
	FILE *fptr;

	fptr = fopen( "/dev/urandom", "rb" );
	if( fptr==NULL ) return( SC_EXIT_UNKNOWN_ERROR );

	if( fread( data, 1, len, fptr )!=len ) return( SC_EXIT_UNKNOWN_ERROR );
#else
	srand( time( NULL ) );

	while( len-- ){
		*data++ = rand() & 0xFF;
	}
#endif /* HAVE_LIBCRYPT */

	return( SC_EXIT_OK );
}
Example #5
0
ticks_t time_ticks( void )
{
#ifdef UNIX
    #ifdef OSX
	//OSX:
	mach_timebase_info_data_t sTimebaseInfo;
	if( sTimebaseInfo.denom == 0 ) 
	{
	    mach_timebase_info( &sTimebaseInfo );
	}
	uint64_t t = mach_absolute_time();
	return (ticks_t)( ( t * sTimebaseInfo.numer / sTimebaseInfo.denom ) / 1000000 );
    #else
	//UNIX:
	timespec t;
	clock_gettime( CLOCK_REALTIME, &t );
	return (ticks_t)( t.tv_nsec / 1000000 ) + t.tv_sec * 1000;
    #endif
#endif
#ifdef PALMOS
    //PALM:
    return (ticks_t)TimGetTicks();
#endif
#if defined(WIN) || defined(WINCE)
    //WINDOWS:
    return (ticks_t)GetTickCount();
#endif
}
Example #6
0
void RunCount(UInt32 start_tik)
{
    UInt32 tik,dtik;
    run=1;
    while(run==1) {
	tik = TimGetTicks();
	dtik = tik - start_tik;
	drawCount(dtik);

	// call this periodically to hold off auto off  
	if (stopWatchPrefs.disableAutoOff) EvtResetAutoOffTimer();

	// delay one tenth of a sec (.09 acksherly to be sly)
	SysTaskDelay((90 * SysTicksPerSecond())/1000);
	// within loop call SysHandleEvent to
	//  give system opportunity to break in? 
	// /opt/palmdev/sdk-5/include/Core/UI/Event.h
	{ 
	    UInt16 err;
	    EventType e;
	    EvtGetEvent(&e, 0);
	    if (! SysHandleEvent (&e))
		if (! MenuHandleEvent (NULL, &e, &err))
		    if (! ApplicationHandleEvent (&e))
			FrmDispatchEvent (&e);
	}
    }

}
Example #7
0
// although it is not the same as gettimeofday as unix
// but we only use the diffrences of tow values
int CCTime::gettimeofdayCocos2d(struct cc_timeval *tp, void *tzp)
{
	unsigned int ms = TimGetTicks();
	tp->tv_sec = ms * 10 / 1000;
	tp->tv_usec = ms * 10 % 1000 * 1000;

	return 0;
}
Example #8
0
File: gmi.c Project: miellaby/v4p
void Application_ProcessMessages(int ticks)
{
     EventType event;
     UInt32 until=TimGetTicks()+ticks;
     UInt16 error;
     do {
	     EvtGetEvent(&event, 3);
	     if(event.eType == appStopEvent) {
		     StopEvent=1;
		     break;
	     }
	     if (! SysHandleEvent(&event))
	         if (! MenuHandleEvent(0, &event, &error))
	             if (! Application_EventHandler(&event))
	                FrmDispatchEvent(&event);
     } while(TimGetTicks()<until);
}
Example #9
0
bool PediaMainForm::handleKeyPress(const EventType& event)
{
    bool handled = false;
    if (fiveWayCenterPressed(&event))
        lastPenDownTimestamp_ = TimGetTicks();

    switch (event.data.keyDown.chr)
    {
        case chrLineFeed:
        case chrCarriageReturn:
            lastPenDownTimestamp_ = TimGetTicks();
            searchButton_.hit();
            handled = true;
            break;
            
    }
    return handled;
}
Example #10
0
/* Set a new Timeout value and callback function*/
void TimeoutSet
    (
    UInt32 ticks,
    void*  callbackFunc
    )
{
    lastTick = TimGetTicks();
    minTicks = ticks;
    TimeoutCallbackHandler = callbackFunc;
}
Example #11
0
static void
TimerStart (void)
{
    if (!game.timer_running)
    {
        game.timer_running = true;
        game.timer_start = TimGetTicks ();
        DamageCount ();
    }
}
Example #12
0
static Boolean MainFormHandleEvent (EventPtr e)
{
    Boolean handled = false;
    FormPtr frm;
    
    CALLBACK_PROLOGUE

    switch (e->eType) {
    case frmOpenEvent:
	frm = FrmGetActiveForm();
	FrmDrawForm(frm);
	handled = true;
	break;

    case menuEvent:
	MenuEraseStatus(NULL);

	switch(e->data.menu.itemID) {
	}

    	handled = true;
	break;

    case ctlSelectEvent:
	switch(e->data.ctlSelect.controlID) {
	}
	break;

    case nilEvent: {
	UInt32 dt, t0 = TimGetTicks();
	mainloop ();
	dt = TimGetTicks() - t0;
	timeout = (TimGetTicks() - t0 > ticks) ? 0 : ticks - dt;
	}
	break;
    default:
        break;
    }

    CALLBACK_EPILOGUE

    return handled;
}
Example #13
0
void
osip_usleep (int useconds)
{
#if defined(__PALMOS__) && (__PALMOS__ >= 0x06000000)
  /* This bit will work for the Protein API, but not the Palm 68K API */
  nsecs_t nanoseconds = useconds * 1000;

  SysThreadDelay (nanoseconds, P_ABSOLUTE_TIMEOUT);
#elif defined(__PALMOS__) && (__PALMOS__ < 0x06000000)
  UInt32 stoptime = TimGetTicks () + (useconds / 1000000) * SysTicksPerSecond ();

  while (stoptime > TimGetTicks ())
    /* I wish there was some type of yield function here */
    ;
#elif defined(WIN32)
  Sleep (useconds / 1000);
#elif defined(__rtems__)
    rtems_task_wake_after( RTEMS_MICROSECONDS_TO_TICKS(useconds) );
#elif defined(__arc__)
  struct timespec req;
  struct timespec rem;
  req.tv_sec = (int) useconds / 1000000;
  req.tv_nsec = (int) (useconds % 1000000)*1000;
  nanosleep (&req, &rem);
#else
  struct timeval delay;
  int sec;

  sec = (int) useconds / 1000000;
  if (sec > 0)
    {
      delay.tv_sec = sec;
      delay.tv_usec = 0;
  } else
    {
      delay.tv_sec = 0;
      delay.tv_usec = useconds;
    }
  select (0, 0, 0, 0, &delay);
#endif
}
Example #14
0
Boolean FlickrProgressCallback(PrgCallbackData* data)
{
    if (errNone != data->error)
        return FlickrErrCallback(data);

    FlickrSocketContext* context = (FlickrSocketContext*)data->userDataP;
    char buffer[32] = {chrNull};
    char* text = "";

    assert(context != NULL);
    switch (data->stage)
    {
        case stageReadingImageData:
            text = "Reading image data: ";
            PrvFormatBytes(buffer, context->imageSize);
            break;

        case stageResolvingHostAddress:
            text = "Resolving host address...";
            break;

        case stageOpeningConnection:
            text = "Connecting...";
            break;

        case stageUploadingImage:
            text = "Uploading image: ";
            PrvFormatPercents(buffer, ((context->sent  * 1000L) + 5L)/(context->requestSize * 10L));
            break;

        case stageReadingResponse:
            text = "Waiting for response...";
            break;

        case stageFinished:
            text = "Upload finished";
            break;

        default:
            assert(false);
    }
    UInt32 ticks = TimGetTicks();
    if (ticks - FLICKR_PROGRESS_ANIMATION_TIMEOUT >= context->lastAnimationTicks)
    {
        data->bitmapId = FlickrNextProgressBitmapID(data->bitmapId);
        context->lastAnimationTicks = ticks;
    }
    PrvFillBuffer(data->textP, data->textLen, text, buffer);
    data->textChanged = true;
    return true;
}
Example #15
0
File: v4pi.c Project: miellaby/v4p
Boolean v4pDisplayStart() {
  int i ;
  t1 = TimGetTicks();
  iBuffer = marginY * screenWidth + marginX ;

  //Init collides
  for (i = 0 ; i < 16 ; i++) {
    collides[i].q = 0 ;
    collides[i].x = 0 ;
    collides[i].y = 0 ;
    collides[i].poly = NULL ;
  }
  return success ;
}
void OSystem_PalmBase::battery_handler() {
	// check battery level every 15secs
	if ((TimGetTicks() - _batCheckLast) > _batCheckTicks) {
		UInt16 voltage, warnThreshold, criticalThreshold;
		Boolean pluggedIn;
		voltage = SysBatteryInfoV20(false, &warnThreshold, &criticalThreshold, NULL, NULL, &pluggedIn);

		if (!pluggedIn) {
			if (voltage <= warnThreshold) {
				if (!_showBatLow) {
					_showBatLow = true;
					draw_osd(kDrawBatLow, _screenDest.w - 18, -16, true, 2);
					displayMessageOnOSD("Battery low.");
				}
			} else {
				if (_showBatLow) {
					_showBatLow = false;
					draw_osd(kDrawBatLow, _screenDest.w - 18, -16, false);
				}
			}

			if (voltage <= criticalThreshold) {
				::EventType event;
				event.eType = keyDownEvent;
				event.data.keyDown.chr = vchrPowerOff;
				event.data.keyDown.modifiers = commandKeyMask;
#if defined(COMPILE_OS5) && defined(PALMOS_ARM)
				SysEventAddToQueue(&event);
#else
				EvtAddEventToQueue(&event);
#endif
			}
		}

		_batCheckLast = TimGetTicks();
	}
}
Example #17
0
OSystem_PalmBase::OSystem_PalmBase() {
	_overlayVisible = false;

	_current_shake_pos = 0;
	_new_shake_pos = 0;

	_paletteDirtyStart = 0;
	_paletteDirtyEnd = 0;

	_gfxLoaded = false;
	_modeChanged = false;
	_setMode = GFX_NORMAL;
	_mode = _setMode;
	_redawOSD = false;
	_setPalette = true;

	_offScreenH = NULL;
	_screenH = NULL;
	_offScreenP = NULL;
	_screenP = NULL;
	_screenPitch = gVars->screenPitch;

	_wasKey = false;
	_lastKeyModifier = kModifierNone;
	_lastKeyRepeat = 100;
	_useNumPad = false;
	_showBatLow = false;
	_batCheckTicks = SysTicksPerSecond() * 15;
	_batCheckLast = TimGetTicks();

	_saveMgr = 0;
	_timerMgr = 0;
	_mixerMgr = 0;

	_mouseDataP = NULL;
	_mouseBackupP = NULL;
	_mouseVisible = false;
	_mouseDrawn = false;
	MemSet(&_keyExtra, sizeof(_keyExtra), 0);
	MemSet(&_mouseCurState, sizeof(_mouseCurState), 0);
	MemSet(&_mouseOldState, sizeof(_mouseOldState), 0);
	MemSet(&_timer, sizeof(TimerType), 0);
	MemSet(&_sound, sizeof(SoundType), 0);

	_keyExtraRepeat = 0;
	_keyExtraPressed = 0;
	_keyExtraDelay = (gVars->arrowKeys) ? computeMsecs(125) : computeMsecs(25);
}
Example #18
0
File: v4pi.c Project: miellaby/v4p
Boolean v4pDisplayEnd() {
   int i ;
   static int j=0;
   UInt32 t2=TimGetTicks();
   tlaps-=laps[j % 4];
   tlaps+=laps[j % 4]=t2-t1;
   j++;
   idebug(tlaps);

   // Bilan des collides
   for (i = 0 ; i < 16 ; i++) {
      if (!collides[i].q) continue ;
      collides[i].x /= collides[i].q ;
      collides[i].y /= collides[i].q ;
   }
   return success ;
}
Example #19
0
void fastPoll( void )
	{
	RANDOM_STATE randomState;
	BYTE buffer[ RANDOM_BUFSIZE + 8 ];
	WinHandle winHandle;
	Coord xCoord, yCoord;
	Boolean flag;
	uint64_t ticks;
	nsecs_t nsTime;

	initRandomData( randomState, buffer, RANDOM_BUFSIZE );

	/* Get the event-available and low-level event-available flag, current
	   pen status, and handle of the window with the input focus */
	flag = EvtEventAvail();
	addRandomValue( randomState, flag );
	flag = EvtSysEventAvail( TRUE );
	addRandomValue( randomState, flag );
	EvtGetPen( &xCoord, &yCoord, &flag );
	addRandomValue( randomState, xCoord );
	addRandomValue( randomState, yCoord );
	winHandle = EvtGetFocusWindow();
	addRandomValue( randomState, winHandle );

	/* Get the number of ticks of the (software) millisecond clock used
	   by the scheduler, and the length of time in nanoseconds since the
	   last reset */
	ticks = TimGetTicks();
	addRandomData( randomState, &ticks, sizeof( uint64_t ) );
	nsTime = SysGetRunTime();
	addRandomData( randomState, &nsTime, sizeof( nsecs_t ) );

	/* Get the value of the real-time and runtime clocks in nanoseconds.
	   One of these may just be a wrapper for SysGetRunTime(), in addition
	   it's likely that they're hardware-specific, being CPU-level cycle
	   counters of some kind */
	nsTime = system_real_time();
	addRandomData( randomState, &nsTime, sizeof( nsecs_t ) );
	nsTime = system_time();
	addRandomData( randomState, &nsTime, sizeof( nsecs_t ) );

	/* Flush any remaining data through */
	endRandomData( randomState, 5 );
	}
Example #20
0
/* Handler to decide if our minTicks waiting time has passed */
Boolean TimeoutEventHandler( void )
{
    Boolean handled;
    UInt32  now;

    handled = false;

    if ( minTicks == 0 || lastTick == 0 )
        return handled;

    /* Sometimes while waiting for a nilEvent, we may receive one before the
       minTicks number of ticks has passed. Be sure to check */
    now = TimGetTicks();
    if ( lastTick <= ( now - minTicks ) ) {
        TimeoutCallbackHandler();
        handled = true;
        lastTick = now;
    }

    return handled;
}
Example #21
0
static void
NewGame (void)
{
    int	color, shape, i;

    DIAG (("NewGame\n"));
    game.seed = TimGetTicks ();
    RandomBoard (game.board);
    DamageBoard ();
    i = 0;
    for (color = RED; color <= BLUE; color = COLOR_NEXT(color))
        for (shape = TARGET_TRIANGLE;
                shape <= TARGET_CIRCLE;
                shape = TARGET_NEXT(shape))
        {
            game.targets[i++] = shape|color;
        }
    game.targets[i++] = TARGET_WHIRL|COLOR_ANY;
    DIAG (("Generated %d targets\n", i));
    Shuffle (game.targets, i);
    game.ntarget = 0;
    DIAG (("NextTarget\n"));
    NextTarget ();
}
Example #22
0
bool PediaMainForm::handleEvent(EventType& event)
{
    if (showArticle == displayMode_ && articleRenderer_.handleEventInForm(event))
        return true;
    if (showArticle != displayMode_ && infoRenderer_.visible() && infoRenderer_.handleEventInForm(event))
        return true;
        
    bool handled=false;
    if (ignoreEvents_)
        return false;
    switch (event.eType)
    {
        case keyDownEvent:
            handled=handleKeyPress(event);
            break;
            
        case ctlSelectEvent:
            handleControlSelect(event);
            break;
        
        case penUpEvent:
            if (penUpsToEat_ > 0)
            {
                --penUpsToEat_;
                handled = true;
            }
            break;
    
        case LookupManager::lookupFinishedEvent:
            handleLookupFinished(event);
            handled = true;
            break;     
            
        case LookupManager::lookupStartedEvent:
            setControlsState(false);            // No break is intentional.
            
        case LookupManager::lookupProgressEvent:
            update(redrawProgressIndicator);
            handled = true;
            break;

        case iPediaApplication::appRegisterEvent:
            Application::popupForm(registrationForm);
            handled = true;
            break;

        case iPediaApplication::appRegistrationFinished:
            if (showAbout == displayMode_)
                prepareAbout();
            update();
            handled = true;
            break;

        case iPediaApplication::appLangNotAvailable:
            // for whatever reason server told us that the language
            // we were using is not available. That shouldn't happen
            // because we only use langauges that server gives us, but
            // it might becaues e.g. we might disable a given language on the
            // server and the client might have outdated list of available
            // languages. In this case we switch to "en" (English) which
            // should always be available
            FrmAlert(langNotAvailableAlert);
            LookupManager* lookupManager = app().getLookupManager(true);
            if (lookupManager && !lookupManager->lookupInProgress())
                lookupManager->switchDatabase("en");
            handled = true;
            break;

        case iPediaApplication::appForceUpgrade:
            {
                UInt16 buttonId = FrmAlert(forceUpgradeAlert);
                if (0==buttonId)
                {
                    // this is "Update" button so take them to a web page
                    if ( errNone != WebBrowserCommand(false, 0, sysAppLaunchCmdGoToURL, updateCheckURL ,NULL) )
                        FrmAlert(noWebBrowserAlert);
                }
                handled = true;
            }
            break;

        case iPediaApplication::appRandomWord:
            randomArticle();
            handled = true;
            break;

        case penDownEvent:
            lastPenDownTimestamp_=TimGetTicks();
            break;
    
        default:
            handled = iPediaForm::handleEvent(event);
    }
    return handled;
}
Example #23
0
systick_t GetTimeTick()
{
    return TimGetTicks();
}
Example #24
0
static Boolean MainFormHandleEvent (EventPtr e)
{
    Boolean handled = false;
    FormPtr frm;
    static UInt32 start_sec=0;
    static UInt32 start_tik;
    static UInt32 end_sec;
    static UInt32 end_tik;
    //static int run = 0;
    
    switch (e->eType) {
    case frmOpenEvent:
	frm = FrmGetActiveForm();
	FrmDrawForm(frm);

	// resume interrupted count
	// note now stopWatchPrefs.tik_timestamp != stopWatchPrefs.timestamp
        // now this does work okay when switching away from app BUT
        // not when palm is turned off & on but stays in app
        // I think possibly GetTicks gets ticks from start of app
        // when palm off the ticks do not increment
	if (stopWatchPrefs.timestamp != 0) {
	    stopWatchPrefs.tik_timestamp = TimGetSeconds();
	    start_tik = TimGetTicks();
	    RunCount(start_tik);
	}

	handled = true;
	break;

    case menuEvent:
	MenuEraseStatus(NULL);

	switch(e->data.menu.itemID) {
	    // TODO add to TestTemp code
	    //case itemBar:
	    case itemRun:
		if (start_sec == 0) {
		    stopWatchPrefs.tik_timestamp =
			stopWatchPrefs.timestamp = 
			start_sec = TimGetSeconds();
		    start_tik = TimGetTicks();
		}
		RunCount(start_tik);
		break;
	    case itemHold:
		// break the run loop
		run = 0;
		break;
	    case itemStop:
		// break the run loop
		run = 0;
		end_sec = TimGetSeconds();
 		end_tik = TimGetTicks();
		break;
	    case itemClear:
		// break the run loop
		run = 0;
		start_sec = 0;
		stopWatchPrefs.timestamp = 0;
		stopWatchPrefs.tik_timestamp = 0;
		end_tik = 0;
		drawCount(0);
		break;

	    case itemPrefs:
		FrmPopupForm(PrefForm);
		break;

	    case itemTest1:

		WinDrawLine(20,20,50,50);
//void WinDrawChar (WChar theChar, Coord x, Coord y)
///void WinDrawChars (const Char *chars, Int16 len, Coord x, Coord y)
//void WinPaintChar (WChar theChar, Coord x, Coord y)
//void WinPaintChars (const Char *chars, Int16 len, Coord x, Coord y)
///opt/palmdev/sdk-5/include/Core/System/Window.h
// Font.h
		WinDrawChar('X',20,50);
		FntSetFont(symbol11Font);
		WinDrawChar('Y',40,50);
		FntSetFont(largeFont);
		WinDrawChar('Z',60,50);
		WinDrawChars("large Font",10,80,50);
		FntSetFont(largeBoldFont);
		WinDrawChars("large Bold",10,110,50);

		{
		    char buf[100];
		    int l=0;
		    UInt32 t = SysTicksPerSecond();
		    l+=StrPrintF(buf+l, "SysTicksPerSec is %lu", t);
		    FntSetFont(largeBoldFont);
		    WinPaintChars(buf,l,1,20);
		}

		if (0){
		    digiFontType ft;
		    ft.h = 20;
		    ft.w = 16;
		    ft.th = 4; ft.tw = 7;
		    drawHSeg(11,9,ft,WinDrawLineF);
		    drawVSeg(10,10,ft,WinDrawLineF);
		    drawHSeg(11,36,ft,WinDrawLineF);
		    drawVSeg(39,10,ft,WinDrawLineF);
		}

		if (0){
		    digiFontType ft;
		    ft.h = 20;
		    ft.w = 12;
		    ft.th = 4; ft.tw = 7;
		    drawHSeg(11,59,ft,WinDrawLineF);
		    drawVSeg(10,60,ft,WinDrawLineF);
		    drawVSeg(38,60,ft,WinDrawLineF);
		    drawHSeg(11,79,ft,WinDrawLineF);
		    drawVSeg(10,80,ft,WinDrawLineF);
		    drawVSeg(38,80,ft,WinDrawLineF);
		    drawHSeg(11,99,ft,WinDrawLineF);
		}

		bigDigit(5,20,'2',WinDrawLineF);
		bigDigit(40,20,'5',WinDrawLineF);
		bigDigit(5,70,'7',WinDrawLineF);
		break;

	    case itemTest2:

		bigDigit(5,20,'8',WinEraseLineF);
		bigDigit(40,20,'8',WinEraseLineF);
		bigDigit(5,70,'8',WinEraseLineF);

		WinDrawChars("Hello",5,20,80);
		WinPaintChars("Paint",5,20,110);

		//Err err; err = TimInit();
		{
		    char buf[100];
		    int l=0;
		    UInt32 s,t;
		    UInt32 hour,min,sec;
		    UInt32 day;
		    // seconds since 1/1/1904
		    //void TimSetSeconds(UInt32 seconds) 	
		    // ticks since power on
		    t = TimGetTicks();
		    s = TimGetSeconds();
		    
		    l+=StrPrintF(buf+l, "Secs %lu", s);
		    FntSetFont(largeBoldFont);
		    WinPaintChars(buf,l,1,20);

		    l=0;
		    l+=StrPrintF(buf+l, "Ticks %lu", t);
		    FntSetFont(largeBoldFont);
		    WinPaintChars(buf,l,1,40);

		    day = s / (UInt32)(24 * 60 * 60);
		    s = s - day * (24 * 60 * 60);
		    hour = s / (60 * 60);
		    s = s - hour * (60 * 60);
		    min = s / 60;
		    sec = s - min * 60;
		    l=0;
		    l+=StrPrintF(buf+l, "%07d:%02d:%02d:%02d", day, hour,min,sec);
		    FntSetFont(largeBoldFont);
		    WinPaintChars(buf,l,1,60);

		}
		break;

		// call this periodically to hold off auto off  
		// Err EvtResetAutoOffTimer(void)

// SystemMgr.h
//Err SysTimerCreate(UInt32 *timerIDP, UInt32 *tagP, 
//            SysTimerProcPtr timerProc, UInt32 periodicDelay, UInt32	param)
//Err		SysTimerDelete(UInt32 timerID)
//Err		SysTimerWrite(UInt32 timerID, UInt32 value)
//Err		SysTimerRead(UInt32 timerID, UInt32 *valueP)

//      SysTaskDelay((100 * SysTicksPerSecond())/1000);

	    case itemOptHelp:
		FrmHelp(hlpHelp);
		break;
		//case itemOptDbgDump:
		//debugDump(e->eType);
		//break;
	    case itemOptCopy:
		FrmHelp(hlpCopy);
		break;
	    case itemOptAbout:
		FrmCustomAlert(alertInfo, 
			       "stopWatch v" VERSION " not even Alpha. "
			       "Built " __DATE__ ", " __TIME__ ". "
			       "James Coleman http://www.dspsrv.com/~jamesc "
			       "copyleft me.", "", "");
		break;

	}

	//DEBUGBOX("menuEvent","");

    	handled = true;
	break;

    case ctlSelectEvent:
	switch(e->data.ctlSelect.controlID) {

	    case btnRun:
		if (start_sec == 0) {
		    stopWatchPrefs.tik_timestamp =
			stopWatchPrefs.timestamp = 
			start_sec = TimGetSeconds();
		    start_tik = TimGetTicks();
		}
		RunCount(start_tik);
		break;
	    case btnHold:
		// break the run loop
		run = 0;
		break;
	    case btnStop:
		// break the run loop
		run = 0;
		end_sec = TimGetSeconds();
 		end_tik = TimGetTicks();
		break;
	    case btnClear:
		// break the run loop
		run = 0;
		stopWatchPrefs.timestamp = start_sec = 0;
		stopWatchPrefs.tik_timestamp = 0;
		end_tik = 0;
		drawCount(0);
		break;

	}
	break;

    //case ctlRepeatEvent:
    //break;

    case penDownEvent:
    case penMoveEvent:
      doPenAction( e->eType, e->screenX, e->screenY, 0, 0); 
      //FrmCustomAlert(alertInfo, "pen down", "ARGSTR1", "ARGSTR2");
      break;

    case penUpEvent:
      doPenAction( penUpEvent, 
      	   e->data.penUp.start.x, e->data.penUp.start.y, 
      	   e->data.penUp.end.x, e->data.penUp.end.y);
      break;

    case keyDownEvent:

      {
	char buf[1000];
	int l=0;
	l+=StrPrintF(buf+l, "Char: %c %02x\n",e->data.keyDown.chr,e->data.keyDown.chr);
	buf[l]=0;
	DEBUGBOX("keyDownEvent",buf);
      }

      switch(e->data.keyDown.chr) {
      case pageUpChr:
      case pageDownChr:
	handled = true;
	break;
      case prevFieldChr:
      case nextFieldChr:
      case '\n':
	handled = true;
	break;
      default:
	if (!TxtCharIsCntrl(e->data.keyDown.chr)) {
	  handled = true;                 /* Swallow event */
	}
	break;
      }
      break;

    default:
        break;
    }

    return handled;
}
Example #25
0
static unsigned int
osip_fallback_random_number ()
#endif
{
  if (!random_seed_set)
    {
      unsigned int ticks;

#ifdef __PALMOS__
#	if __PALMOS__ < 0x06000000
      SysRandom ((Int32) TimGetTicks ());
#	else
      struct timeval tv;

      gettimeofday (&tv, NULL);
      srand (tv.tv_usec);
      ticks = tv.tv_sec + tv.tv_usec;
#	endif
#elif defined(WIN32)
      LARGE_INTEGER lCount;

      QueryPerformanceCounter (&lCount);
      ticks = lCount.LowPart + lCount.HighPart;
#elif defined(_WIN32_WCE)
      ticks = GetTickCount ();
#elif defined(__PSOS__)
#elif defined(__VXWORKS_OS__)
      struct timespec tp;

      clock_gettime (CLOCK_REALTIME, &tp);
      ticks = tp.tv_sec + tp.tv_nsec;
#else
      struct timeval tv;
      int fd;

      gettimeofday (&tv, NULL);
      ticks = tv.tv_sec + tv.tv_usec;
      fd = open ("/dev/urandom", O_RDONLY);
      if (fd > 0)
        {
          unsigned int r;
          int i;

          for (i = 0; i < 512; i++)
            {
              read (fd, &r, sizeof (r));
              ticks += r;
            }
          close (fd);
        }
#endif

#ifdef HAVE_LRAND48
      srand48 (ticks);
#else
      srand (ticks);
#endif
      random_seed_set = 1;
    }
#ifdef HAVE_LRAND48
  return lrand48 ();
#else
  return rand ();
#endif
}
Example #26
0
/* Toggle Autoscroll */
void DoAutoscrollToggle
    (
    AutoscrollType toggle
    )
{
    FormType* mainForm;
    UInt16    prevCoordSys;

    if ( toggle == AUTOSCROLL_OFF &&
         ! Prefs()->autoscrollEnabled )
        return;

    mainForm = FrmGetFormPtr( GetMainFormId() );
    prevCoordSys = PalmSetCoordinateSystem( STANDARD );

    if ( toggle == AUTOSCROLL_TOGGLE )
        Prefs()->autoscrollEnabled = ! Prefs()->autoscrollEnabled;
    else if ( toggle == AUTOSCROLL_ON )
        Prefs()->autoscrollEnabled = true;
    else
        Prefs()->autoscrollEnabled = false;

    if ( Prefs()->autoscrollEnabled )
        Prefs()->autoscrollLastScrollTime = TimGetTicks();

    if ( Prefs()->autoscrollEnabled &&
         Prefs()->autoscrollDir == AUTOSCROLL_DOWN &&
         Prefs()->autoscrollMode == AUTOSCROLL_PIXELS ) {
        LineCacheActivate();
    }
    else {
        LineCacheRefreshCurrentScreenData();
        LineCacheDeactivate();
    }

    if ( Prefs()->toolbar != TOOLBAR_NONE && IsMainFormWinActive() ) {
        if ( Prefs()->autoscrollEnabled ) {
            if ( Prefs()->toolbar == TOOLBAR_SILK ) {
                /* FIXME: figure this out */
            }
            else {
                FrmHideObject( mainForm,
                    FrmGetObjectIndex( mainForm, bmpAutoscrollStart ) );
                FrmShowObject( mainForm,
                    FrmGetObjectIndex( mainForm, bmpAutoscrollStop ) );
            }
        }
        else {
            if ( Prefs()->toolbar == TOOLBAR_SILK ) {
                /* FIXME: figure this out */
            }
            else {
                FrmHideObject( mainForm,
                    FrmGetObjectIndex( mainForm, bmpAutoscrollStop ) );
                FrmShowObject( mainForm,
                    FrmGetObjectIndex( mainForm, bmpAutoscrollStart ) );
            }
        }
    }

    PalmSetCoordinateSystem( prevCoordSys );
}
Boolean CCXEGLView::EventHandler(TApplication * pApp, EventType * pEvent)
{
    Boolean bHandled = FALSE;

    switch(pEvent->eType)
    {
    case EVENT_WinInit:
        CfgRegisterScreenSwitchNotify(GetWindowHwndId(), 0);
        bHandled = TRUE;
        break;

    case EVENT_WinPaint:
        if (CfgGetScreenStatus())
        {
            // draw 
            CCDirector::sharedDirector()->mainLoop();
        }
        bHandled = TRUE;
        break;

    case EVENT_PenDown:
        bHandled = OnPenDown(pEvent, 0);
        break;

    case EVENT_PenMove:
        bHandled = OnPenMove(pEvent);
        break;

    case EVENT_PenUp:
        bHandled = OnPenUp(pEvent, 0);
        break;

    case EVENT_MultiTouchDown:
        bHandled = OnPenDown(pEvent, pEvent->lParam3);
        break;

    case EVENT_MultiTouchUp:
        bHandled = OnPenUp(pEvent, pEvent->lParam3);
        break;

    case EVENT_KeyCommand:
        {
            if (pEvent->sParam1 == SYS_KEY_SOFTKEY_RIGHT_UP ||
                pEvent->sParam1 == SYS_KEY_SOFTKEY_RIGHT_LONG)
            {
                bHandled = CCKeypadDispatcher::sharedDispatcher()->dispatchKeypadMSG(kTypeBackClicked);
            }
            else if (pEvent->sParam1 == SYS_KEY_SOFTKEY_LEFT_UP ||
                     pEvent->sParam1 == SYS_KEY_SOFTKEY_LEFT_LONG)
            {
                bHandled = CCKeypadDispatcher::sharedDispatcher()->dispatchKeypadMSG(kTypeMenuClicked);
            }
        }
        break;

    case MESSAGE_SENSORS_DATA:
        {
            TG3SensorsDataType	data;

            if (Sys_GetMessageBody((MESSAGE_t *)pEvent, &data, sizeof(TG3SensorsDataType)) == sizeof(TG3SensorsDataType) &&
                TG3_SENSOR_TYPE_ACCELEROMETER == data.sensorMask)
            {
                // convert the data to iphone format
                UIAcceleration AccValue;
                AccValue.x = -(data.acceleration.x / TG3_GRAVITY_EARTH);
                AccValue.y = -(data.acceleration.y / TG3_GRAVITY_EARTH);
                AccValue.z = -(data.acceleration.z / TG3_GRAVITY_EARTH);
                AccValue.timestamp = (double) TimGetTicks() / 100;

                // call delegates' didAccelerate function
                UIAccelerometer::sharedAccelerometer()->didAccelerate(&AccValue);
                bHandled = TRUE;
            }
        }
        break;

    case EVENT_WinClose:
        CfgUnRegisterScreenSwitchNotify(GetWindowHwndId(), 0);
        // Stop the application since the main form has been closed
        pApp->SendStopEvent();
        break;

    case EVENT_ScreenSwitchNotify:
        {
            bool bInBack = CCXApplication::sharedApplication()->isInBackground();

            // if the app have be in background,don't handle this message
            CCX_BREAK_IF(bInBack);

            if (! pEvent->sParam1)  // turn off screen
            {
                // CCDirector::sharedDirector()->pause();
                CCXApplication::sharedApplication()->applicationDidEnterBackground();
                CCXApplication::sharedApplication()->StopMainLoop();
            }
            else
            {
                // CCDirector::sharedDirector()->resume();
                CCXApplication::sharedApplication()->applicationWillEnterForeground();
                CCXApplication::sharedApplication()->StartMainLoop();
            }
            break;
        }

    }
//     {
//         char szType[32];
//         sprintf(szType, "%d", pEvent->eType);
//         const char * pszType = szType;
//         switch (pEvent->eType)
//         {
//         case EVENT_ScreenSwitchNotify:
//             pszType = "EVENT_ScreenSwitchNotify";
//             break;
// 
//         case EVENT_GlesUpdateNotify:
//             pszType = "EVENT_GlesUpdateNotify";
//             break;
// 
//         case EVENT_WinPaint:
//             pszType = "EVENT_GlesUpdateNotify";
//             break;
//         }
//         if (pszType)
//         {
//             char szMsg[256];
//             sprintf(szMsg, "%d: %s: %d \r\n", TimGetTicks(), pszType, pEvent->sParam1);
// #if defined (_TRANZDA_VM_)
// #define LOG_FILE_NAME "d:/Work7/NEWPLUS/TDA_DATA/UserData/mesagelog.txt"
// #else
// #define LOG_FILE_NAME "/NEWPLUS/TDA_DATA/UserData/mesagelog.txt"
// #endif
//             FILE * pf = fopen(LOG_FILE_NAME, "a+");
//             fwrite(szMsg, 1, strlen(szMsg), pf);
//             fclose(pf);
//         }
//     }

    if (! bHandled)
    {
        return TWindow::EventHandler(pApp, pEvent);
    }
    return bHandled;
}
Example #28
0
/* Reset the timer */
void TimeoutReset( void )
{
    lastTick = TimGetTicks();
}
Example #29
0
uint32 OSystem_PalmBase::getMillis() {
	return TimGetTicks() * 1000 / SysTicksPerSecond();
}