/home/mrjunejune/zenbu: postdog/main.c comparison

comparison postdog/main.c @ 173:827c6ac504cd hg-web

Merged in default here.

author	MrJuneJune <me@mrjunejune.com>
date	Mon, 19 Jan 2026 18:59:10 -0800
parents	0face9898d04
children

comparison

equal deleted inserted replaced

-:c033667da5f9
+:827c6ac504cd
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <sys/stat.h>
+#include <uv.h>
+#ifdef _WIN32
+#include <direct.h>
+#include <io.h>
+#define mkdir(path, mode) _mkdir(path)
+#define access _access
+#define F_OK 0
+#else
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+#endif
 #include "dowa/dowa.h"
+#include "seobeo/seobeo.h"
-#include <curl/curl.h>
 #include "third_party/raylib/include/raylib.h"
-#define RAYGUI_IMPLEMENTATION
 #include "third_party/raylib/include/raygui.h"
+#include "third_party/raylib/custom.h"
 #ifndef POSTDOG_PATHS
-#define POSTDOG_PATHS "/Users/mrjunejune/zenbu/postdog/history"
+#define POSTDOG_PATHS "/home/june/zenbu/postdog/history"
 #endif
 #define SCREEN_WIDTH 1280
 #define SCREEN_HEIGHT 780
 #define MAX_SCROLL_HEIGHT 10000
 #define DEFAULT_TEXT_BUFFER_LENGTH 1024 * 4
 #define URL_TEXT_BUFFER_LENGTH 1024 * 10
 #define BODY_BUFFER_LENGTH 1024 * 1024 * 5
 #define RESULT_BUFFER_LENGTH 1024 * 1024 * 5
+// #define URL_TEXT_DEFAULT "https://httpbin.org/get"
-#ifdef _WIN32
+#define URL_TEXT_DEFAULT "wss://mrjunejune.com/echo"
-#include <direct.h>
+#define HEADER_TEXT_DEFAULT "Content-Type: application/json"
-#include <io.h>
+#define BODY_TEXT_DEFAULT ""
-#define mkdir(path, mode) _mkdir(path)
+#define GET_PARAM_TEXT_DEFAULT "foo bar"
-#define access _access
-#define F_OK 0
+// ============================================================================
-#else
+// TextArea Component
-#include <sys/stat.h>
+// ============================================================================
-#include <dirent.h>
-#include <unistd.h>
+#define TEXT_SIZE_DEFAULT 20 // used to calcualte spacing
-#endif
+#define TEXT_AREA_LINE_HEIGHT GuiGetStyle(DEFAULT, TEXT_SIZE)
+#define TEXT_AREA_PADDING 30
+#define TEXT_AREA_CURSOR_WIDTH 2
+#define TEXT_AREA_MAX_UNDO_STATES 64
+#define TEXT_AREA_MAX_INSTANCES 8
+typedef struct {
+char *text;
+int cursor_pos;
+int selection_start;
+int selection_end;
+} TextAreaUndoEntry;
+// Cached line info for fast rendering
+typedef struct {
+int start_pos;      // Character position where this line starts
+int end_pos;        // Character position where this line ends (exclusive)
+int char_count;     // Number of characters in this line
+} LineInfo;
+typedef struct {
+int id;             // Unique ID for this text area
+int cursor_pos;         // Current cursor position in text
+int selection_start;      // Selection start (-1 if no selection)
+int selection_end;      // Selection end (-1 if no selection)
+float scroll_offset_y;    // Vertical scroll offset
+float scroll_offset_x;    // Horizontal scroll offset (for non-wrap mode)
+boolean is_selecting;     // Currently dragging to select
+boolean is_initialized;     // State has been initialized
+// Undo history
+TextAreaUndoEntry *undo_stack;  // Dowa array of undo entries
+int undo_index;         // Current position in undo stack
+// Internal tracking
+double last_blink_time;
+boolean cursor_visible;
+// Line cache for fast rendering
+LineInfo *line_cache;     // Dowa array of line info
+int cached_text_len;      // Text length when cache was built
+int cached_text_hash;     // Simple hash to detect text changes
+float cached_content_width; // Content width when cache was built
+boolean cache_valid;      // Whether cache is valid
+} TextAreaState;
+static TextAreaState g_text_area_states[TEXT_AREA_MAX_INSTANCES] = {0};
+static int g_text_area_state_count = 0;
+static char *g_clipboard_text = NULL;
+static Dowa_Arena *g_text_area_arena = NULL;
+// Helper functions
+static int TA_Min_Int(int a, int b) { return a < b ? a : b; }
+static int TA_Max_Int(int a, int b) { return a > b ? a : b; }
+static float TA_Min_Float(float a, float b) { return a < b ? a : b; }
+static float TA_Max_Float(float a, float b) { return a > b ? a : b; }
+// Sanitize text for display - replace tabs with spaces, remove other non-printable chars
+static void SanitizeTextForDisplay(char *text) {
+if (!text) return;
+char *read = text;
+char *write = text;
+while (*read) {
+if (*read == '\t') {
+// Replace tab with 2 spaces
+*write++ = ' ';
+*write++ = ' ';
+} else if (*read == '\n' || *read == '\r') {
+// Keep newlines and carriage returns
+*write++ = *read;
+} else if ((unsigned char)*read >= 32 && (unsigned char)*read < 127) {
+// Keep printable ASCII
+*write++ = *read;
+} else if ((unsigned char)*read >= 128) {
+// Keep UTF-8 characters (high bit set)
+*write++ = *read;
+}
+// Skip other non-printable characters
+read++;
+}
+*write = '\0';
+}
+static TextAreaState* GetTextAreaState(int id) {
+for (int i = 0; i < g_text_area_state_count; i++) {
+if (g_text_area_states[i].id == id && g_text_area_states[i].is_initialized) {
+return &g_text_area_states[i];
+}
+}
+return NULL;
+}
+static TextAreaState* CreateTextAreaState(int id) {
+// First, check if there's an existing slot with this ID (possibly reset)
+for (int i = 0; i < g_text_area_state_count; i++) {
+if (g_text_area_states[i].id == id) {
+TextAreaState *state = &g_text_area_states[i];
+// Reuse this slot - clear it but keep the id
+memset(state, 0, sizeof(TextAreaState));
+state->id = id;
+state->selection_start = -1;
+state->selection_end = -1;
+state->undo_index = -1;
+state->cursor_visible = TRUE;
+state->is_initialized = TRUE;
+return state;
+}
+}
+// No existing slot, create a new one
+if (g_text_area_state_count >= TEXT_AREA_MAX_INSTANCES) {
+return &g_text_area_states[0]; // Reuse first slot as fallback
+}
+TextAreaState *state = &g_text_area_states[g_text_area_state_count++];
+memset(state, 0, sizeof(TextAreaState));
+state->id = id;
+state->selection_start = -1;
+state->selection_end = -1;
+state->undo_index = -1;
+state->cursor_visible = TRUE;
+state->is_initialized = TRUE;
+return state;
+}
+static void GetLineAndColumn(const char *text, int pos, int *out_line, int *out_column) {
+int line = 0;
+int column = 0;
+for (int i = 0; i < pos && text[i] != '\0'; i++) {
+if (text[i] == '\n') {
+line++;
+column = 0;
+} else {
+column++;
+}
+}
+*out_line = line;
+*out_column = column;
+}
+static int GetPosFromLineColumn(const char *text, int line, int column) {
+int current_line = 0;
+int current_col = 0;
+int i = 0;
+while (text[i] != '\0') {
+if (current_line == line && current_col == column) {
+return i;
+}
+if (text[i] == '\n') {
+if (current_line == line) {
+return i;
+}
+current_line++;
+current_col = 0;
+} else {
+current_col++;
+}
+i++;
+}
+return i;
+}
+static int GetLineStart(const char *text, int pos) {
+int i = pos;
+while (i > 0 && text[i - 1] != '\n') {
+i--;
+}
+return i;
+}
+static int GetLineEnd(const char *text, int pos) {
+int i = pos;
+int len = strlen(text);
+while (i < len && text[i] != '\n') {
+i++;
+}
+return i;
+}
+static int CountLines(const char *text) {
+int count = 1;
+for (int i = 0; text[i] != '\0'; i++) {
+if (text[i] == '\n') count++;
+}
+return count;
+}
+// Simple hash to detect text changes (djb2)
+static int SimpleTextHash(const char *text, int len) {
+int hash = 5381;
+int sample_count = len < 100 ? len : 100;  // Sample first 100 chars
+for (int i = 0; i < sample_count; i++) {
+hash = ((hash << 5) + hash) + text[i];
+}
+// Also sample some chars from middle and end
+if (len > 200) {
+for (int i = len/2; i < len/2 + 50 && i < len; i++) {
+hash = ((hash << 5) + hash) + text[i];
+}
+}
+return hash;
+}
+// Build line cache - O(n) once, then O(1) for rendering
+static void BuildLineCache(TextAreaState *state, const char *text, float content_width,
+int font_size, boolean wrap, Dowa_Arena *arena) {
+int text_len = strlen(text);
+// Check if cache is still valid
+int new_hash = SimpleTextHash(text, text_len);
+if (state->cache_valid &&
+state->cached_text_len == text_len &&
+state->cached_text_hash == new_hash &&
+state->cached_content_width == content_width) {
+return;  // Cache is valid, no need to rebuild
+}
+// Clear old cache
+if (state->line_cache) {
+Dowa_Array_Free(state->line_cache);
+state->line_cache = NULL;
+}
+// Approximate character width (for non-monospace, use average)
+float avg_char_width = font_size * 0.6f;  // Reasonable approximation for most fonts
+int max_chars_per_line = (int)(content_width / avg_char_width);
+if (max_chars_per_line < 1) max_chars_per_line = 1;
+Dowa_Array_Reserve(state->line_cache, text_len / max_chars_per_line + 10);
+int line_start = 0;
+int i = 0;
+while (i <= text_len) {
+boolean is_end = (i == text_len);
+boolean is_newline = (!is_end && text[i] == '\n');
+int chars_in_line = i - line_start;
+// Check if we need to wrap (based on character count approximation)
+boolean should_wrap = wrap && !is_end && !is_newline &&
+chars_in_line >= max_chars_per_line;
+if (is_end || is_newline || should_wrap) {
+LineInfo line = {
+.start_pos = line_start,
+.end_pos = i,
+.char_count = chars_in_line
+};
+Dowa_Array_Push(state->line_cache, line);
+if (is_newline) {
+line_start = i + 1;
+} else if (should_wrap) {
+// Try to find a space to wrap at
+int wrap_pos = i;
+for (int j = i - 1; j > line_start && j > i - 20; j--) {
+if (text[j] == ' ') {
+wrap_pos = j;
+break;
+}
+}
+// Update the last line entry with correct end
+state->line_cache[Dowa_Array_Length(state->line_cache) - 1].end_pos = wrap_pos;
+state->line_cache[Dowa_Array_Length(state->line_cache) - 1].char_count = wrap_pos - line_start;
+line_start = (text[wrap_pos] == ' ') ? wrap_pos + 1 : wrap_pos;
+i = line_start - 1;  // Will be incremented at end of loop
+} else {
+line_start = i + 1;
+}
+}
+i++;
+}
+// Ensure at least one line exists
+if (Dowa_Array_Length(state->line_cache) == 0) {
+LineInfo empty_line = { .start_pos = 0, .end_pos = 0, .char_count = 0 };
+Dowa_Array_Push(state->line_cache, empty_line);
+}
+// Update cache metadata
+state->cached_text_len = text_len;
+state->cached_text_hash = new_hash;
+state->cached_content_width = content_width;
+state->cache_valid = TRUE;
+}
+static int MeasureTextRange(const char *text, int start, int end, int font_size) {
+if (start >= end) return 0;
+char temp[1024];
+int len = TA_Min_Int(end - start, 1023);
+strncpy(temp, text + start, len);
+temp[len] = '\0';
+return MeasureTextEx(GuiGetFont(), temp, font_size, TEXT_SIZE_DEFAULT/GuiGetStyle(DEFAULT, TEXT_SIZE)).x;
+}
+static int GetCharIndexFromPos(const char *text, Rectangle bounds, Vector2 pos,
+boolean wrap, float scroll_y, int font_size, int line_height) {
+if (!text || strlen(text) == 0) return 0;
+float content_x = bounds.x + TEXT_AREA_PADDING;
+float content_y = bounds.y + TEXT_AREA_PADDING - scroll_y;
+float content_width = bounds.width - TEXT_AREA_PADDING * 2;
+int text_len = strlen(text);
+float click_line_y = (pos.y - content_y) / line_height;
+int target_visual_line = (int)click_line_y;
+if (target_visual_line < 0) target_visual_line = 0;
+int current_visual_line = 0;
+int i = 0;
+int line_char_start = 0;
+while (i <= text_len) {
+boolean is_newline = (i < text_len && text[i] == '\n');
+if (wrap && i > line_char_start) {
+int line_width = MeasureTextRange(text, line_char_start, i, font_size);
+if (line_width > content_width && i > line_char_start + 1) {
+int wrap_pos = i - 1;
+for (int j = i - 1; j > line_char_start; j--) {
+if (text[j] == ' ') {
+wrap_pos = j;
+break;
+}
+}
+if (current_visual_line == target_visual_line) {
+float click_x = pos.x - content_x;
+int best_pos = line_char_start;
+float best_dist = 99999;
+for (int k = line_char_start; k <= wrap_pos; k++) {
+int char_x = MeasureTextRange(text, line_char_start, k, font_size);
+float dist = (float)(click_x - char_x);
+if (dist < 0) dist = -dist;
+if (dist < best_dist) {
+best_dist = dist;
+best_pos = k;
+}
+}
+return best_pos;
+}
+current_visual_line++;
+line_char_start = (text[wrap_pos] == ' ') ? wrap_pos + 1 : wrap_pos;
+i = line_char_start;
+continue;
+}
+}
+if (is_newline || i == text_len) {
+if (current_visual_line == target_visual_line || i == text_len) {
+float click_x = pos.x - content_x;
+int line_end = i;
+int best_pos = line_char_start;
+float best_dist = 99999;
+for (int k = line_char_start; k <= line_end; k++) {
+int char_x = MeasureTextRange(text, line_char_start, k, font_size);
+float dist = (float)(click_x - char_x);
+if (dist < 0) dist = -dist;
+if (dist < best_dist) {
+best_dist = dist;
+best_pos = k;
+}
+}
+return TA_Min_Int(best_pos, text_len);
+}
+current_visual_line++;
+line_char_start = i + 1;
+}
+i++;
+}
+return text_len;
+}
+// Get character index from mouse position using line cache
+static int GetCharIndexFromPosWithCache(const char *text, Rectangle bounds, Vector2 pos,
+float scroll_y, int font_size, int line_height,
+LineInfo *line_cache) {
+if (!text || strlen(text) == 0) return 0;
+if (!line_cache || Dowa_Array_Length(line_cache) == 0) return 0;
+float content_x = bounds.x + TEXT_AREA_PADDING;
+float content_y = bounds.y + TEXT_AREA_PADDING - scroll_y;
+int text_len = strlen(text);
+int line_count = Dowa_Array_Length(line_cache);
+// Find which visual line was clicked
+float click_line_y = (pos.y - content_y) / line_height;
+int target_line = (int)click_line_y;
+if (target_line < 0) target_line = 0;
+if (target_line >= line_count) target_line = line_count - 1;
+if (target_line < 0) return 0;  // Safety check
+LineInfo *line = &line_cache[target_line];
+// Find character position within the line
+float click_x = pos.x - content_x;
+if (click_x < 0) return line->start_pos;
+// Linear search for the character closest to click position
+int best_pos = line->start_pos;
+float best_dist = 99999;
+for (int k = line->start_pos; k <= line->end_pos; k++) {
+int char_x = MeasureTextRange(text, line->start_pos, k, font_size);
+float dist = click_x - char_x;
+if (dist < 0) dist = -dist;
+if (dist < best_dist) {
+best_dist = dist;
+best_pos = k;
+}
+}
+return TA_Min_Int(best_pos, text_len);
+}
+// Get cursor position using line cache (fast O(log n) or O(n) worst case)
+static Vector2 GetCursorScreenPosFromCache(const char *text, int cursor_pos, Rectangle bounds,
+float scroll_y, int font_size, int line_height,
+LineInfo *line_cache) {
+float content_x = bounds.x + TEXT_AREA_PADDING;
+float content_y = bounds.y + TEXT_AREA_PADDING - scroll_y;
+if (!text || cursor_pos == 0) {
+return (Vector2){content_x, content_y};
+}
+if (!line_cache || Dowa_Array_Length(line_cache) == 0) {
+return (Vector2){content_x, content_y};
+}
+int text_len = strlen(text);
+cursor_pos = TA_Min_Int(cursor_pos, text_len);
+// Find which line contains the cursor
+int line_count = Dowa_Array_Length(line_cache);
+for (int i = 0; i < line_count; i++) {
+LineInfo *line = &line_cache[i];
+// Cursor is within this line or at the end of this line
+if (cursor_pos >= line->start_pos && cursor_pos <= line->end_pos) {
+float x = content_x + MeasureTextRange(text, line->start_pos, cursor_pos, font_size);
+float y = content_y + i * line_height;
+return (Vector2){x, y};
+}
+}
+// Fallback: cursor at the end
+int last_line = line_count > 0 ? line_count - 1 : 0;
+LineInfo *line = &line_cache[last_line];
+float x = content_x + MeasureTextRange(text, line->start_pos, cursor_pos, font_size);
+float y = content_y + last_line * line_height;
+return (Vector2){x, y};
+}
+static float GetContentHeight(const char *text, Rectangle bounds, boolean wrap,
+int font_size, int line_height) {
+if (!text || strlen(text) == 0) return line_height;
+float content_width = bounds.width - TEXT_AREA_PADDING * 2;
+int visual_lines = 1;
+int line_char_start = 0;
+int text_len = strlen(text);
+for (int i = 0; i <= text_len; i++) {
+if (i == text_len || text[i] == '\n') {
+visual_lines++;
+line_char_start = i + 1;
+} else if (wrap) {
+int line_width = MeasureTextRange(text, line_char_start, i + 1, font_size);
+if (line_width > content_width && i > line_char_start) {
+int wrap_pos = i;
+for (int j = i; j > line_char_start; j--) {
+if (text[j] == ' ') {
+wrap_pos = j;
+break;
+}
+}
+visual_lines++;
+line_char_start = (text[wrap_pos] == ' ') ? wrap_pos + 1 : wrap_pos;
+}
+}
+}
+return visual_lines * line_height;
+}
+static void PushUndoState(TextAreaState *state, const char *text, Dowa_Arena *arena) {
+TextAreaUndoEntry entry;
+entry.text = Dowa_String_Copy_Arena((char*)text, arena);
+entry.cursor_pos = state->cursor_pos;
+entry.selection_start = state->selection_start;
+entry.selection_end = state->selection_end;
+if (state->undo_index < (int)Dowa_Array_Length(state->undo_stack) - 1) {
+dowa__header(state->undo_stack)->length = state->undo_index + 1;
+}
+Dowa_Array_Push_Arena(state->undo_stack, entry, arena);
+state->undo_index = Dowa_Array_Length(state->undo_stack) - 1;
+if (Dowa_Array_Length(state->undo_stack) > TEXT_AREA_MAX_UNDO_STATES) {
+for (int i = 0; i < (int)Dowa_Array_Length(state->undo_stack) - 1; i++) {
+state->undo_stack[i] = state->undo_stack[i + 1];
+}
+dowa__header(state->undo_stack)->length--;
+state->undo_index--;
+}
+}
+static boolean PerformUndo(TextAreaState *state, char *text, int text_size) {
+if (state->undo_index <= 0) return FALSE;
+state->undo_index--;
+TextAreaUndoEntry *entry = &state->undo_stack[state->undo_index];
+strncpy(text, entry->text, text_size - 1);
+text[text_size - 1] = '\0';
+state->cursor_pos = entry->cursor_pos;
+state->selection_start = entry->selection_start;
+state->selection_end = entry->selection_end;
+return TRUE;
+}
+static boolean PerformRedo(TextAreaState *state, char *text, int text_size) {
+if (state->undo_index >= (int)Dowa_Array_Length(state->undo_stack) - 1) return FALSE;
+state->undo_index++;
+TextAreaUndoEntry *entry = &state->undo_stack[state->undo_index];
+strncpy(text, entry->text, text_size - 1);
+text[text_size - 1] = '\0';
+state->cursor_pos = entry->cursor_pos;
+state->selection_start = entry->selection_start;
+state->selection_end = entry->selection_end;
+return TRUE;
+}
+static void InsertTextAtCursor(char *text, int text_size, int cursor_pos,
+const char *insert_text, int *new_cursor_pos) {
+int text_len = strlen(text);
+int insert_len = strlen(insert_text);
+if (text_len + insert_len >= text_size - 1) {
+insert_len = text_size - 1 - text_len;
+if (insert_len <= 0) return;
+}
+memmove(text + cursor_pos + insert_len,
+text + cursor_pos,
+text_len - cursor_pos + 1);
+memcpy(text + cursor_pos, insert_text, insert_len);
+*new_cursor_pos = cursor_pos + insert_len;
+}
+static void DeleteTextRange(char *text, int start, int end) {
+if (start >= end) return;
+int text_len = strlen(text);
+if (start < 0) start = 0;
+if (end > text_len) end = text_len;
+memmove(text + start, text + end, text_len - end + 1);
+}
+static char* GetSelectedText(const char *text, int sel_start, int sel_end, Dowa_Arena *arena) {
+if (sel_start < 0 || sel_end < 0 || sel_start >= sel_end) return NULL;
+int len = sel_end - sel_start;
+char *result = Dowa_Arena_Allocate(arena, len + 1);
+strncpy(result, text + sel_start, len);
+result[len] = '\0';
+return result;
+}
+boolean GuiTextArea(int id, Rectangle bounds, char *text, int text_size, boolean is_edit_mode,
+boolean should_text_wrap, boolean readonly, Dowa_Arena *arena) {
+boolean should_toggle_edit_mode = FALSE;
+// Get or create state for this text area
+TextAreaState *state = GetTextAreaState(id);
+if (!state) {
+state = CreateTextAreaState(id);
+state->cursor_pos = readonly ? 0 : strlen(text);  // Readonly starts at beginning
+state->last_blink_time = GetTime();
+if (!readonly) PushUndoState(state, text, arena);
+}
+int text_len = strlen(text);
+Vector2 mouse_pos = GetMousePosition();
+boolean mouse_in_bounds = CheckCollisionPointRec(mouse_pos, bounds);
+// Handle click to enter/exit edit mode (readonly still allows selection mode)
+if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
+if (mouse_in_bounds && !is_edit_mode) {
+should_toggle_edit_mode = TRUE;
+} else if (!mouse_in_bounds && is_edit_mode) {
+should_toggle_edit_mode = TRUE;
+}
+}
+// Content area - build/update line cache
+float content_width = bounds.width - TEXT_AREA_PADDING * 2;
+BuildLineCache(state, text, content_width, GuiGetStyle(DEFAULT, TEXT_SIZE), should_text_wrap, arena);
+// Calculate content height from cache (O(1))
+int total_lines = Dowa_Array_Length(state->line_cache);
+float content_height = total_lines * TEXT_AREA_LINE_HEIGHT;
+float visible_height = bounds.height - TEXT_AREA_PADDING * 2;
+float max_scroll = TA_Max_Float(0, content_height - visible_height);
+// Handle scrolling
+float wheel = GetMouseWheelMove();
+if (mouse_in_bounds && wheel != 0) {
+state->scroll_offset_y -= wheel * TEXT_AREA_LINE_HEIGHT * 3;
+state->scroll_offset_y = TA_Max_Float(0, TA_Min_Float(state->scroll_offset_y, max_scroll));
+}
+if (is_edit_mode) {
+boolean ctrl_pressed = IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_RIGHT_CONTROL) ||
+IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_RIGHT_SUPER);
+boolean shift_pressed = IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT);
+boolean text_changed = FALSE;
+double current_time = GetTime();
+if (current_time - state->last_blink_time > 0.5) {
+state->cursor_visible = !state->cursor_visible;
+state->last_blink_time = current_time;
+}
+// Mouse Selection (use line cache for accurate position)
+if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && mouse_in_bounds) {
+int click_pos = GetCharIndexFromPosWithCache(text, bounds, mouse_pos,
+state->scroll_offset_y, GuiGetStyle(DEFAULT, TEXT_SIZE),
+TEXT_AREA_LINE_HEIGHT, state->line_cache);
+state->cursor_pos = click_pos;
+state->selection_start = -1;
+state->selection_end = -1;
+state->is_selecting = TRUE;
+state->cursor_visible = TRUE;
+state->last_blink_time = current_time;
+}
+if (state->is_selecting && IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
+int drag_pos = GetCharIndexFromPosWithCache(text, bounds, mouse_pos,
+state->scroll_offset_y, GuiGetStyle(DEFAULT, TEXT_SIZE),
+TEXT_AREA_LINE_HEIGHT, state->line_cache);
+if (drag_pos != state->cursor_pos) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+}
+state->selection_end = drag_pos;
+}
+}
+if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) {
+state->is_selecting = FALSE;
+if (state->selection_start >= 0 && state->selection_end >= 0) {
+if (state->selection_start > state->selection_end) {
+int temp = state->selection_start;
+state->selection_start = state->selection_end;
+state->selection_end = temp;
+}
+if (state->selection_start == state->selection_end) {
+state->selection_start = -1;
+state->selection_end = -1;
+}
+}
+}
+// Ctrl+A: Select All
+if (ctrl_pressed && IsKeyPressed(KEY_A)) {
+state->selection_start = 0;
+state->selection_end = text_len;
+state->cursor_pos = text_len;
+}
+// Ctrl+C: Copy
+if (ctrl_pressed && IsKeyPressed(KEY_C)) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+char *selected = GetSelectedText(text, sel_min, sel_max, arena);
+if (selected) {
+if (g_clipboard_text) free(g_clipboard_text);
+g_clipboard_text = strdup(selected);
+SetClipboardText(g_clipboard_text);
+}
+}
+}
+// Ctrl+X: Cut (not allowed in readonly mode)
+if (!readonly && ctrl_pressed && IsKeyPressed(KEY_X)) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+char *selected = GetSelectedText(text, sel_min, sel_max, arena);
+if (selected) {
+if (g_clipboard_text) free(g_clipboard_text);
+g_clipboard_text = strdup(selected);
+SetClipboardText(g_clipboard_text);
+}
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+text_changed = TRUE;
+}
+}
+// Ctrl+V: Paste (not allowed in readonly mode)
+if (!readonly && ctrl_pressed && IsKeyPressed(KEY_V)) {
+const char *clipboard = GetClipboardText();
+if (clipboard && strlen(clipboard) > 0) {
+// Skip leading whitespace (spaces, tabs, newlines)
+while (*clipboard && (*clipboard == ' ' || *clipboard == '\t' ||
+*clipboard == '\n' || *clipboard == '\r')) {
+clipboard++;
+}
+if (strlen(clipboard) > 0) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+} else {
+PushUndoState(state, text, arena);
+}
+int new_cursor;
+InsertTextAtCursor(text, text_size, state->cursor_pos, clipboard, &new_cursor);
+state->cursor_pos = new_cursor;
+text_changed = TRUE;
+}
+}
+}
+// Ctrl+Z: Undo / Ctrl+Shift+Z: Redo (not allowed in readonly mode)
+if (!readonly && ctrl_pressed && IsKeyPressed(KEY_Z)) {
+if (shift_pressed) {
+PerformRedo(state, text, text_size);
+} else {
+PerformUndo(state, text, text_size);
+}
+}
+// Arrow Keys Navigation
+if (IsKeyPressed(KEY_LEFT) || IsKeyPressedRepeat(KEY_LEFT)) {
+if (state->selection_start >= 0 && !shift_pressed) {
+state->cursor_pos = TA_Min_Int(state->selection_start, state->selection_end);
+state->selection_start = -1;
+state->selection_end = -1;
+} else if (state->cursor_pos > 0) {
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->cursor_pos--;
+state->selection_end = state->cursor_pos;
+} else {
+state->cursor_pos--;
+}
+}
+state->cursor_visible = TRUE;
+state->last_blink_time = current_time;
+}
+if (IsKeyPressed(KEY_RIGHT) || IsKeyPressedRepeat(KEY_RIGHT)) {
+if (state->selection_start >= 0 && !shift_pressed) {
+state->cursor_pos = TA_Max_Int(state->selection_start, state->selection_end);
+state->selection_start = -1;
+state->selection_end = -1;
+} else if (state->cursor_pos < text_len) {
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->cursor_pos++;
+state->selection_end = state->cursor_pos;
+} else {
+state->cursor_pos++;
+}
+}
+state->cursor_visible = TRUE;
+state->last_blink_time = current_time;
+}
+if (IsKeyPressed(KEY_UP) || IsKeyPressedRepeat(KEY_UP)) {
+int line, col;
+GetLineAndColumn(text, state->cursor_pos, &line, &col);
+if (line > 0) {
+int new_pos = GetPosFromLineColumn(text, line - 1, col);
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->selection_end = new_pos;
+} else {
+state->selection_start = -1;
+state->selection_end = -1;
+}
+state->cursor_pos = new_pos;
+}
+state->cursor_visible = TRUE;
+state->last_blink_time = current_time;
+}
+if (IsKeyPressed(KEY_DOWN) || IsKeyPressedRepeat(KEY_DOWN)) {
+int line, col;
+GetLineAndColumn(text, state->cursor_pos, &line, &col);
+int total_lines = CountLines(text);
+if (line < total_lines - 1) {
+int new_pos = GetPosFromLineColumn(text, line + 1, col);
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->selection_end = new_pos;
+} else {
+state->selection_start = -1;
+state->selection_end = -1;
+}
+state->cursor_pos = new_pos;
+}
+state->cursor_visible = TRUE;
+state->last_blink_time = current_time;
+}
+// Home/End keys
+if (IsKeyPressed(KEY_HOME)) {
+int line_start = GetLineStart(text, state->cursor_pos);
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->selection_end = line_start;
+} else {
+state->selection_start = -1;
+state->selection_end = -1;
+}
+state->cursor_pos = line_start;
+}
+if (IsKeyPressed(KEY_END)) {
+int line_end = GetLineEnd(text, state->cursor_pos);
+if (shift_pressed) {
+if (state->selection_start < 0) {
+state->selection_start = state->cursor_pos;
+state->selection_end = state->cursor_pos;
+}
+state->selection_end = line_end;
+} else {
+state->selection_start = -1;
+state->selection_end = -1;
+}
+state->cursor_pos = line_end;
+}
+// Text Input (not allowed in readonly mode)
+if (!readonly && !ctrl_pressed) {
+int key = GetCharPressed();
+while (key > 0) {
+if (key >= 32 && key <= 126) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+text_changed = TRUE;
+} else if (!text_changed) {
+PushUndoState(state, text, arena);
+}
+char insert_str[2] = {(char)key, '\0'};
+int new_cursor;
+InsertTextAtCursor(text, text_size, state->cursor_pos, insert_str, &new_cursor);
+state->cursor_pos = new_cursor;
+text_changed = TRUE;
+}
+key = GetCharPressed();
+}
+} else if (readonly) {
+// Consume key presses to prevent them from being handled elsewhere
+while (GetCharPressed() > 0) {}
+}
+// Enter key (not allowed in readonly mode)
+if (!readonly && (IsKeyPressed(KEY_ENTER) || IsKeyPressed(KEY_KP_ENTER))) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+} else {
+PushUndoState(state, text, arena);
+}
+int new_cursor;
+InsertTextAtCursor(text, text_size, state->cursor_pos, "\n", &new_cursor);
+state->cursor_pos = new_cursor;
+text_changed = TRUE;
+}
+// Backspace (not allowed in readonly mode)
+if (!readonly && (IsKeyPressed(KEY_BACKSPACE) || IsKeyPressedRepeat(KEY_BACKSPACE))) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+text_changed = TRUE;
+} else if (state->cursor_pos > 0) {
+PushUndoState(state, text, arena);
+DeleteTextRange(text, state->cursor_pos - 1, state->cursor_pos);
+state->cursor_pos--;
+text_changed = TRUE;
+}
+}
+// Delete key (not allowed in readonly mode)
+if (!readonly && (IsKeyPressed(KEY_DELETE) || IsKeyPressedRepeat(KEY_DELETE))) {
+text_len = strlen(text);
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+text_changed = TRUE;
+} else if (state->cursor_pos < text_len) {
+PushUndoState(state, text, arena);
+DeleteTextRange(text, state->cursor_pos, state->cursor_pos + 1);
+text_changed = TRUE;
+}
+}
+// Tab key (not allowed in readonly mode)
+if (!readonly && IsKeyPressed(KEY_TAB)) {
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+PushUndoState(state, text, arena);
+DeleteTextRange(text, sel_min, sel_max);
+state->cursor_pos = sel_min;
+state->selection_start = -1;
+state->selection_end = -1;
+} else {
+PushUndoState(state, text, arena);
+}
+int new_cursor;
+InsertTextAtCursor(text, text_size, state->cursor_pos, "  ", &new_cursor);
+state->cursor_pos = new_cursor;
+text_changed = TRUE;
+}
+// Auto-scroll to keep cursor visible
+// Rebuild cache if text changed during editing
+if (text_changed) {
+state->cache_valid = FALSE;
+BuildLineCache(state, text, content_width, GuiGetStyle(DEFAULT, TEXT_SIZE), should_text_wrap, arena);
+}
+Vector2 cursor_screen = GetCursorScreenPosFromCache(text, state->cursor_pos, bounds,
+state->scroll_offset_y,
+GuiGetStyle(DEFAULT, TEXT_SIZE), TEXT_AREA_LINE_HEIGHT,
+state->line_cache);
+float visible_top = bounds.y + TEXT_AREA_PADDING;
+float visible_bottom = bounds.y + bounds.height - TEXT_AREA_PADDING - TEXT_AREA_LINE_HEIGHT;
+if (cursor_screen.y < visible_top) {
+state->scroll_offset_y -= visible_top - cursor_screen.y;
+} else if (cursor_screen.y > visible_bottom) {
+state->scroll_offset_y += cursor_screen.y - visible_bottom;
+}
+state->scroll_offset_y = TA_Max_Float(0, TA_Min_Float(state->scroll_offset_y, max_scroll));
+}
+// Drawing
+DrawRectangleSelectiveRounded(bounds, 0.2, 1, g_colors.secondary, FALSE, FALSE, TRUE, TRUE);
+DrawRectangleRec(AddPadding(bounds, 10), WHITE);
+// DrawRectangleRec(bounds, is_edit_mode ? DARKGRAY : (Color){40, 40, 40, 255});
+// DrawRectangleLinesEx(bounds, 1, is_edit_mode ? WHITE : GRAY);
+// DrawRectangleRoundedLines(bounds, 0.2, 1, is_edit_mode ? BLACK : GRAY);
+BeginScissorMode((int)bounds.x, (int)bounds.y, (int)bounds.width, (int)bounds.height);
+float content_x = bounds.x + TEXT_AREA_PADDING;
+float content_y = bounds.y + TEXT_AREA_PADDING - state->scroll_offset_y;
+text_len = strlen(text);
+// Calculate visible line range (only render what's visible)
+int first_visible_line = (int)(state->scroll_offset_y / TEXT_AREA_LINE_HEIGHT);
+int last_visible_line = first_visible_line + (int)(visible_height / TEXT_AREA_LINE_HEIGHT) + 2;
+int line_count = Dowa_Array_Length(state->line_cache);
+if (first_visible_line < 0) first_visible_line = 0;
+if (last_visible_line > line_count) last_visible_line = line_count;
+// Draw selection highlight (only for visible lines)
+if (state->selection_start >= 0 && state->selection_end >= 0 &&
+state->selection_start != state->selection_end) {
+int sel_min = TA_Min_Int(state->selection_start, state->selection_end);
+int sel_max = TA_Max_Int(state->selection_start, state->selection_end);
+for (int line_idx = first_visible_line; line_idx < last_visible_line; line_idx++) {
+LineInfo *line = &state->line_cache[line_idx];
+// Check if selection intersects this line
+if (sel_min < line->end_pos && sel_max > line->start_pos) {
+int highlight_start = TA_Max_Int(sel_min, line->start_pos);
+int highlight_end = TA_Min_Int(sel_max, line->end_pos);
+float x1 = content_x + MeasureTextRange(text, line->start_pos, highlight_start, GuiGetStyle(DEFAULT, TEXT_SIZE));
+float x2 = content_x + MeasureTextRange(text, line->start_pos, highlight_end, GuiGetStyle(DEFAULT, TEXT_SIZE));
+float y = content_y + line_idx * TEXT_AREA_LINE_HEIGHT;
+DrawRectangle((int)x1, (int)y, (int)(x2 - x1), TEXT_AREA_LINE_HEIGHT,
+Fade(SKYBLUE, 0.5f));
+}
+}
+}
+// Draw text using line cache (only visible lines)
+Color text_color = should_text_wrap ? BLACK : WHITE;
+for (int line_idx = first_visible_line; line_idx < last_visible_line; line_idx++) {
+LineInfo *line = &state->line_cache[line_idx];
+if (line->char_count > 0) {
+char line_buffer[1024];
+int line_len = TA_Min_Int(line->end_pos - line->start_pos, 1023);
+strncpy(line_buffer, text + line->start_pos, line_len);
+line_buffer[line_len] = '\0';
+Vector2 draw_text_vector = {
+.x = content_x,
+.y = content_y + line_idx * TEXT_AREA_LINE_HEIGHT
+};
+DrawTextEx(GuiGetFont(), line_buffer, draw_text_vector,
+GuiGetStyle(DEFAULT, TEXT_SIZE), TEXT_SIZE_DEFAULT/GuiGetStyle(DEFAULT, TEXT_SIZE), text_color);
+}
+}
+// Draw cursor
+if (is_edit_mode && state->cursor_visible) {
+Vector2 cursor_pos = GetCursorScreenPosFromCache(text, state->cursor_pos, bounds,
+state->scroll_offset_y,
+GuiGetStyle(DEFAULT, TEXT_SIZE), TEXT_AREA_LINE_HEIGHT,
+state->line_cache);
+DrawRectangle((int)cursor_pos.x, (int)cursor_pos.y,
+TEXT_AREA_CURSOR_WIDTH, TEXT_AREA_LINE_HEIGHT, BLACK);
+}
+EndScissorMode();
+// Draw scrollbar if needed
+if (max_scroll > 0) {
+float scrollbar_height = (visible_height / content_height) * visible_height;
+float scrollbar_y = bounds.y + TEXT_AREA_PADDING +
+(state->scroll_offset_y / max_scroll) * (visible_height - scrollbar_height);
+DrawRectangle((int)(bounds.x + bounds.width - 8), (int)scrollbar_y,
+6, (int)scrollbar_height, Fade(WHITE, 0.3f));
+}
+return should_toggle_edit_mode;
+}
+void GuiTextAreaResetState(int id) {
+TextAreaState *state = GetTextAreaState(id);
+if (state) {
+if (state->undo_stack) {
+Dowa_Array_Free(state->undo_stack);
+state->undo_stack = NULL;
+}
+if (state->line_cache) {
+Dowa_Array_Free(state->line_cache);
+state->line_cache = NULL;
+}
+state->cache_valid = FALSE;
+state->is_initialized = FALSE;
+}
+}
+void GuiTextAreaResetAllStates(void) {
+for (int i = 0; i < g_text_area_state_count; i++) {
+if (g_text_area_states[i].undo_stack) {
+Dowa_Array_Free(g_text_area_states[i].undo_stack);
+g_text_area_states[i].undo_stack = NULL;
+}
+if (g_text_area_states[i].line_cache) {
+Dowa_Array_Free(g_text_area_states[i].line_cache);
+g_text_area_states[i].line_cache = NULL;
+}
+g_text_area_states[i].cache_valid = FALSE;
+g_text_area_states[i].is_initialized = FALSE;
+}
+g_text_area_state_count = 0;
+}
+// ============================================================================
+// End TextArea Component
+// ============================================================================
 typedef Dowa_KV(char*, char*) INPUT_HASHMAP;
 typedef struct {
 char *data;
 size_t size;
 } ResponseBuffer;
 typedef struct {
 char *filename;
 char *title;
 Rectangle rect;
 long time_modified;
 boolean deleted;
 } HistoryItem;
 typedef enum {
 TAB_HEADER = 0,
 TAB_BODY,
 TAB_GET_PARAMS,
-TAB_BAR,
+TAB_WEBSOCKET,
 TAB_LENGTH
 } PostDog_Tab_Enum;
+typedef enum {
+RESULT_TAB_BODY = 0,
+RESULT_TAB_HEADERS,
+RESULT_TAB_LENGTH
+} PostDog_ResultTab_Enum;
+// Text area IDs
+#define TEXT_AREA_ID_INPUT_HEADER   1
+#define TEXT_AREA_ID_INPUT_BODY   2
+#define TEXT_AREA_ID_INPUT_PARAMS   3
+#define TEXT_AREA_ID_INPUT_WS     4
+#define TEXT_AREA_ID_RESULT_BODY    5
+#define TEXT_AREA_ID_RESULT_HEADERS 6
 static uint32 counter = 0;
+static uv_mutex_t history_mutex;
+static uv_loop_t *main_loop = NULL;
 HistoryItem *history_items = NULL;
 HistoryItem *new_history_items = NULL;
 // Global UI state
 char *url_input_text = NULL;
-char *url_result_text = NULL;
+char **result_body_array = NULL;  // [RESULT_TAB_BODY, RESULT_TAB_HEADERS]
-char **url_body_map = NULL;
+char **input_body_array = NULL;
 int active_method_dropdown = 0;
+int active_input_tab = 0;
+int active_result_tab = 0;
+Seobeo_WebSocket *ws = NULL;
+boolean WS_BREAK = FALSE;
+uv_thread_t websocket_thread_id;
+Color TEXT_COLOR = BLACK;
+boolean LOADING = FALSE;
 int CompareHistoryItemsByDate(const void *a, const void *b) {
 HistoryItem *itemA = (HistoryItem *)a;
 HistoryItem *itemB = (HistoryItem *)b;
 return (itemB->time_modified - itemA->time_modified);
 {
 char full_file_path[512] = {0};
 snprintf(full_file_path, 512, "%s/%s", POSTDOG_PATHS, filename);
 FILE *file = fopen(full_file_path, "r");
 if (!file)
 return strdup(filename);
 char *title = malloc(sizeof(char) * 512);
 if (!fgets(title, 512, file)) {
 fclose(file);
-return strdup(filename);
+free(title);
-}
+return strdup(filename);
+}
+fclose(file);
+// Strip trailing newline
+title[strcspn(title, "\n")] = '\0';
 return title;
 }
 // TODO: Make this into generic fucntion so I can use it across different thing.
 if (dp == NULL) return;
 char full_path[256];
 while ((entry = readdir(dp)))
 {
 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
 continue;
 snprintf(full_path, sizeof(full_path), "%s/%s", path, entry->d_name);
 if (stat(full_path, &file_stat) == 0)
 {
 HistoryItem item = {0};
 item.filename = strdup(entry->d_name);
 item.title = PostDog_Extract_Title(entry->d_name);
 item.time_modified = file_stat.st_mtime;
 item.deleted = FALSE;
 Dowa_Array_Push(file_arr, item);
 }
 }
 closedir(dp);
 #endif
+// Update the caller's pointer in case array was reallocated
+*p_file_arr = file_arr;
 int count = Dowa_Array_Length(file_arr);
 if (count > 1) {
 qsort(file_arr, count, sizeof(HistoryItem), CompareHistoryItemsByDate);
 }
 }
 int PostDog_History_Load(HistoryItem **p_history_files)
 {
 printf("Directory '%s' not found. Creating it...\n", POSTDOG_PATHS);
 if (mkdir(POSTDOG_PATHS, 0777) != 0)
 return -1;
 return 0;
 }
 printf("Directory '%s' already exists.\n", POSTDOG_PATHS);
 PostDog_List_Directory(POSTDOG_PATHS, p_history_files);
 return 0;
 }
 bool InArea(Vector2 mouse_position, Rectangle area)
 {
 return (
 mouse_position.x >= area.x &&
 mouse_position.x < area.x + area.width &&
 mouse_position.y >= area.y &&
 mouse_position.y < area.y + area.height
 );
 }
 bool Clicked(Vector2 mouse_position, Rectangle area)
 {
 return (InArea(mouse_position, area) && IsMouseButtonPressed(MOUSE_BUTTON_LEFT));
 }
+// -------- END of UI ---- //
 char *PostDog_Enum_To_String(int active_enum)
 {
 switch(active_enum)
 {
 case 0: return "GET";
 case 1: return "POST";
 case 2: return "PUT";
 case 3: return "DELETE";
 }
 return 0;
 }
-char *PostDog_Construct_URL(char *filename)
+char *PostDog_Construct_URL(char *filename, char *out_buffer, size_t buffer_size)
 {
-char full_file_path[512] = {0};
+snprintf(out_buffer, buffer_size, "%s/%s", POSTDOG_PATHS, filename);
-snprintf(full_file_path, 512, "%s/%s", POSTDOG_PATHS, filename);
+return out_buffer;
-return &full_file_path;
+}
-}
+boolean PostDog_History_CreateFile(char *filename, char* values)
-void PostDog_History_CreateFile(char *filename, char* values)
 {
 char full_file_path[512] = {0};
 snprintf(full_file_path, 512, "%s/%s", POSTDOG_PATHS, filename);
 FILE *file = fopen(full_file_path, "w");
 if (!file)
 {
-printf("Failed to create a file: %s\n", full_file_path);
+fprintf(stderr, "Failed to create a file: %s\n", full_file_path);
-return;
+return FALSE;
 }
 fwrite(values, 1, strlen(values), file);
 fclose(file);
+return TRUE;
 }
 void PostDog_Request_SaveFile(void)
 {
 const char *method = PostDog_Enum_To_String(active_method_dropdown);
 size_t new_file_size = 1024 * 1024;
 Dowa_Arena *arena = Dowa_Arena_Create(1024 * 1024 * 2);
 char *new_file = Dowa_Arena_Allocate(arena, 1024 * 1024);
-char *title = malloc(strlen(method) + strlen(url_input_text) + 2);
+char *title = Dowa_Arena_Allocate(arena, strlen(method) + strlen(url_input_text) + 2);
 sprintf(title, "%s %s", method, url_input_text);
 snprintf(
 new_file,
 new_file_size,
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n"
 "---\n"
 "%s\n",
 title,
 url_input_text,
 method,
-url_body_map[TAB_HEADER],
+input_body_array[TAB_HEADER],
-url_body_map[TAB_BODY],
+input_body_array[TAB_BODY],
-url_body_map[TAB_GET_PARAMS],
+input_body_array[TAB_GET_PARAMS],
-url_body_map[TAB_BAR],
+input_body_array[TAB_WEBSOCKET],
-url_result_text
+result_body_array[RESULT_TAB_BODY]
 );
 char *filename = Dowa_Arena_Allocate(arena, 1024);
 if (!filename)
 {
 perror("Error opening file");
 exit(EXIT_FAILURE);
 }
 char *uuid4 = (char *)Dowa_Arena_Allocate(arena, 37);
 if (!uuid4)
 {
 perror("Error uuid");
 exit(EXIT_FAILURE);
 }
+uv_mutex_lock(&history_mutex);
 int32 seed = (uint32)time(NULL) ^ counter++;
 Dowa_String_UUID(seed, uuid4);
 snprintf(filename, 1024, "%s.txt", uuid4);
-PostDog_History_CreateFile(filename, new_file);
+if (PostDog_History_CreateFile(filename, new_file))
+{
 HistoryItem item = {0};
 item.filename = strdup(filename);
-item.title = title;
+item.title = strdup(title);
 item.deleted = FALSE;
 Dowa_Array_Push(new_history_items, item);
+}
+uv_mutex_unlock(&history_mutex);
 Dowa_Arena_Free(arena);
 }
-static size_t Postdog_Curl_Callback(void *contents, size_t size, size_t nmemb, void *userp)
+void PostDog_Websocket_Listen(void)
 {
-size_t real_size = size * nmemb;
+while (TRUE)
-ResponseBuffer *buf = (ResponseBuffer *)userp;
-char *ptr = realloc(buf->data, buf->size + real_size + 1);
-if (ptr == NULL)
 {
-printf("Not enough memory for response\n");
+if (WS_BREAK) break;
-return 0;
-}
+Seobeo_WebSocket_Message *p_msg = Seobeo_WebSocket_Receive(ws);
+if (p_msg)
-buf->data = ptr;
+{
-memcpy(&(buf->data[buf->size]), contents, real_size);
+if (p_msg->opcode == SEOBEO_WS_OPCODE_TEXT)
-buf->size += real_size;
+{
-buf->data[buf->size] = 0;
+printf("Response: %.*s\n", (int)p_msg->length, (char*)p_msg->data);
+char *body = result_body_array[RESULT_TAB_BODY];
-return real_size;
+size_t current_len = strlen(body);
+snprintf(body + current_len, RESULT_BUFFER_LENGTH - current_len,
+"\n%s", (char*)p_msg->data);
+}
+Seobeo_WebSocket_Message_Destroy(p_msg);
+}
+usleep(10000);
+}
+return;
+}
+void PostDog_Websocket_Connect(void)
+{
+// Pass headers from the Headers tab when connecting
+const char *headers = input_body_array[TAB_HEADER];
+if (headers && strlen(headers) > 0)
+ws = Seobeo_WebSocket_Connect_With_Headers(url_input_text, headers);
+else
+ws = Seobeo_WebSocket_Connect(url_input_text);
+result_body_array[RESULT_TAB_BODY][0] = '\0';
+result_body_array[RESULT_TAB_HEADERS][0] = '\0';
+// Reset result text area states
+GuiTextAreaResetState(TEXT_AREA_ID_RESULT_BODY);
+GuiTextAreaResetState(TEXT_AREA_ID_RESULT_HEADERS);
+}
+int PostDog_Websocket_Send(void)
+{
+char *body = result_body_array[RESULT_TAB_BODY];
+if (Seobeo_WebSocket_Send_Text(ws, input_body_array[active_input_tab]) < 0)
+{
+snprintf(body + strlen(body), RESULT_BUFFER_LENGTH - strlen(body),
+"Failed to send message\n");
+return -1;
+}
+snprintf(body + strlen(body), RESULT_BUFFER_LENGTH - strlen(body),
+"\n%s", input_body_array[active_input_tab]);
+return 0;
+}
+void PostDog_Websocket_Destroy(uv_thread_t thread_id)
+{
+Seobeo_WebSocket_Destroy(ws);
+uv_thread_join(&thread_id);
+}
+void PostDog_Websocket_Start(void *arg)
+{
+PostDog_Websocket_Connect();
+PostDog_Websocket_Listen();
+}
+uv_thread_t PostDog_Websocket_Start_Thread()
+{
+uv_thread_t thread_id;
+if (uv_thread_create(&thread_id, PostDog_Websocket_Start, NULL) != 0)
+{
+perror("Failed to create thread");
+memset(&thread_id, 0, sizeof(thread_id));
+return thread_id;
+}
+return thread_id;
 }
 int PostDog_Http_Request(void)
 {
-const char *method = PostDog_Enum_To_String(active_method_dropdown);
+Seobeo_Client_Request *req = Seobeo_Client_Request_Create(url_input_text);
-CURL *curl;
+printf("URL: %s\n", url_input_text);
-CURLcode res;
+Seobeo_Client_Response *res;
-ResponseBuffer buffer = { .data = malloc(1), .size = 0 };
+switch (active_method_dropdown)
-url_result_text[0] = '\n';
-if (buffer.data == NULL)
 {
-snprintf(url_result_text, RESULT_BUFFER_LENGTH, "Error: Failed to allocate memory");
+case 0:
-return -1;
+{
-}
+Seobeo_Client_Request_Set_Method(req, "GET");
-buffer.data[0] = '\0';
+break;
+}
-curl_global_init(CURL_GLOBAL_DEFAULT);
+case 1:
-curl = curl_easy_init();
+{
+Seobeo_Client_Request_Set_Method(req, "POST");
-if (curl)
+break;
+}
+case 2:
+{
+Seobeo_Client_Request_Set_Method(req, "PUT");
+break;
+}
+case 3:
+{
+Seobeo_Client_Request_Set_Method(req, "DELETE");
+break;
+}
+}
+if (input_body_array[TAB_HEADER] && strlen(input_body_array[TAB_HEADER]) > 0)
 {
-struct curl_slist *headerList = NULL;
+char *headersCopy = strdup(input_body_array[TAB_HEADER]);
+char *line = strtok(headersCopy, "\n");
-// Set URL
+while (line != NULL)
-curl_easy_setopt(curl, CURLOPT_URL, url_input_text);
-// Set HTTP method
-if (strcmp(method, "POST") == 0)
 {
-curl_easy_setopt(curl, CURLOPT_POST, 1L);
+while (*line == ' ' || *line == '\t') line++;
-if (url_body_map[TAB_BODY] && strlen(url_body_map[TAB_BODY]) > 0)
+if (strlen(line) > 0)
-curl_easy_setopt(curl, CURLOPT_POSTFIELDS, url_body_map[TAB_BODY]);
+Seobeo_Client_Request_Add_Header_Array(req, line);
-}
+line = strtok(NULL, "\n");
-else if (strcmp(method, "PUT") == 0)
+}
+}
+Seobeo_Client_Request_Set_Follow_Redirects(req, TRUE, 5); // TODO: remove magic number;
+res = Seobeo_Client_Request_Execute(req);
+if (res == NULL) {
+snprintf(result_body_array[RESULT_TAB_BODY], RESULT_BUFFER_LENGTH, "Error: Failed to send the request\n");
+result_body_array[RESULT_TAB_HEADERS][0] = '\0';
+} else {
+// Store response body
+snprintf(result_body_array[RESULT_TAB_BODY], RESULT_BUFFER_LENGTH, "%s",
+res->body ? res->body : "");
+// Sanitize body for display (replace tabs, remove non-printable chars)
+SanitizeTextForDisplay(result_body_array[RESULT_TAB_BODY]);
+// Store response headers
+int offset = snprintf(result_body_array[RESULT_TAB_HEADERS], RESULT_BUFFER_LENGTH,
+"HTTP Status: %d %s\n\n",
+res->status_code, res->status_text ? res->status_text : "");
+if (res->headers) {
+size_t header_count = Dowa_Array_Length(res->headers);
+for (size_t i = 0; i < header_count && offset < RESULT_BUFFER_LENGTH - 100; i++) {
+offset += snprintf(result_body_array[RESULT_TAB_HEADERS] + offset,
+RESULT_BUFFER_LENGTH - offset,
+"%s: %s\n", res->headers[i].key, res->headers[i].value);
+}
+}
+}
+printf("Body: %s\n", res ? res->body : "NULL");
+Seobeo_Client_Request_Destroy(req);
+Seobeo_Client_Response_Destroy(res);
+PostDog_Request_SaveFile();
+// Reset result text area states so scroll/cursor don't carry over
+GuiTextAreaResetState(TEXT_AREA_ID_RESULT_BODY);
+GuiTextAreaResetState(TEXT_AREA_ID_RESULT_HEADERS);
+return 0;
+}
+void PostDog_Http_Work(uv_work_t *req)
+{
+PostDog_Http_Request();
+printf("HTTP request finished.\n");
+}
+void PostDog_Http_Work_Done(uv_work_t *req, int status)
+{
+LOADING = FALSE;
+free(req);
+}
+void PostDog_Http_Thread_Request()
+{
+uv_work_t *work_req = malloc(sizeof(uv_work_t));
+if (!work_req)
+{
+perror("Failed to allocate work request");
+return;
+}
+LOADING = TRUE;
+if (uv_queue_work(main_loop, work_req, PostDog_Http_Work, PostDog_Http_Work_Done) != 0)
+{
+perror("Failed to queue work");
+free(work_req);
+LOADING = FALSE;
+}
+}
+void PostDog_Update_URL(boolean is_url_updated)
+{
+char *params_start = strchr(url_input_text, '?');
+if (is_url_updated)
+{
+if (!params_start)
+return;
+params_start++;
+Dowa_Arena *arena = Dowa_Arena_Create(1024*1024);
+char buffer[4096] = "";
+char **lines = Dowa_String_Split(params_start, "&", URL_TEXT_BUFFER_LENGTH, 1, arena);
+for (int i = 0; i < Dowa_Array_Length(lines); i++)
 {
-curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+char *line = lines[i];
-if (url_body_map[TAB_BODY] && strlen(url_body_map[TAB_BODY]) > 0)
+char **key_value = Dowa_String_Split(line, "=", (int)strlen(line), 1, arena);
-curl_easy_setopt(curl, CURLOPT_POSTFIELDS, url_body_map[TAB_BODY]);
-}
+if (Dowa_Array_Length(key_value) < 2)
-else if (strcmp(method, "DELETE") == 0)
+break;
+snprintf(buffer + strlen(buffer), 4096 - strlen(buffer), "%s %s\n", key_value[0], key_value[1]);
+}
+snprintf(input_body_array[TAB_GET_PARAMS], URL_TEXT_BUFFER_LENGTH, "%s", buffer);
+int length = strlen(input_body_array[TAB_GET_PARAMS]);
+input_body_array[TAB_GET_PARAMS][length--] = '\0';
+Dowa_Arena_Free(arena);
+}
+else
+{
+if (params_start)
 {
-curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+size_t length = params_start - url_input_text;
-}
+url_input_text[length] = '\0';
-// Default is GET
+}
+int get_params_length = (int)strlen(input_body_array[TAB_GET_PARAMS]);
-// Parse and add headers
+if (get_params_length == 0)
-if (url_body_map[TAB_HEADER] && strlen(url_body_map[TAB_HEADER]) > 0)
+return;
+char *separator = "?";
+Dowa_Arena *arena = Dowa_Arena_Create(1024*1024);
+char **lines = Dowa_String_Split(input_body_array[TAB_GET_PARAMS], "\n", get_params_length, 1, arena);
+for (int i = 0; i < Dowa_Array_Length(lines); i++)
 {
-char *headersCopy = strdup(url_body_map[TAB_HEADER]);
+char *line = lines[i];
-char *line = strtok(headersCopy, "\n");
+char **key_value = Dowa_String_Split(line, " ", (int)strlen(line), 1, arena);
-while (line != NULL) {
-while (*line == ' ' || *line == '\t') line++;
+if (Dowa_Array_Length(key_value) < 2)
-if (strlen(line) > 0)
+break;
-headerList = curl_slist_append(headerList, line);
-line = strtok(NULL, "\n");
+strcat(url_input_text, separator);
-}
+strcat(url_input_text, key_value[0]);
-curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerList);
+strcat(url_input_text, "=");
-free(headersCopy);
+for (int i = 1; i < Dowa_Array_Length(key_value); i++)
-}
+{
+if (!key_value[i] || key_value[i][0] == '\0')
-// Set write callback
+break;
-curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Postdog_Curl_Callback);
+if (i > 1) strcat(url_input_text, "%20");
-curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&buffer);
+strcat(url_input_text, key_value[i]);
+}
-// Follow redirects
+separator = "&";
-curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+}
-curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
-res = curl_easy_perform(curl);
+Dowa_Arena_Free(arena);
+}
-if (res != CURLE_OK)
+}
-snprintf(url_result_text, RESULT_BUFFER_LENGTH, "Error: %s\n", curl_easy_strerror(res));
-else
+int PostDog_String_To_MethodEnum(char *value)
 {
-long response_code;
+if (strstr(value, "GET"))
-curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
-if (buffer.size > RESULT_BUFFER_LENGTH)
-printf("TODO: Realloc\n");
-snprintf(url_result_text, RESULT_BUFFER_LENGTH, "HTTP Status: %ld\n\n%s",
-response_code, buffer.data ? buffer.data : "");
-}
-if (headerList) curl_slist_free_all(headerList);
-curl_easy_cleanup(curl);
-}
-else
-snprintf(url_result_text, RESULT_BUFFER_LENGTH, "Error: Failed to initialize curl");
-free(buffer.data);
-curl_global_cleanup();
-PostDog_Request_SaveFile();
 return 0;
-}
-void PostDog_Update_URL(void)
-{
-// Save existing query string if present
-char *question_mark = strchr(url_input_text, '?');
-if (question_mark)
-*question_mark = '\0';
-int get_params_length = (int)strlen(url_body_map[TAB_GET_PARAMS]);
-if (get_params_length == 0)
-return;
-char *separator = "?";
-Dowa_Arena *arena = Dowa_Arena_Create(1024*1024);
-char **lines = Dowa_String_Split(url_body_map[TAB_GET_PARAMS], "\n", get_params_length, 1, arena);
-for (int i = 0; i < Dowa_Array_Length(lines); i++)
-{
-char *line = lines[i];
-char **key_value = Dowa_String_Split(line, " ", (int)strlen(line), 1, arena);
-if (Dowa_Array_Length(key_value) < 2)
-break;
-strcat(url_input_text, separator);
-strcat(url_input_text, key_value[0]);
-strcat(url_input_text, "=");
-for (int i = 1; i < Dowa_Array_Length(key_value); i++)
-{
-if (!key_value[i] || key_value[i][0] == '\0')
-break;
-if (i > 1) strcat(url_input_text, "%20");
-strcat(url_input_text, key_value[i]);
-}
-separator = "&";
-}
-Dowa_Arena_Free(arena);
-}
-int PostDog_String_To_MethodEnum(char *value)
-{
-if (strstr(value, "GET"))
-return 0;
 if (strstr(value, "POST"))
 return 1;
 if (strstr(value, "PUT"))
 return 2;
 if (strstr(value, "DELETE"))
 return 3;
 return 0;
 }
 void PostDog_Params_Reset(void)
 {
 url_input_text[0] = '\0';
-url_result_text[0] = '\0';
 active_method_dropdown = 0;
-for (int i = 0; i < Dowa_Array_Length(url_body_map); i++)
+active_result_tab = 0;
-url_body_map[i][0] = '\0';
+for (int i = 0; i < Dowa_Array_Length(input_body_array); i++)
+input_body_array[i][0] = '\0';
+for (int i = 0; i < Dowa_Array_Length(result_body_array); i++)
+result_body_array[i][0] = '\0';
+// Reset text area states when clearing
+GuiTextAreaResetAllStates();
 }
 void PostDog_Load_File(const char *filename)
 {
 char full_file_path[512] = {0};
 snprintf(full_file_path, 512, "%s/%s", POSTDOG_PATHS, filename);
 FILE *file = fopen(full_file_path, "r");
 if (!file)
 return;
 fseek(file, 0, SEEK_END);
 size_t file_size = ftell(file);
 fseek(file, 0, SEEK_SET);
 for (int i = 0; i < Dowa_Array_Length(values); i++)
 {
 switch (i)
 {
 case 0:  // Title - skip
 break;
 case 1:  // URL
 snprintf(url_input_text, strlen(values[i]) + 1, "%s", values[i]);
 url_input_text[strcspn(url_input_text, "\n")] = '\0';
 break;
 case 2:  // Method
 active_method_dropdown = PostDog_String_To_MethodEnum(values[i]);
 break;
 case 3:  // Headers (TAB_HEADER)
 case 4:  // Body (TAB_BODY)
 case 5:  // Get Params (TAB_GET_PARAMS)
-case 6:  // Bar (TAB_BAR)
+case 6:  // Websocket (TAB_WEBSOCKET)
 {
 int map_index = i - 3;  // 3->0, 4->1, 5->2, 6->3
-snprintf(url_body_map[map_index], strlen(values[i]) + 1, "%s", values[i]);
+snprintf(input_body_array[map_index], strlen(values[i]) + 1, "%s", values[i]);
 // Trim trailing newlines
 for (int j = strlen(values[i]); j > 0; j--)
+{
+if (input_body_array[map_index][j] == '\n')
 {
-if (url_body_map[map_index][j] == '\n')
+input_body_array[map_index][j] = '\0';
-{
+break;
-url_body_map[map_index][j] = '\0';
-break;
-}
 }
-break;
+}
-}
+break;
+}
-default:  // Response (index 7+)
-snprintf(url_result_text, strlen(values[i]) + 1, "%s", values[i]);
+default:  // Response (index 7+) - load into body tab for backward compatibility
-break;
+snprintf(result_body_array[RESULT_TAB_BODY], strlen(values[i]) + 1, "%s", values[i]);
-}
+break;
 }
+}
+// Reset result tab to body
+active_result_tab = RESULT_TAB_BODY;
+// Reset text area states when loading new file
+GuiTextAreaResetAllStates();
 Dowa_Arena_Free(init_arena);
 Dowa_Arena_Free(split_arena);
 }
-Rectangle AddPadding(Rectangle rect, float padding)
+// ============================================================================
-{
+// UI LAYOUT STRUCTURE - All rectangles for the UI
-return (Rectangle){
+// ============================================================================
-rect.x + padding,
+typedef struct {
-rect.y + padding,
+// Main areas
-rect.width - (2 * padding),
+Rectangle screen;
-rect.height - (2 * padding)
+Rectangle sidebar;
+Rectangle content;
+// Sidebar sections
+Rectangle logo_area;
+Rectangle history_list;
+// URL bar section
+Rectangle url_bar;
+Rectangle method_dropdown;
+Rectangle url_input;
+Rectangle send_button;
+// Body section (input + result split)
+Rectangle body_area;
+Rectangle input_panel;
+Rectangle result_panel;
+// Input panel internals
+Rectangle input_tabs;
+Rectangle input_body;
+// Result panel internals
+Rectangle result_tabs;
+Rectangle result_body;
+} UILayout;
+// ============================================================================
+// UI STATE - All interactive state
+// ============================================================================
+typedef struct {
+boolean url_edit_mode;
+boolean method_edit_mode;
+boolean input_body_edit_mode;
+boolean result_body_edit_mode;
+int prev_input_tab;
+float history_scroll_offset;
+} UIState;
+// ============================================================================
+// LAYOUT CALCULATION FUNCTIONS
+// ============================================================================
+static UILayout CalculateLayout(int screen_width, int screen_height, float padding)
+{
+UILayout layout = {0};
+// Screen
+layout.screen = (Rectangle){0, 0, screen_width, screen_height};
+// Main split: sidebar (20%) | content (80%)
+layout.sidebar = LeftColumn(layout.screen, 0.20f, 0);
+layout.content = RightColumn(layout.screen, layout.sidebar, 0);
+// Sidebar sections
+layout.logo_area = (Rectangle){
+.x = layout.sidebar.x,
+.y = layout.sidebar.y,
+.width = layout.sidebar.width,
+.height = 120
 };
-}
+layout.history_list = (Rectangle){
-Rectangle AddPaddingHorizontal(Rectangle rect, float padding)
+.x = layout.sidebar.x + padding,
-{
+.y = layout.logo_area.y + layout.logo_area.height + padding,
-return (Rectangle){
+.width = layout.sidebar.width - (2 * padding),
-rect.x + padding,
+.height = layout.sidebar.height - layout.logo_area.height - (2 * padding)
-rect.y,
-rect.width - (2 * padding),
-rect.height
 };
-}
+// URL bar section (top of content area)
-Rectangle AddPaddingVertical(Rectangle rect, float padding)
+float url_bar_height = 60;
-{
+layout.url_bar = (Rectangle){
-return (Rectangle){
+.x = layout.content.x,
-rect.x,
+.y = layout.content.y + padding,
-rect.y + padding,
+.width = layout.content.width,
-rect.width,
+.height = url_bar_height
-rect.height - (2 * padding)
 };
-}
+// URL bar components (method dropdown + URL input + send button)
-// Layout helper functions
+float dropdown_width = 100;
-Rectangle RightOf(Rectangle ref, float padding)
+float button_width = 80;
-{
+float url_bar_inner_padding = 8;
-return (Rectangle){
+float control_height = 36;
-.x = ref.x + ref.width + padding,
+float control_y = layout.url_bar.y + (layout.url_bar.height - control_height) / 2;
-.y = ref.y,
-.width = 0,
+layout.method_dropdown = (Rectangle){
-.height = ref.height
+.x = layout.url_bar.x + padding,
+.y = control_y,
+.width = dropdown_width,
+.height = control_height
 };
-}
+layout.url_input = (Rectangle){
-Rectangle Below(Rectangle ref, float padding)
+.x = layout.method_dropdown.x + layout.method_dropdown.width + url_bar_inner_padding,
-{
+.y = control_y,
-return (Rectangle){
+.width = layout.url_bar.width - dropdown_width - button_width - (4 * padding) - (2 * url_bar_inner_padding),
-.x = ref.x,
+.height = control_height
-.y = ref.y + ref.height + padding,
-.width = ref.width,
-.height = 0
 };
-}
+layout.send_button = (Rectangle){
-Rectangle LeftColumn(Rectangle container, float ratio, float padding)
+.x = layout.url_input.x + layout.url_input.width + url_bar_inner_padding,
-{
+.y = control_y,
-return (Rectangle){
+.width = button_width,
-.x = container.x + padding,
+.height = control_height
-.y = container.y + padding,
-.width = (container.width * ratio) - padding,
-.height = container.height - (2 * padding)
 };
-}
+// Body area (below URL bar)
-Rectangle RightColumn(Rectangle container, Rectangle leftCol, float padding)
+layout.body_area = (Rectangle){
-{
+.x = layout.content.x,
-return (Rectangle){
+.y = layout.url_bar.y + layout.url_bar.height + padding,
-.x = leftCol.x + leftCol.width + padding,
+.width = layout.content.width,
-.y = container.y + padding,
+.height = layout.content.height - layout.url_bar.height - (3 * padding)
-.width = container.width - leftCol.width - (3 * padding),
-.height = container.height - (2 * padding)
 };
-}
+// Split body into input (left) and result (right) panels
-Rectangle HorizontalSplit(Rectangle container, float ratio)
+float split_ratio = 0.5f;
-{
+layout.input_panel = (Rectangle){
-return (Rectangle){
+.x = layout.body_area.x,
-.x = container.x,
+.y = layout.body_area.y,
-.y = container.y,
+.width = layout.body_area.width * split_ratio,
-.width = container.width * ratio,
+.height = layout.body_area.height
-.height = container.height
 };
-}
+layout.result_panel = (Rectangle){
+.x = layout.body_area.x + layout.input_panel.width,
+.y = layout.body_area.y,
+.width = layout.body_area.width - layout.input_panel.width,
+.height = layout.body_area.height
+};
+// Input panel internals
+float tab_height = 40;
+layout.input_tabs = (Rectangle){
+.x = layout.input_panel.x + padding,
+.y = layout.input_panel.y + padding,
+.width = layout.input_panel.width - (2 * padding),
+.height = tab_height
+};
+layout.input_body = (Rectangle){
+.x = layout.input_panel.x + padding,
+.y = layout.input_tabs.y + layout.input_tabs.height,
+.width = layout.input_panel.width - (2 * padding),
+.height = layout.input_panel.height - tab_height - (2 * padding)
+};
+// Result panel internals
+layout.result_tabs = (Rectangle){
+.x = layout.result_panel.x + padding,
+.y = layout.result_panel.y + padding,
+.width = layout.result_panel.width - (2 * padding),
+.height = tab_height
+};
+layout.result_body = (Rectangle){
+.x = layout.result_panel.x + padding,
+.y = layout.result_tabs.y + layout.result_tabs.height,
+.width = layout.result_panel.width - (2 * padding),
+.height = layout.result_panel.height - tab_height - (2 * padding)
+};
+return layout;
+}
+// ============================================================================
+// DRAWING FUNCTIONS - Separated for clarity
+// ============================================================================
+static void DrawSidebar(UILayout *layout, Texture2D logo_texture, float padding)
+{
+// Sidebar background with rounded left corners
+DrawRectangleRec(layout->sidebar, g_colors.primary);
+// Logo
+Rectangle logo_inner = AddPadding(layout->logo_area, padding);
+float logo_size = logo_inner.height < logo_inner.width ? logo_inner.height : logo_inner.width;
+Rectangle dest_rect = {
+.x = logo_inner.x + (logo_inner.width - logo_size) / 2,
+.y = logo_inner.y,
+.width = logo_size,
+.height = logo_size
+};
+Rectangle source_rect = {0, 0, logo_texture.width, logo_texture.height};
+DrawTexturePro(logo_texture, source_rect, dest_rect, (Vector2){0, 0}, 0.0f, WHITE);
+}
+static void DrawHistoryList(UILayout *layout, Vector2 mouse_pos, float padding, float scroll_offset)
+{
+int32 new_len = Dowa_Array_Length(new_history_items);
+int32 history_len = Dowa_Array_Length(history_items);
+int32 total = new_len + history_len;
+float item_height = 70;
+BeginScissorMode(layout->history_list.x, layout->history_list.y,
+layout->history_list.width, layout->history_list.height);
+int32 visible_index = 0;
+for (int i = 0; i < total; i++)
+{
+HistoryItem *item = i < new_len ?
+&new_history_items[new_len - i - 1] : &history_items[i - new_len];
+if (item->deleted) continue;
+// Calculate item rectangle
+Rectangle item_rect = {
+.x = layout->history_list.x,
+.y = layout->history_list.y + (padding + item_height) * visible_index + scroll_offset,
+.width = layout->history_list.width,
+.height = item_height
+};
+item->rect = item_rect;
+visible_index++;
+// Skip if not visible
+if (item_rect.y + item_rect.height < layout->history_list.y ||
+item_rect.y > layout->history_list.y + layout->history_list.height)
+continue;
+// Draw item background
+DrawRectangleRounded(item_rect, 0.3f, 8, g_colors.secondary);
+// Title area (top 60%)
+Rectangle title_rect = item_rect;
+title_rect.height = item_rect.height * 0.55f;
+// Draw title text
+Rectangle title_text_rect = AddPadding(title_rect, 8);
+if (item->title)
+{
+DrawTextEx(GuiGetFont(), item->title, (Vector2){ .x=title_text_rect.x, .y=title_text_rect.y + 4 },
+GuiGetStyle(DEFAULT, TEXT_SIZE), TEXT_SIZE_DEFAULT/GuiGetStyle(DEFAULT, TEXT_SIZE), g_colors.text);
+}
+// Button area (bottom 40%)
+Rectangle button_area = {
+.x = item_rect.x,
+.y = title_rect.y + title_rect.height,
+.width = item_rect.width,
+.height = item_rect.height - title_rect.height
+};
+Rectangle btn_view = {
+.x = button_area.x + padding,
+.y = button_area.y,
+.width = (button_area.width - 3 * padding) / 2,
+.height = button_area.height - padding
+};
+Rectangle btn_delete = {
+.x = btn_view.x + btn_view.width + padding,
+.y = btn_view.y,
+.width = btn_view.width,
+.height = btn_view.height
+};
+// Hover cursor for buttons
+if (CheckCollisionPointRec(mouse_pos, btn_view) ||
+CheckCollisionPointRec(mouse_pos, btn_delete))
+SetMouseCursor(MOUSE_CURSOR_POINTING_HAND);
+if (GuiButton(btn_view, "View"))
+PostDog_Load_File(item->filename);
+if (GuiButton(btn_delete, "Delete"))
+{
+char delete_path[512];
+if (!remove(PostDog_Construct_URL(item->filename, delete_path, sizeof(delete_path))))
+item->deleted = TRUE;
+else
+fprintf(stderr, "Couldn't delete file: %s\n", item->filename);
+}
+}
+EndScissorMode();
+// Scrollbar
+float content_height = visible_index * (item_height + padding);
+if (content_height > layout->history_list.height)
+{
+float scrollbar_height = (layout->history_list.height / content_height) * layout->history_list.height;
+float scrollbar_y = layout->history_list.y - (scroll_offset / content_height) * layout->history_list.height;
+Rectangle scrollbar_rect = {
+layout->history_list.x + layout->history_list.width - 6,
+scrollbar_y,
+4,
+scrollbar_height
+};
+DrawRectangleRounded(scrollbar_rect, 0.5f, 4, Fade(g_colors.text_light, 0.5f));
+}
+}
+static void DrawURLBar(UILayout *layout, UIState *state, float padding)
+{
+// URL bar background
+Rectangle url_bar_bg = AddPadding(layout->url_bar, padding / 2);
+DrawRectangleRounded(url_bar_bg, 0.3f, 8, g_colors.secondary);
+// Combined method dropdown + URL input with rounded corners
+Rectangle combined_input = {
+.x = layout->method_dropdown.x,
+.y = layout->method_dropdown.y,
+.width = layout->url_input.x + layout->url_input.width - layout->method_dropdown.x,
+.height = layout->method_dropdown.height
+};
+// Method colors: GET=Green, POST=Blue, PUT=Orange, DELETE=Red
+Color method_colors[] = {
+(Color){76, 175, 80, 255},   // GET - Green
+(Color){33, 150, 243, 255},  // POST - Blue
+(Color){255, 152, 0, 255},   // PUT - Orange
+(Color){244, 67, 54, 255}    // DELETE - Red
+};
+// Method dropdown + URL input combined component
+DropdownTextBoxConfig url_config = {
+.dropdown_items = "GET;POST;PUT;DELETE",
+.dropdown_active = &active_method_dropdown,
+.dropdown_edit_mode = &state->method_edit_mode,
+.dropdown_width = layout->method_dropdown.width,
+.text_buffer = url_input_text,
+.text_buffer_size = URL_TEXT_BUFFER_LENGTH,
+.text_edit_mode = &state->url_edit_mode,
+.corner_radius = 0.2f,
+.background_color = g_colors.background,
+.border_color = g_colors.border,
+.text_color = g_colors.text,
+.item_colors = method_colors,
+.item_count = 4
+};
+PostDog_DropdownTextBox(combined_input, url_config);
+// Handle Enter key in URL input
+if (state->url_edit_mode && IsKeyPressed(KEY_ENTER))
+{
+PostDog_Http_Thread_Request();
+state->url_edit_mode = FALSE;
+}
+// Send button
+DrawRectangleRounded(layout->send_button, 0.3f, 8, g_colors.primary);
+Rectangle btn_text_rect = layout->send_button;
+char *btn_text = "Send";
+int text_width = MeasureText(btn_text, GuiGetStyle(DEFAULT, TEXT_SIZE));
+DrawTextEx(GuiGetFont(),
+btn_text,
+(Vector2){ .x=btn_text_rect.x + (btn_text_rect.width - text_width) / 2, .y=btn_text_rect.y + (btn_text_rect.height - GuiGetStyle(DEFAULT, TEXT_SIZE)) / 2 },
+GuiGetStyle(DEFAULT, TEXT_SIZE), TEXT_SIZE_DEFAULT/GuiGetStyle(DEFAULT, TEXT_SIZE), g_colors.text_light);
+if (CheckCollisionPointRec(GetMousePosition(), layout->send_button) &&
+IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
+PostDog_Http_Thread_Request();
+}
+static void DrawBodyPanels(UILayout *layout, UIState *state, float padding)
+{
+// Draw split panel background (input left, result right)
+DrawRectangleSelectiveRounded(layout->input_panel, 12, 8, g_colors.background,
+TRUE, FALSE, FALSE, TRUE);
+DrawRectangleSelectiveRounded(layout->result_panel, 12, 8,
+LOADING ? Fade(g_colors.error, 0.3f) : g_colors.secondary,
+FALSE, TRUE, TRUE, FALSE);
+// Tab labels
+const char *tab_labels[] = {"Headers", "Body", "Params", "WebSocket"};
+int tab_count = 4;
+// Draw custom tabs
+PostDog_TabBarSimple(layout->input_tabs, tab_labels, tab_count, &active_input_tab);
+// Input body text area
+int text_area_id = TEXT_AREA_ID_INPUT_HEADER + active_input_tab;
+if (GuiTextArea(text_area_id, layout->input_body, input_body_array[active_input_tab],
+BODY_BUFFER_LENGTH, state->input_body_edit_mode, TRUE, FALSE, g_text_area_arena))
+state->input_body_edit_mode = !state->input_body_edit_mode;
+// WebSocket send button (only on WebSocket tab)
+if (active_input_tab == TAB_WEBSOCKET)
+{
+WS_BREAK = FALSE;
+Rectangle ws_send_btn = {
+.x = layout->input_body.x + layout->input_body.width - 90 - padding,
+.y = layout->input_body.y + layout->input_body.height - 35 - padding,
+.width = 90,
+.height = 35
+};
+DrawRectangleRounded(ws_send_btn, 0.3f, 8, g_colors.highlight);
+char *ws_text = !ws ? "Connect" : "Send";
+int ws_text_width = MeasureText(ws_text, GuiGetStyle(DEFAULT, TEXT_SIZE));
+DrawTextEx(GuiGetFont(),
+ws_text,
+(Vector2) { .x=ws_send_btn.x + (ws_send_btn.width - ws_text_width) / 2, .y=ws_send_btn.y + (ws_send_btn.height - GuiGetStyle(DEFAULT, TEXT_SIZE)) / 2 },
+GuiGetStyle(DEFAULT, TEXT_SIZE),
+TEXT_SIZE_DEFAULT/GuiGetStyle(DEFAULT, TEXT_SIZE),
+g_colors.text);
+if ((CheckCollisionPointRec(GetMousePosition(), ws_send_btn) &&
+IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) ||
+(state->input_body_edit_mode && IsKeyDown(KEY_LEFT_SHIFT) && IsKeyPressed(KEY_ENTER)))
+{
+if (!ws)
+websocket_thread_id = PostDog_Websocket_Start_Thread();
+usleep(10000);
+PostDog_Websocket_Send();
+}
+}
+else
+{
+WS_BREAK = TRUE;
+}
+// Result tabs
+const char *result_tab_labels[] = {"Body", "Headers"};
+int result_tab_count = 2;
+PostDog_TabBarSimple(layout->result_tabs, result_tab_labels, result_tab_count, &active_result_tab);
+// Result body text area
+int result_text_area_id = TEXT_AREA_ID_RESULT_BODY + active_result_tab;
+// Result text area is readonly (selectable/copyable but not editable)
+if (GuiTextArea(result_text_area_id, layout->result_body, result_body_array[active_result_tab],
+RESULT_BUFFER_LENGTH, state->result_body_edit_mode, TRUE, TRUE, g_text_area_arena))
+state->result_body_edit_mode = !state->result_body_edit_mode;
+PostDog_Update_URL(state->url_edit_mode);
+}
+// ============================================================================
+// MAIN FUNCTION
+// ============================================================================
 int main()
 {
-// -- initizlied --//
+// ========================================================================
+// INITIALIZATION
+// ========================================================================
+SetConfigFlags(FLAG_WINDOW_UNDECORATED);
+// Initialize libuv
+main_loop = uv_default_loop();
+uv_mutex_init(&history_mutex);
+// Initialize color scheme
+PostDog_InitColorScheme();
+// Initialize window
 InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "PostDog");
 SetWindowState(FLAG_WINDOW_RESIZABLE);
 SetTargetFPS(60);
+// Load resources
 Font customFont = LoadFontEx("postdog/Roboto-Regular.ttf", 20, 0, 0);
 GuiSetFont(customFont);
-GuiSetStyle(DEFAULT, TEXT_SIZE, 10);
+GuiSetStyle(DEFAULT, TEXT_SIZE, TEXT_SIZE_DEFAULT);
-Image logo_original = LoadImage("postdog/epi_all_colors.png");
-ImageResize(&logo_original, 60, 60);
+Image logo_original = LoadImage("postdog/logo_bigger.png");
+ImageResize(&logo_original, 200, 200);
 SetWindowIcon(logo_original);
 Texture2D logo_texture = LoadTextureFromImage(logo_original);
+// ToggleBorderlessWindowed();
 UnloadImage(logo_original);
-// -- Starting pos ---//
+// Initialize text area arena
-Rectangle history_sidebar = { 0 };
+g_text_area_arena = Dowa_Arena_Create(1024 * 1024 * 4);
+// Initialize history
 Dowa_Array_Reserve(history_items, 10);
 Dowa_Array_Reserve(new_history_items, 10);
 PostDog_History_Load(&history_items);
-int32 *history_deleted_items = NULL;
+// Initialize text buffers
-Rectangle url_area = { 0 };
-Rectangle textBounds = { 0 };
-Rectangle url_input_bounds = { 0 };
-bool url_input_edit = false;
-Rectangle url_text_bounds = { 0 };
-Rectangle url_enter_button = { 0 };
-Rectangle method_dropdown = { 0 };
-// Initialize global UI state
 url_input_text = (char *)malloc(sizeof(char) * URL_TEXT_BUFFER_LENGTH);
-snprintf(url_input_text, URL_TEXT_BUFFER_LENGTH, "https://httpbin.org/get");
+snprintf(url_input_text, URL_TEXT_BUFFER_LENGTH, URL_TEXT_DEFAULT);
-Dowa_Array_Push(url_body_map, (char *)malloc(sizeof(char) * HEADER_BUFFER_LENGTH));
+Dowa_Array_Push(input_body_array, (char *)malloc(sizeof(char) * HEADER_BUFFER_LENGTH));
-Dowa_Array_Push(url_body_map, (char *)malloc(sizeof(char) * BODY_BUFFER_LENGTH));
+Dowa_Array_Push(input_body_array, (char *)malloc(sizeof(char) * BODY_BUFFER_LENGTH));
-Dowa_Array_Push(url_body_map, (char *)malloc(sizeof(char) * DEFAULT_TEXT_BUFFER_LENGTH));
+Dowa_Array_Push(input_body_array, (char *)malloc(sizeof(char) * DEFAULT_TEXT_BUFFER_LENGTH));
-Dowa_Array_Push(url_body_map, (char *)malloc(sizeof(char) * DEFAULT_TEXT_BUFFER_LENGTH));
+Dowa_Array_Push(input_body_array, (char *)malloc(sizeof(char) * DEFAULT_TEXT_BUFFER_LENGTH));
-snprintf(url_body_map[TAB_HEADER], HEADER_BUFFER_LENGTH, "Content-Type: application/json");
+snprintf(input_body_array[TAB_HEADER], HEADER_BUFFER_LENGTH, HEADER_TEXT_DEFAULT);
-snprintf(url_body_map[TAB_BODY], HEADER_BUFFER_LENGTH, "");
+snprintf(input_body_array[TAB_BODY], BODY_BUFFER_LENGTH, BODY_TEXT_DEFAULT);
+snprintf(input_body_array[TAB_GET_PARAMS], DEFAULT_TEXT_BUFFER_LENGTH, GET_PARAM_TEXT_DEFAULT);
-url_result_text = (char *)malloc(sizeof(char) * RESULT_BUFFER_LENGTH);
+snprintf(input_body_array[TAB_WEBSOCKET], DEFAULT_TEXT_BUFFER_LENGTH, GET_PARAM_TEXT_DEFAULT);
-bool method_edit = false;
+// Initialize result buffers (body and headers tabs)
+Dowa_Array_Push(result_body_array, (char *)malloc(sizeof(char) * RESULT_BUFFER_LENGTH));
-int sendRequest;
+Dowa_Array_Push(result_body_array, (char *)malloc(sizeof(char) * RESULT_BUFFER_LENGTH));
+result_body_array[RESULT_TAB_BODY][0] = '\0';
-// -- input --//
+result_body_array[RESULT_TAB_HEADERS][0] = '\0';
-Rectangle input_area = { 0 };
-Rectangle input_tab = { 0 };
+// Initialize UI state
-Rectangle input_tab_item = { 0 };
+UIState ui_state = {0};
-Rectangle input_body = { 0 };
+float padding = 10.0f;
-bool input_body_bool = false;
+// ========================================================================
-// -- result --//
+// MAIN LOOP
-Rectangle result_area = { 0 };
+// ========================================================================
-Rectangle result_body = { 0 };
-// General styling.
-float padding = 10; // TODO make it % based?
-int active_input_tab = 0;
-int prev_input_tab = 0;
-// Scroll offsets
-float history_scroll_offset = 0;
-float input_body_scroll_offset = 0;
-float result_body_scroll_offset = 0;
 while (!WindowShouldClose())
 {
+// Process libuv events (non-blocking)
+uv_run(main_loop, UV_RUN_NOWAIT);
+// Handle keyboard shortcuts
+DefaultBehaviours();
+// ====================================================================
+// LAYOUT CALCULATION
+// ====================================================================
 int screen_width = GetScreenWidth();
 int screen_height = GetScreenHeight();
+UILayout layout = CalculateLayout(screen_width, screen_height, padding);
-if ((IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_LEFT_CONTROL)) && IsKeyDown(KEY_EQUAL))
-GuiSetStyle(DEFAULT, TEXT_SIZE, GuiGetStyle(DEFAULT, TEXT_SIZE) + 1);
+// ====================================================================
+// INPUT HANDLING
-if ((IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_LEFT_CONTROL)) && IsKeyDown(KEY_MINUS))
+// ====================================================================
-GuiSetStyle(DEFAULT, TEXT_SIZE, GuiGetStyle(DEFAULT, TEXT_SIZE) - 1);
+Vector2 mouse_pos = GetMousePosition();
+float mouse_wheel = GetMouseWheelMove();
-Rectangle screen = { 0, 0, screen_width, screen_height };
+// Reset cursor
-// -- Side bar --//
+SetMouseCursor(MOUSE_CURSOR_DEFAULT);
-history_sidebar = LeftColumn(screen, 0.15, padding);
-Rectangle content_area = RightColumn(screen, history_sidebar, padding);
+// History scroll
-Rectangle logo_area = (Rectangle){
+if (CheckCollisionPointRec(mouse_pos, layout.history_list) && mouse_wheel != 0)
-.x = history_sidebar.x,
-.y = history_sidebar.y,
-.width = history_sidebar.width,
-.height = 80
-};
-Rectangle history_list_area = Below(logo_area, padding);
-history_list_area.width = history_sidebar.width;
-history_list_area.height = history_sidebar.height - logo_area.height - padding;
-int32 new_history_items_length = Dowa_Array_Length(new_history_items);
-int32 history_item_length = Dowa_Array_Length(history_items);
-int32 total = new_history_items_length + history_item_length;
-float item_height = history_list_area.height * 0.10;
-int32 number_of_skipped_items = 0;
-for (int i = 0; i < total; i++)
 {
-HistoryItem *curr_history_items = i < new_history_items_length ?
+ui_state.history_scroll_offset += mouse_wheel * 30;
-&new_history_items[i - new_history_items_length - 1] : &history_items[i - new_history_items_length];
+int32 total = Dowa_Array_Length(new_history_items) + Dowa_Array_Length(history_items);
+float content_height = total * 80;
-if (curr_history_items->deleted)
+float max_scroll = content_height - layout.history_list.height;
-{
+if (ui_state.history_scroll_offset > 0) ui_state.history_scroll_offset = 0;
-number_of_skipped_items++;
+if (max_scroll > 0 && ui_state.history_scroll_offset < -max_scroll)
-continue;
+ui_state.history_scroll_offset = -max_scroll;
 }
-curr_history_items->rect = (Rectangle){
+// Cursor changes for interactive areas
-.x = history_list_area.x,
+if (CheckCollisionPointRec(mouse_pos, layout.send_button) ||
-.y = history_list_area.y + (padding + item_height) * (i - number_of_skipped_items) + history_scroll_offset,
+CheckCollisionPointRec(mouse_pos, layout.input_tabs) ||
-.width = history_list_area.width,
+CheckCollisionPointRec(mouse_pos, layout.logo_area))
-.height = item_height
+SetMouseCursor(MOUSE_CURSOR_POINTING_HAND);
-};
-}
+// Logo click resets
+if (CheckCollisionPointRec(mouse_pos, layout.logo_area) &&
-// --- URL --- //
+IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
-url_area = (Rectangle){
+PostDog_Params_Reset();
-.x = content_area.x,
-.y = content_area.y,
+// ====================================================================
-.width = content_area.width,
+// DRAWING
-.height = content_area.height * 0.1
+// ====================================================================
-};
-float url_control_y = url_area.y + (url_area.height - TEXT_SIZE * 2) / 2;
-url_text_bounds = (Rectangle){
-.x = url_area.x + padding,
-.y = url_control_y,
-.width = 7 * (TEXT_SIZE / 2),
-.height = TEXT_SIZE * 2
-};
-url_input_bounds = RightOf(url_text_bounds, padding);
-url_input_bounds.width = url_area.width * 0.7;
-url_input_bounds.height = TEXT_SIZE * 2;
-url_enter_button = RightOf(url_input_bounds, padding);
-url_enter_button.width = url_area.width * 0.1;
-url_enter_button.height = TEXT_SIZE * 2;
-method_dropdown = RightOf(url_enter_button, padding);
-method_dropdown.width = url_area.width * 0.1;
-method_dropdown.height = TEXT_SIZE * 2;
-// -- Body -- //
-Rectangle body_area = Below(url_area, 0);
-body_area.height = content_area.height - url_area.height;
-input_area = HorizontalSplit(body_area, 0.5);
-result_area = RightOf(input_area, 0);
-result_area.width = body_area.width - input_area.width;
-input_tab = (Rectangle){
-.x = input_area.x + padding,
-.y = input_area.y + padding,
-.width = input_area.width - (2 * padding),
-.height = input_area.height * 0.1
-};
-input_tab_item = input_tab;
-input_tab_item.width = input_tab.width / 4;
-input_body = Below(input_tab, 0);
-input_body.width = input_tab.width;
-input_body.height = input_area.height - input_tab.height - (2 * padding);
-// -- Result -- /
-result_body = (Rectangle){
-.x = result_area.x + padding,
-.y = input_body.y,
-.width = result_area.width - (2 * padding),
-.height = input_body.height
-};
-Vector2 mouse_position = GetMousePosition();
-float mouse_wheel = GetMouseWheelMove();
-// Reset input body scroll when tab changes
-if (prev_input_tab != active_input_tab) {
-input_body_scroll_offset = 0;
-prev_input_tab = active_input_tab;
-}
-// Handle scroll wheel for history
-if (InArea(mouse_position, history_list_area) && mouse_wheel != 0) {
-history_scroll_offset += mouse_wheel * 30;  // 30 pixels per wheel tick
-// Clamp scroll offset
-float max_scroll = (total * (item_height + padding)) - history_list_area.height;
-if (history_scroll_offset > 0) history_scroll_offset = 0;
-if (history_scroll_offset < -max_scroll && max_scroll > 0) history_scroll_offset = -max_scroll;
-}
-// Handle scroll wheel for input body
-if (InArea(mouse_position, input_body) && mouse_wheel != 0) {
-input_body_scroll_offset += mouse_wheel * 30;
-if (input_body_scroll_offset > 0) input_body_scroll_offset = 0;
-}
-// Handle scroll wheel for result body
-if (InArea(mouse_position, result_body) && mouse_wheel != 0) {
-result_body_scroll_offset += mouse_wheel * 30;
-if (result_body_scroll_offset > 0) result_body_scroll_offset = 0;
-}
 BeginDrawing();
-ClearBackground(GetColor(GuiGetStyle(DEFAULT, BACKGROUND_COLOR)));
+ClearBackground(g_colors.background);
+DrawRectangleSelectiveRounded(layout.content, 12, 8, g_colors.secondary,
-DrawRectangleRec(history_sidebar, Fade(GRAY, 0.1f));
+FALSE, TRUE, TRUE, FALSE);
+DrawSidebar(&layout, logo_texture, padding);
-// DrawRectangleRec(logo_area, Fade(BLUE, 0.2f));
+DrawHistoryList(&layout, mouse_pos, padding, ui_state.history_scroll_offset);
-Rectangle logo_image_rect = AddPadding(logo_area, padding);
+DrawBodyPanels(&layout, &ui_state, padding);
-// Fit logo to area while maintaining aspect ratio
+DrawURLBar(&layout, &ui_state, padding);
-float logo_size = logo_image_rect.height < logo_image_rect.width ? logo_image_rect.height : logo_image_rect.width;
-Rectangle dest = {
-.x = logo_image_rect.x + (logo_image_rect.width - logo_size) / 2,  // Center horizontally
-.y = logo_image_rect.y,
-.width = logo_size,
-.height = logo_size
-};
-Rectangle source = { 0, 0, logo_texture.width, logo_texture.height };
-DrawTexturePro(logo_texture, source, dest, (Vector2){0, 0}, 0.0f, WHITE);
-BeginScissorMode(history_list_area.x, history_list_area.y, history_list_area.width, history_list_area.height);
-for (int i = 0; i < total; i++)
-{
-HistoryItem *curr_history_items = i < new_history_items_length ?
-&new_history_items[i - new_history_items_length - 1] : &history_items[i - new_history_items_length];
-if (curr_history_items->deleted)
-continue;
-float diff = curr_history_items->rect.height*0.3;
-// DrawRectangleRec(curr_history_items->rect, Fade(RED, 0.1f));
-Rectangle filename_area = curr_history_items->rect;
-filename_area.height -= diff;
-Rectangle icon_area = Below(filename_area, 0);
-icon_area.height = diff;
-DrawRectangleRec(filename_area, Fade(BLUE, 0.1f));
-DrawRectangleRec(icon_area, Fade(YELLOW, 0.1f));
-Rectangle icon_area_left_column = LeftColumn(icon_area, 0.5, 0);
-Rectangle icon_area_right_column = RightColumn(icon_area, icon_area_left_column, 0);
-GuiDrawText(curr_history_items->title, AddPadding(filename_area, padding), TEXT_ALIGN_CENTER, RED);
-if (GuiButton(AddPaddingHorizontal(icon_area_left_column, padding), "view"))
-PostDog_Load_File(curr_history_items->filename);
-if (GuiButton(AddPaddingHorizontal(icon_area_right_column,padding), "delete"))
-{
-if (!remove(PostDog_Construct_URL(curr_history_items->filename)))
-curr_history_items->deleted = TRUE;
-else
-fprintf(stderr, "Wasn't able to delete file: %s \n", curr_history_items->filename);
-}
-}
-EndScissorMode();
-if (total > 0)
-{
-float content_height = total * (item_height + padding);
-if (content_height > history_list_area.height)
-{
-float scrollbar_height = (history_list_area.height / content_height) * history_list_area.height;
-float scrollbar_y = history_list_area.y - (history_scroll_offset / content_height) * history_list_area.height;
-Rectangle scrollbar = {
-history_list_area.x + history_list_area.width - 5,
-scrollbar_y,
-5,
-scrollbar_height
-};
-DrawRectangleRec(scrollbar, Fade(WHITE, 0.5f));
-}
-}
-// URL area Rect
-GuiDrawText("URL: ", url_text_bounds, TEXT_ALIGN_CENTER, RED);
-DrawRectangleRec(url_area, Fade(RED, 0.1f));
-if (GuiTextBox(url_input_bounds, url_input_text, DEFAULT_TEXT_BUFFER_LENGTH, url_input_edit))
-url_input_edit = !url_input_edit;
-sendRequest = GuiButton(url_enter_button, "ENTER");
-if (sendRequest)
-PostDog_Http_Request();
-if (GuiDropdownBox(method_dropdown, "GET;POST;PUT;DELETE", &active_method_dropdown, method_edit))
-method_edit = !method_edit;
-// Input Tabs Rect
-DrawRectangleRec(input_area, Fade(BLUE, 0.1f));
-DrawRectangleRec(input_tab,  Fade(DARKBLUE, 0.1f));
-GuiSetStyle(TOGGLE, GROUP_PADDING, 0);
-GuiDrawRectangle(input_body, 1, GetColor(GuiGetStyle(TEXTBOX, BORDER)), GetColor(GuiGetStyle(TEXTBOX, BASE_COLOR_PRESSED)));
-BeginScissorMode(input_body.x, input_body.y, input_body.width, input_body.height);
-Rectangle scrolled_input = AddPadding(input_body, padding * 2);
-scrolled_input.y += input_body_scroll_offset;
-scrolled_input.height = MAX_SCROLL_HEIGHT;
-if (JUNE_GuiTextBox(scrolled_input, url_body_map[active_input_tab], DEFAULT_TEXT_BUFFER_LENGTH, input_body_bool))
-input_body_bool = !input_body_bool;
-EndScissorMode();
-if (input_body_scroll_offset < 0) {
-float scrollbar_height = 10;
-float scrollbar_y = input_body.y - (input_body_scroll_offset / MAX_SCROLL_HEIGHT) * (input_body.height - scrollbar_height);
-Rectangle scrollbar = {
-input_body.x + input_body.width - 5,
-scrollbar_y,
-5,
-scrollbar_height
-};
-DrawRectangleRec(scrollbar, Fade(BLUE, 0.5f));
-}
-GuiToggleGroup(input_tab_item, "Header;Body;Get Param;Bar", &active_input_tab);
-PostDog_Update_URL();
-// Result Rect
-DrawRectangleRec(result_area, Fade(GREEN, 0.1f));
-DrawRectangleRec(result_body, Fade(DARKGREEN, 0.1f));
-// Create scrollable result body with offset
-BeginScissorMode(result_body.x, result_body.y, result_body.width, result_body.height);
-Rectangle scrolled_result = result_body;
-scrolled_result.y += result_body_scroll_offset;
-scrolled_result.height = MAX_SCROLL_HEIGHT;
-GuiTextBoxMulti(scrolled_result, url_result_text, RESULT_BUFFER_LENGTH, false);
-EndScissorMode();
-if (result_body_scroll_offset < 0) {
-float scrollbar_height = 10;
-float scrollbar_y = result_body.y - (result_body_scroll_offset / MAX_SCROLL_HEIGHT) * (result_body.height - scrollbar_height);
-Rectangle scrollbar = {
-result_body.x + result_body.width - 5,
-scrollbar_y,
-5,
-scrollbar_height
-};
-DrawRectangleRec(scrollbar, Fade(GREEN, 0.5f));
-}
-if (url_input_edit && (IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_LEFT_CONTROL)) && IsKeyPressed(KEY_C))
-{
-SetClipboardText(url_input_text);
-}
-else if (input_body_bool && (IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_LEFT_CONTROL)) && IsKeyPressed(KEY_C))
-{
-SetClipboardText(url_body_map[active_input_tab]);
-}
-else if (InArea(mouse_position, result_body))
-{
-DrawRectangleRec(result_body, Fade(GREEN, 0.3f));
-if ((IsKeyDown(KEY_LEFT_SUPER) || IsKeyDown(KEY_LEFT_CONTROL)) && IsKeyPressed(KEY_C))
-SetClipboardText(url_result_text);
-}
 EndDrawing();
 }
+// ========================================================================
+// CLEANUP
+// ========================================================================
+GuiTextAreaResetAllStates();
+Dowa_Arena_Free(g_text_area_arena);
+uv_mutex_destroy(&history_mutex);
+uv_loop_close(main_loop);
+UnloadTexture(logo_texture);
 CloseWindow();
 return 0;
 }

Mercurial

comparison postdog/main.c @ 173:827c6ac504cd hg-web