source: mainline/uspace/lib/display/src/disp_srv.c@ 06176e1

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 06176e1 was 06176e1, checked in by Jiri Svoboda <jiri@…>, 3 years ago

Minimizing windows
  • Property mode set to 100644
File size: 14.6 KB
Line 
1/*
2 * Copyright (c) 2022 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libdisplay
30 * @{
31 */
32/**
33 * @file
34 * @brief Display protocol server stub
35 */
36
37#include <disp_srv.h>
38#include <display/event.h>
39#include <display/info.h>
40#include <display/wndresize.h>
41#include <errno.h>
42#include <io/log.h>
43#include <ipc/display.h>
44#include <mem.h>
45#include <stdlib.h>
46#include <stddef.h>
47#include "../private/params.h"
48
49static void display_callback_create_srv(display_srv_t *srv, ipc_call_t *call)
50{
51 async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
52 if (sess == NULL) {
53 async_answer_0(call, ENOMEM);
54 return;
55 }
56
57 srv->client_sess = sess;
58 async_answer_0(call, EOK);
59}
60
61static void display_window_create_srv(display_srv_t *srv, ipc_call_t *icall)
62{
63 sysarg_t wnd_id;
64 ipc_call_t call;
65 display_wnd_params_enc_t eparams;
66 display_wnd_params_t params;
67 char *caption;
68 size_t size;
69 errno_t rc;
70
71 if (!async_data_write_receive(&call, &size)) {
72 async_answer_0(&call, EREFUSED);
73 async_answer_0(icall, EREFUSED);
74 return;
75 }
76
77 if (size != sizeof(display_wnd_params_enc_t)) {
78 async_answer_0(&call, EINVAL);
79 async_answer_0(icall, EINVAL);
80 return;
81 }
82
83 rc = async_data_write_finalize(&call, &eparams, size);
84 if (rc != EOK) {
85 async_answer_0(&call, rc);
86 async_answer_0(icall, rc);
87 return;
88 }
89
90 caption = calloc(eparams.caption_size + 1, 1);
91 if (caption == NULL) {
92 async_answer_0(icall, ENOMEM);
93 return;
94 }
95
96 if (!async_data_write_receive(&call, &size)) {
97 free(caption);
98 async_answer_0(&call, EREFUSED);
99 async_answer_0(icall, EREFUSED);
100 return;
101 }
102
103 if (size != eparams.caption_size) {
104 free(caption);
105 async_answer_0(&call, EINVAL);
106 async_answer_0(icall, EINVAL);
107 return;
108 }
109
110 rc = async_data_write_finalize(&call, caption, eparams.caption_size);
111 if (rc != EOK) {
112 free(caption);
113 async_answer_0(&call, rc);
114 async_answer_0(icall, rc);
115 return;
116 }
117
118 if (srv->ops->window_create == NULL) {
119 free(caption);
120 async_answer_0(icall, ENOTSUP);
121 return;
122 }
123
124 /* Decode the parameters from transport */
125 params.rect = eparams.rect;
126 params.caption = caption;
127 params.min_size = eparams.min_size;
128 params.pos = eparams.pos;
129 params.flags = eparams.flags;
130
131 rc = srv->ops->window_create(srv->arg, &params, &wnd_id);
132 async_answer_1(icall, rc, wnd_id);
133}
134
135static void display_window_destroy_srv(display_srv_t *srv, ipc_call_t *icall)
136{
137 sysarg_t wnd_id;
138 errno_t rc;
139
140 wnd_id = ipc_get_arg1(icall);
141
142 if (srv->ops->window_destroy == NULL) {
143 async_answer_0(icall, ENOTSUP);
144 return;
145 }
146
147 rc = srv->ops->window_destroy(srv->arg, wnd_id);
148 async_answer_0(icall, rc);
149}
150
151static void display_window_move_req_srv(display_srv_t *srv, ipc_call_t *icall)
152{
153 sysarg_t wnd_id;
154 ipc_call_t call;
155 gfx_coord2_t pos;
156 size_t size;
157 errno_t rc;
158
159 wnd_id = ipc_get_arg1(icall);
160
161 if (!async_data_write_receive(&call, &size)) {
162 async_answer_0(&call, EREFUSED);
163 async_answer_0(icall, EREFUSED);
164 return;
165 }
166
167 if (size != sizeof(gfx_coord2_t)) {
168 async_answer_0(&call, EINVAL);
169 async_answer_0(icall, EINVAL);
170 return;
171 }
172
173 rc = async_data_write_finalize(&call, &pos, size);
174 if (rc != EOK) {
175 async_answer_0(&call, rc);
176 async_answer_0(icall, rc);
177 return;
178 }
179
180 if (srv->ops->window_move_req == NULL) {
181 async_answer_0(icall, ENOTSUP);
182 return;
183 }
184
185 rc = srv->ops->window_move_req(srv->arg, wnd_id, &pos);
186 async_answer_0(icall, rc);
187}
188
189static void display_window_move_srv(display_srv_t *srv, ipc_call_t *icall)
190{
191 sysarg_t wnd_id;
192 ipc_call_t call;
193 gfx_coord2_t dpos;
194 size_t size;
195 errno_t rc;
196
197 wnd_id = ipc_get_arg1(icall);
198
199 if (!async_data_write_receive(&call, &size)) {
200 async_answer_0(&call, EREFUSED);
201 async_answer_0(icall, EREFUSED);
202 return;
203 }
204
205 if (size != sizeof(gfx_coord2_t)) {
206 async_answer_0(&call, EINVAL);
207 async_answer_0(icall, EINVAL);
208 return;
209 }
210
211 rc = async_data_write_finalize(&call, &dpos, size);
212 if (rc != EOK) {
213 async_answer_0(&call, rc);
214 async_answer_0(icall, rc);
215 return;
216 }
217
218 if (srv->ops->window_move == NULL) {
219 async_answer_0(icall, ENOTSUP);
220 return;
221 }
222
223 rc = srv->ops->window_move(srv->arg, wnd_id, &dpos);
224 async_answer_0(icall, rc);
225}
226
227static void display_window_get_pos_srv(display_srv_t *srv, ipc_call_t *icall)
228{
229 sysarg_t wnd_id;
230 ipc_call_t call;
231 gfx_coord2_t dpos;
232 size_t size;
233 errno_t rc;
234
235 wnd_id = ipc_get_arg1(icall);
236
237 if (srv->ops->window_get_pos == NULL) {
238 async_answer_0(icall, ENOTSUP);
239 return;
240 }
241
242 if (!async_data_read_receive(&call, &size)) {
243 async_answer_0(icall, EREFUSED);
244 return;
245 }
246
247 rc = srv->ops->window_get_pos(srv->arg, wnd_id, &dpos);
248 if (rc != EOK) {
249 async_answer_0(&call, rc);
250 async_answer_0(icall, rc);
251 return;
252 }
253
254 if (size != sizeof(gfx_coord2_t)) {
255 async_answer_0(&call, EINVAL);
256 async_answer_0(icall, EINVAL);
257 return;
258 }
259
260 rc = async_data_read_finalize(&call, &dpos, size);
261 if (rc != EOK) {
262 async_answer_0(&call, rc);
263 async_answer_0(icall, rc);
264 return;
265 }
266
267 async_answer_0(icall, EOK);
268}
269
270static void display_window_get_max_rect_srv(display_srv_t *srv,
271 ipc_call_t *icall)
272{
273 sysarg_t wnd_id;
274 ipc_call_t call;
275 gfx_rect_t rect;
276 size_t size;
277 errno_t rc;
278
279 wnd_id = ipc_get_arg1(icall);
280
281 if (srv->ops->window_get_max_rect == NULL) {
282 async_answer_0(icall, ENOTSUP);
283 return;
284 }
285
286 if (!async_data_read_receive(&call, &size)) {
287 async_answer_0(icall, EREFUSED);
288 return;
289 }
290
291 rc = srv->ops->window_get_max_rect(srv->arg, wnd_id, &rect);
292 if (rc != EOK) {
293 async_answer_0(&call, rc);
294 async_answer_0(icall, rc);
295 return;
296 }
297
298 if (size != sizeof(gfx_rect_t)) {
299 async_answer_0(&call, EINVAL);
300 async_answer_0(icall, EINVAL);
301 return;
302 }
303
304 rc = async_data_read_finalize(&call, &rect, size);
305 if (rc != EOK) {
306 async_answer_0(&call, rc);
307 async_answer_0(icall, rc);
308 return;
309 }
310
311 async_answer_0(icall, EOK);
312}
313
314static void display_window_resize_req_srv(display_srv_t *srv, ipc_call_t *icall)
315{
316 sysarg_t wnd_id;
317 ipc_call_t call;
318 display_wnd_rsztype_t rsztype;
319 gfx_coord2_t pos;
320 size_t size;
321 errno_t rc;
322
323 wnd_id = ipc_get_arg1(icall);
324 rsztype = (display_wnd_rsztype_t) ipc_get_arg2(icall);
325
326 if (!async_data_write_receive(&call, &size)) {
327 async_answer_0(&call, EREFUSED);
328 async_answer_0(icall, EREFUSED);
329 return;
330 }
331
332 if (size != sizeof(gfx_coord2_t)) {
333 async_answer_0(&call, EINVAL);
334 async_answer_0(icall, EINVAL);
335 return;
336 }
337
338 rc = async_data_write_finalize(&call, &pos, size);
339 if (rc != EOK) {
340 async_answer_0(&call, rc);
341 async_answer_0(icall, rc);
342 return;
343 }
344
345 if (srv->ops->window_resize_req == NULL) {
346 async_answer_0(icall, ENOTSUP);
347 return;
348 }
349
350 rc = srv->ops->window_resize_req(srv->arg, wnd_id, rsztype, &pos);
351 async_answer_0(icall, rc);
352}
353
354static void display_window_resize_srv(display_srv_t *srv, ipc_call_t *icall)
355{
356 sysarg_t wnd_id;
357 ipc_call_t call;
358 display_wnd_resize_t wresize;
359 size_t size;
360 errno_t rc;
361
362 wnd_id = ipc_get_arg1(icall);
363
364 if (!async_data_write_receive(&call, &size)) {
365 async_answer_0(&call, EREFUSED);
366 async_answer_0(icall, EREFUSED);
367 return;
368 }
369
370 if (size != sizeof(display_wnd_resize_t)) {
371 async_answer_0(&call, EINVAL);
372 async_answer_0(icall, EINVAL);
373 return;
374 }
375
376 rc = async_data_write_finalize(&call, &wresize, size);
377 if (rc != EOK) {
378 async_answer_0(&call, rc);
379 async_answer_0(icall, rc);
380 return;
381 }
382
383 if (srv->ops->window_resize == NULL) {
384 async_answer_0(icall, ENOTSUP);
385 return;
386 }
387
388 rc = srv->ops->window_resize(srv->arg, wnd_id, &wresize.offs,
389 &wresize.nrect);
390 async_answer_0(icall, rc);
391}
392
393static void display_window_minimize_srv(display_srv_t *srv, ipc_call_t *icall)
394{
395 sysarg_t wnd_id;
396 errno_t rc;
397
398 wnd_id = ipc_get_arg1(icall);
399
400 if (srv->ops->window_minimize == NULL) {
401 async_answer_0(icall, ENOTSUP);
402 return;
403 }
404
405 rc = srv->ops->window_minimize(srv->arg, wnd_id);
406 async_answer_0(icall, rc);
407}
408
409static void display_window_maximize_srv(display_srv_t *srv, ipc_call_t *icall)
410{
411 sysarg_t wnd_id;
412 errno_t rc;
413
414 wnd_id = ipc_get_arg1(icall);
415
416 if (srv->ops->window_maximize == NULL) {
417 async_answer_0(icall, ENOTSUP);
418 return;
419 }
420
421 rc = srv->ops->window_maximize(srv->arg, wnd_id);
422 async_answer_0(icall, rc);
423}
424
425static void display_window_unmaximize_srv(display_srv_t *srv, ipc_call_t *icall)
426{
427 sysarg_t wnd_id;
428 errno_t rc;
429
430 wnd_id = ipc_get_arg1(icall);
431
432 if (srv->ops->window_unmaximize == NULL) {
433 async_answer_0(icall, ENOTSUP);
434 return;
435 }
436
437 rc = srv->ops->window_unmaximize(srv->arg, wnd_id);
438 async_answer_0(icall, rc);
439}
440
441static void display_window_set_cursor_srv(display_srv_t *srv, ipc_call_t *icall)
442{
443 sysarg_t wnd_id;
444 display_stock_cursor_t cursor;
445 errno_t rc;
446
447 wnd_id = ipc_get_arg1(icall);
448 cursor = ipc_get_arg2(icall);
449
450 if (srv->ops->window_set_cursor == NULL) {
451 async_answer_0(icall, ENOTSUP);
452 return;
453 }
454
455 rc = srv->ops->window_set_cursor(srv->arg, wnd_id, cursor);
456 async_answer_0(icall, rc);
457}
458
459static void display_window_set_caption_srv(display_srv_t *srv,
460 ipc_call_t *icall)
461{
462 sysarg_t wnd_id;
463 ipc_call_t call;
464 char *caption;
465 size_t size;
466 errno_t rc;
467
468 wnd_id = ipc_get_arg1(icall);
469
470 if (!async_data_write_receive(&call, &size)) {
471 async_answer_0(&call, EREFUSED);
472 async_answer_0(icall, EREFUSED);
473 return;
474 }
475
476 caption = calloc(size + 1, 1);
477 if (caption == NULL) {
478 async_answer_0(&call, ENOMEM);
479 async_answer_0(icall, ENOMEM);
480 return;
481 }
482
483 rc = async_data_write_finalize(&call, caption, size);
484 if (rc != EOK) {
485 free(caption);
486 async_answer_0(&call, rc);
487 async_answer_0(icall, rc);
488 return;
489 }
490
491 if (srv->ops->window_set_caption == NULL) {
492 free(caption);
493 async_answer_0(icall, ENOTSUP);
494 return;
495 }
496
497 rc = srv->ops->window_set_caption(srv->arg, wnd_id, caption);
498 async_answer_0(icall, rc);
499 free(caption);
500}
501
502static void display_get_event_srv(display_srv_t *srv, ipc_call_t *icall)
503{
504 sysarg_t wnd_id;
505 display_wnd_ev_t event;
506 ipc_call_t call;
507 size_t size;
508 errno_t rc;
509
510 if (srv->ops->get_event == NULL) {
511 async_answer_0(icall, ENOTSUP);
512 return;
513 }
514
515 rc = srv->ops->get_event(srv->arg, &wnd_id, &event);
516 if (rc != EOK) {
517 async_answer_0(icall, rc);
518 return;
519 }
520
521 /* Transfer event data */
522 if (!async_data_read_receive(&call, &size)) {
523 async_answer_0(icall, EREFUSED);
524 return;
525 }
526
527 if (size != sizeof(event)) {
528 async_answer_0(icall, EREFUSED);
529 async_answer_0(&call, EREFUSED);
530 return;
531 }
532
533 rc = async_data_read_finalize(&call, &event, sizeof(event));
534 if (rc != EOK) {
535 async_answer_0(icall, rc);
536 async_answer_0(&call, rc);
537 return;
538 }
539
540 async_answer_1(icall, EOK, wnd_id);
541}
542
543static void display_get_info_srv(display_srv_t *srv, ipc_call_t *icall)
544{
545 display_info_t info;
546 ipc_call_t call;
547 size_t size;
548 errno_t rc;
549
550 if (srv->ops->get_info == NULL) {
551 async_answer_0(icall, ENOTSUP);
552 return;
553 }
554
555 /* Transfer information */
556 if (!async_data_read_receive(&call, &size)) {
557 async_answer_0(icall, EREFUSED);
558 return;
559 }
560
561 if (size != sizeof(info)) {
562 async_answer_0(icall, EREFUSED);
563 async_answer_0(&call, EREFUSED);
564 return;
565 }
566
567 rc = srv->ops->get_info(srv->arg, &info);
568 if (rc != EOK) {
569 async_answer_0(icall, rc);
570 async_answer_0(&call, rc);
571 return;
572 }
573
574 rc = async_data_read_finalize(&call, &info, sizeof(info));
575 if (rc != EOK) {
576 async_answer_0(icall, rc);
577 async_answer_0(&call, rc);
578 return;
579 }
580
581 async_answer_0(icall, EOK);
582}
583
584void display_conn(ipc_call_t *icall, display_srv_t *srv)
585{
586 /* Accept the connection */
587 async_accept_0(icall);
588
589 while (true) {
590 ipc_call_t call;
591
592 async_get_call(&call);
593 sysarg_t method = ipc_get_imethod(&call);
594
595 if (!method) {
596 /* The other side has hung up */
597 async_answer_0(&call, EOK);
598 break;
599 }
600
601 switch (method) {
602 case DISPLAY_CALLBACK_CREATE:
603 display_callback_create_srv(srv, &call);
604 break;
605 case DISPLAY_WINDOW_CREATE:
606 display_window_create_srv(srv, &call);
607 break;
608 case DISPLAY_WINDOW_DESTROY:
609 display_window_destroy_srv(srv, &call);
610 break;
611 case DISPLAY_WINDOW_MOVE_REQ:
612 display_window_move_req_srv(srv, &call);
613 break;
614 case DISPLAY_WINDOW_MOVE:
615 display_window_move_srv(srv, &call);
616 break;
617 case DISPLAY_WINDOW_GET_POS:
618 display_window_get_pos_srv(srv, &call);
619 break;
620 case DISPLAY_WINDOW_GET_MAX_RECT:
621 display_window_get_max_rect_srv(srv, &call);
622 break;
623 case DISPLAY_WINDOW_RESIZE_REQ:
624 display_window_resize_req_srv(srv, &call);
625 break;
626 case DISPLAY_WINDOW_RESIZE:
627 display_window_resize_srv(srv, &call);
628 break;
629 case DISPLAY_WINDOW_MINIMIZE:
630 display_window_minimize_srv(srv, &call);
631 break;
632 case DISPLAY_WINDOW_MAXIMIZE:
633 display_window_maximize_srv(srv, &call);
634 break;
635 case DISPLAY_WINDOW_UNMAXIMIZE:
636 display_window_unmaximize_srv(srv, &call);
637 break;
638 case DISPLAY_WINDOW_SET_CURSOR:
639 display_window_set_cursor_srv(srv, &call);
640 break;
641 case DISPLAY_WINDOW_SET_CAPTION:
642 display_window_set_caption_srv(srv, &call);
643 break;
644 case DISPLAY_GET_EVENT:
645 display_get_event_srv(srv, &call);
646 break;
647 case DISPLAY_GET_INFO:
648 display_get_info_srv(srv, &call);
649 break;
650 default:
651 async_answer_0(&call, ENOTSUP);
652 }
653 }
654
655 /* Hang up callback session */
656 if (srv->client_sess != NULL) {
657 async_hangup(srv->client_sess);
658 srv->client_sess = NULL;
659 }
660}
661
662/** Initialize display server structure
663 *
664 * @param srv Display server structure to initialize
665 */
666void display_srv_initialize(display_srv_t *srv)
667{
668 memset(srv, 0, sizeof(*srv));
669}
670
671/** Send 'pending' event to client.
672 *
673 * @param srv Display server structure
674 */
675void display_srv_ev_pending(display_srv_t *srv)
676{
677 async_exch_t *exch;
678
679 exch = async_exchange_begin(srv->client_sess);
680 async_msg_0(exch, DISPLAY_EV_PENDING);
681 async_exchange_end(exch);
682}
683
684/** @}
685 */
Note: See TracBrowser for help on using the repository browser.