src/text-backend.c

   1 /*
   2  * Copyright © 2012 Openismus GmbH
   3  * Copyright © 2012 Intel Corporation
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and
   6  * its documentation for any purpose is hereby granted without fee, provided
   7  * that the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of the copyright holders not be used in
  10  * advertising or publicity pertaining to distribution of the software
  11  * without specific, written prior permission.  The copyright holders make
  12  * no representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  16  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  18  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  19  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  20  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #include <stdlib.h>
  25
  26 #include "compositor.h"
  27 #include "text-server-protocol.h"
  28
  29 struct input_method;
  30
  31 struct text_model {
  32         struct wl_resource resource;
  33
  34         struct weston_compositor *ec;
  35
  36         struct wl_list input_methods;
  37
  38         struct wl_surface *surface;
  39 };
  40
  41 struct input_method {
  42         struct wl_resource *input_method_binding;
  43         struct wl_global *input_method_global;
  44         struct wl_global *text_model_factory_global;
  45         struct wl_listener destroy_listener;
  46
  47         struct weston_compositor *ec;
  48         struct text_model *model;
  49
  50         struct wl_list link;
  51
  52         struct wl_listener keyboard_focus_listener;
  53
  54         int focus_listener_initialized;
  55 };
  56
  57 static void input_method_init_seat(struct weston_seat *seat);
  58
  59 static void
  60 deactivate_text_model(struct text_model *text_model,
  61                       struct input_method *input_method)
  62 {
  63         struct weston_compositor *ec = text_model->ec;
  64
  65         if (input_method->model == text_model) {
  66                 wl_list_remove(&input_method->link);
  67                 input_method->model = NULL;
  68                 wl_signal_emit(&ec->hide_input_panel_signal, ec);
  69                 text_model_send_deactivated(&text_model->resource);
  70         }
  71 }
  72
  73 static void
  74 destroy_text_model(struct wl_resource *resource)
  75 {
  76         struct text_model *text_model =
  77                 container_of(resource, struct text_model, resource);
  78         struct input_method *input_method, *next;
  79
  80         wl_list_for_each_safe(input_method, next, &text_model->input_methods, link)
  81                 deactivate_text_model(text_model, input_method);
  82
  83         free(text_model);
  84 }
  85
  86 static void
  87 text_model_set_surrounding_text(struct wl_client *client,
  88                                 struct wl_resource *resource,
  89                                 const char *text)
  90 {
  91 }
  92
  93 static void
  94 text_model_set_cursor_index(struct wl_client *client,
  95                             struct wl_resource *resource,
  96                             uint32_t index)
  97 {
  98 }
  99
 100 static void
 101 text_model_activate(struct wl_client *client,
 102                     struct wl_resource *resource,
 103                     struct wl_resource *seat,
 104                     struct wl_resource *surface)
 105 {
 106         struct text_model *text_model = resource->data;
 107         struct weston_seat *weston_seat = seat->data;
 108         struct text_model *old = weston_seat->input_method->model;
 109         struct weston_compositor *ec = text_model->ec;
 110
 111         if (old == text_model)
 112                 return;
 113
 114         if (old) {
 115                 deactivate_text_model(old,
 116                                       weston_seat->input_method);
 117         }
 118
 119         weston_seat->input_method->model = text_model;
 120         wl_list_insert(&text_model->input_methods, &weston_seat->input_method->link);
 121         input_method_init_seat(weston_seat);
 122
 123         text_model->surface = surface->data;
 124
 125         wl_signal_emit(&ec->show_input_panel_signal, ec);
 126
 127         text_model_send_activated(&text_model->resource);
 128 }
 129
 130 static void
 131 text_model_deactivate(struct wl_client *client,
 132                       struct wl_resource *resource,
 133                       struct wl_resource *seat)
 134 {
 135         struct text_model *text_model = resource->data;
 136         struct weston_seat *weston_seat = seat->data;
 137
 138         deactivate_text_model(text_model,
 139                               weston_seat->input_method);
 140 }
 141
 142 static void
 143 text_model_set_selected_text(struct wl_client *client,
 144                              struct wl_resource *resource,
 145                              const char *text,
 146                              int32_t index)
 147 {
 148 }
 149
 150 static void
 151 text_model_set_micro_focus(struct wl_client *client,
 152                            struct wl_resource *resource,
 153                            int32_t x,
 154                            int32_t y,
 155                            int32_t width,
 156                            int32_t height)
 157 {
 158 }
 159
 160 static void
 161 text_model_set_preedit(struct wl_client *client,
 162                        struct wl_resource *resource)
 163 {
 164 }
 165
 166 static void
 167 text_model_set_content_type(struct wl_client *client,
 168                             struct wl_resource *resource)
 169 {
 170 }
 171
 172 static const struct text_model_interface text_model_implementation = {
 173         text_model_set_surrounding_text,
 174         text_model_set_cursor_index,
 175         text_model_activate,
 176         text_model_deactivate,
 177         text_model_set_selected_text,
 178         text_model_set_micro_focus,
 179         text_model_set_preedit,
 180         text_model_set_content_type
 181 };
 182
 183 static void text_model_factory_create_text_model(struct wl_client *client,
 184                                                  struct wl_resource *resource,
 185                                                  uint32_t id)
 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