Пример #1
0
void QOpenKODEEventLoopIntegration::startEventLoop()
{

    while(!m_quit) {
        qint64 msec = nextTimerEvent();
        const KDEvent *event = kdWaitEvent(msec);
        if (event) {
            kdDefaultEvent(event);
            while ((event = kdWaitEvent(0)) != 0) {
                kdDefaultEvent(event);
            }
        }
        QPlatformEventLoopIntegration::processEvents();
    }
}
Пример #2
0
KDvoid xmEx_Recursive ( KDvoid )
{
	const KDEvent*    wait;

	KDEvent*     event[2];		
	KDint        i = 0;

	kdLogMessage ( "\n* Case Recursive\n\n" );

	event[i] = kdCreateEvent ();	
	event[i]->type = XM_FOR_PUMP_EVENT;	
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

	kdPostEvent ( event[i] );
	kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

	i++;

	event[i] = kdCreateEvent ();	
	event[i]->type = XM_FOR_WAIT_EVENT;	
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	
	kdPostEvent ( event[i] );
	kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

	kdInstallCallback ( xmRecursiveCallback, XM_FOR_PUMP_EVENT, KD_NULL );
	kdLogMessagefKHR ( "kdInstallCallback  : func  = 0x%08x, type = %04d, userptr = 0x%08x", xmRecursiveCallback, XM_FOR_PUMP_EVENT, KD_NULL );

	kdLogMessagefKHR ( "kdWaitEvent        : waiting message." );	
	wait = kdWaitEvent ( -1 );	
	kdLogMessagefKHR ( "kdWaitEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );

	kdDefaultEvent( wait );	
	kdLogMessagefKHR ( "kdDefaultEvent     : event = 0x%08x", wait );
}
Пример #3
0
///
// kdMain()
//
//    Main function for OpenKODE application
//
KDint KD_APIENTRY kdMain(KDint argc, const KDchar *const *argv)
{
    Example *example = exampleInit();

    UserData userdata;
    example->userptr = &userdata;
    Init(example);

    KDust t1 = kdGetTimeUST();
    KDfloat32 deltatime;
    KDfloat32 totaltime = 0.0f;
    KDuint frames = 0;

    // Main Loop
    while(example->run)
    {
        const KDEvent *event = kdWaitEvent(-1);
        if(event)
        {
            switch(event->type)
            {
                case(KD_EVENT_QUIT):
                case(KD_EVENT_WINDOW_CLOSE):
                {
                    example->run = KD_FALSE;
                    break;
                }
                default:
                {
                    kdDefaultEvent(event);
                    break;
                }
            }
        }
        // Update
        KDust t2 = kdGetTimeUST();
        deltatime = (KDfloat32)((t2 - t1) * 1e-9);
        t1 = t2;
        Update(example, deltatime);

        // Draw frame
        Draw(example);
        exampleRun(example);

        // Benchmark
        totaltime += deltatime;
        frames++;
        if(totaltime > 5.0f)
        {
            kdLogMessagefKHR("%d frames in %3.1f seconds = %6.3f FPS\n", frames, totaltime, frames / totaltime);
            totaltime -= 5.0f;
            frames = 0;
        }
    }

    ShutDown(example);
    return exampleDestroy(example);
}
Пример #4
0
KDvoid xmRecursiveCallback ( const KDEvent *event )
{
	kdLogMessagefKHR ( "recursive_callback : event = 0x%08x, type = %04d, userptr = 0x%08x", event, event->type, event->userptr );

	if ( event->userptr == 0 )
	{
		const KDEvent* wait;
		
		KDEvent*	event[3];
		KDint		i = 0;

		event[i] = kdCreateEvent ();	
		event[i]->type = XM_FOR_PUMP_EVENT;	
		event[i]->userptr = (KDvoid *) xmRecursiveCallback;
		kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
		
		kdPostEvent ( event[i] );
		kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

		i++;

		kdLogMessagefKHR ( "kdWaitEvent        : waiting message." );	
		wait = kdWaitEvent ( 0 );	
		kdLogMessagefKHR ( "kdWaitEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );

		kdDefaultEvent( wait );	
		kdLogMessagefKHR ( "kdDefaultEvent     : event = 0x%08x", wait );

		event[i] = kdCreateEvent ();	
		event[i]->type = XM_FOR_PUMP_EVENT;	
		event[i]->userptr = (KDvoid *) xmRecursiveCallback;
		kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

		kdPostEvent ( event[i] );
		kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

		i++;

		event[i] = kdCreateEvent ();	
		event[i]->type = XM_FOR_WAIT_EVENT;	
		event[i]->userptr = (KDvoid *) xmRecursiveCallback;
		kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );		

		kdPostEvent ( event[i] );
		kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	}
}
Пример #5
0
JNIEXPORT void JNICALL Java_jogamp_newt_driver_kd_DisplayDriver_DispatchMessages
  (JNIEnv *env, jobject obj)
{
    const KDEvent * evt;
    int numEvents = 0;

    // Periodically take a break
    while( numEvents<100 && NULL!=(evt=kdWaitEvent(0)) ) {
        KDWindow *kdWindow;
        jobject javaWindow;
        JOGLKDUserdata * userData = (JOGLKDUserdata *)(intptr_t)evt->userptr;
        if(NULL == userData || userData->magic!=JOGL_KD_USERDATA_MAGIC) {
            DBG_PRINT( "event unrelated: evt type: 0x%X\n", evt->type);
            continue;
        }
        kdWindow = userData->kdWindow;
        javaWindow = userData->javaWindow;
        DBG_PRINT( "[DispatchMessages]: userData %p, evt type: 0x%X\n", userData, evt->type);

        numEvents++;

        // FIXME: support resize and window re-positioning events

        switch(evt->type) {
            case KD_EVENT_WINDOW_FOCUS:
                {
                    KDboolean hasFocus;
                    kdGetWindowPropertybv(kdWindow, KD_WINDOWPROPERTY_FOCUS, &hasFocus);
                    DBG_PRINT( "event window focus : src: %p\n", userData);
                }
                break;
            case KD_EVENT_WINDOW_CLOSE:
                {
                    jboolean closed;
                    DBG_PRINT( "event window close : src: %p .. \n", userData);
                    closed = (*env)->CallBooleanMethod(env, javaWindow, windowDestroyNotifyID, JNI_FALSE);
                    DBG_PRINT( "event window close : src: %p, closed %d\n", userData, (int)closed);
                }
                break;
            case KD_EVENT_WINDOWPROPERTY_CHANGE:
                {
                    const KDEventWindowProperty* prop = &evt->data.windowproperty;
                    switch (prop->pname) {
                        case KD_WINDOWPROPERTY_SIZE:
                            {
                                KDint32 v[2];
                                if(!kdGetWindowPropertyiv(kdWindow, KD_WINDOWPROPERTY_SIZE, v)) {
                                    DBG_PRINT( "event window size change : src: %p %dx%d\n", userData, v[0], v[1]);
                                    (*env)->CallVoidMethod(env, javaWindow, sizeChangedID, JNI_FALSE, (jint) v[0], (jint) v[1], JNI_FALSE);
                                } else {
                                    DBG_PRINT( "event window size change error: src: %p %dx%d\n", userData, v[0], v[1]);
                                }
                            }
                            break;
                        case KD_WINDOWPROPERTY_FOCUS:
                            DBG_PRINT( "event window focus: src: %p\n", userData);
                            break;
                        case KD_WINDOWPROPERTY_VISIBILITY:
                            {
                                KDboolean visible;
                                kdGetWindowPropertybv(kdWindow, KD_WINDOWPROPERTY_VISIBILITY, &visible);
                                DBG_PRINT( "event window visibility: src: %p, v:%d\n", userData, visible);
                                (*env)->CallVoidMethod(env, javaWindow, visibleChangedID, JNI_FALSE, visible?JNI_TRUE:JNI_FALSE);
                            }
                            break;
                        default:
                            break;
                    }
                }
                break;
            case KD_EVENT_INPUT_POINTER:
                {
                    const KDEventInputPointer* ptr = &(evt->data.inputpointer);
                    // button idx: evt->data.input.index
                    // pressed = ev->data.input.value.i
                    // time = ev->timestamp
                    if(KD_INPUT_POINTER_SELECT==ptr->index) {
                        DBG_PRINT( "event mouse click: src: %p, s:%d, (%d,%d)\n", userData, ptr->select, ptr->x, ptr->y);
                        (*env)->CallVoidMethod(env, javaWindow, sendMouseEventID, 
                                              (ptr->select==0) ? (jshort) EVENT_MOUSE_RELEASED : (jshort) EVENT_MOUSE_PRESSED, 
                                              (jint) 0,
                                              (jint) ptr->x, (jint) ptr->y, (short)1, 0.0f);
                    } else {
                        DBG_PRINT( "event mouse: src: %d, s:%p, i:0x%X (%d,%d)\n", userData, ptr->select, ptr->index, ptr->x, ptr->y);
                        (*env)->CallVoidMethod(env, javaWindow, sendMouseEventID, (jshort) EVENT_MOUSE_MOVED, 
                                              0,
                                              (jint) ptr->x, (jint) ptr->y, (jshort)0, 0.0f);
                    }
                }
                break;
        }
    } 
}
Пример #6
0
KDvoid xmEx_Regular ( KDvoid )
{
	const KDEvent* wait;

	KDEvent*	event[4];	
	KDint		ret = 0;
	KDint		i   = 0;
	
	kdLogMessage ( "* Case Regular\n\n" );

	//
	// 설명 : 이벤트 생성
	// 반환 : 이벤트 
	//
	event[i] = kdCreateEvent ();
	kdAssert ( ( event[i] ) );

	event[i]->type = XM_FOR_PUMP_EVENT;	// 펌프 테스트 용
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	i++;

	event[i] = kdCreateEvent ();	
	event[i]->type = XM_FOR_WAIT_EVENT;	// 메세지 대기 테스트 용
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	i++;

	event[i] = kdCreateEvent ();
	event[i]->type = XM_FOR_PUMP_EVENT;	// 이벤트 제거 테스트 용
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	i++;

	event[i] = kdCreateEvent ();	
	event[i]->type = XM_FOR_PUMP_EVENT;	// 메세지 대기시 펌프 테스트 용
	kdLogMessagefKHR ( "kdCreateEvent      : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );

	i = 0;
	//
	// 설명 : 이벤트 전달
	// 인자 : 이벤트
	// 반환 : 성공 = 0, 실패 = -1
	//
	ret = kdPostEvent ( event[i] );
	kdAssert ( !ret );

	kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	i++;

	//
	// 설명 : 이벤트 전달 ( 해당 쓰레드로 이벤트 전달 )
	// 인자 : 이벤트, 쓰레드 핸들 
	// 반환 : 성공 = 0, 실패 = -1
	//	
	ret = kdPostThreadEvent ( event[i], kdThreadSelf() );			// 현재 쓰레드 구현 안됨. 	
	kdAssert ( !ret );

	kdLogMessagefKHR ( "kdPostThreadEvent  : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	i++;

	// 
	// 설명 : 이벤트 제거 ( 이미 포스팅 또는 제거를 한 경우에는 예기치 않은 오류 발생 가능 )
	// 인자 : 이벤트
	//
	kdFreeEvent ( event[i] );

	kdLogMessagefKHR ( "kdFreeEvent        : event = 0x%08x", event[i] );
	i++;

	//
	// 설명 : 콜백 함수 등록 ( 이벤트 및 사용자 포인터를 이중으로 등록 가능 )
	// 인자 : 콜백 함수, 이벤트 종류, 사용자 포인터
	// 반환 : 성공 = 0, 실패 = -1
	//	
	ret = kdInstallCallback ( xmRegularCallback, XM_FOR_PUMP_EVENT, KD_NULL );	
	kdAssert ( !ret );

	kdLogMessagefKHR ( "kdInstallCallback  : func  = 0x%08x, type = %04d, userptr = 0x%08x", xmRegularCallback, XM_FOR_PUMP_EVENT, KD_NULL );

	//
	// 설명 : 이벤트 펌프( 등록된 콜백 함수 조건에 성립된 메세지들을 큐에서 꺼내 전부 콜백 함수를 호출한다 )
	// 반환 : 성공 = 0, 실패 = -1
	//
	kdLogMessagefKHR ( "kdPumpEvents       : pumping messages." );

	ret = kdPumpEvents ( );
	
	kdAssert ( !ret );

	//
	// 설명 : 메세지 대기
	// 인자 : 시간제한 ( -1은 무한 )
	// 반환 : 이벤트
	//		
	i = 3;
	kdPostEvent ( event[i] );
	kdLogMessagefKHR ( "kdPostEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
	kdLogMessagefKHR ( "kdWaitEvent        : waiting message." );	
	
	wait = kdWaitEvent ( -1 );	
	kdAssert ( wait->type == XM_FOR_WAIT_EVENT );

	kdLogMessagefKHR ( "kdWaitEvent        : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );

	//
	// 설명 : 디폴트 처리 ( 전달된 이벤트는 삭제 됨 )
	// 인자 : 이벤트
	// 
	kdDefaultEvent ( wait );	

	kdLogMessagefKHR ( "kdDefaultEvent     : event = 0x%08x", wait );
}