src/text-backend.c

   1 /*
   2  * Copyright © 2012 Openismus GmbH
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include <stdlib.h>
  24
  25 #include "compositor.h"
  26 #include "text-server-protocol.h"
  27
  28 struct input_method;
  29
  30 struct text_model {
  31         struct wl_resource resource;
  32
  33         struct weston_compositor *ec;
  34
  35         struct wl_list input_methods;
  36
  37         struct wl_surface *surface;
  38 };
  39
  40 struct input_method {
  41         struct wl_resource *input_method_binding;
  42         struct wl_global *input_method_global;
  43         struct wl_global *text_model_factory_global;
  44         struct wl_listener destroy_listener;
  45
  46         struct weston_compositor *ec;
  47         struct text_model *model;
  48
  49         struct wl_list link;
  50
  51         struct wl_listener keyboard_focus_listener;
  52
  53         int focus_listener_initialized;
  54 };
  55
  56 static void input_method_init_seat(struct weston_seat *seat);
  57
  58 static void
  59 deactivate_text_model(struct text_model *text_model,
  60                       struct input_method *input_method)
  61 {
  62         struct weston_compositor *ec = text_model->ec;
  63
  64         if (input_method->model == text_model) {
  65                 wl_list_remove(&input_method->link);
  66                 input_method->model = NULL;
  67                 wl_signal_emit(&ec->hide_input_panel_signal, ec);
  68                 text_model_send_deactivated(&text_model->resource);
  69         }
  70 }
  71
  72 static void
  73 destroy_text_model(struct wl_resource *resource)
  74 {
  75         struct text_model *text_model =
  76                 container_of(resource, struct text_model, resource);
  77         struct input_method *input_method, *next;
  78
  79         wl_list_for_each_safe(input_method, next, &text_model->input_methods, link)
  80                 deactivate_text_model(text_model, input_method);
  81
  82         free(text_model);
  83 }
  84
  85 static void
  86 text_model_set_surrounding_text(struct wl_client *client,
  87                                 struct wl_resource *resource,
  88                                 const char *text)
  89 {
  90 }
  91
  92 static void
  93 text_model_set_cursor_index(struct wl_client *client,
  94                             struct wl_resource *resource,
  95                             uint32_t index)
  96 {
  97 }
  98
  99 static void
 100 text_model_activate(struct wl_client *client,
 101                     struct wl_resource *resource,
 102                     struct wl_resource *seat,
 103                     struct wl_resource *surface)
 104 {
 105         struct text_model *text_model = resource->data;
 106         struct weston_seat *weston_seat = seat->data;
 107         struct text_model *old = weston_seat->input_method->model;
 108         struct weston_compositor *ec = text_model->ec;
 109
 110         if (old == text_model)
 111                 return;
 112
 113         if (old) {
 114                 deactivate_text_model(old,
 115                                       weston_seat->input_method);
 116         }
 117
 118         weston_seat->input_method->model = text_model;
 119         wl_list_insert(&text_model->input_methods, &weston_seat->input_method->link);
 120         input_method_init_seat(weston_seat);
 121
 122         text_model->surface = surface->data;
 123
 124         wl_signal_emit(&ec->show_input_panel_signal, ec);
 125
 126         text_model_send_activated(&text_model->resource);
 127 }
 128
 129 static void
 130 text_model_deactivate(struct wl_client *client,
 131                       struct wl_resource *resource,
 132                       struct wl_resource *seat)
 133 {
 134         struct text_model *text_model = resource->data;
 135         struct weston_seat *weston_seat = seat->data;
 136
 137         deactivate_text_model(text_model,
 138                               weston_seat->input_method);
 139 }
 140
 141 static void
 142 text_model_set_selected_text(struct wl_client *client,
 143                              struct wl_resource *resource,
 144                              const char *text,
 145                              int32_t index)
 146 {
 147 }
 148
 149 static void
 150 text_model_set_micro_focus(struct wl_client *client,
 151                            struct wl_resource *resource,
 152                            int32_t x,
 153                            int32_t y,
 154                            int32_t width,
 155                            int32_t height)
 156 {
 157 }
 158
 159 static void
 160 text_model_set_preedit(struct wl_client *client,
 161                        struct wl_resource *resource)
 162 {
 163 }
 164
 165 static void
 166 text_model_set_content_type(struct wl_client *client,
 167                             struct wl_resource *resource)
 168 {
 169 }
 170
 171 static const struct text_model_interface text_model_implementation = {
 172         text_model_set_surrounding_text,
 173         text_model_set_cursor_index,
 174         text_model_activate,
 175         text_model_deactivate,
 176         text_model_set_selected_text,
 177         text_model_set_micro_focus,
 178         text_model_set_preedit,
 179         text_model_set_content_type
 180 };
 181
 182 static void text_model_factory_create_text_model(struct wl_client *client,
 183                                                  struct wl_resource *resource,
 184                                                  uint32_t id,
 185                                                  struct wl_resource *surface)
 186 {
 187         struct input_method *input_method = resource->data;
 188         struct text_model *text_model;
 189
 190         text_model = calloc(1, sizeof *text_model);
 191
 192         text_model->resource.destroy = destroy_text_model;
 193
 194         text_model->resource.object.id = id;
 195         text_model->resource.object.interface = &text_model_interface;
 196         text_model->resource.object.implementation =
 197                 (void (**)(void)) &text_model_implementation;
 198         text_model->resource.data = text_model;
 199
 200         text_model->ec = input_method->ec;
 201
 202         wl_client_add_resource(client, &text_model->resource);
 203
 204         wl_list_init(&text_model->input_methods);
 205 };
 206
 207 static const struct text_model_factory_interface text_model_factory_implementation = {
 208         text_model_factory_create_text_model
 209 };
 210
 211 static void
 212 bind_text_model_factory(struct wl_client *client,
 213                         void *data,
 214                         uint32_t version,
 215                         uint32_t id)
 216 {
 217         struct input_method *input_method = data;
 218
 219         /* No checking for duplicate binding necessary.
 220          * No events have to be sent, so we don't need the return value. */
 221         wl_client_add_object(client, &text_model_factory_interface,
 222                              &text_model_factory_implementation,
 223                              id, input_method);
 224 }
 225
 226 static void
 227 input_method_commit_string(struct wl_client *client,
 228                            struct wl_resource *resource,
 229                            const char *text,
 230                            uint32_t index)
 231 {
 232         struct input_method *input_method = resource->data;
 233
 234         if (input_method->model) {
 235                 text_model_send_commit_string(&input_method->model->resource, text, index);
 236         }
 237 }
 238
 239 static const struct input_method_interface input_method_implementation = {
 240         input_method_commit_string
 241 };
 242
 243 static void
 244 unbind_input_method(struct wl_resource *resource)
 245 {
 246         struct input_method *input_method = resource->data;
 247
 248         input_method->input_method_binding = NULL;
 249         free(resource);
 250 }
 251
 252 static void
 253 bind_input_method(struct wl_client *client,
 254                   void *data,
 255                   uint32_t version,
 256                   uint32_t id)
 257 {
 258         struct input_method *input_method = data;
 259         struct wl_resource *resource;
 260
 261         resource = wl_client_add_object(client, &input_method_interface,
 262                                         &input_method_implementation,
 263                                         id, input_method);
 264
 265         if (input_method->input_method_binding == NULL) {
 266                 resource->destroy = unbind_input_method;
 267                 input_method->input_method_binding = resource;
 268                 return;
 269         }
 270
 271         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
 272                                "interface object already bound");
 273         wl_resource_destroy(resource);
 274 }
 275
 276 static void
 277 input_method_notifier_destroy(struct wl_listener *listener, void *data)
 278 {
 279         struct input_method *input_method =
 280                 container_of(listener, struct input_method, destroy_listener);
 281
 282         wl_display_remove_global(input_method->ec->wl_display,
 283                                  input_method->input_method_global);
 284         wl_display_remove_global(input_method->ec->wl_display,
 285                                  input_method->text_model_factory_global);
 286         free(input_method);
 287 }
 288
 289 static void
 290 handle_keyboard_focus(struct wl_listener *listener, void *data)
 291 {
 292         struct wl_keyboard *keyboard = data;
 293         struct input_method *input_method =
 294                 container_of(listener, struct input_method, keyboard_focus_listener);
 295         struct wl_surface *surface = keyboard->focus;
 296
 297         if (!input_method->model)
 298                 return;
 299
 300         if (!surface || input_method->model->surface != surface)
 301                 deactivate_text_model(input_method->model,
 302                                       input_method);
 303 }
 304
 305 static void
 306 input_method_init_seat(struct weston_seat *seat)
 307 {
 308         if (seat->input_method->focus_listener_initialized)
 309                 return;
 310
 311         if (seat->has_keyboard) {
 312                 seat->input_method->keyboard_focus_listener.notify = handle_keyboard_focus;
 313                 wl_signal_add(&seat->seat.keyboard->focus_signal, &seat->input_method->keyboard_focus_listener);
 314         }
 315
 316         seat->input_method->focus_listener_initialized = 1;
 317 }
 318
 319 void
 320 input_method_create(struct weston_compositor *ec,
 321                     struct weston_seat *seat)
 322 {
 323         struct input_method *input_method;
 324
 325         input_method = calloc(1, sizeof *input_method);
 326
 327         input_method->ec = ec;
 328         input_method->model = NULL;
 329         input_method->focus_listener_initialized = 0;
 330
 331         input_method->input_method_global =
 332                 wl_display_add_global(ec->wl_display,
 333                                       &input_method_interface,
 334                                       input_method, bind_input_method);
 335
 336         input_method->text_model_factory_global =
 337                 wl_display_add_global(ec->wl_display,
 338                                       &text_model_factory_interface,
 339                                       input_method, bind_text_model_factory);
 340
 341         input_method->destroy_listener.notify = input_method_notifier_destroy;
 342         wl_signal_add(&ec->destroy_signal, &input_method->destroy_listener);
 343
 344         seat->input_method = input_method;
 345 }
 346