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