clients/editor.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 <assert.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <linux/input.h>
  30 #include <cairo.h>
  31
  32 #include "window.h"
  33 #include "text-client-protocol.h"
  34
  35 static const char *font_name = "sans-serif";
  36 static int font_size = 14;
  37
  38 struct text_layout {
  39         cairo_glyph_t *glyphs;
  40         int num_glyphs;
  41         cairo_text_cluster_t *clusters;
  42         int num_clusters;
  43         cairo_text_cluster_flags_t cluster_flags;
  44         cairo_scaled_font_t *font;
  45 };
  46
  47 struct text_entry {
  48         struct widget *widget;
  49         struct window *window;
  50         char *text;
  51         int active;
  52         uint32_t cursor;
  53         uint32_t anchor;
  54         char *preedit_text;
  55         uint32_t preedit_cursor;
  56         struct text_model *model;
  57         struct text_layout *layout;
  58 };
  59
  60 struct editor {
  61         struct text_model_factory *text_model_factory;
  62         struct display *display;
  63         struct window *window;
  64         struct widget *widget;
  65         struct text_entry *entry;
  66         struct text_entry *editor;
  67 };
  68
  69 static struct text_layout *
  70 text_layout_create(void)
  71 {
  72         struct text_layout *layout;
  73         cairo_surface_t *surface;
  74         cairo_t *cr;
  75
  76         layout = malloc(sizeof *layout);
  77         if (!layout)
  78                 return NULL;
  79
  80         layout->glyphs = NULL;
  81         layout->num_glyphs = 0;
  82
  83         layout->clusters = NULL;
  84         layout->num_clusters = 0;
  85
  86         surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
  87         cr = cairo_create(surface);
  88         cairo_set_font_size(cr, font_size);
  89         cairo_select_font_face(cr, font_name, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
  90         layout->font = cairo_get_scaled_font(cr);
  91         cairo_scaled_font_reference(layout->font);
  92
  93         cairo_destroy(cr);
  94         cairo_surface_destroy(surface);
  95
  96         return layout;
  97 }
  98
  99 static void
 100 text_layout_destroy(struct text_layout *layout)
 101 {
 102         if (layout->glyphs)
 103                 cairo_glyph_free(layout->glyphs);
 104
 105         if (layout->clusters)
 106                 cairo_text_cluster_free(layout->clusters);
 107
 108         cairo_scaled_font_destroy(layout->font);
 109
 110         free(layout);
 111 }
 112
 113 static void
 114 text_layout_set_text(struct text_layout *layout,
 115                      const char *text)
 116 {
 117         if (layout->glyphs)
 118                 cairo_glyph_free(layout->glyphs);
 119
 120         if (layout->clusters)
 121                 cairo_text_cluster_free(layout->clusters);
 122
 123         layout->glyphs = NULL;
 124         layout->num_glyphs = 0;
 125         layout->clusters = NULL;
 126         layout->num_clusters = 0;
 127
 128         cairo_scaled_font_text_to_glyphs(layout->font, 0, 0, text, -1,
 129                                          &layout->glyphs, &layout->num_glyphs,
 130                                          &layout->clusters, &layout->num_clusters,
 131                                          &layout->cluster_flags);
 132 }
 133
 134 static void
 135 text_layout_draw(struct text_layout *layout, cairo_t *cr)
 136 {
 137         cairo_save(cr);
 138         cairo_set_scaled_font(cr, layout->font);
 139         cairo_show_glyphs(cr, layout->glyphs, layout->num_glyphs);
 140         cairo_restore(cr);
 141 }
 142
 143 static void
 144 text_layout_extents(struct text_layout *layout, cairo_text_extents_t *extents)
 145 {
 146         cairo_scaled_font_glyph_extents(layout->font,
 147                                         layout->glyphs, layout->num_glyphs,
 148                                         extents);
 149 }
 150
 151 static int
 152 text_layout_xy_to_index(struct text_layout *layout, double x, double y)
 153 {
 154         cairo_text_extents_t extents;
 155         int i;
 156
 157         cairo_scaled_font_glyph_extents(layout->font,
 158                                         layout->glyphs, layout->num_glyphs,
 159                                         &extents);
 160
 161         for (i = 1; i < layout->num_glyphs; i++) {
 162                 if (layout->glyphs[i].x >= x) {
 163                         return i - 1;
 164                 }
 165         }
 166
 167         if (x >= layout->glyphs[layout->num_glyphs - 1].x && x < extents.width)
 168                 return layout->num_glyphs - 1;
 169
 170         return layout->num_glyphs;
 171 }
 172
 173 static void
 174 text_layout_index_to_pos(struct text_layout *layout, uint32_t index, cairo_rectangle_t *pos)
 175 {
 176         cairo_text_extents_t extents;
 177
 178         if (!pos)
 179                 return;
 180
 181         cairo_scaled_font_glyph_extents(layout->font,
 182                                         layout->glyphs, layout->num_glyphs,
 183                                         &extents);
 184
 185         if ((int)index >= layout->num_glyphs) {
 186                 pos->x = extents.x_advance;
 187                 pos->y = layout->num_glyphs ? layout->glyphs[layout->num_glyphs - 1].y : 0;
 188                 pos->width = 1;
 189                 pos->height = extents.height;
 190                 return;
 191         }
 192
 193         pos->x = layout->glyphs[index].x;
 194         pos->y = layout->glyphs[index].y;
 195         pos->width = (int)index < layout->num_glyphs - 1 ? layout->glyphs[index + 1].x : extents.x_advance - pos->x;
 196         pos->height = extents.height;
 197 }
 198
 199 static void
 200 text_layout_get_cursor_pos(struct text_layout *layout, int index, cairo_rectangle_t *pos)
 201 {
 202         text_layout_index_to_pos(layout, index, pos);
 203         pos->width = 1;
 204 }
 205
 206 static void text_entry_redraw_handler(struct widget *widget, void *data);
 207 static void text_entry_button_handler(struct widget *widget,
 208                                       struct input *input, uint32_t time,
 209                                       uint32_t button,
 210                                       enum wl_pointer_button_state state, void *data);
 211 static void text_entry_insert_at_cursor(struct text_entry *entry, const char *text);
 212 static void text_entry_set_preedit(struct text_entry *entry,
 213                                    const char *preedit_text,
 214                                    int preedit_cursor);
 215 static void text_entry_delete_text(struct text_entry *entry,
 216                                    uint32_t index, uint32_t length);
 217 static void text_entry_delete_selected_text(struct text_entry *entry);
 218
 219 static void
 220 text_model_commit_string(void *data,
 221                          struct text_model *text_model,
 222                          const char *text,
 223                          uint32_t index)
 224 {
 225         struct text_entry *entry = data;
 226
 227         if (index > strlen(text)) {
 228                 fprintf(stderr, "Invalid cursor index %d\n", index);
 229                 index = strlen(text);
 230         }
 231
 232         text_entry_delete_selected_text(entry);
 233         text_entry_insert_at_cursor(entry, text);
 234
 235         widget_schedule_redraw(entry->widget);
 236 }
 237
 238 static void
 239 text_model_preedit_string(void *data,
 240                           struct text_model *text_model,
 241                           const char *text,
 242                           uint32_t index)
 243 {
 244         struct text_entry *entry = data;
 245
 246         if (index > strlen(text)) {
 247                 fprintf(stderr, "Invalid cursor index %d\n", index);
 248                 index = strlen(text);
 249         }
 250
 251         text_entry_delete_selected_text(entry);
 252         text_entry_set_preedit(entry, text, index);
 253
 254         widget_schedule_redraw(entry->widget);
 255 }
 256
 257 static void
 258 text_model_delete_surrounding_text(void *data,
 259                                    struct text_model *text_model,
 260                                    int32_t index,
 261                                    uint32_t length)
 262 {
 263         struct text_entry *entry = data;
 264         uint32_t cursor_index = index + entry->cursor;
 265
 266         if (cursor_index > strlen(entry->text)) {
 267                 fprintf(stderr, "Invalid cursor index %d\n", index);
 268                 return;
 269         }
 270
 271         if (cursor_index + length > strlen(entry->text)) {
 272                 fprintf(stderr, "Invalid length %d\n", length);
 273                 return;
 274         }
 275
 276         if (length == 0)
 277                 return;
 278
 279         text_entry_delete_text(entry, cursor_index, length);
 280 }
 281
 282 static void
 283 text_model_preedit_styling(void *data,
 284                            struct text_model *text_model)
 285 {
 286 }
 287
 288 static void
 289 text_model_key(void *data,
 290                struct text_model *text_model,
 291                uint32_t key,
 292                uint32_t state)
 293 {
 294         struct text_entry *entry = data;
 295         const char *state_label;
 296         const char *key_label = "released";
 297
 298         if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
 299                 state_label = "pressed";
 300         }
 301
 302         switch (key) {
 303                 case XKB_KEY_Tab:
 304                         key_label = "Tab";
 305                         break;
 306                 case XKB_KEY_KP_Enter:
 307                         key_label = "Enter";
 308                         break;
 309                 case XKB_KEY_Left:
 310                         if (entry->cursor > 0) {
 311                                 entry->cursor--;
 312                                 entry->anchor = entry->cursor;
 313                                 widget_schedule_redraw(entry->widget);
 314                         }
 315                         break;
 316                 case XKB_KEY_Right:
 317                         if (entry->cursor < strlen(entry->text)) {
 318                                 entry->cursor++;
 319                                 entry->anchor = entry->cursor;
 320                                 widget_schedule_redraw(entry->widget);
 321                         }
 322                         break;
 323                 default:
 324                         key_label = "Unknown";
 325         }
 326
 327         fprintf(stderr, "%s key was %s.\n", key_label, state_label);
 328 }
 329
 330 static void
 331 text_model_selection_replacement(void *data,
 332                                  struct text_model *text_model)
 333 {
 334 }
 335
 336 static void
 337 text_model_direction(void *data,
 338                      struct text_model *text_model)
 339 {
 340 }
 341
 342 static void
 343 text_model_locale(void *data,
 344                   struct text_model *text_model)
 345 {
 346 }
 347
 348 static void
 349 text_model_enter(void *data,
 350                  struct text_model *text_model,
 351                  struct wl_surface *surface)
 352 {
 353         struct text_entry *entry = data;
 354
 355         if (surface != window_get_wl_surface(entry->window))
 356                 return;
 357
 358         entry->active = 1;
 359
 360         widget_schedule_redraw(entry->widget);
 361 }
 362
 363 static void
 364 text_model_leave(void *data,
 365                  struct text_model *text_model)
 366 {
 367         struct text_entry *entry = data;
 368
 369         entry->active = 0;
 370
 371         widget_schedule_redraw(entry->widget);
 372 }
 373
 374 static const struct text_model_listener text_model_listener = {
 375         text_model_commit_string,
 376         text_model_preedit_string,
 377         text_model_delete_surrounding_text,
 378         text_model_preedit_styling,
 379         text_model_key,
 380         text_model_selection_replacement,
 381         text_model_direction,
 382         text_model_locale,
 383         text_model_enter,
 384         text_model_leave
 385 };
 386
 387 static struct text_entry*
 388 text_entry_create(struct editor *editor, const char *text)
 389 {
 390         struct text_entry *entry;
 391
 392         entry = malloc(sizeof *entry);
 393
 394         entry->widget = widget_add_widget(editor->widget, entry);
 395         entry->window = editor->window;
 396         entry->text = strdup(text);
 397         entry->active = 0;
 398         entry->cursor = strlen(text);
 399         entry->anchor = entry->cursor;
 400         entry->preedit_text = NULL;
 401         entry->preedit_cursor = 0;
 402         entry->model = text_model_factory_create_text_model(editor->text_model_factory);
 403         text_model_add_listener(entry->model, &text_model_listener, entry);
 404
 405         entry->layout = text_layout_create();
 406         text_layout_set_text(entry->layout, entry->text);
 407
 408         widget_set_redraw_handler(entry->widget, text_entry_redraw_handler);
 409         widget_set_button_handler(entry->widget, text_entry_button_handler);
 410
 411         return entry;
 412 }
 413
 414 static void
 415 text_entry_destroy(struct text_entry *entry)
 416 {
 417         widget_destroy(entry->widget);
 418         text_model_destroy(entry->model);
 419         text_layout_destroy(entry->layout);
 420         free(entry->text);
 421         free(entry);
 422 }
 423
 424 static void
 425 redraw_handler(struct widget *widget, void *data)
 426 {
 427         struct editor *editor = data;
 428         cairo_surface_t *surface;
 429         struct rectangle allocation;
 430         cairo_t *cr;
 431
 432         surface = window_get_surface(editor->window);
 433         widget_get_allocation(editor->widget, &allocation);
 434
 435         cr = cairo_create(surface);
 436         cairo_rectangle(cr, allocation.x, allocation.y, allocation.width, allocation.height);
 437         cairo_clip(cr);
 438
 439         cairo_translate(cr, allocation.x, allocation.y);
 440
 441         /* Draw background */
 442         cairo_push_group(cr);
 443         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 444         cairo_set_source_rgba(cr, 1, 1, 1, 1);
 445         cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
 446         cairo_fill(cr);
 447
 448         cairo_pop_group_to_source(cr);
 449         cairo_paint(cr);
 450
 451         cairo_destroy(cr);
 452         cairo_surface_destroy(surface);
 453 }
 454
 455 static void
 456 text_entry_allocate(struct text_entry *entry, int32_t x, int32_t y,
 457                     int32_t width, int32_t height)
 458 {
 459         widget_set_allocation(entry->widget, x, y, width, height);
 460 }
 461
 462 static void
 463 resize_handler(struct widget *widget,
 464                int32_t width, int32_t height, void *data)
 465 {
 466         struct editor *editor = data;
 467         struct rectangle allocation;
 468
 469         widget_get_allocation(editor->widget, &allocation);
 470
 471         text_entry_allocate(editor->entry,
 472                             allocation.x + 20, allocation.y + 20,
 473                             width - 40, height / 2 - 40);
 474         text_entry_allocate(editor->editor,
 475                             allocation.x + 20, allocation.y + height / 2 + 20,
 476                             width - 40, height / 2 - 40);
 477 }
 478
 479 static void
 480 text_entry_activate(struct text_entry *entry,
 481                     struct wl_seat *seat)
 482 {
 483         struct wl_surface *surface = window_get_wl_surface(entry->window);
 484
 485         text_model_activate(entry->model,
 486                             seat,
 487                             surface);
 488 }
 489
 490 static void
 491 text_entry_deactivate(struct text_entry *entry,
 492                       struct wl_seat *seat)
 493 {
 494         text_model_deactivate(entry->model,
 495                               seat);
 496 }
 497
 498 static void
 499 text_entry_update_layout(struct text_entry *entry)
 500 {
 501         char *text;
 502
 503         assert(((unsigned int)entry->cursor) <= strlen(entry->text) +
 504                (entry->preedit_text ? strlen(entry->preedit_text) : 0));
 505
 506         if (!entry->preedit_text) {
 507                 text_layout_set_text(entry->layout, entry->text);
 508                 return;
 509         }
 510
 511         text = malloc(strlen(entry->text) + strlen(entry->preedit_text) + 1);
 512         strncpy(text, entry->text, entry->cursor);
 513         strcpy(text + entry->cursor, entry->preedit_text);
 514         strcpy(text + entry->cursor + strlen(entry->preedit_text),
 515                entry->text + entry->cursor);
 516
 517         text_layout_set_text(entry->layout, text);
 518         free(text);
 519
 520         widget_schedule_redraw(entry->widget);
 521
 522         text_model_set_surrounding_text(entry->model,
 523                                         entry->text,
 524                                         entry->cursor,
 525                                         entry->anchor);
 526 }
 527
 528 static void
 529 text_entry_insert_at_cursor(struct text_entry *entry, const char *text)
 530 {
 531         char *new_text = malloc(strlen(entry->text) + strlen(text) + 1);
 532
 533         strncpy(new_text, entry->text, entry->cursor);
 534         strcpy(new_text + entry->cursor, text);
 535         strcpy(new_text + entry->cursor + strlen(text),
 536                entry->text + entry->cursor);
 537
 538         free(entry->text);
 539         entry->text = new_text;
 540         entry->cursor += strlen(text);
 541         entry->anchor += strlen(text);
 542
 543         text_entry_update_layout(entry);
 544 }
 545
 546 static void
 547 text_entry_set_preedit(struct text_entry *entry,
 548                        const char *preedit_text,
 549                        int preedit_cursor)
 550 {
 551         if (entry->preedit_text) {
 552                 free(entry->preedit_text);
 553                 entry->preedit_text = NULL;
 554                 entry->preedit_cursor = 0;
 555         }
 556
 557         if (!preedit_text)
 558                 return;
 559
 560         entry->preedit_text = strdup(preedit_text);
 561         entry->preedit_cursor = preedit_cursor;
 562
 563         text_entry_update_layout(entry);
 564 }
 565
 566 static void
 567 text_entry_set_cursor_position(struct text_entry *entry,
 568                                int32_t x, int32_t y)
 569 {
 570         entry->cursor = text_layout_xy_to_index(entry->layout, x, y);
 571
 572         text_model_reset(entry->model);
 573
 574         if (entry->cursor >= entry->preedit_cursor) {
 575                 entry->cursor -= entry->preedit_cursor;
 576         }
 577
 578         text_entry_update_layout(entry);
 579
 580         widget_schedule_redraw(entry->widget);
 581 }
 582
 583 static void
 584 text_entry_set_anchor_position(struct text_entry *entry,
 585                                int32_t x, int32_t y)
 586 {
 587         entry->anchor = text_layout_xy_to_index(entry->layout, x, y);
 588
 589         widget_schedule_redraw(entry->widget);
 590 }
 591
 592 static void
 593 text_entry_delete_text(struct text_entry *entry,
 594                        uint32_t index, uint32_t length)
 595 {
 596         if (entry->cursor > index)
 597                 entry->cursor -= length;
 598
 599         entry->anchor = entry->cursor;
 600
 601         entry->text[index] = '\0';
 602         strcat(entry->text, entry->text + index + length);
 603
 604         text_entry_update_layout(entry);
 605
 606         widget_schedule_redraw(entry->widget);
 607 }
 608
 609 static void
 610 text_entry_delete_selected_text(struct text_entry *entry)
 611 {
 612         uint32_t start_index = entry->anchor < entry->cursor ? entry->anchor : entry->cursor;
 613         uint32_t end_index = entry->anchor < entry->cursor ? entry->cursor : entry->anchor;
 614
 615         if (entry->anchor == entry->cursor)
 616                 return;
 617
 618         text_entry_delete_text(entry, start_index, end_index - start_index);
 619
 620         entry->anchor = entry->cursor;
 621 }
 622
 623 static void
 624 text_entry_draw_selection(struct text_entry *entry, cairo_t *cr)
 625 {
 626         cairo_text_extents_t extents;
 627         uint32_t start_index = entry->anchor < entry->cursor ? entry->anchor : entry->cursor;
 628         uint32_t end_index = entry->anchor < entry->cursor ? entry->cursor : entry->anchor;
 629         cairo_rectangle_t start;
 630         cairo_rectangle_t end;
 631
 632         if (entry->anchor == entry->cursor)
 633                 return;
 634
 635         text_layout_extents(entry->layout, &extents);
 636
 637         text_layout_index_to_pos(entry->layout, start_index, &start);
 638         text_layout_index_to_pos(entry->layout, end_index, &end);
 639
 640         cairo_save (cr);
 641
 642         cairo_set_source_rgba(cr, 0.3, 0.3, 1.0, 0.5);
 643         cairo_rectangle(cr,
 644                         start.x, extents.y_bearing + extents.height + 2,
 645                         end.x - start.x, -extents.height - 4);
 646         cairo_fill(cr);
 647
 648         cairo_rectangle(cr,
 649                         start.x, extents.y_bearing + extents.height,
 650                         end.x - start.x, -extents.height);
 651         cairo_clip(cr);
 652         cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
 653         text_layout_draw(entry->layout, cr);
 654
 655         cairo_restore (cr);
 656 }
 657
 658 static void
 659 text_entry_draw_cursor(struct text_entry *entry, cairo_t *cr)
 660 {
 661         cairo_text_extents_t extents;
 662         cairo_rectangle_t cursor_pos;
 663
 664         text_layout_extents(entry->layout, &extents);
 665         text_layout_get_cursor_pos(entry->layout,
 666                                    entry->cursor + entry->preedit_cursor,
 667                                    &cursor_pos);
 668
 669         cairo_set_line_width(cr, 1.0);
 670         cairo_move_to(cr, cursor_pos.x, extents.y_bearing + extents.height + 2);
 671         cairo_line_to(cr, cursor_pos.x, extents.y_bearing - 2);
 672         cairo_stroke(cr);
 673 }
 674
 675 static void
 676 text_entry_draw_preedit(struct text_entry *entry, cairo_t *cr)
 677 {
 678         cairo_text_extents_t extents;
 679         cairo_rectangle_t start;
 680         cairo_rectangle_t end;
 681
 682         if (!entry->preedit_text)
 683                 return;
 684
 685         text_layout_extents(entry->layout, &extents);
 686
 687         text_layout_index_to_pos(entry->layout, entry->cursor, &start);
 688         text_layout_index_to_pos(entry->layout,
 689                                  entry->cursor + strlen(entry->preedit_text),
 690                                  &end);
 691
 692         cairo_save (cr);
 693
 694         cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0);
 695         cairo_rectangle(cr,
 696                         start.x, 0,
 697                         end.x - start.x, 1);
 698         cairo_fill(cr);
 699
 700         cairo_restore (cr);
 701 }
 702
 703 static void
 704 text_entry_redraw_handler(struct widget *widget, void *data)
 705 {
 706         struct text_entry *entry = data;
 707         cairo_surface_t *surface;
 708         struct rectangle allocation;
 709         cairo_t *cr;
 710
 711         surface = window_get_surface(entry->window);
 712         widget_get_allocation(entry->widget, &allocation);
 713
 714         cr = cairo_create(surface);
 715         cairo_rectangle(cr, allocation.x, allocation.y, allocation.width, allocation.height);
 716         cairo_clip(cr);
 717
 718         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 719
 720         cairo_push_group(cr);
 721         cairo_translate(cr, allocation.x, allocation.y);
 722
 723         cairo_set_source_rgba(cr, 1, 1, 1, 1);
 724         cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
 725         cairo_fill(cr);
 726
 727         cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
 728
 729         if (entry->active) {
 730                 cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
 731                 cairo_set_line_width (cr, 3);
 732                 cairo_set_source_rgba(cr, 0, 0, 1, 1.0);
 733                 cairo_stroke(cr);
 734         }
 735
 736         cairo_set_source_rgba(cr, 0, 0, 0, 1);
 737
 738         cairo_translate(cr, 10, allocation.height / 2);
 739         text_layout_draw(entry->layout, cr);
 740
 741         text_entry_draw_selection(entry, cr);
 742
 743         text_entry_draw_cursor(entry, cr);
 744
 745         text_entry_draw_preedit(entry, cr);
 746
 747         cairo_pop_group_to_source(cr);
 748         cairo_paint(cr);
 749
 750         cairo_destroy(cr);
 751         cairo_surface_destroy(surface);
 752 }
 753
 754 static int
 755 text_entry_motion_handler(struct widget *widget,
 756                           struct input *input, uint32_t time,
 757                           float x, float y, void *data)
 758 {
 759         struct text_entry *entry = data;
 760         struct rectangle allocation;
 761
 762         widget_get_allocation(entry->widget, &allocation);
 763
 764         text_entry_set_cursor_position(entry,
 765                                        x - allocation.x,
 766                                        y - allocation.y);
 767
 768         return CURSOR_IBEAM;
 769 }
 770
 771 static void
 772 text_entry_button_handler(struct widget *widget,
 773                           struct input *input, uint32_t time,
 774                           uint32_t button,
 775                           enum wl_pointer_button_state state, void *data)
 776 {
 777         struct text_entry *entry = data;
 778         struct rectangle allocation;
 779         int32_t x, y;
 780
 781         widget_get_allocation(entry->widget, &allocation);
 782         input_get_position(input, &x, &y);
 783
 784         if (button != BTN_LEFT) {
 785                 return;
 786         }
 787
 788         text_entry_set_cursor_position(entry,
 789                                        x - allocation.x,
 790                                        y - allocation.y);
 791
 792         if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
 793                 struct wl_seat *seat = input_get_seat(input);
 794
 795                 text_entry_activate(entry, seat);
 796
 797                 text_entry_set_anchor_position(entry,
 798                                                x - allocation.x,
 799                                                y - allocation.y);
 800
 801                 widget_set_motion_handler(entry->widget, text_entry_motion_handler);
 802         } else {
 803                 widget_set_motion_handler(entry->widget, NULL);
 804         }
 805 }
 806
 807 static void
 808 editor_button_handler(struct widget *widget,
 809                       struct input *input, uint32_t time,
 810                       uint32_t button,
 811                       enum wl_pointer_button_state state, void *data)
 812 {
 813         struct editor *editor = data;
 814
 815         if (button != BTN_LEFT) {
 816                 return;
 817         }
 818
 819         if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
 820                 struct wl_seat *seat = input_get_seat(input);
 821
 822                 text_entry_deactivate(editor->entry, seat);
 823                 text_entry_deactivate(editor->editor, seat);
 824         }
 825 }
 826
 827 static void
 828 global_handler(struct wl_display *display, uint32_t id,
 829                const char *interface, uint32_t version, void *data)
 830 {
 831         struct editor *editor = data;
 832
 833         if (!strcmp(interface, "text_model_factory")) {
 834                 editor->text_model_factory = wl_display_bind(display, id,
 835                                                              &text_model_factory_interface);
 836         }
 837 }
 838
 839 int
 840 main(int argc, char *argv[])
 841 {
 842         struct editor editor;
 843
 844         editor.display = display_create(argc, argv);
 845         if (editor.display == NULL) {
 846                 fprintf(stderr, "failed to create display: %m\n");
 847                 return -1;
 848         }
 849         wl_display_add_global_listener(display_get_display(editor.display),
 850                                        global_handler, &editor);
 851
 852
 853         editor.window = window_create(editor.display);
 854         editor.widget = frame_create(editor.window, &editor);
 855
 856         editor.entry = text_entry_create(&editor, "Entry");
 857         editor.editor = text_entry_create(&editor, "Editor");
 858         text_entry_set_preedit(editor.editor, "preedit", strlen("preedit"));
 859
 860         window_set_title(editor.window, "Text Editor");
 861
 862         widget_set_redraw_handler(editor.widget, redraw_handler);
 863         widget_set_resize_handler(editor.widget, resize_handler);
 864         widget_set_button_handler(editor.widget, editor_button_handler);
 865
 866         window_schedule_resize(editor.window, 500, 400);
 867
 868         display_run(editor.display);
 869
 870         text_entry_destroy(editor.entry);
 871         text_entry_destroy(editor.editor);
 872
 873         return 0;
 874 }