wm.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460
  1. /* Window manager: fixed-size draggable terminal windows + a system bar.
  2. Slot 0 runs wm_run(); each terminal window is a separate process. */
  3. #include "wm.h"
  4. #include "fbtext.h"
  5. #include "idle.h"
  6. #include "io.h"
  7. #include "kexec.h"
  8. #include "mouse.h"
  9. #include "process.h"
  10. #include "rtc.h"
  11. #include "timer.h"
  12. #include "version.h"
  13. #include "vga.h"
  14. static struct window windows[MAX_WINDOWS];
  15. static struct term terms[MAX_WINDOWS];
  16. static unsigned int term_counter;
  17. static int wm_full_redraw;
  18. /* Mouse drag state. */
  19. static int drag_active;
  20. static int drag_window; /* index into windows[] */
  21. static int drag_dx, drag_dy; /* mouse offset from window origin */
  22. static unsigned int prev_buttons;
  23. void wm_request_redraw(void)
  24. {
  25. wm_full_redraw = 1;
  26. }
  27. struct window *wm_focused_window(void)
  28. {
  29. unsigned int i;
  30. for (i = 0; i < MAX_WINDOWS; i++)
  31. if (windows[i].used && windows[i].focused)
  32. return &windows[i];
  33. return (void *)0;
  34. }
  35. int wm_is_focused(const struct window *w)
  36. {
  37. return w->focused;
  38. }
  39. static int wm_point_in_rect(unsigned int px, unsigned int py,
  40. unsigned int rx, unsigned int ry, unsigned int rw, unsigned int rh)
  41. {
  42. return px >= rx && px < rx + rw && py >= ry && py < ry + rh;
  43. }
  44. static void wm_make_title(struct window *w, unsigned int n)
  45. {
  46. char num[4];
  47. unsigned int i = 0, k = 0;
  48. w->title[k++] = 't'; w->title[k++] = 'e'; w->title[k++] = 'r';
  49. w->title[k++] = 'm'; w->title[k++] = ' ';
  50. do {
  51. num[i++] = (char)('0' + (n % 10));
  52. n /= 10;
  53. } while (n && i < 3);
  54. while (i)
  55. w->title[k++] = num[--i];
  56. w->title[k] = '\0';
  57. }
  58. int wm_spawn_terminal(void)
  59. {
  60. unsigned int i, j, fbw = vga_fb_width();
  61. struct window *w;
  62. struct term *t;
  63. int pid;
  64. unsigned int n;
  65. for (i = 0; i < MAX_WINDOWS; i++)
  66. if (!windows[i].used)
  67. break;
  68. if (i == MAX_WINDOWS)
  69. return -1;
  70. w = &windows[i];
  71. t = &terms[i];
  72. screen_init(&t->screen);
  73. t->screen.cursor_visible = 1;
  74. t->key_head = t->key_tail = 0;
  75. t->history_count = 0;
  76. t->history_next = 0;
  77. w->used = 1;
  78. w->term = t;
  79. w->pid = 0;
  80. w->focused = 0;
  81. w->pw = SCREEN_COLS * 8 + 2;
  82. w->ph = WM_TITLE_H + SCREEN_ROWS * 10 + 2;
  83. /* Cascade position, clamped to the desktop area. */
  84. n = term_counter % 5;
  85. w->x = 24 + n * 32;
  86. w->y = WM_BAR_H + 12 + n * 28;
  87. if (w->x + w->pw > fbw)
  88. w->x = (fbw > w->pw) ? fbw - w->pw : 0;
  89. if (w->y + w->ph > vga_fb_height())
  90. w->y = WM_BAR_H + 4;
  91. term_counter++;
  92. wm_make_title(w, term_counter);
  93. pid = process_create_ptr("term", term_entry, t);
  94. if (pid < 0) {
  95. w->used = 0;
  96. return -1;
  97. }
  98. w->pid = (unsigned int)pid;
  99. for (j = 0; j < MAX_WINDOWS; j++)
  100. if (windows[j].used)
  101. windows[j].focused = (j == i);
  102. wm_request_redraw();
  103. return pid;
  104. }
  105. static void wm_focus_index(unsigned int idx)
  106. {
  107. unsigned int i;
  108. if (windows[idx].used && windows[idx].focused)
  109. return;
  110. for (i = 0; i < MAX_WINDOWS; i++)
  111. if (windows[i].used)
  112. windows[i].focused = (i == idx);
  113. wm_request_redraw();
  114. }
  115. static void wm_focus_top(void)
  116. {
  117. unsigned int i;
  118. for (i = 0; i < MAX_WINDOWS; i++)
  119. if (windows[i].used) {
  120. wm_focus_index(i);
  121. return;
  122. }
  123. }
  124. static void wm_close_window(unsigned int idx)
  125. {
  126. struct window *w = &windows[idx];
  127. if (w->pid)
  128. process_kill(w->pid);
  129. w->used = 0;
  130. w->pid = 0;
  131. w->focused = 0;
  132. wm_focus_top();
  133. wm_request_redraw();
  134. }
  135. /* Topmost window containing (px,py), or -1. */
  136. static int wm_window_at(unsigned int px, unsigned int py)
  137. {
  138. unsigned int i;
  139. for (i = 0; i < MAX_WINDOWS; i++)
  140. if (windows[i].used && windows[i].focused &&
  141. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  142. windows[i].pw, windows[i].ph))
  143. return (int)i;
  144. for (i = 0; i < MAX_WINDOWS; i++)
  145. if (windows[i].used && !windows[i].focused &&
  146. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  147. windows[i].pw, windows[i].ph))
  148. return (int)i;
  149. return -1;
  150. }
  151. static void wm_clamp_window(struct window *w, int nx, int ny)
  152. {
  153. unsigned int fbw = vga_fb_width();
  154. unsigned int fbh = vga_fb_height();
  155. int maxx = (int)fbw - (int)w->pw;
  156. int maxy = (int)fbh - (int)w->ph;
  157. if (maxx < 0)
  158. maxx = 0;
  159. if (maxy < (int)WM_BAR_H)
  160. maxy = (int)WM_BAR_H;
  161. if (nx < 0)
  162. nx = 0;
  163. else if (nx > maxx)
  164. nx = maxx;
  165. if (ny < (int)WM_BAR_H)
  166. ny = (int)WM_BAR_H;
  167. else if (ny > maxy)
  168. ny = maxy;
  169. w->x = (unsigned int)nx;
  170. w->y = (unsigned int)ny;
  171. }
  172. static void wm_handle_mouse(void)
  173. {
  174. unsigned int buttons = mouse_buttons_state();
  175. unsigned int mx = mouse_get_x();
  176. unsigned int my = mouse_get_y();
  177. int left_down = (buttons & 1) != 0;
  178. int left_was_down = (prev_buttons & 1) != 0;
  179. if (left_down && !left_was_down) {
  180. /* Press. */
  181. if (wm_point_in_rect(mx, my, WM_BTN_X, WM_BTN_Y, WM_BTN_W, WM_BTN_H)) {
  182. wm_spawn_terminal();
  183. } else {
  184. int idx = wm_window_at(mx, my);
  185. if (idx >= 0) {
  186. struct window *w = &windows[idx];
  187. wm_focus_index((unsigned int)idx);
  188. /* Close button? */
  189. if (wm_point_in_rect(mx, my,
  190. w->x + w->pw - 1 - WM_CLOSE_W, w->y + 1,
  191. WM_CLOSE_W, WM_TITLE_H)) {
  192. wm_close_window((unsigned int)idx);
  193. } else if (my < w->y + WM_TITLE_H) {
  194. /* Title bar: start drag. */
  195. drag_active = 1;
  196. drag_window = idx;
  197. drag_dx = (int)mx - (int)w->x;
  198. drag_dy = (int)my - (int)w->y;
  199. }
  200. }
  201. }
  202. } else if (left_down && left_was_down && drag_active) {
  203. struct window *w = &windows[drag_window];
  204. if (w->used) {
  205. wm_clamp_window(w, (int)mx - drag_dx, (int)my - drag_dy);
  206. wm_request_redraw();
  207. } else {
  208. drag_active = 0;
  209. }
  210. } else if (!left_down && left_was_down) {
  211. drag_active = 0;
  212. }
  213. prev_buttons = buttons;
  214. }
  215. static void wm_handle_keyboard(void)
  216. {
  217. struct window *fw = wm_focused_window();
  218. int n;
  219. if (!fw || !fw->term)
  220. return;
  221. for (n = 0; n < 8; n++) {
  222. int k = io_poll_key();
  223. if (!k)
  224. break;
  225. term_key_push(fw->term, k);
  226. }
  227. }
  228. static void wm_draw_bar(void)
  229. {
  230. unsigned int fbw = vga_fb_width();
  231. char dt[20];
  232. /* Banner (light green). */
  233. fbtext_draw_string_xy(4, 5, OS_NAME " v" OS_VERSION, 85, 255, 85, 0);
  234. /* "+ New" button: purple box, white text. */
  235. vga_fill_rect(WM_BTN_X, WM_BTN_Y, WM_BTN_W, WM_BTN_H, 150, 60, 210);
  236. fbtext_draw_string_xy(WM_BTN_X + 4, WM_BTN_Y + 3, "+ New", 255, 255, 255, 1);
  237. if (kexec_busy) {
  238. /* Kexec progress, in place of the clock. */
  239. static const char msg[] = "loading new kernel over serial";
  240. char buf[48];
  241. unsigned int n = 0, dots, i;
  242. while (msg[n])
  243. buf[n] = msg[n], n++;
  244. dots = (kexec_total > 0) ? (kexec_progress * 12 / kexec_total) : 0;
  245. for (i = 0; i < 12; i++)
  246. buf[n + i] = (i < dots) ? '.' : ' ';
  247. n += 12;
  248. buf[n] = '\0';
  249. fbtext_draw_string_xy(fbw - n * 8 - 4, 5, buf, 255, 200, 100, 0);
  250. } else {
  251. /* Live clock (light green, right-aligned). */
  252. rtc_read_datetime(dt);
  253. fbtext_draw_string_xy(fbw - 19 * 8 - 4, 5, dt, 85, 255, 85, 0);
  254. }
  255. /* Rainbow separator. */
  256. fbtext_draw_rainbow_separator();
  257. }
  258. static void wm_draw_window(struct window *w)
  259. {
  260. struct text_screen *s = &w->term->screen;
  261. unsigned int cx = w->x + 1;
  262. unsigned int cy = w->y + 1 + WM_TITLE_H;
  263. /* Border. */
  264. vga_fill_rect(w->x, w->y, w->pw, w->ph, 200, 200, 200);
  265. /* Title bar. */
  266. if (w->focused)
  267. vga_fill_rect(cx, w->y + 1, w->pw - 2, WM_TITLE_H, 70, 90, 150);
  268. else
  269. vga_fill_rect(cx, w->y + 1, w->pw - 2, WM_TITLE_H, 100, 100, 100);
  270. /* Title text. */
  271. fbtext_draw_string_xy(w->x + 4, w->y + 3, w->title, 255, 255, 255, 1);
  272. /* Close button. */
  273. {
  274. unsigned int bx = w->x + w->pw - 1 - WM_CLOSE_W;
  275. vga_fill_rect(bx, w->y + 1, WM_CLOSE_W, WM_TITLE_H, 190, 60, 60);
  276. fbtext_draw_string_xy(bx + 3, w->y + 3, "x", 255, 255, 255, 1);
  277. }
  278. /* Content (black background) + cell buffer. */
  279. vga_fill_rect(cx, cy, w->pw - 2, SCREEN_ROWS * 10, 0, 0, 0);
  280. fbtext_draw_cells(s->cells, s->cols, s->rows, cx, cy);
  281. /* Blinking block cursor for the focused window. */
  282. if (w->focused && s->cursor_visible) {
  283. unsigned int col = s->cursor % s->cols;
  284. unsigned int row = s->cursor / s->cols;
  285. vga_fill_rect(cx + col * 8, cy + row * 10, 2, 10, 255, 255, 255);
  286. }
  287. }
  288. static void wm_render_full(void)
  289. {
  290. unsigned int fbw = vga_fb_width();
  291. unsigned int fbh = vga_fb_height();
  292. unsigned int i;
  293. /* Erase the mouse cursor so the scene is drawn onto a clean background. */
  294. mouse_cursor_erase();
  295. /* Desktop background. */
  296. vga_fill_rect(0, 0, fbw, fbh, 32, 32, 48);
  297. /* Windows back-to-front (focused drawn last = on top). */
  298. for (i = 0; i < MAX_WINDOWS; i++)
  299. if (windows[i].used && !windows[i].focused)
  300. wm_draw_window(&windows[i]);
  301. for (i = 0; i < MAX_WINDOWS; i++)
  302. if (windows[i].used && windows[i].focused)
  303. wm_draw_window(&windows[i]);
  304. /* System bar always on top. */
  305. wm_draw_bar();
  306. /* Mouse cursor on top of everything. */
  307. mouse_redraw_cursor();
  308. }
  309. static void wm_render_bar(void)
  310. {
  311. unsigned int fbw = vga_fb_width();
  312. mouse_cursor_erase();
  313. vga_fill_rect(0, 0, fbw, WM_BAR_H, 32, 32, 48);
  314. wm_draw_bar();
  315. mouse_redraw_cursor();
  316. }
  317. static void wm_redraw_if_needed(void)
  318. {
  319. unsigned int i;
  320. static unsigned int last_sec = 0xFFFFFFFF;
  321. static unsigned int last_kexec_tick;
  322. unsigned int now_ms = get_ticks_ms();
  323. unsigned int now_sec = now_ms / 1000;
  324. int clock_changed = (now_sec != last_sec);
  325. int kexec_changed = kexec_busy && (now_ms - last_kexec_tick >= 100);
  326. int need_full = wm_full_redraw;
  327. if (kexec_changed)
  328. last_kexec_tick = now_ms;
  329. /* A background window's content changed -> full redraw (rare). */
  330. for (i = 0; i < MAX_WINDOWS; i++)
  331. if (windows[i].used && !windows[i].focused && windows[i].term->screen.dirty)
  332. need_full = 1;
  333. if (need_full) {
  334. wm_render_full();
  335. for (i = 0; i < MAX_WINDOWS; i++)
  336. if (windows[i].used)
  337. windows[i].term->screen.dirty = 0;
  338. wm_full_redraw = 0;
  339. last_sec = now_sec;
  340. return;
  341. }
  342. if (clock_changed || kexec_changed) {
  343. wm_render_bar();
  344. last_sec = now_sec;
  345. }
  346. /* Focused window's content changed -> redraw only that window. */
  347. for (i = 0; i < MAX_WINDOWS; i++) {
  348. if (windows[i].used && windows[i].focused && windows[i].term->screen.dirty) {
  349. mouse_cursor_erase();
  350. wm_draw_window(&windows[i]);
  351. mouse_redraw_cursor();
  352. windows[i].term->screen.dirty = 0;
  353. }
  354. }
  355. }
  356. static void wm_init(void)
  357. {
  358. unsigned int i;
  359. for (i = 0; i < MAX_WINDOWS; i++) {
  360. windows[i].used = 0;
  361. windows[i].term = &terms[i];
  362. }
  363. term_counter = 0;
  364. wm_full_redraw = 1;
  365. drag_active = 0;
  366. prev_buttons = 0;
  367. wm_spawn_terminal();
  368. }
  369. static void wm_blink_cursor(void)
  370. {
  371. static unsigned int last_cursor_tick;
  372. struct window *fw = wm_focused_window();
  373. unsigned int now = get_ticks_ms();
  374. if (!fw || !fw->term)
  375. return;
  376. if (now - last_cursor_tick >= CURSOR_MS) {
  377. last_cursor_tick = now;
  378. fw->term->screen.cursor_visible = !fw->term->screen.cursor_visible;
  379. fw->term->screen.dirty = 1;
  380. }
  381. }
  382. static void wm_handle_kexec(void)
  383. {
  384. if (!kexec_busy && kexec_pending()) {
  385. kexec_busy = 1;
  386. if (process_create("kexec", program_kexec_main) < 0)
  387. kexec_busy = 0;
  388. }
  389. }
  390. void wm_run(void)
  391. {
  392. wm_init();
  393. for (;;) {
  394. mouse_poll_update();
  395. wm_handle_mouse();
  396. wm_handle_keyboard();
  397. wm_blink_cursor();
  398. wm_handle_kexec();
  399. wm_redraw_if_needed();
  400. vga_fb_flush_pending_check();
  401. cpu_idle();
  402. }
  403. }