reugenio
c6b9bd080a
- Insert at selected_row + 1 instead of at selected_row - Use startInjectedEdit() for proper injection tracking - Row appears below cursor, more intuitive UX
1443 lines
55 KiB
Zig
1443 lines
55 KiB
Zig
//! AdvancedTable Widget - Schema-driven data table
|
|
//!
|
|
//! A full-featured table widget with:
|
|
//! - Schema-driven configuration (TableSchema + ColumnDef)
|
|
//! - Excel-style cell editing with overlay
|
|
//! - Auto-CRUD (automatic CREATE/UPDATE/DELETE detection)
|
|
//! - Keyboard navigation (arrows, Tab, Enter, Escape)
|
|
//! - Column sorting (click header)
|
|
//! - Row operations (Ctrl+N/A/B, Ctrl+arrows)
|
|
//! - Visual state indicators (normal, modified, new, deleted, error)
|
|
//! - Lookup & auto-fill for related data
|
|
//!
|
|
//! This module re-exports types from the advanced_table/ subdirectory.
|
|
|
|
const std = @import("std");
|
|
const Context = @import("../../core/context.zig").Context;
|
|
const Command = @import("../../core/command.zig");
|
|
const Layout = @import("../../core/layout.zig");
|
|
const Style = @import("../../core/style.zig");
|
|
const table_core = @import("../table_core.zig");
|
|
|
|
// Re-export types
|
|
pub const types = @import("types.zig");
|
|
pub const CellValue = types.CellValue;
|
|
pub const ColumnType = types.ColumnType;
|
|
pub const RowState = types.RowState;
|
|
pub const RowLockState = types.RowLockState;
|
|
pub const SortDirection = types.SortDirection;
|
|
pub const CRUDAction = types.CRUDAction;
|
|
pub const ValidationResult = types.ValidationResult;
|
|
pub const TableColors = types.TableColors;
|
|
pub const BasicColors = types.BasicColors;
|
|
pub const TableConfig = types.TableConfig;
|
|
pub const Row = types.Row;
|
|
|
|
// Re-export schema
|
|
pub const schema = @import("schema.zig");
|
|
pub const ColumnDef = schema.ColumnDef;
|
|
pub const ColumnAlign = schema.ColumnAlign;
|
|
pub const AutoFillMapping = schema.AutoFillMapping;
|
|
pub const SelectOption = schema.SelectOption;
|
|
pub const TableSchema = schema.TableSchema;
|
|
pub const DataStore = schema.DataStore;
|
|
|
|
// Re-export state
|
|
pub const state = @import("state.zig");
|
|
pub const AdvancedTableState = state.AdvancedTableState;
|
|
pub const AdvancedTableResult = state.AdvancedTableResult;
|
|
|
|
// Re-export datasource
|
|
pub const datasource = @import("datasource.zig");
|
|
pub const MemoryDataSource = datasource.MemoryDataSource;
|
|
|
|
// Re-export table_core types
|
|
pub const NavigateDirection = table_core.NavigateDirection;
|
|
|
|
// =============================================================================
|
|
// Public API
|
|
// =============================================================================
|
|
|
|
/// Draw an AdvancedTable with default layout
|
|
pub fn advancedTable(
|
|
ctx: *Context,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
) AdvancedTableResult {
|
|
return advancedTableEx(ctx, table_state, table_schema, null);
|
|
}
|
|
|
|
/// Draw an AdvancedTable with custom colors
|
|
pub fn advancedTableEx(
|
|
ctx: *Context,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
colors: ?*const TableColors,
|
|
) AdvancedTableResult {
|
|
const bounds = ctx.layout.nextRect();
|
|
return advancedTableRect(ctx, bounds, table_state, table_schema, colors);
|
|
}
|
|
|
|
/// Draw an AdvancedTable in a specific rectangle
|
|
pub fn advancedTableRect(
|
|
ctx: *Context,
|
|
bounds: Layout.Rect,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
custom_colors: ?*const TableColors,
|
|
) AdvancedTableResult {
|
|
var result = AdvancedTableResult{};
|
|
|
|
if (bounds.isEmpty() or table_schema.columns.len == 0) return result;
|
|
|
|
// Get colors
|
|
const default_colors = TableColors{};
|
|
const colors = custom_colors orelse table_schema.colors orelse &default_colors;
|
|
const config = table_schema.config;
|
|
|
|
// Ensure valid selection if table has data (like Table widget does)
|
|
if (table_state.getRowCount() > 0 and table_schema.columns.len > 0) {
|
|
if (table_state.selected_row < 0) table_state.selected_row = 0;
|
|
if (table_state.selected_col < 0) table_state.selected_col = 0;
|
|
}
|
|
|
|
// Generate unique ID for focus system
|
|
const widget_id: u64 = @intFromPtr(table_state);
|
|
|
|
// Register as focusable
|
|
ctx.registerFocusable(widget_id);
|
|
|
|
// Check mouse interaction
|
|
const mouse = ctx.input.mousePos();
|
|
const hovered = bounds.contains(mouse.x, mouse.y);
|
|
const clicked = hovered and ctx.input.mousePressed(.left);
|
|
|
|
if (clicked) {
|
|
ctx.requestFocus(widget_id);
|
|
result.clicked = true;
|
|
}
|
|
|
|
// Check if we have focus
|
|
const has_focus = ctx.hasFocus(widget_id);
|
|
table_state.nav.has_focus = has_focus;
|
|
|
|
// Calculate dimensions
|
|
const state_col_w: u32 = if (config.show_row_state_indicators) config.state_indicator_width else 0;
|
|
const header_h: u32 = if (config.show_headers) config.header_height else 0;
|
|
const content_h = bounds.h -| header_h;
|
|
const visible_rows: usize = @intCast(content_h / config.row_height);
|
|
|
|
// Begin clipping
|
|
ctx.pushCommand(Command.clip(bounds.x, bounds.y, bounds.w, bounds.h));
|
|
|
|
// Draw header
|
|
if (config.show_headers) {
|
|
drawHeader(ctx, bounds, table_state, table_schema, state_col_w, colors, &result);
|
|
}
|
|
|
|
// Calculate visible row range
|
|
const first_visible = table_state.nav.scroll_row;
|
|
const last_visible = @min(first_visible + visible_rows, table_state.getRowCount());
|
|
|
|
// Manejar clicks en filas (separado del renderizado)
|
|
handleRowClicks(ctx, bounds, table_state, table_schema, header_h, state_col_w, first_visible, last_visible, &result);
|
|
|
|
// Construir ColumnRenderDefs para la función unificada
|
|
var col_defs: [64]table_core.ColumnRenderDef = undefined;
|
|
var col_count: usize = 0;
|
|
for (table_schema.columns) |col| {
|
|
if (col_count >= 64) break;
|
|
col_defs[col_count] = .{
|
|
.width = col.width,
|
|
.visible = col.visible,
|
|
.text_align = 0, // Por ahora left-align
|
|
};
|
|
col_count += 1;
|
|
}
|
|
|
|
// Crear MemoryDataSource y dibujar filas con función unificada
|
|
var memory_ds = MemoryDataSource.init(table_state, table_schema.columns);
|
|
const data_src = memory_ds.toDataSource();
|
|
|
|
// Construir RowRenderColors manualmente (los dos TableColors son tipos diferentes)
|
|
const render_colors = table_core.RowRenderColors{
|
|
.row_normal = colors.row_normal,
|
|
.row_alternate = colors.row_alternate,
|
|
.selected_row = colors.selected_row,
|
|
.selected_row_unfocus = colors.selected_row_unfocus,
|
|
.selected_cell = colors.selected_cell,
|
|
.selected_cell_unfocus = Style.Color.rgb(80, 80, 90), // Default similar a table_core
|
|
.text_normal = colors.text_normal,
|
|
.text_selected = colors.text_selected,
|
|
.border = colors.border,
|
|
.state_modified = colors.state_modified,
|
|
.state_new = colors.state_new,
|
|
.state_deleted = colors.state_deleted,
|
|
.state_error = colors.state_error,
|
|
};
|
|
|
|
var cell_buffer: [256]u8 = undefined;
|
|
_ = table_core.drawRowsWithDataSource(ctx, data_src, .{
|
|
.bounds_x = bounds.x,
|
|
.bounds_y = bounds.y + @as(i32, @intCast(header_h)),
|
|
.bounds_w = bounds.w,
|
|
.row_height = config.row_height,
|
|
.first_row = first_visible,
|
|
.last_row = last_visible,
|
|
.has_focus = has_focus,
|
|
.selected_row = table_state.selected_row,
|
|
.active_col = @intCast(@max(0, table_state.selected_col)),
|
|
.colors = render_colors,
|
|
.columns = col_defs[0..col_count],
|
|
.state_indicator_width = state_col_w,
|
|
.apply_state_colors = true,
|
|
.draw_row_borders = true,
|
|
.alternating_rows = config.alternating_rows,
|
|
.edit_buffer = &table_state.row_edit_buffer,
|
|
}, &cell_buffer);
|
|
|
|
// End clipping
|
|
ctx.pushCommand(Command.clipEnd());
|
|
|
|
// Draw focus ring (outside clip)
|
|
if (has_focus) {
|
|
if (Style.isFancy()) {
|
|
ctx.pushCommand(Command.focusRing(bounds.x, bounds.y, bounds.w, bounds.h, 4));
|
|
} else {
|
|
ctx.pushCommand(Command.rectOutline(
|
|
bounds.x - 1,
|
|
bounds.y - 1,
|
|
bounds.w + 2,
|
|
bounds.h + 2,
|
|
colors.focus_ring,
|
|
));
|
|
}
|
|
}
|
|
|
|
// Draw scrollbar if needed
|
|
if (table_state.getRowCount() > visible_rows) {
|
|
drawScrollbar(ctx, bounds, table_state, visible_rows, config, colors);
|
|
}
|
|
|
|
// Handle keyboard
|
|
if (has_focus) {
|
|
if (table_state.isEditing()) {
|
|
// Handle editing keyboard
|
|
handleEditingKeyboard(ctx, table_state, table_schema, &result);
|
|
|
|
// Draw editing overlay
|
|
drawEditingOverlay(ctx, bounds, table_state, table_schema, header_h, state_col_w, colors);
|
|
} else if (config.keyboard_nav) {
|
|
// Handle navigation keyboard
|
|
handleKeyboard(ctx, table_state, table_schema, visible_rows, &result);
|
|
}
|
|
}
|
|
|
|
// Ensure selection is visible
|
|
ensureSelectionVisible(table_state, visible_rows);
|
|
|
|
// Auto-CRUD detection (when row changes)
|
|
if (config.auto_crud_enabled and result.selection_changed and table_state.rowChanged()) {
|
|
result.crud_action = detectCRUDAction(table_state, table_schema);
|
|
|
|
// Capture snapshot of new row
|
|
if (table_state.selected_row >= 0) {
|
|
table_state.captureSnapshot(@intCast(table_state.selected_row)) catch {};
|
|
}
|
|
}
|
|
|
|
// Phase 8: Invoke callbacks
|
|
invokeCallbacks(ctx, table_state, table_schema, &result);
|
|
|
|
return result;
|
|
}
|
|
|
|
// =============================================================================
|
|
// Callback System (Phase 8)
|
|
// =============================================================================
|
|
|
|
fn invokeCallbacks(
|
|
ctx: *Context,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
const config = table_schema.config;
|
|
const current_time = ctx.current_time_ms;
|
|
|
|
// Check debounce
|
|
const time_since_last = current_time -| table_state.last_callback_time_ms;
|
|
const debounce_ok = time_since_last >= config.callback_debounce_ms;
|
|
|
|
// on_row_selected: called when selection changes (with debounce)
|
|
if (result.selection_changed and debounce_ok) {
|
|
if (table_schema.on_row_selected) |callback| {
|
|
if (table_state.selected_row >= 0) {
|
|
const row_idx: usize = @intCast(table_state.selected_row);
|
|
if (table_state.getRowConst(row_idx)) |row| {
|
|
callback(row_idx, row);
|
|
table_state.last_callback_time_ms = current_time;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// on_active_row_changed: called when moving to a different row (for loading detail panels)
|
|
// Only fires once per row change, not on every frame
|
|
if (table_state.selected_row != table_state.last_notified_row) {
|
|
if (table_schema.on_active_row_changed) |callback| {
|
|
if (table_state.selected_row >= 0) {
|
|
const new_row_idx: usize = @intCast(table_state.selected_row);
|
|
if (table_state.getRowConst(new_row_idx)) |row| {
|
|
const old_row: ?usize = if (table_state.last_notified_row >= 0)
|
|
@intCast(table_state.last_notified_row)
|
|
else
|
|
null;
|
|
callback(old_row, new_row_idx, row);
|
|
}
|
|
}
|
|
}
|
|
table_state.last_notified_row = table_state.selected_row;
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Row Click Handling (separado del rendering)
|
|
// =============================================================================
|
|
|
|
/// Maneja clicks en las filas de la tabla (single-click y double-click)
|
|
/// Retorna si hubo algún cambio de selección o edición iniciada
|
|
fn handleRowClicks(
|
|
ctx: *Context,
|
|
bounds: Layout.Rect,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
header_h: u32,
|
|
state_col_w: u32,
|
|
first_visible: usize,
|
|
last_visible: usize,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
const config = table_schema.config;
|
|
const mouse = ctx.input.mousePos();
|
|
|
|
// Solo procesar si hubo click
|
|
if (!ctx.input.mousePressed(.left)) return;
|
|
|
|
// Verificar si el click está en el área de filas
|
|
const rows_area_y = bounds.y + @as(i32, @intCast(header_h));
|
|
if (mouse.y < rows_area_y) return;
|
|
if (mouse.x < bounds.x or mouse.x >= bounds.x + @as(i32, @intCast(bounds.w))) return;
|
|
|
|
// Calcular fila clickeada
|
|
const relative_y = mouse.y - rows_area_y;
|
|
if (relative_y < 0) return;
|
|
const row_offset: usize = @intCast(@divFloor(relative_y, @as(i32, @intCast(config.row_height))));
|
|
const row_idx = first_visible + row_offset;
|
|
|
|
if (row_idx >= last_visible or row_idx >= table_state.getRowCount()) return;
|
|
|
|
// Calcular columna clickeada
|
|
var col_x = bounds.x + @as(i32, @intCast(state_col_w));
|
|
var clicked_col: ?usize = null;
|
|
|
|
for (table_schema.columns, 0..) |col, col_idx| {
|
|
if (!col.visible) continue;
|
|
|
|
const col_end = col_x + @as(i32, @intCast(col.width));
|
|
if (mouse.x >= col_x and mouse.x < col_end) {
|
|
clicked_col = col_idx;
|
|
break;
|
|
}
|
|
col_x = col_end;
|
|
}
|
|
|
|
if (clicked_col == null) return;
|
|
|
|
const col_idx = clicked_col.?;
|
|
const is_selected_cell = table_state.selected_row == @as(i32, @intCast(row_idx)) and
|
|
table_state.selected_col == @as(i32, @intCast(col_idx));
|
|
|
|
// Detectar doble-click
|
|
const current_time = ctx.current_time_ms;
|
|
const same_cell = table_state.nav.double_click.last_click_row == @as(i32, @intCast(row_idx)) and
|
|
table_state.nav.double_click.last_click_col == @as(i32, @intCast(col_idx));
|
|
const time_diff = current_time -| table_state.nav.double_click.last_click_time;
|
|
const is_double_click = same_cell and time_diff < table_state.nav.double_click.threshold_ms;
|
|
|
|
if (is_double_click and config.allow_edit and col_idx < table_schema.columns.len and
|
|
table_schema.columns[col_idx].editable and !table_state.isEditing())
|
|
{
|
|
// Double-click: iniciar edición
|
|
if (table_state.getRow(row_idx)) |row| {
|
|
const value = row.get(table_schema.columns[col_idx].name);
|
|
var format_buf: [128]u8 = undefined;
|
|
const edit_text = value.format(&format_buf);
|
|
table_state.startEditing(edit_text);
|
|
table_state.original_value = value;
|
|
result.edit_started = true;
|
|
}
|
|
// Reset click tracking
|
|
table_state.nav.double_click.last_click_time = 0;
|
|
table_state.nav.double_click.last_click_row = -1;
|
|
table_state.nav.double_click.last_click_col = -1;
|
|
} else {
|
|
// Single click: seleccionar celda
|
|
if (!is_selected_cell) {
|
|
table_state.selectCell(row_idx, col_idx);
|
|
result.selection_changed = true;
|
|
result.selected_row = row_idx;
|
|
result.selected_col = col_idx;
|
|
}
|
|
// Actualizar tracking para posible doble-click
|
|
table_state.nav.double_click.last_click_time = current_time;
|
|
table_state.nav.double_click.last_click_row = @intCast(row_idx);
|
|
table_state.nav.double_click.last_click_col = @intCast(col_idx);
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Internal Rendering
|
|
// =============================================================================
|
|
|
|
fn drawHeader(
|
|
ctx: *Context,
|
|
bounds: Layout.Rect,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
state_col_w: u32,
|
|
colors: *const TableColors,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
const config = table_schema.config;
|
|
const header_y = bounds.y;
|
|
var col_x = bounds.x;
|
|
|
|
// State indicator column header
|
|
if (state_col_w > 0) {
|
|
ctx.pushCommand(Command.rect(col_x, header_y, state_col_w, config.header_height, colors.header_bg));
|
|
col_x += @as(i32, @intCast(state_col_w));
|
|
}
|
|
|
|
// Column headers
|
|
const mouse = ctx.input.mousePos();
|
|
|
|
for (table_schema.columns, 0..) |col, idx| {
|
|
if (!col.visible) continue;
|
|
|
|
const col_rect = Layout.Rect.init(col_x, header_y, col.width, config.header_height);
|
|
const col_hovered = col_rect.contains(mouse.x, mouse.y);
|
|
const col_clicked = col_hovered and ctx.input.mousePressed(.left);
|
|
|
|
// Determine background color
|
|
var bg_color = colors.header_bg;
|
|
if (table_state.sort_column == @as(i32, @intCast(idx))) {
|
|
bg_color = colors.header_sorted;
|
|
} else if (col_hovered) {
|
|
bg_color = colors.header_hover;
|
|
}
|
|
|
|
// Draw header cell
|
|
if (Style.isFancy()) {
|
|
ctx.pushCommand(Command.roundedRect(col_rect.x, col_rect.y, col_rect.w, col_rect.h, bg_color, 0));
|
|
} else {
|
|
ctx.pushCommand(Command.rect(col_rect.x, col_rect.y, col_rect.w, col_rect.h, bg_color));
|
|
}
|
|
|
|
// Draw header text
|
|
const text_y = header_y + @as(i32, @intCast((config.header_height - 8) / 2));
|
|
ctx.pushCommand(Command.text(col_x + 4, text_y, col.title, colors.header_fg));
|
|
|
|
// Draw lookup indicator (Phase 7c) - small "?" icon
|
|
if (col.hasLookup()) {
|
|
const lookup_x = col_x + @as(i32, @intCast(col.width)) - 24;
|
|
ctx.pushCommand(Command.text(lookup_x, text_y, "?", Style.Color.primary));
|
|
}
|
|
|
|
// Draw sort indicator (▴/▾ Unicode glyphs)
|
|
if (table_state.sort_column == @as(i32, @intCast(idx))) {
|
|
const indicator_x = col_x + @as(i32, @intCast(col.width)) - 16;
|
|
const indicator = switch (table_state.sort_direction) {
|
|
.ascending => "▴",
|
|
.descending => "▾",
|
|
.none => "",
|
|
};
|
|
if (indicator.len > 0) {
|
|
ctx.pushCommand(Command.text(indicator_x, text_y, indicator, colors.sort_indicator));
|
|
}
|
|
}
|
|
|
|
// Handle click for sorting
|
|
if (col_clicked and col.sortable and config.allow_sorting) {
|
|
_ = table_state.toggleSort(idx);
|
|
result.sort_changed = true;
|
|
result.sort_column = idx;
|
|
result.sort_direction = table_state.sort_direction;
|
|
|
|
// Actually sort the rows
|
|
sortRows(table_state, table_schema.columns[idx].name, table_state.sort_direction);
|
|
}
|
|
|
|
// Draw separator
|
|
ctx.pushCommand(Command.rect(
|
|
col_x + @as(i32, @intCast(col.width)) - 1,
|
|
header_y,
|
|
1,
|
|
config.header_height,
|
|
colors.border,
|
|
));
|
|
|
|
col_x += @as(i32, @intCast(col.width));
|
|
}
|
|
}
|
|
|
|
fn drawScrollbar(
|
|
ctx: *Context,
|
|
bounds: Layout.Rect,
|
|
table_state: *AdvancedTableState,
|
|
visible_rows: usize,
|
|
config: TableConfig,
|
|
colors: *const TableColors,
|
|
) void {
|
|
const total_rows = table_state.getRowCount();
|
|
if (total_rows == 0) return;
|
|
|
|
const scrollbar_w: u32 = 12;
|
|
const header_h: u32 = if (config.show_headers) config.header_height else 0;
|
|
const scrollbar_h = bounds.h -| header_h;
|
|
|
|
// Usar función unificada de table_core
|
|
table_core.drawVerticalScrollbar(ctx, .{
|
|
.track_x = bounds.x + @as(i32, @intCast(bounds.w -| scrollbar_w)),
|
|
.track_y = bounds.y + @as(i32, @intCast(header_h)),
|
|
.width = scrollbar_w,
|
|
.height = scrollbar_h,
|
|
.visible_count = visible_rows,
|
|
.total_count = total_rows,
|
|
.scroll_pos = table_state.nav.scroll_row,
|
|
.track_color = colors.border,
|
|
.thumb_color = colors.header_bg,
|
|
});
|
|
}
|
|
|
|
fn drawEditingOverlay(
|
|
ctx: *Context,
|
|
bounds: Layout.Rect,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
header_h: u32,
|
|
state_col_w: u32,
|
|
colors: *const TableColors,
|
|
) void {
|
|
if (table_state.selected_row < 0 or table_state.selected_col < 0) return;
|
|
|
|
const row_idx: usize = @intCast(table_state.selected_row);
|
|
const col_idx: usize = @intCast(table_state.selected_col);
|
|
const config = table_schema.config;
|
|
|
|
// Check if row is visible
|
|
if (row_idx < table_state.nav.scroll_row) return;
|
|
const visible_row = row_idx - table_state.nav.scroll_row;
|
|
const visible_rows = (bounds.h -| header_h) / config.row_height;
|
|
if (visible_row >= visible_rows) return;
|
|
|
|
// Calculate cell position
|
|
var col_x = bounds.x + @as(i32, @intCast(state_col_w));
|
|
for (table_schema.columns[0..col_idx]) |col| {
|
|
if (col.visible) {
|
|
col_x += @as(i32, @intCast(col.width));
|
|
}
|
|
}
|
|
|
|
const col_def = table_schema.columns[col_idx];
|
|
const cell_y = bounds.y + @as(i32, @intCast(header_h + visible_row * config.row_height));
|
|
const cell_h = config.row_height;
|
|
|
|
// Draw editing overlay background
|
|
ctx.pushCommand(Command.rect(col_x, cell_y, col_def.width, cell_h, colors.cell_editing_bg));
|
|
|
|
// Draw border
|
|
ctx.pushCommand(Command.rectOutline(col_x, cell_y, col_def.width, cell_h, colors.cell_editing_border));
|
|
|
|
// Draw edit text
|
|
const edit_text = table_state.getEditText();
|
|
const text_y = cell_y + @as(i32, @intCast((cell_h - 8) / 2));
|
|
|
|
// Draw selection highlight if exists (Excel-style)
|
|
const sel_start = table_state.cell_edit.selection_start;
|
|
const sel_end = table_state.cell_edit.selection_end;
|
|
if (sel_start != sel_end and edit_text.len > 0) {
|
|
const sel_min = @min(sel_start, sel_end);
|
|
const sel_max = @min(@max(sel_start, sel_end), edit_text.len);
|
|
if (sel_max > sel_min) {
|
|
const sel_x = col_x + 4 + @as(i32, @intCast(sel_min * 8));
|
|
const sel_width = @as(u32, @intCast((sel_max - sel_min) * 8));
|
|
ctx.pushCommand(Command.rect(sel_x, text_y, sel_width, 8, colors.cell_selection_bg));
|
|
}
|
|
}
|
|
|
|
// Draw text (on top of selection)
|
|
ctx.pushCommand(Command.text(col_x + 4, text_y, edit_text, colors.text_selected));
|
|
|
|
// Draw cursor only if no selection
|
|
if (sel_start == sel_end) {
|
|
const cursor_x = col_x + 4 + @as(i32, @intCast(table_state.cell_edit.edit_cursor * 8));
|
|
ctx.pushCommand(Command.rect(cursor_x, text_y, 1, 8, colors.text_selected));
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Keyboard Handling (Brain-in-Core pattern)
|
|
// =============================================================================
|
|
//
|
|
// Arquitectura: TODA la lógica de decisión está en table_core.processTableEvents()
|
|
// Este handler solo aplica flags y maneja lógica específica de AdvancedTable.
|
|
|
|
fn handleKeyboard(
|
|
ctx: *Context,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
visible_rows: usize,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
const row_count = table_state.getRowCount();
|
|
if (row_count == 0) return;
|
|
|
|
const config = table_schema.config;
|
|
const col_count = table_schema.columns.len;
|
|
|
|
// =========================================================================
|
|
// BRAIN-IN-CORE: Delegar toda la lógica de decisión al Core
|
|
// =========================================================================
|
|
const events = table_core.processTableEvents(ctx, table_state.isEditing());
|
|
|
|
// =========================================================================
|
|
// Aplicar navegación desde el Core
|
|
// =========================================================================
|
|
if (events.move_up and table_state.selected_row > 0) {
|
|
const new_row: usize = @intCast(table_state.selected_row - 1);
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.move_down and table_state.selected_row < @as(i32, @intCast(row_count)) - 1) {
|
|
const new_row: usize = @intCast(table_state.selected_row + 1);
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.move_left and table_state.selected_col > 0) {
|
|
const new_row: usize = @intCast(@max(0, table_state.selected_row));
|
|
const new_col: usize = @intCast(table_state.selected_col - 1);
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.move_right and table_state.selected_col < @as(i32, @intCast(col_count)) - 1) {
|
|
const new_row: usize = @intCast(@max(0, table_state.selected_row));
|
|
const new_col: usize = @intCast(table_state.selected_col + 1);
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.page_up) {
|
|
const new_row: usize = @intCast(@max(0, table_state.selected_row - @as(i32, @intCast(visible_rows))));
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.page_down) {
|
|
const new_row: usize = @intCast(@min(
|
|
@as(i32, @intCast(row_count)) - 1,
|
|
table_state.selected_row + @as(i32, @intCast(visible_rows)),
|
|
));
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.go_to_first_col) {
|
|
const new_row: usize = if (events.go_to_first_row) 0 else @intCast(@max(0, table_state.selected_row));
|
|
table_state.selectCell(new_row, 0);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = 0;
|
|
} else if (events.go_to_first_row) {
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(0, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = 0;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
if (events.go_to_last_col) {
|
|
const new_row: usize = if (events.go_to_last_row)
|
|
(if (row_count > 0) row_count - 1 else 0)
|
|
else
|
|
@intCast(@max(0, table_state.selected_row));
|
|
const new_col: usize = col_count - 1;
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
} else if (events.go_to_last_row) {
|
|
const new_row: usize = if (row_count > 0) row_count - 1 else 0;
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
table_state.selectCell(new_row, new_col);
|
|
result.selection_changed = true;
|
|
result.selected_row = new_row;
|
|
result.selected_col = new_col;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Tab navigation con commit Excel-style (DRY: lógica en table_core)
|
|
// =========================================================================
|
|
if (events.tab_out and config.handle_tab) {
|
|
// Wrapper para obtener row_id por índice (en AdvancedTable, usamos índice como ID)
|
|
const RowIdGetter = struct {
|
|
total: usize,
|
|
|
|
pub fn getRowId(self: @This(), row: usize) i64 {
|
|
// Ghost row está al final
|
|
if (row >= self.total) return table_core.NEW_ROW_ID;
|
|
return @intCast(row);
|
|
}
|
|
};
|
|
|
|
const getter = RowIdGetter{ .total = row_count };
|
|
const current_row: usize = @intCast(@max(0, table_state.selected_row));
|
|
const current_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
const forward = !events.tab_shift;
|
|
// AdvancedTable: usar count de filas existentes (no tiene ghost row como VirtualAdvancedTable)
|
|
const num_rows = row_count;
|
|
|
|
const plan = table_core.planTabNavigation(
|
|
&table_state.row_edit_buffer,
|
|
current_row,
|
|
current_col,
|
|
col_count,
|
|
num_rows,
|
|
forward,
|
|
config.wrap_navigation,
|
|
getter,
|
|
&result.row_changes,
|
|
);
|
|
|
|
// Ejecutar el plan
|
|
switch (plan.action) {
|
|
.move, .move_with_commit => {
|
|
table_state.selectCell(plan.new_row, plan.new_col);
|
|
result.selection_changed = true;
|
|
|
|
if (plan.action == .move_with_commit) {
|
|
if (plan.commit_info) |info| {
|
|
result.row_committed = true;
|
|
result.row_commit_id = info.row_id;
|
|
result.row_commit_is_insert = info.is_insert;
|
|
result.row_changes_count = info.change_count;
|
|
}
|
|
}
|
|
},
|
|
.exit, .exit_with_commit => {
|
|
result.tab_out = true;
|
|
result.tab_shift = events.tab_shift;
|
|
|
|
if (plan.action == .exit_with_commit) {
|
|
if (plan.commit_info) |info| {
|
|
result.row_committed = true;
|
|
result.row_commit_id = info.row_id;
|
|
result.row_commit_is_insert = info.is_insert;
|
|
result.row_changes_count = info.change_count;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Inicio de edición (F2, Space, o tecla alfanumérica desde el Core)
|
|
// =========================================================================
|
|
if (events.start_editing and config.allow_edit) {
|
|
if (table_state.selected_row >= 0 and table_state.selected_col >= 0) {
|
|
const col_idx: usize = @intCast(table_state.selected_col);
|
|
if (col_idx < table_schema.columns.len and table_schema.columns[col_idx].editable) {
|
|
if (table_state.getRow(@intCast(table_state.selected_row))) |row| {
|
|
const value = row.get(table_schema.columns[col_idx].name);
|
|
if (events.initial_char) |ch| {
|
|
// Tecla alfanumérica: empezar con ese caracter
|
|
var char_buf: [1]u8 = .{ch};
|
|
table_state.startEditing(&char_buf);
|
|
} else {
|
|
// F2/Space: empezar con valor actual
|
|
var format_buf: [128]u8 = undefined;
|
|
const text = value.format(&format_buf);
|
|
table_state.startEditing(text);
|
|
}
|
|
table_state.original_value = value;
|
|
result.edit_started = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Operaciones CRUD (Ctrl+N, Ctrl+Delete, Ctrl+B desde el Core)
|
|
// =========================================================================
|
|
if (config.allow_row_operations) {
|
|
// Ctrl+N: Insert row BELOW current row (inyección local)
|
|
if (events.insert_row) {
|
|
const insert_idx: usize = if (table_state.selected_row >= 0)
|
|
@as(usize, @intCast(table_state.selected_row)) + 1 // +1 = debajo
|
|
else
|
|
0;
|
|
if (table_state.insertRow(insert_idx)) |new_idx| {
|
|
table_state.selectCell(new_idx, 0);
|
|
// Inicializar buffer para fila inyectada (Excel-style)
|
|
table_state.row_edit_buffer.startInjectedEdit(new_idx);
|
|
result.row_inserted = true;
|
|
result.selection_changed = true;
|
|
} else |_| {}
|
|
}
|
|
|
|
// Ctrl+Delete o Ctrl+B: Delete row
|
|
if (events.delete_row) {
|
|
if (table_state.selected_row >= 0) {
|
|
const delete_idx: usize = @intCast(table_state.selected_row);
|
|
table_state.deleteRow(delete_idx);
|
|
result.row_deleted = true;
|
|
|
|
// Adjust selection
|
|
const remaining_rows = table_state.getRowCount();
|
|
if (remaining_rows == 0) {
|
|
table_state.selected_row = -1;
|
|
} else if (delete_idx >= remaining_rows) {
|
|
table_state.selected_row = @intCast(remaining_rows - 1);
|
|
}
|
|
result.selection_changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Ctrl+A: Select all (lógica específica de AdvancedTable)
|
|
// =========================================================================
|
|
if (config.allow_multi_select and ctx.input.keyPressed(.a) and ctx.input.modifiers.ctrl) {
|
|
table_state.selectAllRows();
|
|
result.selection_changed = true;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Búsqueda incremental (solo si NO se inició edición)
|
|
// Solo para celdas no editables - lógica específica de AdvancedTable
|
|
// =========================================================================
|
|
if (!events.start_editing and !ctx.input.modifiers.ctrl and !ctx.input.modifiers.alt) {
|
|
if (ctx.input.text_input_len > 0) {
|
|
const text = ctx.input.text_input[0..ctx.input.text_input_len];
|
|
|
|
// Solo búsqueda si la celda actual NO es editable
|
|
const current_cell_editable = blk: {
|
|
if (!config.allow_edit) break :blk false;
|
|
if (table_state.selected_row < 0 or table_state.selected_col < 0) break :blk false;
|
|
const col_idx: usize = @intCast(table_state.selected_col);
|
|
if (col_idx >= table_schema.columns.len) break :blk false;
|
|
break :blk table_schema.columns[col_idx].editable;
|
|
};
|
|
|
|
if (!current_cell_editable) {
|
|
// Incremental search (type-to-search) in first column
|
|
for (text) |char| {
|
|
if (char >= 32 and char < 127) {
|
|
const search_term = table_state.addSearchChar(char, ctx.current_time_ms);
|
|
|
|
if (search_term.len > 0 and table_schema.columns.len > 0) {
|
|
const first_col_name = table_schema.columns[0].name;
|
|
const start_row: usize = if (table_state.selected_row >= 0)
|
|
@intCast(table_state.selected_row)
|
|
else
|
|
0;
|
|
|
|
var found_row: ?usize = null;
|
|
|
|
// Search from current position to end
|
|
for (start_row..row_count) |row| {
|
|
if (table_state.getRowConst(row)) |row_data| {
|
|
const cell_value = row_data.get(first_col_name);
|
|
var format_buf: [128]u8 = undefined;
|
|
const cell_text = cell_value.format(&format_buf);
|
|
if (startsWithIgnoreCase(cell_text, search_term)) {
|
|
found_row = row;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Wrap to beginning if not found
|
|
if (found_row == null and start_row > 0) {
|
|
for (0..start_row) |row| {
|
|
if (table_state.getRowConst(row)) |row_data| {
|
|
const cell_value = row_data.get(first_col_name);
|
|
var format_buf: [128]u8 = undefined;
|
|
const cell_text = cell_value.format(&format_buf);
|
|
if (startsWithIgnoreCase(cell_text, search_term)) {
|
|
found_row = row;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move selection if found
|
|
if (found_row) |row_idx| {
|
|
table_state.selectCell(row_idx, @intCast(@max(0, table_state.selected_col)));
|
|
result.selection_changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handleEditingKeyboard(
|
|
ctx: *Context,
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
const config = table_schema.config;
|
|
|
|
// Obtener texto original para revert
|
|
var orig_format_buf: [128]u8 = undefined;
|
|
const original_text: ?[]const u8 = if (table_state.original_value) |orig|
|
|
orig.format(&orig_format_buf)
|
|
else
|
|
null;
|
|
|
|
// Usar table_core para procesamiento de teclado (DRY) con soporte selección
|
|
const kb_result = table_core.handleEditingKeyboard(
|
|
ctx,
|
|
&table_state.cell_edit.edit_buffer,
|
|
&table_state.cell_edit.edit_len,
|
|
&table_state.cell_edit.edit_cursor,
|
|
&table_state.cell_edit.escape_count,
|
|
original_text,
|
|
&table_state.cell_edit.selection_start,
|
|
&table_state.cell_edit.selection_end,
|
|
);
|
|
|
|
// Si no se procesó ningún evento, salir
|
|
if (!kb_result.handled) return;
|
|
|
|
// Escape canceló la edición
|
|
if (kb_result.cancelled) {
|
|
table_state.stopEditing();
|
|
result.edit_ended = true;
|
|
return;
|
|
}
|
|
|
|
// Commit (Enter, Tab, flechas) y navegación
|
|
if (kb_result.committed) {
|
|
commitEdit(table_state, table_schema, result);
|
|
table_state.stopEditing();
|
|
result.edit_ended = true;
|
|
|
|
// Procesar navegación después de commit
|
|
switch (kb_result.navigate) {
|
|
.next_cell, .prev_cell => {
|
|
if (!config.handle_tab) return;
|
|
|
|
const col_count = table_schema.columns.len;
|
|
const row_count = table_state.getRowCount();
|
|
|
|
if (kb_result.navigate == .prev_cell) {
|
|
// Shift+Tab: move left
|
|
if (table_state.selected_col > 0) {
|
|
table_state.selectCell(
|
|
@intCast(@max(0, table_state.selected_row)),
|
|
@intCast(table_state.selected_col - 1),
|
|
);
|
|
} else if (table_state.selected_row > 0 and config.wrap_navigation) {
|
|
table_state.selectCell(
|
|
@intCast(table_state.selected_row - 1),
|
|
col_count - 1,
|
|
);
|
|
}
|
|
} else {
|
|
// Tab: move right
|
|
if (table_state.selected_col < @as(i32, @intCast(col_count)) - 1) {
|
|
table_state.selectCell(
|
|
@intCast(@max(0, table_state.selected_row)),
|
|
@intCast(table_state.selected_col + 1),
|
|
);
|
|
} else if (table_state.selected_row < @as(i32, @intCast(row_count)) - 1 and config.wrap_navigation) {
|
|
table_state.selectCell(
|
|
@intCast(table_state.selected_row + 1),
|
|
0,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Auto-start editing in new cell if editable
|
|
const new_col: usize = @intCast(@max(0, table_state.selected_col));
|
|
if (new_col < table_schema.columns.len and table_schema.columns[new_col].editable) {
|
|
if (table_state.getRow(@intCast(@max(0, table_state.selected_row)))) |row| {
|
|
const value = row.get(table_schema.columns[new_col].name);
|
|
var format_buf: [128]u8 = undefined;
|
|
const text = value.format(&format_buf);
|
|
table_state.startEditing(text);
|
|
result.edit_started = true;
|
|
}
|
|
}
|
|
|
|
result.selection_changed = true;
|
|
},
|
|
.next_row, .prev_row => {
|
|
// Enter o flechas arriba/abajo: solo commit, sin navegación adicional aquí
|
|
// (La navegación entre filas se maneja en otro lugar si es necesario)
|
|
},
|
|
.none => {},
|
|
}
|
|
}
|
|
}
|
|
|
|
fn commitEdit(
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
if (table_state.selected_row < 0 or table_state.selected_col < 0) return;
|
|
|
|
const row_idx: usize = @intCast(table_state.selected_row);
|
|
const col_idx: usize = @intCast(table_state.selected_col);
|
|
|
|
if (col_idx >= table_schema.columns.len) return;
|
|
|
|
const col_def = &table_schema.columns[col_idx];
|
|
const edit_text = table_state.getEditText();
|
|
|
|
// Parse text to CellValue based on column type
|
|
const new_value = parseValue(edit_text, col_def.column_type);
|
|
|
|
// Check if value changed
|
|
if (table_state.original_value) |orig| {
|
|
if (new_value.eql(orig)) {
|
|
return; // No change
|
|
}
|
|
}
|
|
|
|
// Update the row
|
|
if (table_state.getRow(row_idx)) |row| {
|
|
row.set(col_def.name, new_value) catch {};
|
|
table_state.markDirty(row_idx);
|
|
result.cell_edited = true;
|
|
|
|
// Lookup & Auto-fill (Phase 7)
|
|
if (col_def.hasLookup()) {
|
|
performLookupAndAutoFill(table_state, table_schema, row, col_def, new_value, result);
|
|
}
|
|
|
|
// Call on_cell_changed callback (Phase 8)
|
|
if (table_schema.on_cell_changed) |callback| {
|
|
const old_value = table_state.original_value orelse CellValue{ .null_val = {} };
|
|
callback(row_idx, col_idx, old_value, new_value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Perform lookup in related table and auto-fill columns
|
|
fn performLookupAndAutoFill(
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
row: *Row,
|
|
col_def: *const ColumnDef,
|
|
lookup_value: CellValue,
|
|
result: *AdvancedTableResult,
|
|
) void {
|
|
// Need DataStore to perform lookup
|
|
const data_store = table_schema.data_store orelse return;
|
|
|
|
// Get lookup configuration
|
|
const lookup_table = col_def.lookup_table orelse return;
|
|
const lookup_key = col_def.lookup_key_column orelse return;
|
|
|
|
// Perform lookup
|
|
const lookup_result = data_store.lookup(
|
|
lookup_table,
|
|
lookup_key,
|
|
lookup_value,
|
|
table_state.allocator,
|
|
) catch return;
|
|
|
|
// If lookup found a match, auto-fill related columns
|
|
if (lookup_result) |lookup_row| {
|
|
defer {
|
|
// Clean up the lookup row after use
|
|
var mutable_lookup = lookup_row;
|
|
mutable_lookup.deinit();
|
|
}
|
|
|
|
// Auto-fill columns based on mapping
|
|
if (col_def.auto_fill_columns) |mappings| {
|
|
for (mappings) |mapping| {
|
|
const source_value = lookup_row.get(mapping.source_field);
|
|
if (!source_value.isEmpty()) {
|
|
row.set(mapping.target_column, source_value) catch {};
|
|
}
|
|
}
|
|
}
|
|
|
|
result.lookup_success = true;
|
|
} else {
|
|
result.lookup_success = false;
|
|
}
|
|
}
|
|
|
|
fn parseValue(text: []const u8, column_type: ColumnType) CellValue {
|
|
return switch (column_type) {
|
|
.string => CellValue{ .string = text },
|
|
.integer => blk: {
|
|
const val = std.fmt.parseInt(i64, text, 10) catch 0;
|
|
break :blk CellValue{ .integer = val };
|
|
},
|
|
.float, .money => blk: {
|
|
const val = std.fmt.parseFloat(f64, text) catch 0.0;
|
|
break :blk CellValue{ .float = val };
|
|
},
|
|
.boolean => blk: {
|
|
const lower = text;
|
|
const is_true = std.mem.eql(u8, lower, "true") or
|
|
std.mem.eql(u8, lower, "yes") or
|
|
std.mem.eql(u8, lower, "1") or
|
|
std.mem.eql(u8, lower, "Y");
|
|
break :blk CellValue{ .boolean = is_true };
|
|
},
|
|
.date, .select, .lookup => CellValue{ .string = text },
|
|
};
|
|
}
|
|
|
|
fn detectCRUDAction(
|
|
table_state: *AdvancedTableState,
|
|
table_schema: *const TableSchema,
|
|
) ?CRUDAction {
|
|
// Check if previous row was valid
|
|
if (table_state.prev_selected_row < 0) return null;
|
|
|
|
const prev_row_idx: usize = @intCast(table_state.prev_selected_row);
|
|
|
|
// Check if row was marked for deletion
|
|
if (table_state.isDeleted(prev_row_idx)) {
|
|
return .delete;
|
|
}
|
|
|
|
// Get the row (might have been deleted)
|
|
const row = table_state.getRow(prev_row_idx) orelse return null;
|
|
|
|
// Get snapshot for comparison
|
|
const snapshot = table_state.getSnapshot(prev_row_idx);
|
|
|
|
// Check if row is new (was in new_rows map)
|
|
const is_new = table_state.isNew(prev_row_idx);
|
|
|
|
if (is_new) {
|
|
// Check if new row has any data
|
|
if (rowHasData(row, table_schema)) {
|
|
return .create;
|
|
}
|
|
return null; // Empty new row, no action
|
|
}
|
|
|
|
// Check if row was modified
|
|
if (snapshot) |snap| {
|
|
if (rowsAreDifferent(row, snap, table_schema)) {
|
|
return .update;
|
|
}
|
|
} else if (table_state.isDirty(prev_row_idx)) {
|
|
// No snapshot but marked dirty - assume update
|
|
return .update;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
fn rowHasData(row: *const Row, table_schema: *const TableSchema) bool {
|
|
for (table_schema.columns) |col| {
|
|
if (!col.visible) continue;
|
|
const value = row.get(col.name);
|
|
if (!value.isEmpty()) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn rowsAreDifferent(row: *const Row, snapshot: *const Row, table_schema: *const TableSchema) bool {
|
|
for (table_schema.columns) |col| {
|
|
if (!col.editable) continue;
|
|
const current = row.get(col.name);
|
|
const original = snapshot.get(col.name);
|
|
if (!current.eql(original)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn ensureSelectionVisible(table_state: *AdvancedTableState, visible_rows: usize) void {
|
|
if (table_state.selected_row < 0) return;
|
|
|
|
const row: usize = @intCast(table_state.selected_row);
|
|
|
|
// Scroll to show selected row
|
|
if (row < table_state.nav.scroll_row) {
|
|
table_state.nav.scroll_row = row;
|
|
} else if (row >= table_state.nav.scroll_row + visible_rows) {
|
|
table_state.nav.scroll_row = row - visible_rows + 1;
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Color Helpers
|
|
// =============================================================================
|
|
|
|
fn blendColor(base: Style.Color, overlay: Style.Color, alpha: f32) Style.Color {
|
|
const inv_alpha = 1.0 - alpha;
|
|
|
|
return Style.Color.rgba(
|
|
@intFromFloat(@as(f32, @floatFromInt(base.r)) * inv_alpha + @as(f32, @floatFromInt(overlay.r)) * alpha),
|
|
@intFromFloat(@as(f32, @floatFromInt(base.g)) * inv_alpha + @as(f32, @floatFromInt(overlay.g)) * alpha),
|
|
@intFromFloat(@as(f32, @floatFromInt(base.b)) * inv_alpha + @as(f32, @floatFromInt(overlay.b)) * alpha),
|
|
base.a,
|
|
);
|
|
}
|
|
|
|
// =============================================================================
|
|
// Sorting
|
|
// =============================================================================
|
|
|
|
/// Sort rows by column value
|
|
fn sortRows(
|
|
table_state: *AdvancedTableState,
|
|
column_name: []const u8,
|
|
direction: SortDirection,
|
|
) void {
|
|
if (direction == .none) return;
|
|
if (table_state.rows.items.len < 2) return;
|
|
|
|
// Simple bubble sort (stable, works for small-medium datasets)
|
|
// For large datasets, consider using std.mem.sort with a context
|
|
const len = table_state.rows.items.len;
|
|
var swapped = true;
|
|
|
|
while (swapped) {
|
|
swapped = false;
|
|
for (0..len - 1) |i| {
|
|
const val_a = table_state.rows.items[i].get(column_name);
|
|
const val_b = table_state.rows.items[i + 1].get(column_name);
|
|
const cmp = val_a.compare(val_b);
|
|
|
|
const should_swap = switch (direction) {
|
|
.ascending => cmp > 0,
|
|
.descending => cmp < 0,
|
|
.none => false,
|
|
};
|
|
|
|
if (should_swap) {
|
|
// Swap rows usando std.mem.swap (seguro para structs con punteros internos)
|
|
// NOTA: Row contiene StringHashMap que tiene punteros a buckets.
|
|
// El swap mueve el struct completo, no clona los datos.
|
|
// Los punteros obtenidos via getRow() se invalidan tras sort.
|
|
std.mem.swap(Row, &table_state.rows.items[i], &table_state.rows.items[i + 1]);
|
|
|
|
// Swap state map entries
|
|
swapRowStates(table_state, i, i + 1);
|
|
|
|
swapped = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Swap state map entries between two row indices
|
|
fn swapRowStates(table_state: *AdvancedTableState, idx_a: usize, idx_b: usize) void {
|
|
// Helper to swap a single map's entries
|
|
const swapInMap = struct {
|
|
fn swap(map: anytype, a: usize, b: usize) void {
|
|
const val_a = map.get(a);
|
|
const val_b = map.get(b);
|
|
|
|
if (val_a != null and val_b != null) {
|
|
// Both exist - no change needed (both stay)
|
|
} else if (val_a) |v| {
|
|
// Only a exists - move to b
|
|
_ = map.remove(a);
|
|
map.put(b, v) catch {};
|
|
} else if (val_b) |v| {
|
|
// Only b exists - move to a
|
|
_ = map.remove(b);
|
|
map.put(a, v) catch {};
|
|
}
|
|
// Neither exists - nothing to do
|
|
}
|
|
}.swap;
|
|
|
|
swapInMap(&table_state.dirty_rows, idx_a, idx_b);
|
|
swapInMap(&table_state.new_rows, idx_a, idx_b);
|
|
swapInMap(&table_state.deleted_rows, idx_a, idx_b);
|
|
swapInMap(&table_state.validation_errors, idx_a, idx_b);
|
|
}
|
|
|
|
// =============================================================================
|
|
// Search Helpers
|
|
// =============================================================================
|
|
|
|
/// Case-insensitive prefix match for incremental search
|
|
fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
|
|
if (needle.len > haystack.len) return false;
|
|
if (needle.len == 0) return true;
|
|
|
|
for (needle, 0..) |needle_char, i| {
|
|
const haystack_char = haystack[i];
|
|
// Simple ASCII case-insensitive comparison
|
|
const needle_lower = if (needle_char >= 'A' and needle_char <= 'Z')
|
|
needle_char + 32
|
|
else
|
|
needle_char;
|
|
const haystack_lower = if (haystack_char >= 'A' and haystack_char <= 'Z')
|
|
haystack_char + 32
|
|
else
|
|
haystack_char;
|
|
|
|
if (needle_lower != haystack_lower) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// =============================================================================
|
|
// Tests
|
|
// =============================================================================
|
|
|
|
test "AdvancedTable basic rendering" {
|
|
var ctx = try Context.init(std.testing.allocator, 800, 600);
|
|
defer ctx.deinit();
|
|
|
|
var table_state = AdvancedTableState.init(std.testing.allocator);
|
|
defer table_state.deinit();
|
|
|
|
const columns = [_]ColumnDef{
|
|
.{ .name = "id", .title = "ID", .width = 50, .editable = false },
|
|
.{ .name = "name", .title = "Name", .width = 150 },
|
|
.{ .name = "value", .title = "Value", .width = 100 },
|
|
};
|
|
|
|
const table_schema = TableSchema{
|
|
.table_name = "test",
|
|
.columns = &columns,
|
|
};
|
|
|
|
ctx.beginFrame();
|
|
ctx.layout.row_height = 200;
|
|
|
|
_ = advancedTable(&ctx, &table_state, &table_schema);
|
|
|
|
// Should generate commands
|
|
try std.testing.expect(ctx.commands.items.len > 0);
|
|
|
|
ctx.endFrame();
|
|
}
|
|
|
|
test "blendColor" {
|
|
const white = Style.Color.rgb(255, 255, 255);
|
|
const black = Style.Color.rgb(0, 0, 0);
|
|
|
|
const gray = blendColor(white, black, 0.5);
|
|
try std.testing.expectEqual(@as(u8, 127), gray.r);
|
|
try std.testing.expectEqual(@as(u8, 127), gray.g);
|
|
try std.testing.expectEqual(@as(u8, 127), gray.b);
|
|
}
|
|
|
|
test "AdvancedTableResult lookup_success field" {
|
|
var result = AdvancedTableResult{};
|
|
|
|
// Default is null (no lookup attempted)
|
|
try std.testing.expect(result.lookup_success == null);
|
|
|
|
// Can be set to true (lookup found)
|
|
result.lookup_success = true;
|
|
try std.testing.expect(result.lookup_success.? == true);
|
|
|
|
// Can be set to false (lookup not found)
|
|
result.lookup_success = false;
|
|
try std.testing.expect(result.lookup_success.? == false);
|
|
}
|
|
|
|
test "AdvancedTableState callback fields" {
|
|
var table_state = AdvancedTableState.init(std.testing.allocator);
|
|
defer table_state.deinit();
|
|
|
|
// Initial state
|
|
try std.testing.expectEqual(@as(u64, 0), table_state.last_callback_time_ms);
|
|
try std.testing.expectEqual(@as(i32, -1), table_state.last_notified_row);
|
|
|
|
// Can be updated
|
|
table_state.last_callback_time_ms = 1000;
|
|
table_state.last_notified_row = 5;
|
|
|
|
try std.testing.expectEqual(@as(u64, 1000), table_state.last_callback_time_ms);
|
|
try std.testing.expectEqual(@as(i32, 5), table_state.last_notified_row);
|
|
}
|
|
|
|
test "ColumnDef hasLookup" {
|
|
// Column without lookup
|
|
const col_no_lookup = ColumnDef{
|
|
.name = "test",
|
|
.title = "Test",
|
|
};
|
|
try std.testing.expect(!col_no_lookup.hasLookup());
|
|
|
|
// Column with lookup enabled but no config
|
|
const col_partial = ColumnDef{
|
|
.name = "test",
|
|
.title = "Test",
|
|
.enable_lookup = true,
|
|
};
|
|
try std.testing.expect(!col_partial.hasLookup()); // Missing table/key
|
|
|
|
// Column with full lookup config
|
|
const col_full = ColumnDef{
|
|
.name = "test",
|
|
.title = "Test",
|
|
.enable_lookup = true,
|
|
.lookup_table = "other_table",
|
|
.lookup_key_column = "id",
|
|
};
|
|
try std.testing.expect(col_full.hasLookup());
|
|
}
|
|
|
|
test "startsWithIgnoreCase" {
|
|
// Basic match
|
|
try std.testing.expect(startsWithIgnoreCase("Hello World", "Hello"));
|
|
try std.testing.expect(startsWithIgnoreCase("Hello World", "hello"));
|
|
try std.testing.expect(startsWithIgnoreCase("hello world", "HELLO"));
|
|
|
|
// Empty needle matches everything
|
|
try std.testing.expect(startsWithIgnoreCase("anything", ""));
|
|
|
|
// Non-match
|
|
try std.testing.expect(!startsWithIgnoreCase("Hello", "World"));
|
|
try std.testing.expect(!startsWithIgnoreCase("Hi", "Hello"));
|
|
|
|
// Needle longer than haystack
|
|
try std.testing.expect(!startsWithIgnoreCase("Hi", "Hello World"));
|
|
}
|