hokusai-zero 0.1.1

data/ast/src/core/text.h

@@ -0,0 +1,93 @@
+#ifndef HOKU_TEXT_H
+#define HOKU_TEXT_H
+
+#include <string.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <md4c.h>
+
+typedef struct HokuChar
+{
+  int offset;
+  int width;
+  struct HokuChar* next_char;
+} hoku_char;
+
+enum HOKU_GROUP_TYPE
+{
+  HOKU_GROUP_NORMAL = 1 << 0,
+  HOKU_GROUP_BOLD = 1 << 1,
+  HOKU_GROUP_ITALICS = 1 << 2,
+  HOKU_GROUP_LINK = 1 << 3,
+  HOKU_GROUP_IMAGE = 1 << 4,
+  HOKU_GROUP_CODE = 1 << 5,
+  HOKU_GROUP_LIST_ITEM = 1 << 6
+};
+
+typedef struct HokuGroupLink
+{
+  char* url;
+} hoku_group_link;
+
+typedef struct HokuGroupImage
+{
+  char* src;
+} hoku_group_image;
+
+typedef struct HokuGroupCode
+{
+  char* language;
+} hoku_group_code;
+
+typedef struct HokuGroupListItem
+{
+  int level;
+} hoku_group_list_item;
+
+typedef struct HokuGroup
+{
+  int offset;
+  int size;
+  enum HOKU_GROUP_TYPE type;
+  void* payload;
+  hoku_char* chars;
+  struct HokuGroup* next_group;
+} hoku_group;
+
+typedef struct HokuSegment
+{
+  int offset;
+  int size;
+  int select_begin;
+  int select_end;
+  hoku_char* chars;
+  hoku_group* groups;
+  struct HokuSegment* next_segment;
+} hoku_segment;
+
+
+typedef int (*hoku_char_width_cb)(char character, void* payload);
+
+typedef struct HokuClamping
+{
+  char* text;
+  float width;
+  hoku_segment* segments;
+} hoku_clamping;
+
+int hoku_text_char_init(hoku_char** character, int offset, int width);
+int hoku_text_group_init(hoku_group** group, int offset, enum HOKU_GROUP_TYPE type, void* payload);
+int hoku_text_segment_init(hoku_segment** segment, int offset);
+int hoku_text_clamping_init(hoku_clamping** clamping, char* text, float width);
+hoku_char* hoku_text_segment_split(hoku_segment* segment, int at);
+float hoku_text_char_sum(hoku_char* character);
+void hoku_text_group_append_char(hoku_group* group, hoku_char* character);
+int hoku_text_md_clamp(hoku_clamping** out, char* text, float width, float initial, void* payload, hoku_char_width_cb cb);
+int hoku_text_clamp(hoku_clamping** out, char* text, float width, float initial, void* payload, hoku_char_width_cb cb);
+void hoku_text_char_free(hoku_char* chars);
+void hoku_text_segment_free(hoku_segment* segment);
+void hoku_text_clamping_free(hoku_clamping* clamping);
+
+
+#endif

data/ast/src/core/util.c

@@ -0,0 +1,140 @@
+#ifndef HOKU_UTIL
+#define HOKU_UTIL
+
+#include "util.h"
+
+bool hoku_rect_includes_y(hoku_rect rect, float y)
+{
+  return y > rect.y && y <= (rect.y + rect.h);
+}
+
+bool hoku_rect_includes_x(hoku_rect rect, float x)
+{
+  return x > rect.x && x <= (rect.x + rect.w);
+}
+
+float hoku_rect_x_left(hoku_rect rect, int times)
+{
+  return (rect.x - ((rect.w / 2) * times));
+}
+float hoku_rect_x_right(hoku_rect rect, int times)
+{
+  return (rect.x + ((rect.w / 2) * times));
+}
+
+float hoku_rect_y_up(hoku_rect rect, int times)
+{
+  return (rect.y - ((rect.h / 2) * times));
+}
+
+float hoku_rect_y_down(hoku_rect rect, int times)
+{
+  return (rect.y + ((rect.h / 2) * times));
+}
+
+int hoku_selection_init(hoku_selection** selection)
+{
+  hoku_selection* init = malloc(sizeof(hoku_selection));
+  if (init == NULL)
+  {
+    return -1;
+  }
+
+  init->type = HOKU_SELECT_NONE;
+  init->start_x = 0.0;
+  init->start_y = 0.0;
+  init->stop_x = 0.0;
+  init->stop_y = 0.0;
+  init->offset_y = 0.0;
+
+  init->cursor = NULL;
+
+  *selection = init;
+  return 0;
+}
+
+bool hoku_selection_selected(hoku_selection* selection, float x, float y, float width, float height)
+{
+  if (selection->type == HOKU_SELECT_NONE) return false;
+
+  float sx = selection->start_x;
+  float sy = selection->start_y;
+  float ex = selection->stop_x;
+  float ey = selection->stop_y;
+
+  bool down = selection->start_y <= selection->stop_y;
+  bool up = selection->stop_y < selection->start_y;
+  bool left = selection->stop_x < selection->start_x;
+  bool right = selection->start_x <= selection->stop_x;
+
+  hoku_rect hit_box = (hoku_rect){.x=x, .y=y, .w=width, .h=height};
+  float x_shifted_right = hoku_rect_x_right(hit_box, 1);
+  float y_shifted_up = hoku_rect_y_up(hit_box, 2);
+  float y_shifted_down = hoku_rect_y_down(hit_box, 2);
+  float end_y = y + height;
+
+  return (
+   (down &&
+    // first line of multiline selection
+    ((x_shifted_right > sx && end_y < ey && hoku_rect_includes_y(hit_box, sy)) ||
+      // last line of multiline selection
+      (x_shifted_right <= ex && y_shifted_up + hit_box.h < ey && hit_box.y > sy) ||
+      // middle line (all selected)
+      (hit_box.y > sy && end_y < ey))) ||
+    (up &&
+      // first line of multiline selection
+      ((x_shifted_right <= sx && hit_box.y > ey && hoku_rect_includes_y(hit_box, sy)) ||
+      // last line of multiline selection
+        (x_shifted_right >= ex && y_shifted_down > ey && end_y < sy) ||
+        // middle line (all selected)
+        (hit_box.y > ey && hit_box.y + hit_box.h < sy))) ||
+    // single line selection
+    ((hoku_rect_includes_y(hit_box, sy) && hoku_rect_includes_y(hit_box, ey)) &&
+      ((left && x_shifted_right < sx && x_shifted_right > ex) || (right && x_shifted_right > sx && x_shifted_right < ex)))
+  );
+}
+
+hoku_cursor_position hoku_selection_cursor_get(hoku_selection* selection)
+{
+  if (selection->cursor == NULL) return (hoku_cursor_position){.x=0.0, .y=0.0, .w=0.0, .h=0.0 };
+  hoku_cursor_position pos = (hoku_cursor_position){ .x=selection->cursor->x, .y=selection->cursor->y, .w=selection->cursor->w, .h=selection->cursor->h };
+
+  if (selection->type == HOKU_SELECT_FROZEN)
+  {
+    pos.y = selection->offset_y;
+    return pos;
+  }
+
+  return pos;
+}
+
+int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position cursor)
+{
+  if (selection->cursor == NULL)
+  {
+    selection->cursor = malloc(sizeof(hoku_cursor_position));
+
+    if (selection->cursor == NULL) return -1;
+  }
+
+  selection->cursor->x = cursor.x;
+  selection->cursor->y = cursor.y;
+  selection->cursor->w = cursor.w;
+  selection->cursor->h = cursor.h;
+
+  return 0;
+}
+
+void hoku_selection_cursor_free(hoku_selection* selection)
+{
+  if (selection->cursor != NULL) free(selection->cursor);
+  selection->cursor = NULL;
+}
+
+void hoku_selection_free(hoku_selection* selection)
+{
+  hoku_selection_cursor_free(selection);
+  free(selection);
+}
+
+#endif

data/ast/src/core/util.h

@@ -0,0 +1,48 @@
+#ifndef HOKU_UTIL_H
+#define HOKU_UTIL_H
+
+#include "common.h"
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef enum HokuSelectType {
+  HOKU_SELECT_ACTIVE = 1 << 1,
+  HOKU_SELECT_FROZEN = 1 << 2,
+  HOKU_SELECT_NONE = 1 << 3
+} hoku_select_type;
+
+typedef struct HokuSelectionCursorPosition
+{
+  float x;
+  float y;
+  float w;
+  float h;
+} hoku_cursor_position;
+
+typedef struct HokuSelection
+{
+   hoku_select_type type;
+   float start_x;
+   float start_y;
+   float stop_x;
+   float stop_y;
+   float offset_y;
+   hoku_cursor_position* cursor;
+} hoku_selection;
+
+bool hoku_rect_includes_y(hoku_rect rect, float y);
+bool hoku_rect_includes_x(hoku_rect rect, float x);
+float hoku_rect_x_left(hoku_rect rect, int times);
+float hoku_rect_x_right(hoku_rect rect, int times);
+float hoku_rect_y_up(hoku_rect rect, int times);
+float hoku_rect_y_down(hoku_rect rect, int times);
+
+int hoku_selection_init(hoku_selection** selection);
+bool hoku_selection_selected(hoku_selection* selection, float x, float y, float width, float height);
+int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position cursor);
+void hoku_selection_cursor_free(hoku_selection* selection);
+void hoku_selection_free(hoku_selection* selection);
+
+
+
+#endif

data/ast/src/hokusai.c

@@ -0,0 +1,6 @@
+#ifndef HOKUSAI
+#define HOKUSAI
+
+#include "hokusai.h"
+
+#endif

data/ast/src/hokusai.h

@@ -0,0 +1,6 @@
+#ifndef HOKUSAI
+#define HOKUSAI
+
+#include "ast.h"
+
+#endif

data/ast/test/fixtures/test.ui

@@ -0,0 +1,13 @@
+<root>
+	<a>
+		<b>
+			<c/>
+			<d/>
+		</b>
+		<e>
+			<f>
+				<g/>
+			</f>
+		</e>
+	</a>
+</root>