[deprecated] stupid brain

Author: mrsrina

include/ekg/io/utf.hpp

@@ -151,8 +151,10 @@ namespace ekg {
   protected:
     std::vector<ekg::io::chunk_t> loaded_chunks {};
     size_t lines_per_chunk_limit {10};
-    size_t total_lines {};
+    size_t total_chars {};
+    size_t prev_total_chars {};
     bool was_audited {};
+    bool should_count {};
   public:
     static std::string line_not_found;
   public:
@@ -179,8 +181,11 @@ namespace ekg {
 
     std::vector<ekg::io::chunk_t> &data();
 
+    size_t size();
     size_t lines();
     size_t chunks();
+
+    void unset_audited();
     bool audited();
   };
 }

include/ekg/ui/textbox/textbox.hpp

@@ -56,36 +56,43 @@ namespace ekg {
       ekg::rect_t<float> rect {};
     public:
       bool operator == (size_t index) {
-        return this->index_a == index && this->index_b == index;
+        return index == this->index_a && index == this->index_b;
       }
 
       bool operator > (size_t index) {
-        return this->index_a > index;
+        return index > this->index_a;
       }
 
       bool operator >= (size_t index) {
-        return this->index_a >= index;
+        return index >= this->index_a;
       }
 
       bool operator < (size_t index) {
-        return this->index_b < index;
+        return index < this->index_b;
       }
 
       bool operator <= (size_t index) {
-        return this->index_b <= index;
+        return index <= this->index_b;
       }
 
       bool operator == (const ekg::textbox_t::cursor_t &cursor) {
         return this->index_a == cursor.index_a && this->index_b == cursor.index_b;
       }
     };
 
+    struct untracked_line_ending_t {
+    public:
+      ekg::vec2_t<size_t> indices {};
+      std::string text {};
+    };
+
     struct widget_t {
     public:
       ekg::rect_t<float> rect_text_size {};
       ekg::scrollbar_t scrollbar {};
       std::vector<ekg::textbox_t::cursor_t> cursors {};
       std::vector<ekg::textbox_t::select_draw_layer_t> layers_select {};
+      std::vector<ekg::textbox_t::untracked_line_ending_t> line_ending_untracked {};
       size_t last_layers_select_size {};
     };
 

src/ekg.cpp

@@ -167,7 +167,7 @@ void ekg::render() {
          * 
          * I do not know why this is hapenning, likely wtf, if I remove this
          * scrolling is horrible, I am not sure why this is hapning, I tried make the make redraw always,
-         * rendering everything, no allocators asserts. Nothing. I tried do a stupid `meow<t>` where t receives a descriptor,
+         * rendering everything, no allocators asscerts. Nothing. I tried do a stupid `meow<t>` where t receives a descriptor,
          * but nothing too. I do not know why this happens but it is very insanely weird. Post does not affect the performance
          * a lot, may we consider to let for some long time. While no solution was found.
          * 

src/io/utf.cpp

@@ -270,20 +270,20 @@ std::string ekg::text::line_not_found {'\x1B'};
 
 std::string &ekg::text::write(size_t index) {
   size_t chunks_size {this->loaded_chunks.size()};
-  size_t total_lines {};
-  size_t previous_total_lines {};
+  size_t total_chars {};
+  size_t previous_total_chars {};
   size_t chunk_size {};
 
   this->was_audited = true;
 
   for (size_t it {}; it < chunks_size; it++) {
     ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
 
-    previous_total_lines = total_lines;
-    total_lines += (chunk_size = chunk.size());
+    previous_total_chars = total_chars;
+    total_chars += (chunk_size = chunk.size());
 
-    if (index < total_lines && (index - previous_total_lines) < chunk_size) {
-      return chunk.at(index - previous_total_lines);
+    if (index < total_chars && (index - previous_total_chars) < chunk_size) {
+      return chunk.at(index - previous_total_chars);
     }
   }
 
@@ -308,31 +308,31 @@ void ekg::text::insert(
     }
     return;
   }
+  this->was_audited = true;
 
   bool ok {};
 
-  size_t previous_total_lines {};
+  size_t previous_total_chars {};
   size_t chunk_size {};
-  size_t current_total_lines {};
+  size_t current_total_chars {};
 
   ekg::io::chunk_t to_swizzle_chunk {};
 
-  this->total_lines = 0;
   for (size_t it {}; it < this->loaded_chunks.size(); it++) {
     ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
 
-    previous_total_lines = this->total_lines;
-    current_total_lines += (chunk_size = chunk.size());
+    previous_total_chars = this->total_chars;
+    current_total_chars += (chunk_size = chunk.size());
 
     if (
       !ok
       &&
-      index < current_total_lines
+      index < current_total_chars
       &&
-      (index - previous_total_lines) < chunk_size
+      (index - previous_total_chars) < chunk_size
     ) {
       chunk.insert(
-        chunk.begin() + (index - previous_total_lines),
+        chunk.begin() + (index - previous_total_chars),
         to_insert_chunk.begin(),
         to_insert_chunk.end()
       );
@@ -381,8 +381,6 @@ void ekg::text::insert(
 
       ok = true;
     }
-
-    this->total_lines += this->loaded_chunks.at(it).size();
   }
 }
 
@@ -404,16 +402,22 @@ void ekg::text::erase(
     return;
   }
 
-  if (begin >= this->total_lines || end >= this->total_lines || end <= begin) {
-    throw std::out_of_range("ekg::text::erase -> begin or end out of index");
+  if (begin > this->total_chars) {
+    throw std::out_of_range("ekg::text::erase: " + std::to_string(begin) + ", " + std::to_string(this->total_chars));
     return;
   }
 
-  this->total_lines -= end - begin;
+  end = ekg::min(begin + end, this->total_chars);
+
+  this->should_count = true;
+  this->size();
+
+  this->total_chars -= end - begin;
+  this->was_audited = true;
 
-  size_t previous_total_lines {};
+  size_t previous_total_chars {};
   size_t chunk_size {};
-  size_t total_lines {};
+  size_t total_chars {};
   size_t remains_lines {};
 
   bool empty_chunk {};
@@ -422,12 +426,12 @@ void ekg::text::erase(
   for (size_t it {}; it < this->loaded_chunks.size(); it++) {
     ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
 
-    previous_total_lines = total_lines;
-    total_lines += (chunk_size = chunk.size());
+    previous_total_chars = total_chars;
+    total_chars += (chunk_size = chunk.size());
 
-    if (begin < total_lines) {
+    if (begin < total_chars) {
       remains_lines = end - begin;
-      begin = begin - previous_total_lines;
+      begin = begin - previous_total_chars;
       while (remains_lines != 0) {
         ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
 
@@ -459,15 +463,19 @@ void ekg::text::erase(
       break;
     }
   }
+
+  this->should_count = true;
+  this->size();
 }
 
 void ekg::text::push_back(const std::string &line) {
   if (this->loaded_chunks.empty()) {
     this->loaded_chunks.emplace_back().push_back(line);
     return;
   }
-
-  this->total_lines++;
+  
+  this->should_count = true;
+  this->size();
 
   size_t chunks_size {this->loaded_chunks.size()};
   ekg::io::chunk_t &chunk {this->loaded_chunks.at(chunks_size - (chunks_size != 0))};
@@ -484,7 +492,8 @@ std::string &ekg::text::emplace_back() {
     return this->loaded_chunks.emplace_back().emplace_back();
   }
 
-  this->total_lines++;
+  this->should_count = true;
+  this->size();
 
   size_t chunks_size {this->loaded_chunks.size()};
   ekg::io::chunk_t &chunk {this->loaded_chunks.at(chunks_size - (chunks_size != 0))};
@@ -496,17 +505,36 @@ std::string &ekg::text::emplace_back() {
 }
 
 size_t ekg::text::lines() {
-  return this->total_lines;
+  return 0;
+}
+
+size_t ekg::text::size() {
+  if (this->should_count) {
+    this->total_chars = 0;
+    for (ekg::io::chunk_t &chunk : this->loaded_chunks) {
+      for (std::string &lines : chunk) {
+        this->total_chars += lines.size();
+      }
+    }
+
+    this->should_count = false;
+  }
+
+  return this->total_chars;
 }
 
 size_t ekg::text::chunks() {
   return this->loaded_chunks.size();
 }
 
-bool ekg::text::audited() {
-  bool should {this->was_audited};
+void ekg::text::unset_audited() {
   this->was_audited = false;
-  return should;
+}
+
+bool ekg::text::audited() {
+  this->was_audited = this->was_audited || (this->prev_total_chars != this->total_chars);
+  this->prev_total_chars = this->total_chars;
+  return this->was_audited;
 }
 
 std::vector<ekg::io::chunk_t> &ekg::text::data() {