rtgui_system.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807
  1. /*
  2. * File : rtgui_system.c
  3. * This file is part of RTGUI in RT-Thread RTOS
  4. * COPYRIGHT (C) 2006 - 2009, RT-Thread Development Team
  5. *
  6. * The license and distribution terms for this file may be
  7. * found in the file LICENSE in this distribution or at
  8. * http://www.rt-thread.org/license/LICENSE
  9. *
  10. * Change Logs:
  11. * Date Author Notes
  12. * 2009-10-04 Bernard first version
  13. * 2016-03-23 Bernard fix the default font initialization issue.
  14. */
  15. #include <rtgui/rtgui.h>
  16. #include <rtgui/image.h>
  17. #include <rtgui/font.h>
  18. #include <rtgui/event.h>
  19. #include <rtgui/rtgui_app.h>
  20. #include <rtgui/rtgui_server.h>
  21. #include <rtgui/rtgui_system.h>
  22. #include <rtgui/widgets/window.h>
  23. #ifdef _WIN32_NATIVE
  24. #define RTGUI_MEM_TRACE
  25. #endif
  26. const rtgui_color_t default_foreground = RTGUI_RGB(0x00, 0x00, 0x00);
  27. const rtgui_color_t default_background = RTGUI_RGB(212, 208, 200);
  28. extern struct rtgui_font rtgui_font_asc16;
  29. extern struct rtgui_font rtgui_font_asc12;
  30. static rtgui_rect_t _mainwin_rect;
  31. static struct rt_mutex _screen_lock;
  32. int rtgui_system_server_init(void)
  33. {
  34. rt_mutex_init(&_screen_lock, "screen", RT_IPC_FLAG_FIFO);
  35. /* init image */
  36. rtgui_system_image_init();
  37. /* init font */
  38. rtgui_font_system_init();
  39. /* init rtgui server */
  40. rtgui_topwin_init();
  41. rtgui_server_init();
  42. /* use driver rect for main window */
  43. rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &_mainwin_rect);
  44. /* set the default font */
  45. #if RTGUI_DEFAULT_FONT_SIZE == 16
  46. rtgui_font_set_defaut(&rtgui_font_asc16);
  47. #elif RTGUI_DEFAULT_FONT_SIZE == 12
  48. rtgui_font_set_defaut(&rtgui_font_asc12);
  49. #else
  50. rtgui_font_set_defaut(&rtgui_font_asc12);
  51. #endif
  52. return 0;
  53. }
  54. INIT_APP_EXPORT(rtgui_system_server_init);
  55. /************************************************************************/
  56. /* RTGUI Timer */
  57. /************************************************************************/
  58. static void rtgui_time_out(void *parameter)
  59. {
  60. rtgui_timer_t *timer;
  61. rtgui_event_timer_t event;
  62. timer = (rtgui_timer_t *)parameter;
  63. if (!(timer->state == RTGUI_TIMER_ST_RUNNING))
  64. return;
  65. /*
  66. * Note: event_timer can not use RTGUI_EVENT_TIMER_INIT to init, for there is no
  67. * thread context
  68. */
  69. event.parent.type = RTGUI_EVENT_TIMER;
  70. event.parent.sender = RT_NULL;
  71. event.timer = timer;
  72. timer->pending_cnt++;
  73. rtgui_send(timer->app, &(event.parent), sizeof(rtgui_event_timer_t));
  74. }
  75. rtgui_timer_t *rtgui_timer_create(rt_int32_t time, rt_int32_t flag, rtgui_timeout_func timeout, void *parameter)
  76. {
  77. rtgui_timer_t *timer;
  78. timer = (rtgui_timer_t *) rtgui_malloc(sizeof(rtgui_timer_t));
  79. timer->app = rtgui_app_self();
  80. timer->timeout = timeout;
  81. timer->pending_cnt = 0;
  82. timer->state = RTGUI_TIMER_ST_INIT;
  83. timer->user_data = parameter;
  84. /* init rt-thread timer */
  85. rt_timer_init(&(timer->timer), "rtgui", rtgui_time_out, timer, time, (rt_uint8_t)flag);
  86. return timer;
  87. }
  88. RTM_EXPORT(rtgui_timer_create);
  89. void rtgui_timer_destory(rtgui_timer_t *timer)
  90. {
  91. RT_ASSERT(timer != RT_NULL);
  92. /* stop timer firstly */
  93. rtgui_timer_stop(timer);
  94. if (timer->pending_cnt != 0 && timer->app->ref_count != 0)
  95. {
  96. timer->state = RTGUI_TIMER_ST_DESTROY_PENDING;
  97. }
  98. else
  99. {
  100. /* detach rt-thread timer */
  101. rt_timer_detach(&(timer->timer));
  102. rtgui_free(timer);
  103. }
  104. }
  105. RTM_EXPORT(rtgui_timer_destory);
  106. void rtgui_timer_set_timeout(rtgui_timer_t *timer, rt_int32_t time)
  107. {
  108. RT_ASSERT(timer != RT_NULL);
  109. /* start rt-thread timer */
  110. if (timer->state == RTGUI_TIMER_ST_RUNNING)
  111. {
  112. rtgui_timer_stop(timer);
  113. rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_TIME, &time);
  114. rtgui_timer_start(timer);
  115. }
  116. else
  117. {
  118. rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_TIME, &time);
  119. }
  120. }
  121. RTM_EXPORT(rtgui_timer_set_timeout);
  122. void rtgui_timer_start(rtgui_timer_t *timer)
  123. {
  124. RT_ASSERT(timer != RT_NULL);
  125. /* start rt-thread timer */
  126. timer->state = RTGUI_TIMER_ST_RUNNING;
  127. rt_timer_start(&(timer->timer));
  128. }
  129. RTM_EXPORT(rtgui_timer_start);
  130. void rtgui_timer_stop(rtgui_timer_t *timer)
  131. {
  132. RT_ASSERT(timer != RT_NULL);
  133. /* stop rt-thread timer */
  134. timer->state = RTGUI_TIMER_ST_INIT;
  135. rt_timer_stop(&(timer->timer));
  136. }
  137. RTM_EXPORT(rtgui_timer_stop);
  138. /************************************************************************/
  139. /* RTGUI Memory Management */
  140. /************************************************************************/
  141. #ifdef RTGUI_MEM_TRACE
  142. struct rtgui_mem_info
  143. {
  144. rt_uint32_t allocated_size;
  145. rt_uint32_t max_allocated;
  146. };
  147. struct rtgui_mem_info mem_info;
  148. #define MEMTRACE_MAX 4096
  149. #define MEMTRACE_HASH_SIZE 256
  150. struct rti_memtrace_item
  151. {
  152. void *mb_ptr; /* memory block pointer */
  153. rt_uint32_t mb_len; /* memory block length */
  154. struct rti_memtrace_item *next;
  155. };
  156. struct rti_memtrace_item trace_list[MEMTRACE_MAX];
  157. struct rti_memtrace_item *item_hash[MEMTRACE_HASH_SIZE];
  158. struct rti_memtrace_item *item_free;
  159. rt_bool_t rti_memtrace_inited = 0;
  160. void rti_memtrace_init()
  161. {
  162. struct rti_memtrace_item *item;
  163. rt_uint32_t index;
  164. rt_memset(trace_list, 0, sizeof(trace_list));
  165. rt_memset(item_hash, 0, sizeof(item_hash));
  166. item_free = &trace_list[0];
  167. item = &trace_list[0];
  168. for (index = 1; index < MEMTRACE_HASH_SIZE; index ++)
  169. {
  170. item->next = &trace_list[index];
  171. item = item->next;
  172. }
  173. item->next = RT_NULL;
  174. }
  175. void rti_malloc_hook(void *ptr, rt_uint32_t len)
  176. {
  177. rt_uint32_t index;
  178. struct rti_memtrace_item *item;
  179. if (item_free == RT_NULL) return;
  180. mem_info.allocated_size += len;
  181. if (mem_info.max_allocated < mem_info.allocated_size)
  182. mem_info.max_allocated = mem_info.allocated_size;
  183. /* lock context */
  184. item = item_free;
  185. item_free = item->next;
  186. item->mb_ptr = ptr;
  187. item->mb_len = len;
  188. item->next = RT_NULL;
  189. /* get hash item index */
  190. index = ((rt_uint32_t)ptr) % MEMTRACE_HASH_SIZE;
  191. if (item_hash[index] != RT_NULL)
  192. {
  193. /* add to list */
  194. item->next = item_hash[index];
  195. item_hash[index] = item;
  196. }
  197. else
  198. {
  199. /* set list header */
  200. item_hash[index] = item;
  201. }
  202. /* unlock context */
  203. }
  204. void rti_free_hook(void *ptr)
  205. {
  206. rt_uint32_t index;
  207. struct rti_memtrace_item *item;
  208. /* get hash item index */
  209. index = ((rt_uint32_t)ptr) % MEMTRACE_HASH_SIZE;
  210. if (item_hash[index] != RT_NULL)
  211. {
  212. item = item_hash[index];
  213. if (item->mb_ptr == ptr)
  214. {
  215. /* delete item from list */
  216. item_hash[index] = item->next;
  217. }
  218. else
  219. {
  220. /* find ptr in list */
  221. while (item->next != RT_NULL && item->next->mb_ptr != ptr)
  222. item = item->next;
  223. /* delete item from list */
  224. if (item->next != RT_NULL)
  225. {
  226. struct rti_memtrace_item *i;
  227. i = item->next;
  228. item->next = item->next->next;
  229. item = i;
  230. }
  231. else
  232. {
  233. /* not found */
  234. return;
  235. }
  236. }
  237. /* reduce allocated size */
  238. mem_info.allocated_size -= item->mb_len;
  239. /* clear item */
  240. rt_memset(item, 0, sizeof(struct rti_memtrace_item));
  241. /* add item to the free list */
  242. item->next = item_free;
  243. item_free = item;
  244. }
  245. }
  246. #endif
  247. //#define DEBUG_MEMLEAK
  248. #undef rtgui_malloc
  249. void *rtgui_malloc(rt_size_t size)
  250. {
  251. void *ptr;
  252. ptr = rt_malloc(size);
  253. #ifdef RTGUI_MEM_TRACE
  254. if (rti_memtrace_inited == 0)
  255. {
  256. rti_memtrace_init();
  257. rti_memtrace_inited = 1;
  258. }
  259. if (ptr != RT_NULL)
  260. rti_malloc_hook(ptr, size);
  261. #endif
  262. #ifdef DEBUG_MEMLEAK
  263. rt_kprintf("alloc %p (%d) on %p %.*s\n",
  264. ptr, size, __builtin_return_address(0),
  265. RT_NAME_MAX, rt_thread_self()->name);
  266. #endif
  267. return ptr;
  268. }
  269. RTM_EXPORT(rtgui_malloc);
  270. #undef rtgui_realloc
  271. void *rtgui_realloc(void *ptr, rt_size_t size)
  272. {
  273. void *new_ptr;
  274. #ifdef RTGUI_MEM_TRACE
  275. new_ptr = rtgui_malloc(size);
  276. if ((new_ptr != RT_NULL) && (ptr != RT_NULL))
  277. {
  278. rt_memcpy(new_ptr, ptr, size);
  279. rtgui_free(ptr);
  280. }
  281. #else
  282. new_ptr = rt_realloc(ptr, size);
  283. #endif
  284. #ifdef DEBUG_MEMLEAK
  285. rt_kprintf("realloc %p to %p (%d) on %p %*.s\n",
  286. ptr, new_ptr, size, __builtin_return_address(0),
  287. RT_NAME_MAX, rt_thread_self()->name);
  288. #endif
  289. return new_ptr;
  290. }
  291. RTM_EXPORT(rtgui_realloc);
  292. #undef rtgui_free
  293. void rtgui_free(void *ptr)
  294. {
  295. #ifdef DEBUG_MEMLEAK
  296. rt_kprintf("dealloc %p on %p\n",
  297. ptr, __builtin_return_address(0));
  298. #endif
  299. #ifdef RTGUI_MEM_TRACE
  300. if (ptr != RT_NULL)
  301. rti_free_hook(ptr);
  302. #endif
  303. rt_free(ptr);
  304. }
  305. RTM_EXPORT(rtgui_free);
  306. #if defined(RTGUI_MEM_TRACE) && defined(RT_USING_FINSH)
  307. #include <finsh.h>
  308. void list_guimem(void)
  309. {
  310. rt_kprintf("Current Used: %d, Maximal Used: %d\n", mem_info.allocated_size, mem_info.max_allocated);
  311. }
  312. FINSH_FUNCTION_EXPORT(list_guimem, display memory information);
  313. #endif
  314. /************************************************************************/
  315. /* RTGUI Event Dump */
  316. /************************************************************************/
  317. // #define RTGUI_EVENT_DEBUG
  318. #ifdef RTGUI_EVENT_DEBUG
  319. const char *rtgui_event_string[] =
  320. {
  321. /* application event */
  322. "APP_CREATE", /* create an application */
  323. "APP_DESTROY", /* destroy an application */
  324. "APP_ACTIVATE", /* activate an application */
  325. /* window event */
  326. "WIN_CREATE", /* create a window */
  327. "WIN_DESTROY", /* destroy a window */
  328. "WIN_SHOW", /* show a window */
  329. "WIN_HIDE", /* hide a window */
  330. "WIN_ACTIVATE", /* activate a window */
  331. "WIN_DEACTIVATE", /* deactivate a window */
  332. "WIN_CLOSE", /* close a window */
  333. "WIN_MOVE", /* move a window */
  334. "WIN_RESIZE", /* resize a window */
  335. "WIN_MODAL_ENTER", /* a window modals */
  336. "SET_WM", /* set window manager */
  337. "UPDATE_BEGIN", /* begin of update rect */
  338. "UPDATE_END", /* end of update rect */
  339. "MONITOR_ADD", /* add a monitor rect */
  340. "MONITOR_REMOVE", /* remove a monitor rect*/
  341. "SHOW", /* the widget is going to be shown */
  342. "HIDE", /* the widget is going to be hidden */
  343. "PAINT", /* paint on screen */
  344. "TIMER", /* timer */
  345. "UPDATE_TOPLVL", /* update toplevel */
  346. "VPAINT_REQ", /* virtual paint request */
  347. /* clip rect information */
  348. "CLIP_INFO", /* clip rect info */
  349. /* mouse and keyboard event */
  350. "MOUSE_MOTION", /* mouse motion */
  351. "MOUSE_BUTTON", /* mouse button info */
  352. "KBD", /* keyboard info */
  353. "TOUCH", /* touch info */
  354. "GESTURE", /* gesture */
  355. "FOCUSED", /* widget got focuse */
  356. "SCROLLED", /* scroll bar scrolled */
  357. "RESIZE", /* widget resize */
  358. "SELECTED", /* widget selected */
  359. "UNSELECTED", /* widget unselected */
  360. "MV_MODEL", /* modal chaned in MV */
  361. "BUS_NOTIFY_EVENT",
  362. };
  363. #define DBG_MSG(x) rt_kprintf x
  364. static void rtgui_event_dump(struct rtgui_app* app, rtgui_event_t *event)
  365. {
  366. char *sender = "(unknown)";
  367. if ((event->type == RTGUI_EVENT_TIMER) ||
  368. (event->type == RTGUI_EVENT_UPDATE_BEGIN) ||
  369. (event->type == RTGUI_EVENT_MOUSE_MOTION) ||
  370. (event->type == RTGUI_EVENT_UPDATE_END))
  371. {
  372. /* don't dump timer event */
  373. return ;
  374. }
  375. if (event->sender != RT_NULL)
  376. sender = (char*)event->sender->name;
  377. if (event->type >= RTGUI_EVENT_COMMAND)
  378. {
  379. rt_kprintf("%s -- USER COMMAND EVENT --> %s \n", sender, app->name);
  380. return ;
  381. }
  382. else
  383. {
  384. rt_kprintf("%s -- %s --> %s ", sender, rtgui_event_string[event->type], app->name);
  385. }
  386. switch (event->type)
  387. {
  388. case RTGUI_EVENT_APP_CREATE:
  389. case RTGUI_EVENT_APP_DESTROY:
  390. case RTGUI_EVENT_APP_ACTIVATE:
  391. {
  392. struct rtgui_event_application *eapp = (struct rtgui_event_application *)event;
  393. rt_kprintf("app: %s", eapp->app->name);
  394. }
  395. break;
  396. case RTGUI_EVENT_PAINT:
  397. {
  398. struct rtgui_event_paint *paint = (struct rtgui_event_paint *)event;
  399. if (paint->wid != RT_NULL)
  400. rt_kprintf("win: %s", paint->wid->title);
  401. }
  402. break;
  403. case RTGUI_EVENT_KBD:
  404. {
  405. struct rtgui_event_kbd *ekbd = (struct rtgui_event_kbd *) event;
  406. if (ekbd->wid != RT_NULL)
  407. rt_kprintf("win: %s", ekbd->wid->title);
  408. if (RTGUI_KBD_IS_UP(ekbd)) rt_kprintf(", up");
  409. else rt_kprintf(", down");
  410. }
  411. break;
  412. case RTGUI_EVENT_CLIP_INFO:
  413. {
  414. struct rtgui_event_clip_info *info = (struct rtgui_event_clip_info *)event;
  415. if (info->wid != RT_NULL)
  416. rt_kprintf("win: %s", info->wid->title);
  417. }
  418. break;
  419. case RTGUI_EVENT_WIN_CREATE:
  420. {
  421. struct rtgui_event_win_create *create = (struct rtgui_event_win_create *)event;
  422. rt_kprintf(" win: %s at (x1:%d, y1:%d, x2:%d, y2:%d), addr: %p",
  423. create->wid->title,
  424. RTGUI_WIDGET(create->wid)->extent.x1,
  425. RTGUI_WIDGET(create->wid)->extent.y1,
  426. RTGUI_WIDGET(create->wid)->extent.x2,
  427. RTGUI_WIDGET(create->wid)->extent.y2,
  428. create->wid
  429. );
  430. }
  431. break;
  432. case RTGUI_EVENT_UPDATE_END:
  433. {
  434. struct rtgui_event_update_end *update_end = (struct rtgui_event_update_end *)event;
  435. rt_kprintf("(x:%d, y1:%d, x2:%d, y2:%d)", update_end->rect.x1,
  436. update_end->rect.y1,
  437. update_end->rect.x2,
  438. update_end->rect.y2);
  439. }
  440. break;
  441. case RTGUI_EVENT_WIN_ACTIVATE:
  442. case RTGUI_EVENT_WIN_DEACTIVATE:
  443. case RTGUI_EVENT_WIN_SHOW:
  444. case RTGUI_EVENT_WIN_HIDE:
  445. case RTGUI_EVENT_WIN_MODAL_ENTER:
  446. {
  447. struct rtgui_event_win *win = (struct rtgui_event_win *)event;
  448. if (win->wid != RT_NULL)
  449. rt_kprintf("win: %s", win->wid->title);
  450. }
  451. break;
  452. case RTGUI_EVENT_WIN_MOVE:
  453. {
  454. struct rtgui_event_win_move *win = (struct rtgui_event_win_move *)event;
  455. if (win->wid != RT_NULL)
  456. {
  457. rt_kprintf("win: %s", win->wid->title);
  458. rt_kprintf(" to (x:%d, y:%d)", win->x, win->y);
  459. }
  460. }
  461. break;
  462. case RTGUI_EVENT_WIN_RESIZE:
  463. {
  464. struct rtgui_event_win_resize *win = (struct rtgui_event_win_resize *)event;
  465. if (win->wid != RT_NULL)
  466. {
  467. rt_kprintf("win: %s, rect(x1:%d, y1:%d, x2:%d, y2:%d)", win->wid->title,
  468. RTGUI_WIDGET(win->wid)->extent.x1,
  469. RTGUI_WIDGET(win->wid)->extent.y1,
  470. RTGUI_WIDGET(win->wid)->extent.x2,
  471. RTGUI_WIDGET(win->wid)->extent.y2);
  472. }
  473. }
  474. break;
  475. case RTGUI_EVENT_MOUSE_BUTTON:
  476. case RTGUI_EVENT_MOUSE_MOTION:
  477. {
  478. struct rtgui_event_mouse *mouse = (struct rtgui_event_mouse *)event;
  479. if (mouse->button & RTGUI_MOUSE_BUTTON_LEFT) rt_kprintf("left ");
  480. else rt_kprintf("right ");
  481. if (mouse->button & RTGUI_MOUSE_BUTTON_DOWN) rt_kprintf("down ");
  482. else rt_kprintf("up ");
  483. if (mouse->wid != RT_NULL)
  484. rt_kprintf("win: %s at (%d, %d)", mouse->wid->title,
  485. mouse->x, mouse->y);
  486. else
  487. rt_kprintf("(%d, %d)", mouse->x, mouse->y);
  488. }
  489. break;
  490. case RTGUI_EVENT_MONITOR_ADD:
  491. {
  492. struct rtgui_event_monitor *monitor = (struct rtgui_event_monitor *)event;
  493. if (monitor->wid != RT_NULL)
  494. {
  495. rt_kprintf("win: %s, the rect is:(%d, %d) - (%d, %d)", monitor->wid->title,
  496. monitor->rect.x1, monitor->rect.y1,
  497. monitor->rect.x2, monitor->rect.y2);
  498. }
  499. }
  500. break;
  501. default:
  502. break;
  503. }
  504. rt_kprintf("\n");
  505. }
  506. #else
  507. #define DBG_MSG(x)
  508. #define rtgui_event_dump(app, event)
  509. #endif
  510. /************************************************************************/
  511. /* RTGUI IPC APIs */
  512. /************************************************************************/
  513. rt_err_t rtgui_send(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size)
  514. {
  515. rt_err_t result;
  516. RT_ASSERT(app != RT_NULL);
  517. RT_ASSERT(event != RT_NULL);
  518. RT_ASSERT(event_size != 0);
  519. rtgui_event_dump(app, event);
  520. result = rt_mq_send(app->mq, event, event_size);
  521. if (result != RT_EOK)
  522. {
  523. if (event->type != RTGUI_EVENT_TIMER)
  524. rt_kprintf("send event to %s failed\n", app->name);
  525. }
  526. return result;
  527. }
  528. RTM_EXPORT(rtgui_send);
  529. rt_err_t rtgui_send_urgent(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size)
  530. {
  531. rt_err_t result;
  532. RT_ASSERT(app != RT_NULL);
  533. RT_ASSERT(event != RT_NULL);
  534. RT_ASSERT(event_size != 0);
  535. rtgui_event_dump(app, event);
  536. result = rt_mq_urgent(app->mq, event, event_size);
  537. if (result != RT_EOK)
  538. rt_kprintf("send ergent event to %s failed\n", app->name);
  539. return result;
  540. }
  541. RTM_EXPORT(rtgui_send_urgent);
  542. rt_err_t rtgui_send_sync(struct rtgui_app* app, rtgui_event_t *event, rt_size_t event_size)
  543. {
  544. rt_err_t r;
  545. rt_int32_t ack_buffer, ack_status;
  546. struct rt_mailbox ack_mb;
  547. RT_ASSERT(app != RT_NULL);
  548. RT_ASSERT(event != RT_NULL);
  549. RT_ASSERT(event_size != 0);
  550. rtgui_event_dump(app, event);
  551. /* init ack mailbox */
  552. r = rt_mb_init(&ack_mb, "ack", &ack_buffer, 1, 0);
  553. if (r != RT_EOK)
  554. goto __return;
  555. event->ack = &ack_mb;
  556. r = rt_mq_send(app->mq, event, event_size);
  557. if (r != RT_EOK)
  558. {
  559. rt_kprintf("send sync event failed\n");
  560. goto __return;
  561. }
  562. r = rt_mb_recv(&ack_mb, (rt_uint32_t *)&ack_status, RT_WAITING_FOREVER);
  563. if (r != RT_EOK)
  564. goto __return;
  565. if (ack_status != RTGUI_STATUS_OK)
  566. r = -RT_ERROR;
  567. else
  568. r = RT_EOK;
  569. __return:
  570. /* fini ack mailbox */
  571. rt_mb_detach(&ack_mb);
  572. return r;
  573. }
  574. RTM_EXPORT(rtgui_send_sync);
  575. rt_err_t rtgui_ack(rtgui_event_t *event, rt_int32_t status)
  576. {
  577. RT_ASSERT(event != RT_NULL);
  578. RT_ASSERT(event->ack != RT_NULL);
  579. rt_mb_send(event->ack, status);
  580. return RT_EOK;
  581. }
  582. RTM_EXPORT(rtgui_ack);
  583. rt_err_t rtgui_recv(rtgui_event_t *event, rt_size_t event_size, rt_int32_t timeout)
  584. {
  585. struct rtgui_app *app;
  586. rt_err_t r;
  587. RT_ASSERT(event != RT_NULL);
  588. RT_ASSERT(event_size != 0);
  589. app = (struct rtgui_app *)(rt_thread_self()->user_data);
  590. if (app == RT_NULL) return -RT_ERROR;
  591. r = rt_mq_recv(app->mq, event, event_size, timeout);
  592. return r;
  593. }
  594. RTM_EXPORT(rtgui_recv);
  595. rt_err_t rtgui_recv_filter(rt_uint32_t type, rtgui_event_t *event, rt_size_t event_size)
  596. {
  597. rtgui_event_t *e;
  598. struct rtgui_app *app;
  599. RT_ASSERT(event != RT_NULL);
  600. RT_ASSERT(event_size != 0);
  601. app = (struct rtgui_app *)(rt_thread_self()->user_data);
  602. if (app == RT_NULL)
  603. return -RT_ERROR;
  604. e = (rtgui_event_t*)&app->event_buffer[0];
  605. while (rt_mq_recv(app->mq, e, sizeof(union rtgui_event_generic), RT_WAITING_FOREVER) == RT_EOK)
  606. {
  607. if (e->type == type)
  608. {
  609. rt_memcpy(event, e, event_size);
  610. return RT_EOK;
  611. }
  612. else
  613. {
  614. if (RTGUI_OBJECT(app)->event_handler != RT_NULL)
  615. {
  616. RTGUI_OBJECT(app)->event_handler(RTGUI_OBJECT(app), e);
  617. }
  618. }
  619. }
  620. return -RT_ERROR;
  621. }
  622. RTM_EXPORT(rtgui_recv_filter);
  623. void rtgui_set_mainwin_rect(struct rtgui_rect *rect)
  624. {
  625. _mainwin_rect = *rect;
  626. }
  627. RTM_EXPORT(rtgui_set_mainwin_rect);
  628. void rtgui_get_mainwin_rect(struct rtgui_rect *rect)
  629. {
  630. *rect = _mainwin_rect;
  631. }
  632. RTM_EXPORT(rtgui_get_mainwin_rect);
  633. void rtgui_get_screen_rect(struct rtgui_rect *rect)
  634. {
  635. rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), rect);
  636. }
  637. RTM_EXPORT(rtgui_get_screen_rect);
  638. void rtgui_screen_lock(rt_int32_t timeout)
  639. {
  640. rt_mutex_take(&_screen_lock, timeout);
  641. }
  642. RTM_EXPORT(rtgui_screen_lock);
  643. void rtgui_screen_unlock(void)
  644. {
  645. rt_mutex_release(&_screen_lock);
  646. }
  647. RTM_EXPORT(rtgui_screen_unlock);
  648. int rtgui_screen_lock_freeze(void)
  649. {
  650. int hold = 0;
  651. if (_screen_lock.owner == rt_thread_self())
  652. {
  653. int index;
  654. index = hold = _screen_lock.hold;
  655. while (index --) rt_mutex_release(&_screen_lock);
  656. }
  657. return hold;
  658. }
  659. RTM_EXPORT(rtgui_screen_lock_freeze);
  660. void rtgui_screen_lock_thaw(int value)
  661. {
  662. while (value--) rt_mutex_take(&_screen_lock, RT_WAITING_FOREVER);
  663. }
  664. RTM_EXPORT(rtgui_screen_lock_thaw);