workbench.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524
  1. /*
  2. * File : workbench.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. */
  14. #include <rtgui/rtgui_system.h>
  15. #include <rtgui/widgets/window.h>
  16. #include <rtgui/widgets/workbench.h>
  17. static void _rtgui_workbench_constructor(rtgui_workbench_t *workbench)
  18. {
  19. /* set event handler */
  20. rtgui_widget_set_event_handler(RTGUI_WIDGET(workbench), rtgui_workbench_event_handler);
  21. /* set attributes */
  22. workbench->panel = RT_NULL;
  23. workbench->flag = RTGUI_WORKBENCH_FLAG_DEFAULT;
  24. workbench->modal_code = RTGUI_MODAL_OK;
  25. workbench->title = RT_NULL;
  26. workbench->current_view = RT_NULL;
  27. }
  28. static void _rtgui_workbench_destructor(rtgui_workbench_t *workbench)
  29. {
  30. RT_ASSERT(workbench != RT_NULL);
  31. if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)
  32. {
  33. struct rtgui_event_panel_detach edetach;
  34. RTGUI_EVENT_PANEL_DETACH_INIT(&edetach);
  35. /* detach from panel */
  36. edetach.panel = workbench->panel;
  37. /* send PANEL DETACH to server */
  38. if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server,
  39. RTGUI_EVENT(&edetach), sizeof(struct rtgui_event_panel_detach)) != RT_EOK)
  40. return;
  41. RTGUI_TOPLEVEL(workbench)->server = RT_NULL;
  42. }
  43. /* release title */
  44. rt_free(workbench->title);
  45. workbench->title = RT_NULL;
  46. }
  47. rtgui_type_t *rtgui_workbench_type_get(void)
  48. {
  49. static rtgui_type_t *workbench_type = RT_NULL;
  50. if (!workbench_type)
  51. {
  52. workbench_type = rtgui_type_create("workbench", RTGUI_TOPLEVEL_TYPE,
  53. sizeof(rtgui_workbench_t),
  54. RTGUI_CONSTRUCTOR(_rtgui_workbench_constructor),
  55. RTGUI_DESTRUCTOR(_rtgui_workbench_destructor));
  56. }
  57. return workbench_type;
  58. }
  59. rtgui_workbench_t *rtgui_workbench_create(const char* panel_name, const unsigned char* title)
  60. {
  61. struct rtgui_workbench* workbench;
  62. /* the server thread id */
  63. rt_thread_t server = rtgui_thread_get_server();
  64. if (server == RT_NULL)
  65. {
  66. rt_kprintf("can't find rtgui server\n");
  67. return RT_NULL;
  68. }
  69. /* create workbench */
  70. workbench = (rtgui_workbench_t*) rtgui_widget_create (RTGUI_WORKBENCH_TYPE);
  71. if (workbench != RT_NULL)
  72. {
  73. /* the buffer uses to receive event */
  74. union
  75. {
  76. struct rtgui_event_panel_attach ecreate;
  77. struct rtgui_event_panel_info epanel;
  78. char buffer[256]; /* use to recv other information */
  79. } event;
  80. /* set workbench title */
  81. workbench->title = (unsigned char*)rt_strdup((char*)title);
  82. /* create application in server */
  83. RTGUI_EVENT_PANEL_ATTACH_INIT(&(event.ecreate));
  84. /* set the panel name and workbench */
  85. rt_strncpy(event.ecreate.panel_name, panel_name, RTGUI_NAME_MAX);
  86. event.ecreate.workbench = workbench;
  87. /* send PANEL ATTACH to server */
  88. if (rtgui_thread_send_sync(server,
  89. &(event.ecreate.parent), sizeof(struct rtgui_event_panel_attach)) != RTGUI_STATUS_OK)
  90. {
  91. return RT_NULL;
  92. }
  93. /* get PANEL INFO */
  94. rtgui_thread_recv_filter(RTGUI_EVENT_PANEL_INFO, &(event.epanel.parent), sizeof(event));
  95. /* set panel */
  96. workbench->panel = (struct rtgui_panel*)event.epanel.panel;
  97. /* connected */
  98. RTGUI_TOPLEVEL(workbench)->server = server;
  99. /* set extent of workbench */
  100. rtgui_widget_set_rect(RTGUI_WIDGET(workbench), &(event.epanel.extent));
  101. /* set workbench in thread */
  102. rtgui_thread_set_widget(RTGUI_WIDGET(workbench));
  103. }
  104. return workbench;
  105. }
  106. void rtgui_workbench_destroy(rtgui_workbench_t* workbench)
  107. {
  108. RT_ASSERT(workbench != RT_NULL);
  109. if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)
  110. {
  111. struct rtgui_event_panel_detach edetach;
  112. RTGUI_EVENT_PANEL_DETACH_INIT(&edetach);
  113. /* detach from panel */
  114. edetach.panel = workbench->panel;
  115. /* send PANEL DETACH to server */
  116. if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server,
  117. RTGUI_EVENT(&edetach), sizeof(struct rtgui_event_panel_detach)) != RT_EOK)
  118. return;
  119. RTGUI_TOPLEVEL(workbench)->server = RT_NULL;
  120. }
  121. rtgui_widget_destroy(RTGUI_WIDGET(workbench));
  122. }
  123. void rtgui_workbench_set_flag(rtgui_workbench_t* workbench, rt_uint8_t flag)
  124. {
  125. RT_ASSERT(workbench != RT_NULL);
  126. workbench->flag = flag;
  127. }
  128. rt_bool_t rtgui_workbench_event_loop(rtgui_workbench_t* workbench)
  129. {
  130. /* the buffer uses to receive event */
  131. char event_buf[256];
  132. struct rtgui_event* event = (struct rtgui_event*)&event_buf[0];
  133. if (workbench->flag & RTGUI_WORKBENCH_FLAG_MODAL_MODE)
  134. {
  135. /* event loop for modal mode shown view */
  136. while (workbench->flag & RTGUI_WORKBENCH_FLAG_MODAL_MODE)
  137. {
  138. if (rtgui_thread_recv(event, sizeof(event_buf)) == RT_EOK)
  139. {
  140. RTGUI_WIDGET(workbench)->event_handler(RTGUI_WIDGET(workbench), event);
  141. }
  142. }
  143. }
  144. else
  145. {
  146. /* show workbench firstly */
  147. rtgui_workbench_show(workbench);
  148. while (!(workbench->flag & RTGUI_WORKBENCH_FLAG_CLOSED))
  149. {
  150. if (rtgui_thread_recv(event, sizeof(event_buf)) == RT_EOK)
  151. {
  152. RTGUI_WIDGET(workbench)->event_handler(RTGUI_WIDGET(workbench), event);
  153. }
  154. }
  155. }
  156. return RT_TRUE;
  157. }
  158. rt_err_t rtgui_workbench_show(rtgui_workbench_t* workbench)
  159. {
  160. RT_ASSERT(workbench != RT_NULL);
  161. if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)
  162. {
  163. struct rtgui_event_panel_show eraise;
  164. RTGUI_EVENT_PANEL_SHOW_INIT(&eraise);
  165. eraise.workbench = workbench;
  166. eraise.panel = workbench->panel;
  167. if (rtgui_thread_send_sync(workbench->parent.server, RTGUI_EVENT(&eraise),
  168. sizeof(struct rtgui_event_panel_show)) != RT_EOK)
  169. return -RT_ERROR;
  170. RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(workbench));
  171. rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));
  172. }
  173. else return -RT_ERROR;
  174. return RT_EOK;
  175. }
  176. rt_err_t rtgui_workbench_hide(rtgui_workbench_t* workbench)
  177. {
  178. if (RTGUI_TOPLEVEL(workbench)->server != RT_NULL)
  179. {
  180. struct rtgui_event_panel_hide ehide;
  181. RTGUI_EVENT_PANEL_HIDE_INIT(&ehide);
  182. RT_ASSERT(workbench != RT_NULL);
  183. if (workbench->parent.server == RT_NULL) return -RT_ERROR;
  184. ehide.panel = workbench->panel;
  185. if (rtgui_thread_send_sync(RTGUI_TOPLEVEL(workbench)->server, RTGUI_EVENT(&ehide),
  186. sizeof(struct rtgui_event_panel_hide)) != RT_EOK)
  187. return -RT_ERROR;
  188. RTGUI_WIDGET_HIDE(RTGUI_WIDGET(workbench));
  189. rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));
  190. }
  191. return RT_EOK;
  192. }
  193. rt_bool_t rtgui_workbench_event_handler(rtgui_widget_t* widget, rtgui_event_t* event)
  194. {
  195. struct rtgui_workbench* workbench = (struct rtgui_workbench*)widget;
  196. switch (event->type)
  197. {
  198. case RTGUI_EVENT_PANEL_DETACH:
  199. RTGUI_WIDGET_HIDE(RTGUI_WIDGET(workbench));
  200. RTGUI_TOPLEVEL(workbench)->server = RT_NULL;
  201. return RT_TRUE;
  202. case RTGUI_EVENT_PANEL_SHOW:
  203. /* show workbench in server */
  204. rtgui_workbench_show(workbench);
  205. break;
  206. case RTGUI_EVENT_PANEL_HIDE:
  207. /* hide widget */
  208. RTGUI_WIDGET_HIDE(widget);
  209. break;
  210. case RTGUI_EVENT_MOUSE_MOTION:
  211. {
  212. struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
  213. struct rtgui_toplevel* top = RTGUI_TOPLEVEL(emouse->wid);
  214. /* check the destination window */
  215. if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
  216. {
  217. RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
  218. }
  219. else
  220. {
  221. /* let viewer to handle it */
  222. rtgui_view_t* view = workbench->current_view;
  223. if (view != RT_NULL &&
  224. RTGUI_WIDGET(view)->event_handler != RT_NULL)
  225. {
  226. RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
  227. }
  228. }
  229. }
  230. break;
  231. case RTGUI_EVENT_MOUSE_BUTTON:
  232. {
  233. struct rtgui_event_mouse* emouse = (struct rtgui_event_mouse*)event;
  234. struct rtgui_toplevel* top = RTGUI_TOPLEVEL(emouse->wid);
  235. /* check the destination window */
  236. if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
  237. {
  238. RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
  239. }
  240. else
  241. {
  242. if (RTGUI_WORKBENCH_IS_MODAL_MODE(workbench))
  243. {
  244. /* let modal widget to handle it */
  245. if (workbench->modal_widget != RT_NULL &&
  246. workbench->modal_widget->event_handler != RT_NULL)
  247. {
  248. workbench->modal_widget->event_handler(workbench->modal_widget, event);
  249. }
  250. }
  251. else
  252. {
  253. /* let viewer to handle it */
  254. rtgui_view_t* view = workbench->current_view;
  255. if (view != RT_NULL &&
  256. RTGUI_WIDGET(view)->event_handler != RT_NULL)
  257. {
  258. RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
  259. }
  260. }
  261. }
  262. }
  263. break;
  264. case RTGUI_EVENT_KBD:
  265. {
  266. struct rtgui_event_kbd* kbd = (struct rtgui_event_kbd*)event;
  267. struct rtgui_toplevel* top = RTGUI_TOPLEVEL(kbd->wid);
  268. /* check the destination window */
  269. if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
  270. {
  271. RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
  272. }
  273. else
  274. {
  275. if (RTGUI_WORKBENCH_IS_MODAL_MODE(workbench))
  276. {
  277. /* let modal widget to handle it */
  278. if (workbench->modal_widget != RT_NULL &&
  279. workbench->modal_widget->event_handler != RT_NULL)
  280. {
  281. workbench->modal_widget->event_handler(workbench->modal_widget, event);
  282. }
  283. }
  284. else
  285. {
  286. if (RTGUI_CONTAINER(widget)->focused == widget)
  287. {
  288. /* set focused widget to the current view */
  289. if (workbench->current_view != RT_NULL)
  290. rtgui_widget_focus(RTGUI_WIDGET(RTGUI_CONTAINER(workbench->current_view)->focused));
  291. }
  292. return rtgui_toplevel_event_handler(widget, event);
  293. }
  294. }
  295. }
  296. break;
  297. case RTGUI_EVENT_PAINT:
  298. {
  299. struct rtgui_event_paint* epaint = (struct rtgui_event_paint*)event;
  300. struct rtgui_toplevel* top = RTGUI_TOPLEVEL(epaint->wid);
  301. /* check the destination window */
  302. if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
  303. {
  304. RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
  305. }
  306. else
  307. {
  308. rtgui_view_t* view;
  309. /* paint a view */
  310. view = workbench->current_view;
  311. if (view != RT_NULL)
  312. {
  313. /* remake a paint event */
  314. RTGUI_EVENT_PAINT_INIT(epaint);
  315. epaint->wid = RT_NULL;
  316. /* send this event to the view */
  317. if (RTGUI_WIDGET(view)->event_handler != RT_NULL)
  318. {
  319. RTGUI_WIDGET(view)->event_handler(RTGUI_WIDGET(view), event);
  320. }
  321. }
  322. else
  323. {
  324. struct rtgui_dc* dc;
  325. struct rtgui_rect rect;
  326. dc = rtgui_dc_begin_drawing(widget);
  327. rtgui_widget_get_rect(widget, &rect);
  328. rtgui_dc_fill_rect(dc, &rect);
  329. rtgui_dc_end_drawing(dc);
  330. }
  331. }
  332. }
  333. break;
  334. case RTGUI_EVENT_CLIP_INFO:
  335. {
  336. struct rtgui_event_clip_info* eclip = (struct rtgui_event_clip_info*)event;
  337. struct rtgui_widget* dest_widget = RTGUI_WIDGET(eclip->wid);
  338. if (dest_widget != RT_NULL && dest_widget->event_handler != RT_NULL)
  339. {
  340. dest_widget->event_handler(dest_widget, event);
  341. }
  342. else
  343. {
  344. return rtgui_toplevel_event_handler(widget, event);
  345. }
  346. }
  347. break;
  348. case RTGUI_EVENT_WIN_CLOSE:
  349. case RTGUI_EVENT_WIN_ACTIVATE:
  350. case RTGUI_EVENT_WIN_DEACTIVATE:
  351. {
  352. struct rtgui_event_win* wevent = (struct rtgui_event_win*)event;
  353. struct rtgui_widget* dest_widget = RTGUI_WIDGET(wevent->wid);
  354. if (dest_widget != RT_NULL && dest_widget->event_handler != RT_NULL)
  355. {
  356. dest_widget->event_handler(dest_widget, event);
  357. }
  358. }
  359. break;
  360. case RTGUI_EVENT_WIN_MOVE:
  361. {
  362. struct rtgui_event_win_move* wevent = (struct rtgui_event_win_move*)event;
  363. struct rtgui_toplevel* top = RTGUI_TOPLEVEL(wevent->wid);
  364. if (top != RT_NULL && RTGUI_WIDGET(top)->event_handler != RT_NULL)
  365. {
  366. RTGUI_WIDGET(top)->event_handler(RTGUI_WIDGET(top), event);
  367. }
  368. }
  369. break;
  370. default:
  371. return rtgui_toplevel_event_handler(widget, event);
  372. }
  373. return RT_TRUE;
  374. }
  375. /*
  376. *
  377. * view on workbench
  378. *
  379. */
  380. void rtgui_workbench_add_view(rtgui_workbench_t* workbench, rtgui_view_t* view)
  381. {
  382. rtgui_container_add_child(RTGUI_CONTAINER(workbench), RTGUI_WIDGET(view));
  383. /* hide view in default */
  384. RTGUI_WIDGET_HIDE(RTGUI_WIDGET(view));
  385. /* reset view extent */
  386. rtgui_widget_set_rect(RTGUI_WIDGET(view), &(RTGUI_WIDGET(workbench)->extent));
  387. }
  388. void rtgui_workbench_remove_view(rtgui_workbench_t* workbench, rtgui_view_t* view)
  389. {
  390. if (view == workbench->current_view)
  391. rtgui_workbench_hide_view(workbench, view);
  392. rtgui_container_remove_child(RTGUI_CONTAINER(workbench), RTGUI_WIDGET(view));
  393. }
  394. void rtgui_workbench_show_view(rtgui_workbench_t* workbench, rtgui_view_t* view)
  395. {
  396. RT_ASSERT(workbench != RT_NULL);
  397. RT_ASSERT(view != RT_NULL);
  398. /* already shown */
  399. if (workbench->current_view == view) return;
  400. if (workbench->current_view != RT_NULL)
  401. {
  402. /* hide old view */
  403. RTGUI_WIDGET_HIDE(RTGUI_WIDGET(workbench->current_view));
  404. }
  405. /* show view */
  406. RTGUI_WIDGET_UNHIDE(RTGUI_WIDGET(view));
  407. workbench->current_view = view;
  408. /* update workbench clip */
  409. rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));
  410. if (!RTGUI_WIDGET_IS_HIDE(RTGUI_WIDGET(workbench)))
  411. {
  412. rtgui_widget_update(RTGUI_WIDGET(view));
  413. }
  414. }
  415. void rtgui_workbench_hide_view(rtgui_workbench_t* workbench, rtgui_view_t* view)
  416. {
  417. RT_ASSERT(workbench != RT_NULL);
  418. RT_ASSERT(view != RT_NULL);
  419. /* hide view */
  420. RTGUI_WIDGET_HIDE(RTGUI_WIDGET(view));
  421. if (view == workbench->current_view)
  422. {
  423. rtgui_view_t *next_view;
  424. workbench->current_view = RT_NULL;
  425. next_view = RTGUI_VIEW(rtgui_widget_get_next_sibling(RTGUI_WIDGET(view)));
  426. if (next_view == RT_NULL)
  427. next_view = RTGUI_VIEW(rtgui_widget_get_prev_sibling(RTGUI_WIDGET(view)));
  428. if (next_view != RT_NULL)
  429. {
  430. rtgui_view_show(next_view, RT_FALSE);
  431. }
  432. else
  433. {
  434. /* update workbench clip */
  435. rtgui_toplevel_update_clip(RTGUI_TOPLEVEL(workbench));
  436. }
  437. }
  438. }