TEST_F(NotificationTest, MultipleRegistrationsSurface) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // get called once ilm_surfaceSetOrientation(surface,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); assertCallbackcalled(); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); // change a lot of things t_ilm_float opacity = 0.789; ilm_surfaceSetOpacity(surface,opacity); ilm_surfaceSetVisibility(surface,true); ilm_surfaceSetDestinationRectangle(surface,133,1567,155,199); ilm_surfaceSetSourceRectangle(surface,33,567,55,99); ilm_surfaceSetOrientation(surface,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); // assert that we have not been notified assertNoCallbackIsCalled(); // register for notifications again ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); ilm_surfaceSetOrientation(surface,ILM_ZERO); ilm_commitChanges(); assertCallbackcalled(); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
void SetUp() { ASSERT_EQ(ILM_SUCCESS, ilm_initWithNativedisplay((t_ilm_nativedisplay)wlDisplay)); ASSERT_EQ(ILM_SUCCESS, ilmClient_init((t_ilm_nativedisplay)wlDisplay)); // set default values callbackLayerId = -1; LayerProperties = ilmLayerProperties(); mask = static_cast<t_ilm_notification_mask>(0); surface = -1; SurfaceProperties = ilmSurfaceProperties(); // create a layer layer = 345; ilm_layerRemove(layer); ilm_commitChanges(); ilm_layerCreateWithDimension(&layer, 800, 480); ilm_commitChanges(); // create a surface surface = 456; ilm_surfaceRemove(surface); ilm_commitChanges(); ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0],10,10,ILM_PIXELFORMAT_RGBA_8888,&surface); ilm_commitChanges(); timesCalled=0; callbackLayerId = INVALID_ID; callbackSurfaceId = INVALID_ID; }
TEST_F(NotificationTest, ilm_surfaceAddNotificationWithoutCallback) { // create a layer t_ilm_uint surface = 67; ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1],10,10,ILM_PIXELFORMAT_RGBA_8888,&surface); ilm_commitChanges(); // add notification ilmErrorTypes status = ilm_surfaceAddNotification(surface,NULL); ASSERT_EQ(ILM_SUCCESS, status); ilm_surfaceRemove(surface); ilm_commitChanges(); }
TEST_F(NotificationTest, NotifyOnSurfaceAllValues) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something t_ilm_float opacity = 0.789; ilm_surfaceSetOpacity(surface,opacity); ilm_surfaceSetVisibility(surface,true); ilm_surfaceSetDestinationRectangle(surface,133,1567,155,199); ilm_surfaceSetSourceRectangle(surface,33,567,55,99); ilm_surfaceSetOrientation(surface,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_EQ(33u,SurfaceProperties.sourceX); EXPECT_EQ(567u,SurfaceProperties.sourceY); EXPECT_EQ(55u,SurfaceProperties.sourceWidth); EXPECT_EQ(99u,SurfaceProperties.sourceHeight); EXPECT_EQ(ILM_ONEHUNDREDEIGHTY,SurfaceProperties.orientation); EXPECT_TRUE(SurfaceProperties.visibility); EXPECT_NEAR(opacity, SurfaceProperties.opacity, 0.1); EXPECT_EQ(133u,SurfaceProperties.destX); EXPECT_EQ(1567u,SurfaceProperties.destY); EXPECT_EQ(155u,SurfaceProperties.destWidth); EXPECT_EQ(199u,SurfaceProperties.destHeight); EXPECT_EQ(ILM_NOTIFICATION_DEST_RECT|ILM_NOTIFICATION_VISIBILITY|ILM_NOTIFICATION_OPACITY|ILM_NOTIFICATION_SOURCE_RECT|ILM_NOTIFICATION_ORIENTATION,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
void TearDown() { //print_lmc_get_scene(); t_ilm_layer* layers = NULL; t_ilm_int numLayer=0; EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers)); for (t_ilm_int i=0; i<numLayer; i++) { EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i])); }; free(layers); t_ilm_surface* surfaces = NULL; t_ilm_int numSurfaces=0; EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&numSurfaces, &surfaces)); for (t_ilm_int i=0; i<numSurfaces; i++) { EXPECT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surfaces[i])); }; free(surfaces); EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges()); EXPECT_EQ(ILM_SUCCESS, ilmClient_destroy()); EXPECT_EQ(ILM_SUCCESS, ilm_destroy()); }
TEST_F(NotificationTest, ilm_layerAddNotificationWithoutCallback) { // create a layer t_ilm_uint layer = 89; ASSERT_EQ(ILM_SUCCESS,ilm_layerCreateWithDimension(&layer, 800, 480)); ASSERT_EQ(ILM_SUCCESS,ilm_commitChanges()); // add notification printf("test calling ilm_layerAddNotification\n"); //ASSERT_EQ(ILM_SUCCESS,ilm_commitChanges()); ASSERT_EQ(ILM_SUCCESS, ilm_layerAddNotification(layer,NULL)); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemove(layer)); ASSERT_EQ(ILM_SUCCESS,ilm_commitChanges()); }
TEST_F(NotificationTest, DefaultIsNotToReceiveNotificationsSurface) { // get called once ilm_surfaceSetOrientation(surface,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); // change a lot of things t_ilm_float opacity = 0.789; ilm_surfaceSetOpacity(surface,opacity); ilm_surfaceSetVisibility(surface,true); ilm_surfaceSetDestinationRectangle(surface,133,1567,155,199); ilm_surfaceSetSourceRectangle(surface,33,567,55,99); ilm_surfaceSetOrientation(surface,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); // assert that we have not been notified assertNoCallbackIsCalled(); }
t_ilm_bool createGLXContext(t_ilm_int width, t_ilm_int height) { int glxMajor; int glxMinor; g_glxContextStruct.glxContext = glXCreateContext( g_x11ContextStruct.x11Display, g_x11ContextStruct.x11Visual, 0, GL_TRUE); glXMakeCurrent(g_x11ContextStruct.x11Display, g_x11ContextStruct.x11Window, g_glxContextStruct.glxContext); // do egl stuff glXQueryVersion(g_x11ContextStruct.x11Display, &glxMajor, &glxMinor); printf("GLX-Version %d.%d\n", glxMajor, glxMinor); if (glXIsDirect(g_x11ContextStruct.x11Display, g_glxContextStruct.glxContext)) { printf("DRI enabled\n"); } else { printf("no DRI available\n"); } t_ilm_layer layerid = (t_ilm_layer) LAYER_EXAMPLE_X_APPLICATIONS; // TODO: remove all C stylec asts in C++ code t_ilm_surface surfaceid = (t_ilm_surface) SURFACE_EXAMPLE_GLXX11_APPLICATION; printf("create a surface %lu\n", (t_ilm_nativehandle) (g_x11ContextStruct.x11Window)); ilm_surfaceCreate((t_ilm_nativehandle) g_x11ContextStruct.x11Window, width, height, ILM_PIXELFORMAT_RGBA_8888, &surfaceid); printf("set surface dest region\n"); ilm_surfaceSetDestinationRectangle(surfaceid, 0, 0, width, height); printf("set surface src region\n"); ilm_surfaceSetSourceRectangle(surfaceid, 0, 0, width, height); printf("add surface to layer\n"); ilm_layerAddSurface(layerid, surfaceid); printf("Set surface visible\n"); ilm_surfaceSetVisibility(surfaceid, ILM_TRUE); printf("Set surface opacity\n"); ilm_surfaceSetOpacity(surfaceid, 0.75f); xeventInitialiaze(g_x11ContextStruct.x11Display, surfaceid, 0, 0, width, height); printf("commit\n"); // commit will indicate error, if any command failed ilmErrorTypes error = ilm_commitChanges(); return (error != ILM_FAILED) ? ILM_TRUE : ILM_FALSE; }
TEST_F(NotificationTest, DoNotSendNotificationsAfterRemoveLayer) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // get called once ilm_layerSetOrientation(layer,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); assertCallbackcalled(); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); // change a lot of things t_ilm_float opacity = 0.789; ilm_layerSetOpacity(layer,opacity); ilm_layerSetVisibility(layer,true); ilm_layerSetDestinationRectangle(layer,133,1567,155,199); ilm_layerSetSourceRectangle(layer,33,567,55,99); ilm_layerSetOrientation(layer,ILM_ONEHUNDREDEIGHTY); ilm_commitChanges(); // assert that we have not been notified assertNoCallbackIsCalled(); }
/** * @Description Initialize the xevent management module * * @param dpy X11 Display * @param Surface ID of the surface to control * @param x Initial destination x position of the surface * @param y Initial destination y position of the surface * @param width Initial width of the surface destination * @param height Initial height of the surface destination * */ void xeventInitialiaze(Display* dpy, t_ilm_surface surfaceid, t_ilm_int x, t_ilm_int y, t_ilm_int width, t_ilm_int height) { t_ilm_surface surf; g_surfPosX = x; g_surfPosY = y; g_surfWidthOrig = width; g_surfHeightOrig = height; g_x11Display = dpy; g_surfaceid = surfaceid; g_surfMoveDirection = move_right; /***********************************************************************/ /* Deal with LayerManager Input Framework to demonstrate possibilities */ /* * By default, a surface accept input events from all type of devices. (See type ilmInputDevice) * It is anyway possible to override this setting device by device. * Note1: ilmInputDevice can be used as a bit mask * Note2: ilm_UpdateInputEventAcceptanceOn() is assynchronous */ // Accept events from keyboard & mouse ilm_UpdateInputEventAcceptanceOn( SURFACE_EXAMPLE_GLXX11_APPLICATION, ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_POINTER, ILM_TRUE); // Refuse events from touch devices ilm_UpdateInputEventAcceptanceOn( SURFACE_EXAMPLE_GLXX11_APPLICATION, ILM_INPUT_DEVICE_TOUCH, ILM_FALSE); // Apply the changes ilm_commitChanges(); /* * The keyboard is managed by a focus. Only the surface which has the focus will receive * keyboard events. (if it is set to receive keyboard events) * ilm_SetKeyboardFocusOn() can be used to control which surface has the keyboard focus * ilm_GetKeyboardFocusSurfaceId() can be used to know which surface has the keyboard focus * Note1: ilm_SetKeyboardFocusOn() & ilm_GetKeyboardFocusSurfaceId() are synchronous */ ilm_SetKeyboardFocusOn(SURFACE_EXAMPLE_GLXX11_APPLICATION); // Play with ilm_SetKeyboardFocusOn(); ilm_GetKeyboardFocusSurfaceId(&surf); assert(SURFACE_EXAMPLE_GLXX11_APPLICATION == surf); }
TEST_F(NotificationTest, NotifyOnLayerSetOpacity) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something t_ilm_float opacity = 0.789; ilm_layerSetOpacity(layer,opacity); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(layer,callbackLayerId); EXPECT_NEAR(0.789, LayerProperties.opacity, 0.1); EXPECT_EQ(ILM_NOTIFICATION_OPACITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnSurfaceSetOrientation) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something e_ilmOrientation orientation = ILM_ONEHUNDREDEIGHTY; ilm_surfaceSetOrientation(surface,orientation); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_EQ(ILM_ONEHUNDREDEIGHTY,SurfaceProperties.orientation); EXPECT_EQ(ILM_NOTIFICATION_ORIENTATION,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
TEST_F(NotificationTest, NotifyOnLayerSetVisibility) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something t_ilm_bool value = ILM_TRUE; ilm_layerSetVisibility(layer,value); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(layer,callbackLayerId); EXPECT_TRUE(LayerProperties.visibility); EXPECT_EQ(ILM_NOTIFICATION_VISIBILITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnLayerSetOrientation) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something e_ilmOrientation orientation = ILM_ONEHUNDREDEIGHTY; ilm_layerSetOrientation(layer,orientation); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(layer,callbackLayerId); EXPECT_EQ(ILM_ONEHUNDREDEIGHTY,LayerProperties.orientation); EXPECT_EQ(ILM_NOTIFICATION_ORIENTATION,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnSurfaceSetVisibility) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something t_ilm_bool value = ILM_TRUE; ilm_surfaceSetVisibility(surface,value); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_TRUE(SurfaceProperties.visibility); EXPECT_EQ(ILM_NOTIFICATION_VISIBILITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
TEST_F(NotificationTest, NotifyOnSurfaceSetOpacity) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something t_ilm_float opacity = 0.789; ilm_surfaceSetOpacity(surface,opacity); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_NEAR(0.789, SurfaceProperties.opacity, 0.1); EXPECT_EQ(ILM_NOTIFICATION_OPACITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
TEST_F(NotificationTest, NotifyOnSurfaceSetSourceRectangle) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something ilm_surfaceSetSourceRectangle(surface,33,567,55,99); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_EQ(33u,SurfaceProperties.sourceX); EXPECT_EQ(567u,SurfaceProperties.sourceY); EXPECT_EQ(55u,SurfaceProperties.sourceWidth); EXPECT_EQ(99u,SurfaceProperties.sourceHeight); EXPECT_EQ(ILM_NOTIFICATION_SOURCE_RECT,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
TEST_F(NotificationTest, NotifyOnLayerSetSourceRectangle) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something ilm_layerSetSourceRectangle(layer,33,567,55,99); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(layer,callbackLayerId); EXPECT_EQ(33u,LayerProperties.sourceX); EXPECT_EQ(567u,LayerProperties.sourceY); EXPECT_EQ(55u,LayerProperties.sourceWidth); EXPECT_EQ(99u,LayerProperties.sourceHeight); EXPECT_EQ(ILM_NOTIFICATION_SOURCE_RECT,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnLayerSetDimension) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something t_ilm_uint* pos = new t_ilm_uint[2]; pos[0] = 70; pos[1] = 22; ilm_layerSetDimension(layer,pos); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(layer,callbackLayerId); EXPECT_EQ(70u,LayerProperties.destWidth); EXPECT_EQ(22u,LayerProperties.destHeight); EXPECT_EQ(ILM_NOTIFICATION_DEST_RECT,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnSurfaceSetDimension) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something t_ilm_uint* pos = new t_ilm_uint[2]; pos[0] = 70; pos[1] = 22; ilm_surfaceSetDimension(surface,pos); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_EQ(70u,SurfaceProperties.destWidth); EXPECT_EQ(22u,SurfaceProperties.destHeight); EXPECT_EQ(ILM_NOTIFICATION_DEST_RECT,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
static void zoomSurface(t_ilm_int x, t_ilm_int y) { t_ilm_int width; t_ilm_int height; struct ilmSurfaceProperties surfaceProperties; ilm_getPropertiesOfSurface(g_surfaceid, &surfaceProperties); width = (t_ilm_int) ((float) surfaceProperties.sourceWidth) / ZOOM_FACTOR; height = (t_ilm_int) ((float) surfaceProperties.sourceHeight) / ZOOM_FACTOR; // Center the zoom on the x,y position x -= width / 2; x = x < 0 ? 0 : x; x = x + width > g_surfWidthOrig ? g_surfWidthOrig - width - 1: x; y -= height / 2; y = y < 0 ? 0 : y; y = y + height > g_surfHeightOrig ? g_surfHeightOrig - height - 1: y; ilm_surfaceSetSourceRectangle(g_surfaceid, x, y, width, height); ilm_commitChanges(); }
void TearDown() { //print_lmc_get_scene(); t_ilm_layer* layers = NULL; t_ilm_int numLayer=0; EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers)); for (t_ilm_int i=0; i<numLayer; i++) { EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i])); }; free(layers); for (std::vector<iviSurface>::reverse_iterator it = iviSurfaces.rbegin(); it != iviSurfaces.rend(); ++it) { ivi_surface_destroy((*it).surface); } iviSurfaces.clear(); EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges()); EXPECT_EQ(ILM_SUCCESS, ilm_destroy()); }
TEST_F(NotificationTest, NotifyOnLayerMultipleValues2) { ASSERT_EQ(ILM_SUCCESS,ilm_layerAddNotification(layer,&LayerCallbackFunction)); // change something t_ilm_float opacity = 0.789; ilm_layerSetOpacity(layer,opacity); ilm_layerSetVisibility(layer,true); ilm_layerSetDestinationRectangle(layer,33,567,55,99); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(3); EXPECT_EQ(layer,callbackLayerId); EXPECT_TRUE(LayerProperties.visibility); EXPECT_NEAR(0.789, LayerProperties.opacity, 0.1); EXPECT_EQ(33u,LayerProperties.destX); EXPECT_EQ(567u,LayerProperties.destY); EXPECT_EQ(55u,LayerProperties.destWidth); EXPECT_EQ(99u,LayerProperties.destHeight); EXPECT_EQ(ILM_NOTIFICATION_DEST_RECT|ILM_NOTIFICATION_VISIBILITY|ILM_NOTIFICATION_OPACITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_layerRemoveNotification(layer)); }
TEST_F(NotificationTest, NotifyOnSurfaceMultipleValues2) { ASSERT_EQ(ILM_SUCCESS,ilm_surfaceAddNotification(surface,&SurfaceCallbackFunction)); // change something t_ilm_float opacity = 0.789; ilm_surfaceSetOpacity(surface,opacity); ilm_surfaceSetVisibility(surface,true); ilm_surfaceSetDestinationRectangle(surface,33,567,55,99); ilm_commitChanges(); // expect callback to have been called assertCallbackcalled(); EXPECT_EQ(surface,callbackSurfaceId); EXPECT_TRUE(SurfaceProperties.visibility); EXPECT_NEAR(0.789, SurfaceProperties.opacity, 0.1); EXPECT_EQ(33u,SurfaceProperties.destX); EXPECT_EQ(567u,SurfaceProperties.destY); EXPECT_EQ(55u,SurfaceProperties.destWidth); EXPECT_EQ(99u,SurfaceProperties.destHeight); EXPECT_EQ(ILM_NOTIFICATION_DEST_RECT|ILM_NOTIFICATION_VISIBILITY|ILM_NOTIFICATION_OPACITY,mask); ASSERT_EQ(ILM_SUCCESS,ilm_surfaceRemoveNotification(surface)); }
static void moveSurface() { static t_ilm_uint screenWidth = 0; static t_ilm_uint screenHeight = 0; static t_ilm_int surfWidth = 0; static t_ilm_int surfHeight = 0; struct ilmSurfaceProperties surfaceProperties; // Init if (!screenWidth || !screenHeight) { ilm_getScreenResolution(0, &screenWidth, &screenHeight); } if (!surfWidth || !surfHeight) { ilm_getPropertiesOfSurface(g_surfaceid, &surfaceProperties); surfWidth = (t_ilm_int) surfaceProperties.destWidth; surfHeight = (t_ilm_int) surfaceProperties.destHeight; } // Do the real job switch (g_surfMoveDirection) { case move_right: g_surfPosX += SURFACE_MOVE_STEP; if (g_surfPosX >= (t_ilm_int) (screenWidth - surfWidth)) { g_surfPosX = screenWidth - surfWidth; g_surfMoveDirection = move_down; } break; case move_down: g_surfPosY += SURFACE_MOVE_STEP; if (g_surfPosY >= (t_ilm_int) (screenHeight - surfHeight)) { g_surfPosY = screenHeight - surfHeight; g_surfMoveDirection = move_left; } break; case move_left: g_surfPosX -= SURFACE_MOVE_STEP; if (g_surfPosX <= 0) { g_surfPosX = 0; g_surfMoveDirection = move_up; } break; case move_up: g_surfPosY -= SURFACE_MOVE_STEP; if (g_surfPosY <= 0) { g_surfPosY = 0; g_surfMoveDirection = move_right; } break; default: break; } ilm_surfaceSetDestinationRectangle(g_surfaceid, g_surfPosX, g_surfPosY, surfWidth, surfHeight); ilm_commitChanges(); }
static ilmErrorTypes createILMAttribute(t_ilm_layer *pLayerId, t_ilm_surface *pSurfaceId, unsigned int colorkey[]) { ilmErrorTypes error = ILM_FAILED; t_ilm_layer layerid = *pLayerId; t_ilm_surface surfaceid = *pSurfaceId; do { printf("Creating Layer... "); error = ilm_layerCreateWithDimension(&layerid, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); CHECK_ILM_ERROR(error); printf("Setting Layer destination rectangle(0, 0, %d, %d)... \n", g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); error = ilm_layerSetDestinationRectangle(layerid, 0, 0, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); CHECK_ILM_ERROR(error); printf("Setting Layer source rectangle(0, 0, %d, %d)... \n", g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); error = ilm_layerSetSourceRectangle(layerid, 0, 0, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); CHECK_ILM_ERROR(error); printf("Setting Layer visibility(%d)... \n", 1); error = ilm_layerSetVisibility(layerid, ILM_TRUE); CHECK_ILM_ERROR(error); error = ilm_layerSetOpacity(layerid, 1.0f); CHECK_ILM_ERROR(error); struct wl_object* p_obj = (struct wl_object*)g_wlContextStruct.wlSurface; t_ilm_nativehandle native_ilm_handle = (g_wlContextStruct.connect_id << 16) | (uint32_t)p_obj->id; error = ilm_surfaceCreate(native_ilm_handle, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height, ILM_PIXELFORMAT_RGBA_8888, &surfaceid); CHECK_ILM_ERROR(error); printf("set surface dest region\n"); error = ilm_surfaceSetDestinationRectangle(surfaceid, 0, 0, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); CHECK_ILM_ERROR(error); printf("set surface src region\n"); error = ilm_surfaceSetSourceRectangle(surfaceid, 0, 0, g_wlContextStruct.ctx_bmp->width, g_wlContextStruct.ctx_bmp->height); CHECK_ILM_ERROR(error); printf("add surface to layer\n"); error = ilm_layerAddSurface(layerid, surfaceid); CHECK_ILM_ERROR(error); printf("Set surface visible\n"); error = ilm_surfaceSetVisibility(surfaceid, ILM_TRUE); CHECK_ILM_ERROR(error); printf("Set surface opacity\n"); error = ilm_surfaceSetOpacity(surfaceid, 0.7f); CHECK_ILM_ERROR(error); printf("Set surface chromakey\n"); //unsigned int col[3] = {255, 242, 0}; error = ilm_surfaceSetChromaKey(surfaceid, colorkey); CHECK_ILM_ERROR(error); printf("commit\n"); error = ilm_commitChanges(); CHECK_ILM_ERROR(error); } while (0); *pLayerId = layerid; *pSurfaceId = surfaceid; return error; }
int main(int argc, char *argv[]) { ilmErrorTypes result = ILM_FAILED; t_ilm_layer layerid = (t_ilm_layer)LAYER_CHROMAKEY; t_ilm_surface surfaceid = (t_ilm_surface)SURFACE_CHROMAKEY; char* bitmapFile = NULL; int o; static const char opts[] = "f:c:h"; static const struct option longopts[] = { { "file", 1, NULL, 'f' }, { "color", 1, NULL, 'c' }, { "help", 1, NULL, 'h' }, { NULL, } }; unsigned int rgb[] = {255, 255, 255}; /* Default color key is 'White' */ while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) { switch (o) { case 'f': bitmapFile = optarg; break; case 'c': sscanf(optarg, "%d,%d,%d", &rgb[0], &rgb[1], &rgb[2]); break; case 'h': print_usage(); return 0; } } if (bitmapFile == NULL) { print_usage(); return -1; } printf("[INFO] bitmap file = %s\n", bitmapFile); printf("[INFO] color key = R(%d),G(%d),B(%d)\n", rgb[0], rgb[1], rgb[2]); /* signal handling */ signal(SIGINT, sigFunc); signal(SIGKILL, sigFunc); gRun = 1; memset(&g_wlContextStruct, 0x00, sizeof(g_wlContextStruct)); g_wlContextStruct.ctx_bmp = bmpaccessor_open(bitmapFile); if (NULL == g_wlContextStruct.ctx_bmp) { printf("Failed to create bmp accessor\n"); return -1; } do { createWLContext(); result = ilm_init(); if (ILM_SUCCESS == result) { printf("ilm_init success\n"); } else { printf("ilm_init failed\n"); break; } result = createILMAttribute(&layerid, &surfaceid, rgb); if (result != ILM_SUCCESS) { break; } t_ilm_layer layer[] = {1000, 2000, 3000, LAYER_CHROMAKEY}; ilm_displaySetRenderOrder(0, &layer[0], 4); ilm_commitChanges(); while(gRun) { drawImage(); } ilm_surfaceRemove(surfaceid); ilm_layerRemove(layerid); } while(0); ilm_destroy(); destroyWLContext(); bmpaccessor_close(g_wlContextStruct.ctx_bmp); return 0; }
static void unzoomSurface() { ilm_surfaceSetSourceRectangle(g_surfaceid, 0, 0, g_surfWidthOrig, g_surfHeightOrig); ilm_commitChanges(); }
CommandResult ExpressionInterpreter::interpretCommand(string userInput) { CommandResult result = CommandSuccess; string text; stringstream ss; ss << userInput; ExpressionList currentState; currentState.push_back(mpRoot); ExpressionList nextState; while (result == CommandSuccess && !ss.eof()) { ss >> text; transform(text.begin(), text.end(), text.begin(), ::tolower); ExpressionList::const_iterator iter = currentState.begin(); ExpressionList::const_iterator end = currentState.end(); for (; iter != end; ++iter) { Expression* expr = *iter; ExpressionList exprNextList = expr->getNextExpressionClosure(text); nextState.splice(nextState.end(), exprNextList); } if (nextState.size() > 0) { currentState = nextState; nextState.clear(); } else { mErrorText = "'" + text + "' not recognized."; result = CommandInvalid; } } //remove impossible expressions in the final state before checking for ambiguity nextState.clear(); ExpressionList::const_iterator iter = currentState.begin(); ExpressionList::const_iterator end = currentState.end(); for (; iter != end; ++iter) { Expression* expr = *iter; if (expr->isExecutable()) { nextState.push_back(expr); } else { ExpressionList children = expr->getNextExpressions(); bool flag = false; ExpressionList::const_iterator iter = children.begin(); ExpressionList::const_iterator end = children.end(); for (; iter != end; ++iter) { if ((*iter)->getName()[0] == '[') { flag = true; } } if (flag || children.size() == 0) { nextState.push_back(expr); } } } currentState = nextState; if (currentState.size() != 1) { mErrorText = "'" + text + "' ambiguous or incomplete."; result = CommandInvalid; } //run command if executable and non-ambiguous if (result == CommandSuccess) { Expression* expr = *(currentState.begin()); ExpressionList executables = expr->getClosureExecutables(false); if (executables.size() == 1) { ilmErrorTypes initResult = ilm_init(); if (ILM_SUCCESS != initResult) { mErrorText = ILM_ERROR_STRING(initResult); result = CommandExecutionFailed; } else { Expression* exec = executables.front(); exec->execute(); ilm_commitChanges(); ilm_destroy(); } } else if (executables.size() == 0) { mErrorText = "command is incomplete."; result = CommandIncomplete; } else { mErrorText = "command is ambiguous."; result = CommandIncomplete; } } return result; }
t_ilm_bool createEGLContext(t_ilm_int width, t_ilm_int height) { g_eglContextStruct.eglDisplay = NULL; g_eglContextStruct.eglSurface = NULL; g_eglContextStruct.eglContext = NULL; g_eglContextStruct.eglDisplay = eglGetDisplay((EGLNativeDisplayType) g_x11ContextStruct.x11Display); // TODO: remove all C style casts in C++ code; use C++ casts EGLint eglstatus = eglGetError(); if (!g_eglContextStruct.eglDisplay) { printf("Error: eglGetDisplay() failed.\n"); } EGLint iMajorVersion, iMinorVersion; if (!eglInitialize(g_eglContextStruct.eglDisplay, &iMajorVersion, &iMinorVersion)) { printf("Error: eglInitialize() failed.\n"); } eglBindAPI(EGL_OPENGL_ES_API); eglstatus = eglGetError(); if (eglstatus != EGL_SUCCESS) { printf("Error: eglBindAPI() failed.\n"); } EGLint pi32ConfigAttribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_RED_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_NONE }; int iConfigs; if (!eglChooseConfig(g_eglContextStruct.eglDisplay, pi32ConfigAttribs, &g_eglContextStruct.eglConfig, 1, &iConfigs) || (iConfigs != 1)) { printf("Error: eglChooseConfig() failed.\n"); } g_eglContextStruct.eglSurface = eglCreateWindowSurface( g_eglContextStruct.eglDisplay, g_eglContextStruct.eglConfig, (EGLNativeWindowType) g_x11ContextStruct.x11Window, NULL); eglstatus = eglGetError(); if (eglstatus != EGL_SUCCESS) { printf("Error: eglCreateWindowSurface() failed.\n"); // TODO: do not use printf directly here } g_eglContextStruct.eglContext = eglCreateContext( g_eglContextStruct.eglDisplay, g_eglContextStruct.eglConfig, NULL, contextAttribs); eglstatus = eglGetError(); if (eglstatus != EGL_SUCCESS) { printf("Error: eglCreateContext() failed.\n"); } eglMakeCurrent(g_eglContextStruct.eglDisplay, g_eglContextStruct.eglSurface, g_eglContextStruct.eglSurface, g_eglContextStruct.eglContext); eglSwapInterval(g_eglContextStruct.eglDisplay, 1); eglstatus = eglGetError(); if (eglstatus != EGL_SUCCESS) { printf("Error: eglMakeCurrent() failed.\n"); } // register surfaces to layermanager t_ilm_layer layerid = (t_ilm_layer)LAYER_EXAMPLE_GLES_APPLICATIONS; t_ilm_surface surfaceid = (t_ilm_surface)SURFACE_EXAMPLE_EGLX11_APPLICATION; printf("create a surface %lu\n", (t_ilm_nativehandle) g_x11ContextStruct.x11Window); ilm_surfaceCreate( (t_ilm_nativehandle) g_x11ContextStruct.x11Window, width, height, ILM_PIXELFORMAT_RGBA_8888, &surfaceid); printf("set surface dest region\n"); ilm_surfaceSetDestinationRectangle(surfaceid, 0, 0, width, height); printf("set surface src region\n"); ilm_surfaceSetSourceRectangle(surfaceid, 0, 0, width, height); printf("add surface to layer\n"); ilm_layerAddSurface(layerid, surfaceid); printf("Set surface visible\n"); ilm_surfaceSetVisibility(surfaceid, ILM_TRUE); printf("Set surface opacity\n"); ilm_surfaceSetOpacity(surfaceid, 0.75f); printf("commit\n"); return (ILM_SUCCESS == ilm_commitChanges()) ? ILM_TRUE : ILM_FALSE; }