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 );
}
Exemple #2
0
KDint KD_APIENTRY kdMain(KDint argc, const KDchar *const *argv)
{
    kdInstallCallback(&callback1, KD_EVENT_QUIT, (void *)1234);
    kdInstallCallback(&callback2, KD_EVENT_QUIT, (void *)1234);
    for(;;)
    {
        KDEvent *event = kdCreateEvent();
        event->type = KD_EVENT_QUIT;
        event->userptr = (void *)1234;
        kdPostEvent(event);
        kdPumpEvents();
        if(quit)
        {
            break;
        }
    }
    return 0;
}
KDvoid xmEx_RemoveCallback ( KDvoid )
{
	kdLogMessage ( "\n* Case RemoveCallback\n\n" );

	//
	// 콜백 등록 제거
	//
	kdLogMessagefKHR ( "kdInstallCallback  : uninstall all callbacks." );
	kdInstallCallback ( KD_NULL, (KDint) KD_NULL, KD_NULL );	
}
Exemple #4
0
QOpenKODEWindow::QOpenKODEWindow(QWidget *tlw)
    : QPlatformWindow(tlw), isFullScreen(false)
{
    if (tlw->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenVG) {
        m_eglApi = EGL_OPENVG_API;
    } else {
        m_eglContextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
        m_eglContextAttrs.append(2);

        m_eglApi = EGL_OPENGL_ES_API;
    }
    eglBindAPI(m_eglApi);

    m_eglContextAttrs.append(EGL_NONE);
    m_eglWindowAttrs.append(EGL_NONE);

    QList<QPlatformScreen *> screens = QApplicationPrivate::platformIntegration()->screens();
    //XXXX: jl figure out how to pick the correct screen.
//    Q_ASSERT(screens.size() > tlw->d_func()->screenNumber);
//    QOpenKODEScreen *screen = qobject_cast<QOpenKODEScreen *>(screens.at(tlw->d_func()->screenNumber));
    QOpenKODEScreen *screen = qobject_cast<QOpenKODEScreen *>(screens.at(0));
    if (!screen) {
        qErrnoWarning("Could not make QOpenKODEWindow without a screen");
    }

    QPlatformWindowFormat format = tlw->platformWindowFormat();
    format.setRedBufferSize(5);
    format.setGreenBufferSize(6);
    format.setBlueBufferSize(5);

    m_eglConfig = q_configFromQPlatformWindowFormat(screen->eglDisplay(),format);

    m_kdWindow = kdCreateWindow(screen->eglDisplay(),
                              m_eglConfig,
                              this);
    kdInstallCallback(kdProcessMouseEvents,KD_EVENT_INPUT_POINTER,this);
#ifdef KD_ATX_keyboard
    kdInstallCallback(kdProcessKeyEvents, KD_EVENT_INPUT_KEY_ATX,this);
#endif //KD_ATX_keyboard

    if (!m_kdWindow) {
        qErrnoWarning(kdGetError(), "Error creating native window");
        return;
    }

    KDboolean exclusive(false);
    if (kdSetWindowPropertybv(m_kdWindow,KD_WINDOWPROPERTY_DESKTOP_EXCLUSIVE_NV, &exclusive)) {
        isFullScreen = true;
    }

    if (isFullScreen) {
        tlw->setGeometry(screen->geometry());
        screen->setFullScreen(isFullScreen);
    }else {
        const KDint windowSize[2]  = { tlw->width(), tlw->height() };
        if (kdSetWindowPropertyiv(m_kdWindow, KD_WINDOWPROPERTY_SIZE, windowSize)) {
            qErrnoWarning(kdGetError(), "Could not set native window size");
        }
        KDboolean visibillity(false);
        if (kdSetWindowPropertybv(m_kdWindow, KD_WINDOWPROPERTY_VISIBILITY, &visibillity)) {
            qErrnoWarning(kdGetError(), "Could not set visibillity to false");
        }

        const KDint windowPos[2] = { tlw->x(), tlw->y() };
        if (kdSetWindowPropertyiv(m_kdWindow, KD_WINDOWPROPERTY_DESKTOP_OFFSET_NV, windowPos)) {
            qErrnoWarning(kdGetError(), "Could not set native window position");
            return;
        }
    }


    QOpenKODEIntegration *integration = static_cast<QOpenKODEIntegration *>(QApplicationPrivate::platformIntegration());

    if (!isFullScreen || (isFullScreen && !integration->mainGLContext())) {
        if (kdRealizeWindow(m_kdWindow, &m_eglWindow)) {
            qErrnoWarning(kdGetError(), "Could not realize native window");
            return;
        }

        EGLSurface surface = eglCreateWindowSurface(screen->eglDisplay(),m_eglConfig,m_eglWindow,m_eglWindowAttrs.constData());
        m_platformGlContext = new QEGLPlatformContext(screen->eglDisplay(), m_eglConfig,
                                                      m_eglContextAttrs.data(), surface, m_eglApi);
        integration->setMainGLContext(m_platformGLContext);
    } else {
        m_platformGlContext = integration->mainGLContext();
        kdDestroyWindow(m_kdWindow);
        m_kdWindow = 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 );
}
QOpenKODEEventLoopIntegration::QOpenKODEEventLoopIntegration()
    : m_quit(false)
{
    m_kdThread = kdThreadSelf();
    kdInstallCallback(&kdprocessevent,QT_EVENT_WAKEUP_EVENTLOOP,this);
}