src/kmscon_dummy.c

   1 /*
   2  * kmscon - Dummy Session
   3  *
   4  * Copyright (c) 2012 David Herrmann <dh.herrmann@googlemail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files
   8  * (the "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /*
  27  * Dummy Session
  28  */
  29
  30 #include <errno.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include "kmscon_dummy.h"
  34 #include "kmscon_seat.h"
  35 #include "shl_dlist.h"
  36 #include "shl_log.h"
  37
  38 #define LOG_SUBSYSTEM "dummy"
  39
  40 struct display {
  41         struct shl_dlist list;
  42         struct uterm_display *disp;
  43 };
  44
  45 struct kmscon_dummy {
  46         struct kmscon_session *session;
  47         struct shl_dlist displays;
  48         bool active;
  49 };
  50
  51 static void dummy_redraw(struct kmscon_dummy *dummy, struct display *d)
  52 {
  53         struct uterm_mode *mode;
  54         unsigned int w, h;
  55
  56         mode = uterm_display_get_current(d->disp);
  57         w = uterm_mode_get_width(mode);
  58         h = uterm_mode_get_height(mode);
  59
  60         uterm_display_fill(d->disp, 0, 0, 0, 0, 0, w, h);
  61         uterm_display_swap(d->disp, false);
  62 }
  63
  64 static int dummy_session_event(struct kmscon_session *session,
  65                                struct kmscon_session_event *ev, void *data)
  66 {
  67         struct kmscon_dummy *dummy = data;
  68         struct display *d;
  69         struct shl_dlist *iter;
  70
  71         switch (ev->type) {
  72         case KMSCON_SESSION_DISPLAY_NEW:
  73                 d = malloc(sizeof(*d));
  74                 if (!d) {
  75                         log_error("cannot allocate memory for new display");
  76                         break;
  77                 }
  78                 memset(d, 0, sizeof(*d));
  79                 d->disp = ev->disp;
  80                 shl_dlist_link_tail(&dummy->displays, &d->list);
  81                 if (dummy->active)
  82                         dummy_redraw(dummy, d);
  83                 break;
  84         case KMSCON_SESSION_DISPLAY_GONE:
  85                 shl_dlist_for_each(iter, &dummy->displays) {
  86                         d = shl_dlist_entry(iter, struct display, list);
  87                         if (d->disp != ev->disp)
  88                                 continue;
  89
  90                         shl_dlist_unlink(&d->list);
  91                         free(d);
  92                         break;
  93                 }
  94                 break;
  95         case KMSCON_SESSION_ACTIVATE:
  96                 dummy->active = true;
  97                 shl_dlist_for_each(iter, &dummy->displays) {
  98                         d = shl_dlist_entry(iter, struct display, list);
  99                         dummy_redraw(dummy, d);
 100                 }
 101                 break;
 102         case KMSCON_SESSION_DEACTIVATE:
 103                 dummy->active = false;
 104                 break;
 105         case KMSCON_SESSION_UNREGISTER:
 106                 while (!shl_dlist_empty(&dummy->displays)) {
 107                         d = shl_dlist_entry(dummy->displays.prev,
 108                                             struct display, list);
 109                         shl_dlist_unlink(&d->list);
 110                         free(d);
 111                 }
 112
 113                 free(dummy);
 114                 break;
 115         }
 116
 117         return 0;
 118 }
 119
 120 int kmscon_dummy_register(struct kmscon_session **out,
 121                           struct kmscon_seat *seat)
 122 {
 123         struct kmscon_dummy *dummy;
 124         int ret;
 125
 126         if (!out || !seat)
 127                 return -EINVAL;
 128
 129         dummy = malloc(sizeof(*dummy));
 130         if (!dummy)
 131                 return -ENOMEM;
 132         memset(dummy, 0, sizeof(*dummy));
 133         shl_dlist_init(&dummy->displays);
 134
 135         ret = kmscon_seat_register_session(seat, &dummy->session,
 136                                            dummy_session_event, dummy);
 137         if (ret) {
 138                 log_error("cannot register session for dummy: %d", ret);
 139                 goto err_free;
 140         }
 141
 142         *out = dummy->session;
 143         log_debug("new dummy object %p", dummy);
 144         return 0;
 145
 146 err_free:
 147         free(dummy);
 148         return ret;
 149 }