/src/backend/wince/ftk_display_wince_gles.c

http://ftk.googlecode.com/ · C · 569 lines · 482 code · 77 blank · 10 comment · 62 complexity · 85c9adc289f6fe72bb58eb016618a96b MD5 · raw file

  1. #include "ftk_typedef.h"
  2. #include "ftk.h"
  3. #include "ftk_log.h"
  4. #include "ftk_event.h"
  5. #include "ftk_globals.h"
  6. #include "ftk_display_wince.h"
  7. #include "ftk_input_method_manager.h"
  8. #include "ftk_input_method_wince.h"
  9. #include "GLES/egl.h"
  10. #include "GLES/gl.h"
  11. #include <aygshell.h>
  12. #define FTK_EGL_FUNC(ret, func, params) ret (WINAPI *func) params;
  13. #define FTK_GLES_FUNC(ret, func, params) ret (WINAPI *func) params;
  14. #include "ftk_gles_funcs.h"
  15. #undef FTK_EGL_FUNC
  16. #undef FTK_GLES_FUNC
  17. typedef struct _PrivInfo
  18. {
  19. HWND wnd;
  20. HDC dc;
  21. HANDLE egl_dll;
  22. HANDLE gles_dll;
  23. EGLDisplay display;
  24. EGLContext context;
  25. EGLSurface surface;
  26. EGLConfig config;
  27. int width;
  28. int height;
  29. int screen_width;
  30. int screen_height;
  31. void* bits;
  32. FtkEvent event;
  33. }PrivInfo;
  34. static int s_key_map[0xff] = {0};
  35. static wchar_t szClassName[] = L"FtkEmulator";
  36. static Ret ftk_display_wince_gles_get_funcs(PrivInfo* priv)
  37. {
  38. #define FTK_EGL_FUNC(ret, func, params) \
  39. func = (ret (WINAPI *) params)GetProcAddress(priv->egl_dll, L#func); \
  40. if(func == NULL) \
  41. { \
  42. ftk_loge("GetProcAddress(\"%s\") failed\n", #func); \
  43. return RET_FAIL; \
  44. }
  45. #define FTK_GLES_FUNC(ret, func, params) \
  46. func = (ret (WINAPI *) params)GetProcAddress(priv->gles_dll, L#func); \
  47. if(func == NULL) \
  48. { \
  49. ftk_loge("GetProcAddress(\"%s\") failed\n", #func); \
  50. return RET_FAIL; \
  51. }
  52. #include "ftk_gles_funcs.h"
  53. #undef FTK_EGL_FUNC
  54. #undef FTK_GLES_FUNC
  55. return RET_OK;
  56. }
  57. static void ftk_display_wince_gles_set_fullscreen(PrivInfo* priv)
  58. {
  59. SHFullScreen(priv->wnd, SHFS_HIDESIPBUTTON|SHFS_HIDETASKBAR|SHFS_HIDESTARTICON);
  60. SetWindowPos(priv->wnd, HWND_TOPMOST, 0, 0, priv->screen_width, priv->screen_height, SWP_NOOWNERZORDER|SWP_SHOWWINDOW);
  61. }
  62. static void ftk_display_wince_gles_keymap_init(void)
  63. {
  64. s_key_map[0xBD] = FTK_KEY_MINUS;
  65. s_key_map[0x20] = FTK_KEY_SPACE;
  66. s_key_map[0xBB] = FTK_KEY_EQUAL;
  67. s_key_map[0x08] = FTK_KEY_BACKSPACE;
  68. s_key_map[0x09] = FTK_KEY_TAB;
  69. s_key_map[0xC0] = FTK_KEY_QUOTELEFT;
  70. s_key_map[0xDE] = FTK_KEY_QUOTERIGHT;
  71. s_key_map[0xDB] = FTK_KEY_BRACKETLEFT;
  72. s_key_map[0xDD] = FTK_KEY_BRACKETRIGHT;
  73. s_key_map[0x0d] = FTK_KEY_ENTER;
  74. s_key_map[0xBA] = FTK_KEY_SEMICOLON;
  75. s_key_map[0x30] = FTK_KEY_0;
  76. s_key_map[0x31] = FTK_KEY_1;
  77. s_key_map[0x32] = FTK_KEY_2;
  78. s_key_map[0x33] = FTK_KEY_3;
  79. s_key_map[0x34] = FTK_KEY_4;
  80. s_key_map[0x35] = FTK_KEY_5;
  81. s_key_map[0x36] = FTK_KEY_6;
  82. s_key_map[0x37] = FTK_KEY_7;
  83. s_key_map[0x38] = FTK_KEY_8;
  84. s_key_map[0x39] = FTK_KEY_9;
  85. s_key_map[0x70] = FTK_KEY_F1;
  86. s_key_map[0x71] = FTK_KEY_F2;
  87. s_key_map[0x72] = FTK_KEY_F3;
  88. s_key_map[0x73] = FTK_KEY_F4;
  89. s_key_map[0x74] = FTK_KEY_F5;
  90. s_key_map[0x75] = FTK_KEY_F6;
  91. s_key_map[0x76] = FTK_KEY_F7;
  92. s_key_map[0x77] = FTK_KEY_F8;
  93. s_key_map[0x78] = FTK_KEY_F9;
  94. s_key_map[0xBC] = FTK_KEY_COMMA;
  95. s_key_map[0xBE] = FTK_KEY_DOT;
  96. s_key_map[0xBF] = FTK_KEY_SLASH;
  97. s_key_map[0x10] = FTK_KEY_RIGHTSHIFT;
  98. s_key_map[0x11] = FTK_KEY_LEFTCTRL;
  99. s_key_map[0x14] = FTK_KEY_CAPSLOCK;
  100. s_key_map[0x40] = FTK_KEY_LEFTALT;
  101. s_key_map[0x41] = FTK_KEY_a;
  102. s_key_map[0x42] = FTK_KEY_b;
  103. s_key_map[0x43] = FTK_KEY_c;
  104. s_key_map[0x44] = FTK_KEY_d;
  105. s_key_map[0x45] = FTK_KEY_e;
  106. s_key_map[0x46] = FTK_KEY_f;
  107. s_key_map[0x47] = FTK_KEY_g;
  108. s_key_map[0x48] = FTK_KEY_h;
  109. s_key_map[0x49] = FTK_KEY_i;
  110. s_key_map[0x4a] = FTK_KEY_j;
  111. s_key_map[0x4b] = FTK_KEY_k;
  112. s_key_map[0x4c] = FTK_KEY_l;
  113. s_key_map[0x4d] = FTK_KEY_m;
  114. s_key_map[0x4e] = FTK_KEY_n;
  115. s_key_map[0x4f] = FTK_KEY_o;
  116. s_key_map[0x50] = FTK_KEY_p;
  117. s_key_map[0x51] = FTK_KEY_q;
  118. s_key_map[0x52] = FTK_KEY_r;
  119. s_key_map[0x53] = FTK_KEY_s;
  120. s_key_map[0x54] = FTK_KEY_t;
  121. s_key_map[0x55] = FTK_KEY_u;
  122. s_key_map[0x56] = FTK_KEY_v;
  123. s_key_map[0x57] = FTK_KEY_w;
  124. s_key_map[0x58] = FTK_KEY_x;
  125. s_key_map[0x59] = FTK_KEY_y;
  126. s_key_map[0x5a] = FTK_KEY_z;
  127. s_key_map[0x21] = FTK_KEY_PAGEUP;
  128. s_key_map[0x25] = FTK_KEY_LEFT;
  129. s_key_map[0x27] = FTK_KEY_RIGHT;
  130. s_key_map[0x24] = FTK_KEY_HOME;
  131. s_key_map[0x23] = FTK_KEY_END;
  132. s_key_map[0x28] = FTK_KEY_DOWN;
  133. s_key_map[0x22] = FTK_KEY_PAGEDOWN;
  134. s_key_map[0x2d] = FTK_KEY_INSERT;
  135. s_key_map[0x2e] = FTK_KEY_DELETE;
  136. s_key_map[0x26] = FTK_KEY_UP;
  137. }
  138. static char* ftk_display_wince_gles_on_ime(HWND hwnd, LPARAM lParam)
  139. {
  140. LONG n;
  141. wchar_t* unicode;
  142. char* utf8;
  143. HIMC himc;
  144. FtkInputMethod* im = NULL;
  145. if(!(lParam & GCS_RESULTSTR))
  146. {
  147. return NULL;
  148. }
  149. if(ftk_input_method_manager_get_current(ftk_default_input_method_manager(), &im) == RET_FAIL || im == NULL)
  150. {
  151. return NULL;
  152. }
  153. if(ftk_input_method_wince_get_editor(im) == NULL)
  154. {
  155. return NULL;
  156. }
  157. himc = ImmGetContext(hwnd);
  158. if((void*)himc == NULL)
  159. {
  160. return NULL;
  161. }
  162. n = ImmGetCompositionStringW(himc, GCS_RESULTSTR, NULL, 0);
  163. if(n <= 0)
  164. {
  165. ImmReleaseContext(hwnd, himc);
  166. return NULL;
  167. }
  168. unicode = (wchar_t*)FTK_ALLOC(n + 2);
  169. if(unicode == NULL)
  170. {
  171. ImmReleaseContext(hwnd, himc);
  172. return NULL;
  173. }
  174. if(ImmGetCompositionStringW(himc, GCS_RESULTSTR, unicode, n) != n)
  175. {
  176. FTK_FREE(unicode);
  177. ImmReleaseContext(hwnd, himc);
  178. return NULL;
  179. }
  180. ImmReleaseContext(hwnd, himc);
  181. ftk_logd("%s:%d WM_IME_COMPOSITION:%s\n", __FILE__, __LINE__, unicode);
  182. unicode[n / 2] = L'\0';
  183. ftk_logd("%s:%d WM_IME_COMPOSITION:%s\n", __FILE__, __LINE__, unicode);
  184. n = WideCharToMultiByte(CP_UTF8, 0, unicode, -1, NULL, 0, NULL, NULL);
  185. if(n < 1)
  186. {
  187. FTK_FREE(unicode);
  188. return NULL;
  189. }
  190. utf8 = (char*) FTK_ALLOC(n);
  191. if(utf8 == NULL)
  192. {
  193. FTK_FREE(unicode);
  194. return NULL;
  195. }
  196. n = WideCharToMultiByte(CP_UTF8, 0, unicode, -1, utf8, n, NULL, NULL);
  197. if(n < 1)
  198. {
  199. FTK_FREE(unicode);
  200. FTK_FREE(utf8);
  201. return NULL;
  202. }
  203. FTK_FREE(unicode);
  204. ftk_logd("%s:%d WM_IME_COMPOSITION:%s\n", __FILE__, __LINE__, utf8);
  205. return utf8;
  206. }
  207. static void ftk_display_wince_gles_on_paint(PrivInfo* priv)
  208. {
  209. GLfloat coordinates[] = { 0, priv->screen_height / (float)priv->height,
  210. priv->screen_width / (float)priv->width, priv->screen_height / (float)priv->height,
  211. 0, 0,
  212. priv->screen_width / (float)priv->width, 0 };
  213. GLfloat vertices[] = {
  214. 0.0f, 0.0f, 0.0,
  215. 0.0f + priv->screen_width, 0.0f, 0.0,
  216. 0.0f, 0.0f + priv->screen_height, 0.0,
  217. 0.0f + priv->screen_width, 0.0f + priv->screen_height, 0.0 };
  218. glClear(GL_COLOR_BUFFER_BIT);
  219. glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
  220. glBindTexture(GL_TEXTURE_2D, 0);
  221. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  222. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, priv->width, priv->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, priv->bits);
  223. glVertexPointer(3, GL_FLOAT, 0, vertices);
  224. glTexCoordPointer(2, GL_FLOAT, 0, coordinates);
  225. glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  226. //eglWaitNative(EGL_NATIVE_RENDERABLE);
  227. //eglWaitGL();
  228. eglSwapBuffers(priv->display, priv->surface);
  229. }
  230. static LRESULT CALLBACK WinProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  231. {
  232. char* buf = NULL;
  233. HDC dc;
  234. PAINTSTRUCT ps;
  235. PrivInfo* priv = (PrivInfo*)GetWindowLongW(hwnd, GWL_USERDATA);
  236. switch(message)
  237. {
  238. case WM_DESTROY:
  239. PostQuitMessage(0);
  240. FTK_QUIT();
  241. break;
  242. //case WM_ACTIVATE:
  243. // set_fullscreen(priv);
  244. // break;
  245. case WM_PAINT:
  246. dc = BeginPaint(hwnd, &ps);
  247. EndPaint(hwnd, &ps);
  248. if(priv != NULL)
  249. {
  250. ftk_display_wince_gles_on_paint(priv);
  251. }
  252. break;
  253. case WM_KEYDOWN:
  254. case WM_KEYUP:
  255. priv->event.type = message == WM_KEYDOWN ? FTK_EVT_KEY_DOWN : FTK_EVT_KEY_UP;
  256. priv->event.u.key.code = s_key_map[0xFF & wParam];
  257. break;
  258. case WM_LBUTTONUP:
  259. case WM_LBUTTONDOWN:
  260. priv->event.u.mouse.x = LOWORD(lParam);
  261. priv->event.u.mouse.y = HIWORD(lParam);
  262. priv->event.type = message == WM_LBUTTONUP? FTK_EVT_MOUSE_UP : FTK_EVT_MOUSE_DOWN;
  263. break;
  264. case WM_MOUSEMOVE:
  265. priv->event.u.mouse.x = LOWORD(lParam);
  266. priv->event.u.mouse.y = HIWORD(lParam);
  267. priv->event.type = FTK_EVT_MOUSE_MOVE;
  268. break;
  269. case WM_IME_COMPOSITION:
  270. buf = ftk_display_wince_gles_on_ime(hwnd, lParam);
  271. if(buf == NULL)
  272. {
  273. return DefWindowProcW(hwnd, message, wParam, lParam);
  274. }
  275. priv->event.u.extra = buf;
  276. priv->event.type = FTK_EVT_OS_IM_COMMIT;
  277. break;
  278. default:
  279. return DefWindowProcW(hwnd, message, wParam, lParam);
  280. }
  281. if(priv->event.type != FTK_EVT_NOP)
  282. {
  283. ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &priv->event);
  284. priv->event.type = FTK_EVT_NOP;
  285. }
  286. return 0;
  287. }
  288. static HWND ftk_display_wince_gles_create_win(PrivInfo* priv)
  289. {
  290. HWND hwnd;
  291. WNDCLASSW wincl;
  292. wincl.hInstance = NULL;
  293. wincl.lpszClassName = szClassName;
  294. wincl.lpfnWndProc = WinProc;
  295. wincl.style = CS_DBLCLKS;
  296. wincl.hIcon = NULL;
  297. wincl.hCursor = LoadCursorW(NULL, IDC_ARROW);
  298. wincl.lpszMenuName = NULL;
  299. wincl.cbClsExtra = 0;
  300. wincl.cbWndExtra = 64;
  301. wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  302. if (!RegisterClassW(&wincl))
  303. {
  304. return NULL;
  305. }
  306. hwnd = CreateWindowExW(0, szClassName, L"FtkEmulator", WS_DLGFRAME,
  307. CW_USEDEFAULT, CW_USEDEFAULT, priv->width, priv->height,
  308. HWND_DESKTOP, NULL, NULL, NULL);
  309. return hwnd;
  310. }
  311. static Ret ftk_display_wince_gles_update(FtkDisplay* thiz, FtkBitmap* bitmap, FtkRect* rect, int xoffset, int yoffset)
  312. {
  313. Ret ret = RET_OK;
  314. DECL_PRIV(thiz, priv);
  315. ret = ftk_bitmap_copy_to_data_rgba32(bitmap, rect, priv->bits, xoffset, yoffset, priv->width, priv->height);
  316. ftk_display_wince_gles_on_paint(priv);
  317. return ret;
  318. }
  319. static int ftk_display_wince_gles_width(FtkDisplay* thiz)
  320. {
  321. DECL_PRIV(thiz, priv);
  322. return_val_if_fail(priv != NULL, 0);
  323. return priv->screen_width;
  324. }
  325. static int ftk_display_wince_gles_height(FtkDisplay* thiz)
  326. {
  327. DECL_PRIV(thiz, priv);
  328. return_val_if_fail(priv != NULL, 0);
  329. return priv->screen_height;
  330. }
  331. static Ret ftk_display_wince_gles_snap(FtkDisplay* thiz, FtkRect* r, FtkBitmap* bitmap)
  332. {
  333. #if 0
  334. FtkRect rect = {0};
  335. DECL_PRIV(thiz, priv);
  336. int w = ftk_display_width(thiz);
  337. int h = ftk_display_height(thiz);
  338. int bw = ftk_bitmap_width(bitmap);
  339. int bh = ftk_bitmap_height(bitmap);
  340. rect.x = r->x;
  341. rect.y = r->y;
  342. rect.width = FTK_MIN(bw, r->width);
  343. rect.height = FTK_MIN(bh, r->height);
  344. return ftk_bitmap_copy_from_data_bgra32(bitmap, priv->bits, w, h, &rect);
  345. #else
  346. //DECL_PRIV(thiz, priv);
  347. /*TODO*/
  348. /*snap_bitmap(priv, bitmap, r->x, r->y, r->width, r->height);*/
  349. return RET_OK;
  350. #endif
  351. }
  352. static void ftk_display_wince_gles_destroy(FtkDisplay* thiz)
  353. {
  354. if(thiz != NULL)
  355. {
  356. DECL_PRIV(thiz, priv);
  357. eglMakeCurrent(priv->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
  358. eglDestroySurface(priv->display, priv->surface);
  359. eglDestroyContext(priv->display, priv->context);
  360. eglTerminate(priv->display);
  361. FreeLibrary(priv->egl_dll);
  362. FreeLibrary(priv->gles_dll);
  363. ReleaseDC(priv->wnd, priv->dc);
  364. FTK_FREE(priv->bits);
  365. FTK_ZFREE(thiz, sizeof(FtkDisplay) + sizeof(PrivInfo));
  366. }
  367. }
  368. FtkDisplay* ftk_display_wince_create(void)
  369. {
  370. EGLint i, n, attrs[64];
  371. EGLint major = 0;
  372. EGLint minor = 0;
  373. FtkDisplay* thiz;
  374. thiz = (FtkDisplay*)FTK_ZALLOC(sizeof(FtkDisplay) + sizeof(PrivInfo));
  375. if(thiz != NULL)
  376. {
  377. DECL_PRIV(thiz, priv);
  378. thiz->update = ftk_display_wince_gles_update;
  379. thiz->snap = ftk_display_wince_gles_snap;
  380. thiz->width = ftk_display_wince_gles_width;
  381. thiz->height = ftk_display_wince_gles_height;
  382. thiz->destroy = ftk_display_wince_gles_destroy;
  383. #if 0
  384. priv->egl_dll = LoadLibraryW(L"/Windows/libEGL.dll");
  385. if(priv->egl_dll == NULL)
  386. {
  387. ftk_loge("%s: LoadLibrary(\"libEGL.dll\") failed (%d)\n", __func__, GetLastError());
  388. return NULL;
  389. }
  390. #endif
  391. priv->gles_dll = LoadLibraryW(L"/Windows/libGLESv1_CM.dll");
  392. if(priv->gles_dll == NULL)
  393. {
  394. ftk_loge("%s: LoadLibrary(\"libGLESv1_CM.dll\") failed (%d)\n", __func__, GetLastError());
  395. return NULL;
  396. }
  397. #if 1
  398. priv->egl_dll = priv->gles_dll;
  399. #endif
  400. if(ftk_display_wince_gles_get_funcs(priv) != RET_OK)
  401. {
  402. return NULL;
  403. }
  404. priv->screen_width = GetSystemMetrics(SM_CXSCREEN);
  405. priv->screen_height = GetSystemMetrics(SM_CYSCREEN);
  406. priv->width = 512;
  407. priv->height = 512;
  408. priv->bits = FTK_ZALLOC(priv->width * priv->height * 4);
  409. if(priv->bits == NULL)
  410. {
  411. ftk_loge("%s: FTK_ZALLOC() failed\n", __func__);
  412. return NULL;
  413. }
  414. priv->wnd = ftk_display_wince_gles_create_win(priv);
  415. if(priv->wnd == NULL)
  416. {
  417. ftk_loge("%s: ftk_display_wince_gles_create_win() failed\n", __func__);
  418. FTK_FREE(priv->bits);
  419. return NULL;
  420. }
  421. priv->dc = GetDC(priv->wnd);
  422. priv->display = eglGetDisplay((NativeDisplayType)priv->dc);
  423. if(priv->display == EGL_NO_DISPLAY)
  424. {
  425. ftk_loge("%s:%d eglGetDisplay() failed\n", __FILE__, __LINE__);
  426. return NULL;
  427. }
  428. if(eglInitialize(priv->display, &major, &minor) != EGL_TRUE)
  429. {
  430. ftk_loge("%s:%d eglInitialize() failed\n", __FILE__, __LINE__);
  431. return NULL;
  432. }
  433. i = 0;
  434. attrs[i++] = EGL_RED_SIZE;
  435. attrs[i++] = 8;
  436. attrs[i++] = EGL_GREEN_SIZE;
  437. attrs[i++] = 8;
  438. attrs[i++] = EGL_BLUE_SIZE;
  439. attrs[i++] = 8;
  440. attrs[i++] = EGL_ALPHA_SIZE;
  441. attrs[i++] = EGL_DONT_CARE;
  442. attrs[i++] = EGL_SURFACE_TYPE;
  443. attrs[i++] = EGL_WINDOW_BIT;
  444. attrs[i++] = EGL_DEPTH_SIZE;
  445. attrs[i++] = 16;
  446. attrs[i++] = EGL_STENCIL_SIZE;
  447. attrs[i++] = EGL_DONT_CARE;
  448. attrs[i] = EGL_NONE;
  449. n = 0;
  450. if(eglChooseConfig(priv->display, attrs, &priv->config, 1, &n) != EGL_TRUE || n == 0)
  451. {
  452. ftk_loge("%s:%d eglChooseConfig() failed\n", __FILE__, __LINE__);
  453. return NULL;
  454. }
  455. priv->surface = eglCreateWindowSurface(priv->display, priv->config, priv->wnd, NULL);
  456. if(priv->surface == EGL_NO_SURFACE)
  457. {
  458. ftk_loge("%s:%d eglCreateWindowSurface() failed\n", __FILE__, __LINE__);
  459. return NULL;
  460. }
  461. priv->context = eglCreateContext(priv->display, priv->config, EGL_NO_CONTEXT, NULL);
  462. if(priv->context == EGL_NO_CONTEXT)
  463. {
  464. ftk_loge("%s:%d eglCreateContext() failed\n", __FILE__, __LINE__);
  465. return NULL;
  466. }
  467. if(eglMakeCurrent(priv->display, priv->surface, priv->surface, priv->context) != EGL_TRUE)
  468. {
  469. ftk_loge("%s:%d eglMakeCurrent() failed\n", __FILE__, __LINE__);
  470. return NULL;
  471. }
  472. glViewport(0, 0, priv->screen_width, priv->screen_height);
  473. glMatrixMode(GL_PROJECTION);
  474. glLoadIdentity();
  475. glOrthof(0, (float)priv->screen_width, 0, (float)priv->screen_height, 0, 100);
  476. glMatrixMode(GL_MODELVIEW);
  477. glLoadIdentity();
  478. glEnable(GL_TEXTURE_2D);
  479. glEnable(GL_BLEND);
  480. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  481. glEnableClientState (GL_VERTEX_ARRAY);
  482. glEnableClientState (GL_TEXTURE_COORD_ARRAY);
  483. glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  484. //ftk_logd("%s:%d %s\n", __FILE__, __LINE__, glGetString(GL_EXTENSIONS));
  485. ftk_display_wince_gles_keymap_init();
  486. SetWindowLongW(priv->wnd, GWL_USERDATA, (LONG)priv);
  487. ShowWindow(priv->wnd, SW_SHOW);
  488. //UpdateWindow(priv->wnd);
  489. ftk_display_wince_gles_set_fullscreen(priv);
  490. }
  491. return thiz;
  492. }