Fix style and warnings

AllyTally · InfoTeddy · AllyTally · commit b0ea04c68495 · 2023-04-04T14:41:32.000-03:00
Co-authored-by: Misa Elizabeth Kai &lt;infoteddy@infoteddy.info&gt;
diff --git a/desktop_version/src/Editor.cpp b/desktop_version/src/Editor.cpp
@@ -1583,11 +1583,10 @@ void editorrender(void)
             // so we can redraw the text over top
             // with a different color.
 
-            if (TextInput::selecting) {
+            if (TextInput::selecting)
+            {
                 const SDL_Color color = graphics.getRGB(123, 111, 218);
-                const int x = TextInput::cursor_select_pos.x;
                 const int y = TextInput::cursor_select_pos.y;
-                const int w = TextInput::cursor_pos.x - x;
                 const int h = TextInput::cursor_pos.y - y;
 
                 const SelectionRect rect = TextInput::reorder_selection_positions();
diff --git a/desktop_version/src/TextInput.cpp b/desktop_version/src/TextInput.cpp
@@ -11,7 +11,8 @@
 #include "UtilityClass.h"
 #include "Vlogging.h"
 
-namespace TextInput {
+namespace TextInput
+{
     bool taking_input;
     bool selecting;
     int flash_timer;
@@ -24,11 +25,13 @@ namespace TextInput {
     SDL_Point cursor_select_pos;
     int cursor_x_tallest;
 
-    void init(void) {
+    void init(void)
+    {
         taking_input = false;
     }
 
-    void attach_input(std::vector<std::string>* text) {
+    void attach_input(std::vector<std::string>* text)
+    {
         taking_input = true;
         current_text = text;
         selecting = false;
@@ -41,7 +44,8 @@ namespace TextInput {
         send_cursor_to_end();
     }
 
-    void attach_input(std::string* text) {
+    void attach_input(std::string* text)
+    {
         taking_input = true;
         current_text_line = text;
         selecting = false;
@@ -58,7 +62,8 @@ namespace TextInput {
         cursor_x_tallest = cursor_pos.x;
     }
 
-    void detach_input(void) {
+    void detach_input(void)
+    {
         taking_input = false;
         SDL_StopTextInput();
     }
@@ -70,13 +75,16 @@ namespace TextInput {
         cursor_x_tallest = cursor_pos.x;
     }
 
-    void insert_text(std::string text) {
+    void insert_text(std::string text)
+    {
         // Insert text at cursor position, respecting newlines
         // Don't bother deleting selection, already done
 
         std::string::iterator it;
-        for (it = text.begin(); it != text.end(); it++) {
-            if (*it == '\n') {
+        for (it = text.begin(); it != text.end(); it++)
+        {
+            if (*it == '\n')
+            {
                 insert_newline();
             }
             else if (*it != '\r' && *it != '\0')
@@ -193,7 +201,8 @@ namespace TextInput {
 
         SelectionRect rect = reorder_selection_positions();
 
-        if (rect.y == rect.y2) {
+        if (rect.y == rect.y2)
+        {
             return UTF8_substr(get_line(rect.y), rect.x, rect.x2);
         }
 
@@ -202,14 +211,16 @@ namespace TextInput {
 
         // Loop through the lines in between
         int total_length = SDL_strlen(select_part_first_line) + SDL_strlen(select_part_last_line) + 1;
-        for (int i = rect.y + 1; i < rect.y2; i++) {
+        for (int i = rect.y + 1; i < rect.y2; i++)
+        {
             total_length += SDL_strlen(get_line(i)) + 1;
         }
 
         char* select_part = (char*)SDL_malloc(total_length);
         strcpy(select_part, select_part_first_line);
         strcat(select_part, "\n");
-        for (int i = rect.y + 1; i < rect.y2; i++) {
+        for (int i = rect.y + 1; i < rect.y2; i++)
+        {
             strcat(select_part, get_line(i));
             strcat(select_part, "\n");
         }
@@ -221,15 +232,19 @@ namespace TextInput {
         return select_part;
     }
 
-    SelectionRect reorder_selection_positions(void) {
+    SelectionRect reorder_selection_positions(void)
+    {
         SelectionRect positions;
         bool in_front = false;
 
-        if (cursor_pos.y > cursor_select_pos.y) {
+        if (cursor_pos.y > cursor_select_pos.y)
+        {
             in_front = true;
         }
-        else if (cursor_pos.y == cursor_select_pos.y) {
-            if (cursor_pos.x >= cursor_select_pos.x) {
+        else if (cursor_pos.y == cursor_select_pos.y)
+        {
+            if (cursor_pos.x >= cursor_select_pos.x)
+            {
                 in_front = true;
             }
         }
@@ -254,7 +269,8 @@ namespace TextInput {
 
     void remove_characters(int x, int y, int x2, int y2)
     {
-        if (x == x2 && y == y2) {
+        if (x == x2 && y == y2)
+        {
             return;
         }
         // Get the rest of the last line
@@ -295,14 +311,17 @@ namespace TextInput {
     void move_cursor_up(void)
     {
         bool reset = process_selection();  // Only returns true if you don't hold shift
-        if (reset && (cursor_pos.y > cursor_select_pos.y)) {
+        if (reset && cursor_pos.y > cursor_select_pos.y)
+        {
             cursor_pos.y = cursor_select_pos.y;
         }
 
-        if (cursor_pos.y > 0) {
+        if (cursor_pos.y > 0)
+        {
             cursor_pos.y--;
             cursor_pos.x = cursor_x_tallest;
-            if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {
+            if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
+            {
                 cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));
             }
         }
@@ -311,14 +330,17 @@ namespace TextInput {
     void move_cursor_down(void)
     {
         bool reset = process_selection();  // Only returns true if you don't hold shift
-        if (reset && (cursor_pos.y < cursor_select_pos.y)) {
+        if (reset && cursor_pos.y < cursor_select_pos.y)
+        {
             cursor_pos.y = cursor_select_pos.y;
         }
 
-        if (cursor_pos.y < get_lines() - 1) {
+        if (cursor_pos.y < get_lines() - 1)
+        {
             cursor_pos.y++;
             cursor_pos.x = cursor_x_tallest;
-            if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {
+            if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
+            {
                 cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));
             }
         }
@@ -330,17 +352,19 @@ namespace TextInput {
 
     bool is_word_part(char character)
     {
-        return character > 0x7F || isalpha(character) || isdigit(character) || character == '_' || character == '-';
+        return (short) character < 0 || (short) character > 0x7F || isalpha(character) || isdigit(character) || character == '_' || character == '-';
     }
 
     void move_cursor_left(void)
     {
         bool reset = process_selection();  // Only returns true if you don't hold shift
-        if (reset) {
+        if (reset)
+        {
             cursor_pos.x = cursor_select_pos.x;
         }
 
-        if (cursor_pos.x == 0 && cursor_pos.y == 0) {
+        if (cursor_pos.x == 0 && cursor_pos.y == 0)
+        {
             cursor_x_tallest = 0;
             return;
         }
@@ -354,7 +378,7 @@ namespace TextInput {
 
             while (true)
             {
-                char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);
+                character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);
                 if (is_word_part(character[0]) != is_word)
                 {
                     SDL_free(character);
@@ -372,7 +396,8 @@ namespace TextInput {
         }
         else
         {
-            if (cursor_pos.x > 0) {
+            if (cursor_pos.x > 0)
+            {
                 cursor_pos.x--;
             }
             else if (cursor_pos.y > 0)
@@ -388,11 +413,13 @@ namespace TextInput {
     void move_cursor_right(void)
     {
         bool reset = process_selection();  // Only returns true if you don't hold shift
-        if (reset) {
+        if (reset)
+        {
             cursor_pos.x = cursor_select_pos.x;
         }
 
-        if (cursor_pos.x >= UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y == get_lines() - 1) {
+        if (cursor_pos.x >= (int) UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y == get_lines() - 1)
+        {
             cursor_x_tallest = cursor_pos.x;
             return;
         }
@@ -406,15 +433,15 @@ namespace TextInput {
 
             while (true)
             {
-                char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);
+                character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);
                 if (is_word_part(character[0]) != is_word)
                 {
                     SDL_free(character);
                     break;
                 }
                 SDL_free(character);
                 cursor_pos.x++;
-                if (cursor_pos.x >= UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y < get_lines() - 1)
+                if (cursor_pos.x >= (int) UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y < get_lines() - 1)
                 {
                     cursor_pos.y++;
                     cursor_pos.x = 0;
@@ -425,7 +452,8 @@ namespace TextInput {
         else
         {
 
-            if (cursor_pos.x < UTF8_total_codepoints(get_line(cursor_pos.y))) {
+            if (cursor_pos.x < (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
+            {
                 cursor_pos.x++;
             }
             else if (cursor_pos.y < get_lines() - 1)
@@ -441,7 +469,8 @@ namespace TextInput {
     void backspace(void)
     {
         // The user pressed backspace.
-        if (selecting) {
+        if (selecting)
+        {
             remove_selection();
             return;
         }
@@ -481,7 +510,7 @@ namespace TextInput {
                 int start_x = cursor_pos.x;
                 while (true)
                 {
-                    char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);
+                    character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);
                     if (is_word_part(character[0]) != is_word)
                     {
                         SDL_free(character);
@@ -537,12 +566,13 @@ namespace TextInput {
     void delete_key(void)
     {
         // The user pressed delete.
-        if (selecting) {
+        if (selecting)
+        {
             remove_selection();
             return;
         }
 
-        if (cursor_pos.x == UTF8_total_codepoints(get_line(cursor_pos.y)))
+        if (cursor_pos.x == (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
         {
             if (cursor_pos.y < get_lines() - 1)
             {
@@ -570,7 +600,7 @@ namespace TextInput {
                 int start_x = cursor_pos.x;
                 while (true)
                 {
-                    char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);
+                    character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);
                     if (is_word_part(character[0]) != is_word)
                     {
                         SDL_free(character);
@@ -598,10 +628,12 @@ namespace TextInput {
         }
     }
 
-    void handle_events(SDL_Event e) {
+    void handle_events(SDL_Event e)
+    {
         if (!taking_input) return;
 
-        if (e.type == SDL_KEYDOWN) {
+        if (e.type == SDL_KEYDOWN)
+        {
             // Show cursor!!
             flash_timer = 0;
 
@@ -613,7 +645,8 @@ namespace TextInput {
             }
             else if (e.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL)
             {
-                if (selecting) {
+                if (selecting)
+                {
                     remove_selection();
                 }
                 char* clipboard_text = SDL_GetClipboardText();
@@ -695,20 +728,24 @@ namespace TextInput {
             else if (e.key.keysym.sym == SDLK_PAGEUP && can_move_cursor)
             {
                 cursor_pos.y -= 10;
-                if (cursor_pos.y < 0) {
+                if (cursor_pos.y < 0)
+                {
                     cursor_pos.y = 0;
                 }
-                if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {
+                if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
+                {
                     cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));
                 }
             }
             else if (e.key.keysym.sym == SDLK_PAGEDOWN && can_move_cursor)
             {
                 cursor_pos.y += 10;
-                if (cursor_pos.y >= get_lines()) {
+                if (cursor_pos.y >= get_lines())
+                {
                     cursor_pos.y = get_lines() - 1;
                 }
-                if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {
+                if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))
+                {
                     cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));
                 }
             }
@@ -720,7 +757,8 @@ namespace TextInput {
             flash_timer = 0;
 
             //Append character(s)
-            if (selecting) {
+            if (selecting)
+            {
                 remove_selection();
             }
             insert_text(e.text.text);

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,8 @@`
`11`	`11`	`#include "UtilityClass.h"`
`12`	`12`	`#include "Vlogging.h"`
`13`	`13`
`14`		`-namespace TextInput {`
	`14`	`+namespace TextInput`
	`15`	`+{`
`15`	`16`	`bool taking_input;`
`16`	`17`	`bool selecting;`
`17`	`18`	`int flash_timer;`
`@@ -24,11 +25,13 @@ namespace TextInput {`
`24`	`25`	`SDL_Point cursor_select_pos;`
`25`	`26`	`int cursor_x_tallest;`
`26`	`27`
`27`		`- void init(void) {`
	`28`	`+ void init(void)`
	`29`	`+ {`
`28`	`30`	`taking_input = false;`
`29`	`31`	`}`
`30`	`32`
`31`		`- void attach_input(std::vector<std::string>* text) {`
	`33`	`+ void attach_input(std::vector<std::string>* text)`
	`34`	`+ {`
`32`	`35`	`taking_input = true;`
`33`	`36`	`current_text = text;`
`34`	`37`	`selecting = false;`
`@@ -41,7 +44,8 @@ namespace TextInput {`
`41`	`44`	`send_cursor_to_end();`
`42`	`45`	`}`
`43`	`46`
`44`		`- void attach_input(std::string* text) {`
	`47`	`+ void attach_input(std::string* text)`
	`48`	`+ {`
`45`	`49`	`taking_input = true;`
`46`	`50`	`current_text_line = text;`
`47`	`51`	`selecting = false;`
`@@ -58,7 +62,8 @@ namespace TextInput {`
`58`	`62`	`cursor_x_tallest = cursor_pos.x;`
`59`	`63`	`}`
`60`	`64`
`61`		`- void detach_input(void) {`
	`65`	`+ void detach_input(void)`
	`66`	`+ {`
`62`	`67`	`taking_input = false;`
`63`	`68`	`SDL_StopTextInput();`
`64`	`69`	`}`
`@@ -70,13 +75,16 @@ namespace TextInput {`
`70`	`75`	`cursor_x_tallest = cursor_pos.x;`
`71`	`76`	`}`
`72`	`77`
`73`		`- void insert_text(std::string text) {`
	`78`	`+ void insert_text(std::string text)`
	`79`	`+ {`
`74`	`80`	`// Insert text at cursor position, respecting newlines`
`75`	`81`	`// Don't bother deleting selection, already done`
`76`	`82`
`77`	`83`	`std::string::iterator it;`
`78`		`- for (it = text.begin(); it != text.end(); it++) {`
`79`		`- if (*it == '\n') {`
	`84`	`+ for (it = text.begin(); it != text.end(); it++)`
	`85`	`+ {`
	`86`	`+ if (*it == '\n')`
	`87`	`+ {`
`80`	`88`	`insert_newline();`
`81`	`89`	`}`
`82`	`90`	`else if (it != '\r' && it != '\0')`
`@@ -193,7 +201,8 @@ namespace TextInput {`
`193`	`201`
`194`	`202`	`SelectionRect rect = reorder_selection_positions();`
`195`	`203`
`196`		`- if (rect.y == rect.y2) {`
	`204`	`+ if (rect.y == rect.y2)`
	`205`	`+ {`
`197`	`206`	`return UTF8_substr(get_line(rect.y), rect.x, rect.x2);`
`198`	`207`	`}`
`199`	`208`
`@@ -202,14 +211,16 @@ namespace TextInput {`
`202`	`211`
`203`	`212`	`// Loop through the lines in between`
`204`	`213`	`int total_length = SDL_strlen(select_part_first_line) + SDL_strlen(select_part_last_line) + 1;`
`205`		`- for (int i = rect.y + 1; i < rect.y2; i++) {`
	`214`	`+ for (int i = rect.y + 1; i < rect.y2; i++)`
	`215`	`+ {`
`206`	`216`	`total_length += SDL_strlen(get_line(i)) + 1;`
`207`	`217`	`}`
`208`	`218`
`209`	`219`	`char* select_part = (char*)SDL_malloc(total_length);`
`210`	`220`	`strcpy(select_part, select_part_first_line);`
`211`	`221`	`strcat(select_part, "\n");`
`212`		`- for (int i = rect.y + 1; i < rect.y2; i++) {`
	`222`	`+ for (int i = rect.y + 1; i < rect.y2; i++)`
	`223`	`+ {`
`213`	`224`	`strcat(select_part, get_line(i));`
`214`	`225`	`strcat(select_part, "\n");`
`215`	`226`	`}`
`@@ -221,15 +232,19 @@ namespace TextInput {`
`221`	`232`	`return select_part;`
`222`	`233`	`}`
`223`	`234`
`224`		`- SelectionRect reorder_selection_positions(void) {`
	`235`	`+ SelectionRect reorder_selection_positions(void)`
	`236`	`+ {`
`225`	`237`	`SelectionRect positions;`
`226`	`238`	`bool in_front = false;`
`227`	`239`
`228`		`- if (cursor_pos.y > cursor_select_pos.y) {`
	`240`	`+ if (cursor_pos.y > cursor_select_pos.y)`
	`241`	`+ {`
`229`	`242`	`in_front = true;`
`230`	`243`	`}`
`231`		`- else if (cursor_pos.y == cursor_select_pos.y) {`
`232`		`- if (cursor_pos.x >= cursor_select_pos.x) {`
	`244`	`+ else if (cursor_pos.y == cursor_select_pos.y)`
	`245`	`+ {`
	`246`	`+ if (cursor_pos.x >= cursor_select_pos.x)`
	`247`	`+ {`
`233`	`248`	`in_front = true;`
`234`	`249`	`}`
`235`	`250`	`}`
`@@ -254,7 +269,8 @@ namespace TextInput {`
`254`	`269`
`255`	`270`	`void remove_characters(int x, int y, int x2, int y2)`
`256`	`271`	`{`
`257`		`- if (x == x2 && y == y2) {`
	`272`	`+ if (x == x2 && y == y2)`
	`273`	`+ {`
`258`	`274`	`return;`
`259`	`275`	`}`
`260`	`276`	`// Get the rest of the last line`
`@@ -295,14 +311,17 @@ namespace TextInput {`
`295`	`311`	`void move_cursor_up(void)`
`296`	`312`	`{`
`297`	`313`	`bool reset = process_selection(); // Only returns true if you don't hold shift`
`298`		`- if (reset && (cursor_pos.y > cursor_select_pos.y)) {`
	`314`	`+ if (reset && cursor_pos.y > cursor_select_pos.y)`
	`315`	`+ {`
`299`	`316`	`cursor_pos.y = cursor_select_pos.y;`
`300`	`317`	`}`
`301`	`318`
`302`		`- if (cursor_pos.y > 0) {`
	`319`	`+ if (cursor_pos.y > 0)`
	`320`	`+ {`
`303`	`321`	`cursor_pos.y--;`
`304`	`322`	`cursor_pos.x = cursor_x_tallest;`
`305`		`- if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {`
	`323`	`+ if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`324`	`+ {`
`306`	`325`	`cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));`
`307`	`326`	`}`
`308`	`327`	`}`
`@@ -311,14 +330,17 @@ namespace TextInput {`
`311`	`330`	`void move_cursor_down(void)`
`312`	`331`	`{`
`313`	`332`	`bool reset = process_selection(); // Only returns true if you don't hold shift`
`314`		`- if (reset && (cursor_pos.y < cursor_select_pos.y)) {`
	`333`	`+ if (reset && cursor_pos.y < cursor_select_pos.y)`
	`334`	`+ {`
`315`	`335`	`cursor_pos.y = cursor_select_pos.y;`
`316`	`336`	`}`
`317`	`337`
`318`		`- if (cursor_pos.y < get_lines() - 1) {`
	`338`	`+ if (cursor_pos.y < get_lines() - 1)`
	`339`	`+ {`
`319`	`340`	`cursor_pos.y++;`
`320`	`341`	`cursor_pos.x = cursor_x_tallest;`
`321`		`- if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {`
	`342`	`+ if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`343`	`+ {`
`322`	`344`	`cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));`
`323`	`345`	`}`
`324`	`346`	`}`
`@@ -330,17 +352,19 @@ namespace TextInput {`
`330`	`352`
`331`	`353`	`bool is_word_part(char character)`
`332`	`354`	`{`
`333`		`- return character > 0x7F \|\| isalpha(character) \|\| isdigit(character) \|\| character == '_' \|\| character == '-';`
	`355`	`+ return (short) character < 0 \|\| (short) character > 0x7F \|\| isalpha(character) \|\| isdigit(character) \|\| character == '_' \|\| character == '-';`
`334`	`356`	`}`
`335`	`357`
`336`	`358`	`void move_cursor_left(void)`
`337`	`359`	`{`
`338`	`360`	`bool reset = process_selection(); // Only returns true if you don't hold shift`
`339`		`- if (reset) {`
	`361`	`+ if (reset)`
	`362`	`+ {`
`340`	`363`	`cursor_pos.x = cursor_select_pos.x;`
`341`	`364`	`}`
`342`	`365`
`343`		`- if (cursor_pos.x == 0 && cursor_pos.y == 0) {`
	`366`	`+ if (cursor_pos.x == 0 && cursor_pos.y == 0)`
	`367`	`+ {`
`344`	`368`	`cursor_x_tallest = 0;`
`345`	`369`	`return;`
`346`	`370`	`}`
`@@ -354,7 +378,7 @@ namespace TextInput {`
`354`	`378`
`355`	`379`	`while (true)`
`356`	`380`	`{`
`357`		`- char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);`
	`381`	`+ character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);`
`358`	`382`	`if (is_word_part(character[0]) != is_word)`
`359`	`383`	`{`
`360`	`384`	`SDL_free(character);`
`@@ -372,7 +396,8 @@ namespace TextInput {`
`372`	`396`	`}`
`373`	`397`	`else`
`374`	`398`	`{`
`375`		`- if (cursor_pos.x > 0) {`
	`399`	`+ if (cursor_pos.x > 0)`
	`400`	`+ {`
`376`	`401`	`cursor_pos.x--;`
`377`	`402`	`}`
`378`	`403`	`else if (cursor_pos.y > 0)`
`@@ -388,11 +413,13 @@ namespace TextInput {`
`388`	`413`	`void move_cursor_right(void)`
`389`	`414`	`{`
`390`	`415`	`bool reset = process_selection(); // Only returns true if you don't hold shift`
`391`		`- if (reset) {`
	`416`	`+ if (reset)`
	`417`	`+ {`
`392`	`418`	`cursor_pos.x = cursor_select_pos.x;`
`393`	`419`	`}`
`394`	`420`
`395`		`- if (cursor_pos.x >= UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y == get_lines() - 1) {`
	`421`	`+ if (cursor_pos.x >= (int) UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y == get_lines() - 1)`
	`422`	`+ {`
`396`	`423`	`cursor_x_tallest = cursor_pos.x;`
`397`	`424`	`return;`
`398`	`425`	`}`
`@@ -406,15 +433,15 @@ namespace TextInput {`
`406`	`433`
`407`	`434`	`while (true)`
`408`	`435`	`{`
`409`		`- char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);`
	`436`	`+ character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);`
`410`	`437`	`if (is_word_part(character[0]) != is_word)`
`411`	`438`	`{`
`412`	`439`	`SDL_free(character);`
`413`	`440`	`break;`
`414`	`441`	`}`
`415`	`442`	`SDL_free(character);`
`416`	`443`	`cursor_pos.x++;`
`417`		`- if (cursor_pos.x >= UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y < get_lines() - 1)`
	`444`	`+ if (cursor_pos.x >= (int) UTF8_total_codepoints(get_line(cursor_pos.y)) && cursor_pos.y < get_lines() - 1)`
`418`	`445`	`{`
`419`	`446`	`cursor_pos.y++;`
`420`	`447`	`cursor_pos.x = 0;`
`@@ -425,7 +452,8 @@ namespace TextInput {`
`425`	`452`	`else`
`426`	`453`	`{`
`427`	`454`
`428`		`- if (cursor_pos.x < UTF8_total_codepoints(get_line(cursor_pos.y))) {`
	`455`	`+ if (cursor_pos.x < (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`456`	`+ {`
`429`	`457`	`cursor_pos.x++;`
`430`	`458`	`}`
`431`	`459`	`else if (cursor_pos.y < get_lines() - 1)`
`@@ -441,7 +469,8 @@ namespace TextInput {`
`441`	`469`	`void backspace(void)`
`442`	`470`	`{`
`443`	`471`	`// The user pressed backspace.`
`444`		`- if (selecting) {`
	`472`	`+ if (selecting)`
	`473`	`+ {`
`445`	`474`	`remove_selection();`
`446`	`475`	`return;`
`447`	`476`	`}`
`@@ -481,7 +510,7 @@ namespace TextInput {`
`481`	`510`	`int start_x = cursor_pos.x;`
`482`	`511`	`while (true)`
`483`	`512`	`{`
`484`		`- char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);`
	`513`	`+ character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x - 1, cursor_pos.x);`
`485`	`514`	`if (is_word_part(character[0]) != is_word)`
`486`	`515`	`{`
`487`	`516`	`SDL_free(character);`
`@@ -537,12 +566,13 @@ namespace TextInput {`
`537`	`566`	`void delete_key(void)`
`538`	`567`	`{`
`539`	`568`	`// The user pressed delete.`
`540`		`- if (selecting) {`
	`569`	`+ if (selecting)`
	`570`	`+ {`
`541`	`571`	`remove_selection();`
`542`	`572`	`return;`
`543`	`573`	`}`
`544`	`574`
`545`		`- if (cursor_pos.x == UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`575`	`+ if (cursor_pos.x == (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
`546`	`576`	`{`
`547`	`577`	`if (cursor_pos.y < get_lines() - 1)`
`548`	`578`	`{`
`@@ -570,7 +600,7 @@ namespace TextInput {`
`570`	`600`	`int start_x = cursor_pos.x;`
`571`	`601`	`while (true)`
`572`	`602`	`{`
`573`		`- char* character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);`
	`603`	`+ character = UTF8_substr(get_line(cursor_pos.y), cursor_pos.x, cursor_pos.x + 1);`
`574`	`604`	`if (is_word_part(character[0]) != is_word)`
`575`	`605`	`{`
`576`	`606`	`SDL_free(character);`
`@@ -598,10 +628,12 @@ namespace TextInput {`
`598`	`628`	`}`
`599`	`629`	`}`
`600`	`630`
`601`		`- void handle_events(SDL_Event e) {`
	`631`	`+ void handle_events(SDL_Event e)`
	`632`	`+ {`
`602`	`633`	`if (!taking_input) return;`
`603`	`634`
`604`		`- if (e.type == SDL_KEYDOWN) {`
	`635`	`+ if (e.type == SDL_KEYDOWN)`
	`636`	`+ {`
`605`	`637`	`// Show cursor!!`
`606`	`638`	`flash_timer = 0;`
`607`	`639`
`@@ -613,7 +645,8 @@ namespace TextInput {`
`613`	`645`	`}`
`614`	`646`	`else if (e.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL)`
`615`	`647`	`{`
`616`		`- if (selecting) {`
	`648`	`+ if (selecting)`
	`649`	`+ {`
`617`	`650`	`remove_selection();`
`618`	`651`	`}`
`619`	`652`	`char* clipboard_text = SDL_GetClipboardText();`
`@@ -695,20 +728,24 @@ namespace TextInput {`
`695`	`728`	`else if (e.key.keysym.sym == SDLK_PAGEUP && can_move_cursor)`
`696`	`729`	`{`
`697`	`730`	`cursor_pos.y -= 10;`
`698`		`- if (cursor_pos.y < 0) {`
	`731`	`+ if (cursor_pos.y < 0)`
	`732`	`+ {`
`699`	`733`	`cursor_pos.y = 0;`
`700`	`734`	`}`
`701`		`- if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {`
	`735`	`+ if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`736`	`+ {`
`702`	`737`	`cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));`
`703`	`738`	`}`
`704`	`739`	`}`
`705`	`740`	`else if (e.key.keysym.sym == SDLK_PAGEDOWN && can_move_cursor)`
`706`	`741`	`{`
`707`	`742`	`cursor_pos.y += 10;`
`708`		`- if (cursor_pos.y >= get_lines()) {`
	`743`	`+ if (cursor_pos.y >= get_lines())`
	`744`	`+ {`
`709`	`745`	`cursor_pos.y = get_lines() - 1;`
`710`	`746`	`}`
`711`		`- if (cursor_pos.x > UTF8_total_codepoints(get_line(cursor_pos.y))) {`
	`747`	`+ if (cursor_pos.x > (int) UTF8_total_codepoints(get_line(cursor_pos.y)))`
	`748`	`+ {`
`712`	`749`	`cursor_pos.x = UTF8_total_codepoints(get_line(cursor_pos.y));`
`713`	`750`	`}`
`714`	`751`	`}`
`@@ -720,7 +757,8 @@ namespace TextInput {`
`720`	`757`	`flash_timer = 0;`
`721`	`758`
`722`	`759`	`//Append character(s)`
`723`		`- if (selecting) {`
	`760`	`+ if (selecting)`
	`761`	`+ {`
`724`	`762`	`remove_selection();`
`725`	`763`	`}`
`726`	`764`	`insert_text(e.text.text);`