The Battle for Wesnoth  1.19.8+dev
text_box_base.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2008 - 2024
3  by Mark de Wever <koraq@xs4all.nl>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #define GETTEXT_DOMAIN "wesnoth-lib"
17 
19 
20 #include "cursor.hpp"
21 #include "desktop/clipboard.hpp"
23 #include "gui/core/log.hpp"
24 #include "gui/core/timer.hpp"
25 #include "gui/widgets/window.hpp"
27 
28 #include <functional>
29 #include <limits>
30 
31 #define LOG_SCOPE_HEADER get_control_type() + " [" + id() + "] " + __func__
32 #define LOG_HEADER LOG_SCOPE_HEADER + ':'
33 
34 using namespace std::chrono_literals;
35 
36 namespace gui2
37 {
38 
39 text_box_base::text_box_base(const implementation::builder_styled_widget& builder, const std::string& control_type)
40  : styled_widget(builder, control_type)
41  , state_(ENABLED)
42  , text_()
43  , selection_start_(0)
44  , selection_length_(0)
45  , editable_(true)
46  , ime_composing_(false)
47  , ime_start_point_(0)
48  , cursor_timer_(0)
49  , cursor_alpha_(0)
50  , cursor_blink_rate_(750ms)
51 {
52  auto cfg = get_control(control_type, builder.definition);
53  set_font_family(cfg->text_font_family);
54 
55 #ifdef __unix__
56  // pastes on UNIX systems.
57  connect_signal<event::MIDDLE_BUTTON_CLICK>(std::bind(
58  &text_box_base::signal_handler_middle_button_click, this, std::placeholders::_2, std::placeholders::_3));
59 
60 #endif
61 
62  connect_signal<event::SDL_KEY_DOWN>(std::bind(
63  &text_box_base::signal_handler_sdl_key_down, this, std::placeholders::_2, std::placeholders::_3, std::placeholders::_5, std::placeholders::_6));
64  connect_signal<event::SDL_TEXT_INPUT>(std::bind(&text_box_base::handle_commit, this, std::placeholders::_3, std::placeholders::_5));
65  connect_signal<event::SDL_TEXT_EDITING>(std::bind(&text_box_base::handle_editing, this, std::placeholders::_3, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7));
66 
67  connect_signal<event::RECEIVE_KEYBOARD_FOCUS>(std::bind(
68  &text_box_base::signal_handler_receive_keyboard_focus, this, std::placeholders::_2));
69  connect_signal<event::LOSE_KEYBOARD_FOCUS>(
70  std::bind(&text_box_base::signal_handler_lose_keyboard_focus, this, std::placeholders::_2));
71 
72  connect_signal<event::MOUSE_ENTER>(
73  std::bind(&text_box_base::signal_handler_mouse_enter, this, std::placeholders::_2, std::placeholders::_3));
74  connect_signal<event::MOUSE_LEAVE>(
75  std::bind(&text_box_base::signal_handler_mouse_leave, this, std::placeholders::_2, std::placeholders::_3));
76 
77  toggle_cursor_timer(true);
78 }
79 
81 {
82  toggle_cursor_timer(false);
83  update_mouse_cursor(false);
84 }
85 
86 void text_box_base::set_active(const bool active)
87 {
88  if(get_active() != active) {
89  set_state(active ? ENABLED : DISABLED);
90  }
91 }
92 
94 {
95  return state_ != DISABLED;
96 }
97 
98 unsigned text_box_base::get_state() const
99 {
100  return state_;
101 }
102 
103 void text_box_base::set_maximum_length(const std::size_t maximum_length)
104 {
105  if(maximum_length == 0) {
106  return;
107  }
108 
109  const bool need_update = text_.get_length() > maximum_length;
110 
111  text_.set_maximum_length(maximum_length);
112 
113  if(need_update) {
114  if(selection_start_ > maximum_length) {
115  selection_start_ = maximum_length;
116  selection_length_ = 0;
117  } else if(selection_start_ + selection_length_ > maximum_length) {
118  selection_length_ = maximum_length - selection_start_;
119  }
120  update_canvas();
121  queue_redraw();
122  }
123 }
124 
125 void text_box_base::set_value(const std::string& text)
126 {
127  if(text != text_.text()) {
129 
130  // default to put the cursor at the end of the buffer.
132  selection_length_ = 0;
133  update_canvas();
134  queue_redraw();
135  }
136 }
137 
138 void text_box_base::set_cursor(const std::size_t offset, const bool select)
139 {
141 
142  if(select) {
143  selection_length_ = (selection_start_ == offset) ? 0 : -static_cast<int>(selection_start_ - offset);
144  } else {
145  selection_start_ = (offset <= text_.get_length()) ? offset : 0;
146  selection_length_ = 0;
147  }
148 
149  update_canvas();
150  queue_redraw();
151 }
152 
153 void text_box_base::insert_char(const std::string& unicode)
154 {
155  if(!editable_)
156  {
157  return;
158  }
159 
161 
163  // Update status
164  size_t plain_text_len = utf8::size(plain_text());
165  size_t cursor_pos = selection_start_ + utf8::size(unicode);
166  if (get_use_markup() && (selection_start_ + utf8::size(unicode) > plain_text_len + 1)) {
167  cursor_pos = plain_text_len;
168  }
169  set_cursor(cursor_pos, false);
170  update_canvas();
171  queue_redraw();
172  }
173 }
174 
176 {
177  if(!is_composing()) {
178  return 0;
179  }
180 
181  size_t text_length = utf8::size(text_.text());
182  size_t text_cached_length = utf8::size(text_cached_);
183  if(text_length < text_cached_length) {
184  return 0;
185  }
186 
188 }
189 
191 {
192  ime_composing_ = false;
193  // We need to inform the IME that text input is no longer in progress.
194  SDL_StopTextInput();
195  SDL_StartTextInput();
196 }
197 
199 {
200  if(selection_length_ == 0) {
201  return;
202  }
203 
204  unsigned end, start = selection_start_;
205  const std::string txt = get_use_markup() ? plain_text() : text_.text();
206 
207  if(selection_length_ > 0) {
208  end = utf8::index(txt, start + selection_length_);
209  start = utf8::index(txt, start);
210  } else {
211  // inverse selection: selection_start_ is in fact the end
212  end = utf8::index(txt, start);
214  }
216 }
217 
219 {
220  if(!editable_)
221  {
222  return;
223  }
224 
225  const std::string& text = desktop::clipboard::copy_from_clipboard();
226  if(text.empty()) {
227  return;
228  }
229 
231 
233 
234  update_canvas();
235  queue_redraw();
236  fire(event::NOTIFY_MODIFIED, *this, nullptr);
237 }
238 
239 void text_box_base::set_selection_start(const std::size_t selection_start)
240 {
241  if(selection_start != selection_start_) {
242  selection_start_ = selection_start;
243  queue_redraw();
244  }
245 }
246 
247 void text_box_base::set_selection_length(const int selection_length)
248 {
249  if(selection_length != selection_length_) {
250  selection_length_ = selection_length;
251  queue_redraw();
252  }
253 }
254 
255 void text_box_base::set_selection(std::size_t start, int length)
256 {
257  const std::size_t text_size = text_.get_length();
258 
259  if(start >= text_size) {
260  start = text_size;
261  }
262 
263  if(length == 0) {
264  set_cursor(start, false);
265  return;
266  }
267 
268  // The text pos/size type differs in both signedness and size with the
269  // selection length. Such is life.
270  const int sel_start = std::min<std::size_t>(start, std::numeric_limits<int>::max());
271  const int sel_max_length = std::min<std::size_t>(text_size - start, std::numeric_limits<int>::max());
272 
273  const bool backwards = length < 0;
274 
275  if(backwards && -length > sel_start) {
276  length = -sel_start;
277  } else if(!backwards && length > sel_max_length) {
278  length = sel_max_length;
279  }
280 
282  set_selection_length(length);
283 
284  update_canvas();
285 }
286 
288 {
289  if(state != state_) {
290  state_ = state;
291  queue_redraw();
292  }
293 }
294 
296 {
297  if(cursor_blink_rate_ == 0ms) {
298  return;
299  }
300 
301  if(cursor_timer_) {
303  }
304 
305  cursor_timer_ = enable
307  : 0;
308 }
309 
311 {
312  unsigned was_alpha = cursor_alpha_;
313  switch(state_) {
314  case DISABLED:
315  cursor_alpha_ = 0;
316  return;
317  case ENABLED:
318  cursor_alpha_ = 255;
319  return;
320  default:
321  // FIXME: very hacky way to check if the widget's owner is the top window
322  // back() on an empty vector is UB and was causing a crash when run on Wayland (see #7104 on github)
323  const auto& dispatchers = event::get_all_dispatchers();
324  if(!dispatchers.empty() && static_cast<event::dispatcher*>(get_window()) != dispatchers.back()) {
325  cursor_alpha_ = 0;
326  } else {
327  cursor_alpha_ = (~cursor_alpha_) & 0xFF;
328  }
329  }
330 
331  if(was_alpha == cursor_alpha_) {
332  return;
333  }
334 
335  for(auto& tmp : get_canvases()) {
336  tmp.set_variable("cursor_alpha", wfl::variant(cursor_alpha_));
337  }
338 
339  queue_redraw();
340 }
341 
343 {
344  if(cursor_blink_rate_ == 0ms) {
345  return;
346  }
347 
348  cursor_alpha_ = 255;
349 
350  for(auto& tmp : get_canvases()) {
351  tmp.set_variable("cursor_alpha", wfl::variant(cursor_alpha_));
352  }
353 
354  // Restart the blink timer.
355  toggle_cursor_timer(true);
356 }
357 
358 void text_box_base::handle_key_left_arrow(SDL_Keymod modifier, bool& handled)
359 {
360  /** @todo implement the ctrl key. */
362 
363  handled = true;
364  const int offset = selection_start_ - 1 + selection_length_;
365  if(offset >= 0) {
366  set_cursor(offset, (modifier & KMOD_SHIFT) != 0);
367  }
368 }
369 
370 void text_box_base::handle_key_right_arrow(SDL_Keymod modifier, bool& handled)
371 {
372  /** @todo implement the ctrl key. */
374 
375  handled = true;
376  const std::size_t offset = selection_start_ + 1 + selection_length_;
377  if(offset <= (get_use_markup() ? utf8::size(plain_text()) : text_.get_length())) {
378  set_cursor(offset, (modifier & KMOD_SHIFT) != 0);
379  }
380 }
381 
382 void text_box_base::handle_key_home(SDL_Keymod modifier, bool& handled)
383 {
385 
386  handled = true;
387  if(modifier & KMOD_CTRL) {
388  goto_start_of_data((modifier & KMOD_SHIFT) != 0);
389  } else {
390  goto_start_of_line((modifier & KMOD_SHIFT) != 0);
391  }
392 }
393 
394 void text_box_base::handle_key_end(SDL_Keymod modifier, bool& handled)
395 {
397 
398  handled = true;
399  if(modifier & KMOD_CTRL) {
400  goto_end_of_data((modifier & KMOD_SHIFT) != 0);
401  } else {
402  goto_end_of_line((modifier & KMOD_SHIFT) != 0);
403  }
404 }
405 
406 void text_box_base::handle_key_backspace(SDL_Keymod /*modifier*/, bool& handled)
407 {
409 
410  handled = true;
411  if(selection_length_ != 0) {
413  } else if(selection_start_) {
414  delete_char(true);
415  if(is_composing()) {
416  if(get_composition_length() == 0) {
417  ime_composing_ = false;
418  }
419  }
420  }
421  fire(event::NOTIFY_MODIFIED, *this, nullptr);
422 }
423 
424 void text_box_base::handle_key_delete(SDL_Keymod /*modifier*/, bool& handled)
425 {
427 
428  handled = true;
429  if(selection_length_ != 0) {
431  } else if(selection_start_ < text_.get_length()) {
432  delete_char(false);
433  if(is_composing()) {
434  if(get_composition_length() == 0) {
435  ime_composing_ = false;
436  }
437  }
438  }
439  fire(event::NOTIFY_MODIFIED, *this, nullptr);
440 }
441 
442 void text_box_base::handle_commit(bool& handled, const std::string& unicode)
443 {
445 
446  if(unicode.size() > 1 || unicode[0] != 0) {
447  handled = true;
448  if(is_composing()) {
450  ime_composing_ = false;
451  }
452  insert_char(unicode);
453  fire(event::NOTIFY_MODIFIED, *this, nullptr);
454  }
455 }
456 
457 /**
458  * SDL_TEXTEDITING handler. See example at https://wiki.libsdl.org/Tutorials/TextInput
459  */
460 void text_box_base::handle_editing(bool& handled, const std::string& unicode, int32_t start, int32_t len)
461 {
462  if(unicode.size() > 1 || unicode[0] != 0) {
463  handled = true;
464  std::size_t new_len = utf8::size(unicode);
465  if(!is_composing()) {
466  ime_composing_ = true;
469  text_cached_ = text_.text();
470  SDL_Rect rect = get_rectangle();
471  if(new_len > 0) {
473  rect.w = get_cursor_position(ime_start_point_ + new_len).x - rect.x;
474  } else {
475  rect.x += get_cursor_position(ime_start_point_ + new_len).x;
477  }
478  SDL_SetTextInputRect(&rect);
479  }
480 
481 #ifdef __unix__
482  // In SDL_TextEditingEvent, size of editing_text is limited
483  // If length of composition text is more than the limit,
484  // Linux (ibus) implementation of SDL separates it into multiple
485  // SDL_TextEditingEvent.
486  // start is start position of the separated event in entire composition text
487  if(start == 0) {
489  }
491 #else
492  std::string new_text(text_cached_);
493  utf8::insert(new_text, ime_start_point_, unicode);
494  text_.set_text(new_text, get_use_markup());
495 
496 #endif
497  int maximum_length = text_.get_length();
498 
499  // Update status
500  set_cursor(std::min(maximum_length, ime_start_point_ + start), false);
501  if(len > 0) {
502  set_cursor(std::min(maximum_length, ime_start_point_ + start + len), true);
503  }
504  update_canvas();
505  queue_redraw();
506  }
507 }
508 
510  bool& handled)
511 {
512  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
513 
514  paste_selection();
515 
516  handled = true;
517 }
518 
520  bool& handled,
521  const SDL_Keycode key,
522  SDL_Keymod modifier)
523 {
524 
525  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
526 
527 /*
528  * For copy, cut and paste we use a different key on the MAC. Even for 'select
529  * all', contradicting the comment in widgets/textbox.cpp:495.
530  *
531  * The reason for that is, by coupling 'select all' to the behavior for copy,
532  * cut and paste, the text box behavior as a whole gets consistent with default
533  * macOS hotkey idioms.
534  */
535 #ifdef __APPLE__
536  // Idiomatic modifier key in macOS computers.
537  const SDL_Keycode modifier_key = KMOD_GUI;
538 #else
539  // Idiomatic modifier key in Microsoft desktop environments. Common in
540  // GNU/Linux as well, to some extent.
541  const SDL_Keycode modifier_key = KMOD_CTRL;
542 #endif
543 
544  switch(key) {
545 
546  case SDLK_LEFT:
547  handle_key_left_arrow(modifier, handled);
548  break;
549 
550  case SDLK_RIGHT:
551  handle_key_right_arrow(modifier, handled);
552  break;
553 
554  case SDLK_UP:
555  handle_key_up_arrow(modifier, handled);
556  break;
557 
558  case SDLK_DOWN:
559  handle_key_down_arrow(modifier, handled);
560  break;
561 
562  case SDLK_PAGEUP:
563  handle_key_page_up(modifier, handled);
564  break;
565 
566  case SDLK_PAGEDOWN:
567  handle_key_page_down(modifier, handled);
568  break;
569 
570  case SDLK_a:
571  if(!(modifier & modifier_key)) {
572  return;
573  }
574 
575  select_all();
576  break;
577 
578  case SDLK_HOME:
579  handle_key_home(modifier, handled);
580  break;
581 
582  case SDLK_END:
583  handle_key_end(modifier, handled);
584  break;
585 
586  case SDLK_BACKSPACE:
587  if (!is_editable())
588  {
589  return;
590  }
591 
592  handle_key_backspace(modifier, handled);
593  break;
594 
595  case SDLK_u:
596  if( !(modifier & KMOD_CTRL) || !is_editable() ) {
597  return;
598  }
599 
600  handle_key_clear_line(modifier, handled);
601  break;
602 
603  case SDLK_DELETE:
604  if (!is_editable())
605  {
606  return;
607  }
608 
609  handle_key_delete(modifier, handled);
610  break;
611 
612  case SDLK_c:
613  if(!(modifier & modifier_key)) {
614  return;
615  }
616 
617  // atm we don't care whether there is something to copy or paste
618  // if nothing is there we still don't want to be chained.
619  copy_selection();
620  handled = true;
621  break;
622 
623  case SDLK_x:
624  if( !(modifier & modifier_key) ) {
625  return;
626  }
627 
628  copy_selection();
629 
630  if ( is_editable() ) {
632  }
633  handled = true;
634  break;
635 
636  case SDLK_v:
637  if( !(modifier & modifier_key) || !is_editable() ) {
638  return;
639  }
640 
641  paste_selection();
642  handled = true;
643  break;
644 
645  case SDLK_RETURN:
646  case SDLK_KP_ENTER:
647 
648 // TODO: check if removing the following check causes any side effects
649 // To be removed if there aren't any text rendering problems.
650 // if(!is_composing()) {
651 // return;
652 // }
653 
654  handle_key_enter(modifier, handled);
655  break;
656 
657  case SDLK_ESCAPE:
658  if(!is_composing() || (modifier & (KMOD_CTRL | KMOD_ALT | KMOD_GUI | KMOD_SHIFT))) {
659  return;
660  }
662  handled = true;
663  break;
664 
665  case SDLK_TAB:
666  handle_key_tab(modifier, handled);
667  break;
668 
669  default:
670  return;
671  }
672 }
673 
675 {
676  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
677 
679 }
680 
682 {
683  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
684 
686 }
687 
689  bool& handled)
690 {
691  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
692 
693  if(state_ != FOCUSED) {
695  }
696 
697  update_mouse_cursor(true);
698 
699  handled = true;
700 }
701 
703  bool& handled)
704 {
705  DBG_GUI_E << LOG_HEADER << ' ' << event << ".";
706 
707  if(state_ != FOCUSED) {
709  }
710 
711  update_mouse_cursor(false);
712 
713  handled = true;
714 }
715 
717 {
718  // Someone else may set the mouse cursor for us to something unusual (e.g.
719  // the WAIT cursor) so we ought to mess with that only if it's set to
720  // NORMAL or IBEAM.
721 
722  if(enable && cursor::get() == cursor::NORMAL) {
724  } else if(!enable && cursor::get() == cursor::IBEAM) {
726  }
727 }
728 
729 
730 } // namespace gui2
std::size_t get_length() const
Gets the length of the text in bytes.
Definition: text.hpp:270
pango_text & set_maximum_length(const std::size_t maximum_length)
Definition: text.cpp:601
unsigned insert_text(const unsigned offset, const std::string &text, const bool use_markup=false)
Inserts UTF-8 text.
Definition: text.cpp:141
bool set_text(const std::string &text, const bool markedup)
Sets the text to render.
Definition: text.cpp:440
const std::string & text() const
Definition: text.hpp:288
Base class for event handling.
Definition: dispatcher.hpp:150
bool fire(const ui_event event, widget &target)
Fires an event which has no extra parameters.
Definition: dispatcher.cpp:74
std::vector< canvas > & get_canvases()
virtual void update_canvas()
Updates the canvas(ses).
bool get_use_markup() const
virtual void handle_key_backspace(SDL_Keymod modifier, bool &handled)
Backspace key pressed.
virtual void handle_commit(bool &handled, const std::string &unicode)
virtual bool get_active() const override
See styled_widget::get_active.
virtual unsigned get_state() const override
See styled_widget::get_state.
void update_mouse_cursor(bool enable)
virtual void goto_start_of_line(const bool select=false)=0
Moves the cursor to the beginning of the line.
virtual void handle_key_delete(SDL_Keymod modifier, bool &handled)
Delete key pressed.
virtual void insert_char(const std::string &unicode)
Inserts a character at the cursor.
virtual void handle_editing(bool &handled, const std::string &unicode, int32_t start, int32_t length)
SDL_TEXTEDITING handler.
void set_state(const state_t state)
std::chrono::milliseconds cursor_blink_rate_
virtual void copy_selection()
Copies the current selection.
virtual void handle_key_left_arrow(SDL_Keymod modifier, bool &handled)
Left arrow key pressed.
virtual void toggle_cursor_timer(bool enable)
state_t state_
Current state of the widget.
virtual void goto_end_of_line(const bool select=false)=0
Moves the cursor to the end of the line.
void signal_handler_mouse_leave(const event::ui_event event, bool &handled)
void set_selection(std::size_t start, int length)
Sets or clears the text selection.
std::size_t selection_start_
Start of the selected text.
size_t get_composition_length() const
Get length of composition text by IME.
std::string plain_text()
virtual void handle_key_enter(SDL_Keymod, bool &)
Enter key.
int selection_length_
Length of the selected text.
unsigned short cursor_alpha_
std::size_t cursor_timer_
virtual void handle_key_up_arrow(SDL_Keymod modifier, bool &handled)=0
Every key can have several behaviors.
const std::string & text() const
point get_cursor_position(const unsigned column, const unsigned line=0) const
void signal_handler_mouse_enter(const event::ui_event event, bool &handled)
virtual void handle_key_tab(SDL_Keymod, bool &)
Tab key.
std::string text_cached_
Cached version of the text without any pending IME modifications.
void set_font_family(font::family_class fclass)
virtual void set_value(const std::string &text)
The set_value is virtual for the password_box class.
virtual void paste_selection()
Pastes the current selection.
state_t
Note the order of the states must be the same as defined in settings.hpp.
font::pango_text text_
The text entered in the widget.
void signal_handler_lose_keyboard_focus(const event::ui_event event)
void signal_handler_sdl_key_down(const event::ui_event event, bool &handled, const SDL_Keycode key, SDL_Keymod modifier)
virtual void handle_key_right_arrow(SDL_Keymod modifier, bool &handled)
Right arrow key pressed.
virtual void handle_key_clear_line(SDL_Keymod modifier, bool &handled)=0
Clears the current line.
void set_selection_start(const std::size_t selection_start)
virtual void set_cursor(const std::size_t offset, const bool select)
Moves the cursor at the wanted position.
virtual void handle_key_page_up(SDL_Keymod, bool &)
Page up key.
virtual void handle_key_home(SDL_Keymod modifier, bool &handled)
Home key pressed.
bool is_editable() const
Check whether text can be edited or not.
virtual void handle_key_down_arrow(SDL_Keymod modifier, bool &handled)=0
Down arrow key pressed.
void signal_handler_receive_keyboard_focus(const event::ui_event event)
virtual void goto_end_of_data(const bool select=false)
Moves the cursor to the end of all text.
void signal_handler_middle_button_click(const event::ui_event event, bool &handled)
virtual void handle_key_end(SDL_Keymod modifier, bool &handled)
End key pressed.
virtual void handle_key_page_down(SDL_Keymod, bool &)
Page down key.
virtual void set_active(const bool active) override
See styled_widget::set_active.
void set_selection_length(const int selection_length)
bool is_composing() const
bool editable_
If this text_box_base is editable.
virtual void goto_start_of_data(const bool select=false)
Moves the cursor to the beginning of the data.
virtual void cursor_timer_callback()
Implements blinking cursor functionality.
virtual void reset_cursor_state()
void set_maximum_length(const std::size_t maximum_length)
virtual void delete_selection()=0
Deletes the current selection.
virtual void delete_char(const bool before_cursor)=0
Deletes the character.
void select_all()
Selects all text.
void queue_redraw()
Indicates that this widget should be redrawn.
Definition: widget.cpp:464
window * get_window()
Get the parent window.
Definition: widget.cpp:117
rect get_rectangle() const
Gets the bounding rectangle of the widget on the screen.
Definition: widget.cpp:321
Define the common log macros for the gui toolkit.
#define DBG_GUI_E
Definition: log.hpp:35
This file contains the window object, this object is a top level container which has the event manage...
CURSOR_TYPE get()
Definition: cursor.cpp:216
@ NORMAL
Definition: cursor.hpp:28
@ IBEAM
Definition: cursor.hpp:28
void set(CURSOR_TYPE type)
Use the default parameter to reset cursors.
Definition: cursor.cpp:176
void copy_to_clipboard(const std::string &text)
Copies text to the clipboard.
Definition: clipboard.cpp:27
std::string copy_from_clipboard()
Copies text from the clipboard.
Definition: clipboard.cpp:32
EXIT_STATUS start(bool clear_id, const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
ui_event
The event sent to the dispatcher.
Definition: handler.hpp:115
@ NOTIFY_MODIFIED
Definition: handler.hpp:158
std::vector< dispatcher * > & get_all_dispatchers()
Gets all event dispatchers in the Z order.
Definition: handler.cpp:873
Generic file dialog.
std::size_t add_timer(const std::chrono::milliseconds &interval, const std::function< void(std::size_t id)> &callback, const bool repeat)
Adds a new timer.
Definition: timer.cpp:123
bool remove_timer(const std::size_t id)
Removes a timer.
Definition: timer.cpp:164
resolution_definition_ptr get_control(const std::string &control_type, const std::string &definition)
Returns the appropriate config data for a widget instance fom the active GUI definition.
std::string & insert(std::string &str, const std::size_t pos, const std::string &insert)
Insert a UTF-8 string at the specified position.
Definition: unicode.cpp:98
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:85
std::size_t index(std::string_view str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:70
std::string definition
Parameters for the styled_widget.
An abstract description of a rectangle with integer coordinates.
Definition: rect.hpp:49
#define LOG_HEADER
#define LOG_SCOPE_HEADER
Contains the gui2 timer routines.