yves-biener/tui-website
1
0
Fork 0
Code Issues Pull Requests Actions Releases 5 Activity

feat(layout): fix compile errors for newly introduced layouts

Browse Source
This commit is contained in:
Yves Biener
2024-11-09 14:29:55 +01:00
parent 225368280a
commit b5c5f4e3e2
5 changed files with 186 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/layout/Framing.zig
View File

@@ -12,7 +12,7 @@ pub fn Layout(comptime Event: type) type {
if (!isTaggedUnion(Event)) { if (!isTaggedUnion(Event)) {
@compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`."); @compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`.");
} }
const Element = union { const Element = union(enum) {
layout: @import("../layout.zig").Layout(Event), layout: @import("../layout.zig").Layout(Event),
widget: @import("../widget.zig").Widget(Event), widget: @import("../widget.zig").Widget(Event),
}; };
@@ -34,11 +34,18 @@ pub fn Layout(comptime Event: type) type {
pub fn deinit(this: *@This()) void { pub fn deinit(this: *@This()) void {
this.contents.deinit(); this.contents.deinit();
this.element.deinit();
this.events.deinit(); this.events.deinit();
switch ((&this.element).*) {
.layout => |*layout| {
layout.deinit();
},
.widget => |*widget| {
widget.deinit();
},
}
} }
pub fn handle(this: *@This(), event: Event) !*Event { pub fn handle(this: *@This(), event: Event) !*Events {
this.events.clearRetainingCapacity(); this.events.clearRetainingCapacity();
// order is important // order is important
switch (event) { switch (event) {
@@ -46,47 +53,48 @@ pub fn Layout(comptime Event: type) type {
this.size = size; this.size = size;
// adjust size according to the containing elements // adjust size according to the containing elements
const sub_event = event; const sub_event = event;
switch (this.element) { switch ((&this.element).*) {
.layout => |layout| { .layout => |*layout| {
this.events.appendSlice(layout.handle(sub_event).items); const events = try layout.handle(sub_event);
try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(sub_event)) |e| { if (widget.handle(sub_event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
}, },
else => { else => {
for (this.elements.items) |element| { switch ((&this.element).*) {
switch (element) { .layout => |*layout| {
.layout => |layout| { const events = try layout.handle(event);
this.events.appendSlice(layout.handle(event).items); try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(event)) |e| { if (widget.handle(event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
}
}, },
} }
return &this.events;
} }
pub fn content(this: *@This()) !*Contents { pub fn content(this: *@This()) !*Contents {
this.contents.clearRetainingCapacity(); this.contents.clearRetainingCapacity();
// TODO: frame contents // TODO: padding contents accordingly
switch (this.element) { switch ((&this.element).*) {
.layout => |layout| { .layout => |*layout| {
const layout_content = try layout.content(); const layout_content = try layout.content();
try this.contents.appendSlice(layout_content.items); try this.contents.appendSlice(layout_content.items);
}, },
.widget => |widget| { .widget => |*widget| {
try this.contents.appendSlice(try widget.content()); try this.contents.appendSlice(try widget.content());
}, },
} }
return &this.c; return &this.contents;
} }
}; };
} }

86
src/layout/HStack.zig
View File

@@ -12,9 +12,11 @@ pub fn Layout(comptime Event: type) type {
if (!isTaggedUnion(Event)) { if (!isTaggedUnion(Event)) {
@compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`."); @compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`.");
} }
const Element = union { const Widget = @import("../widget.zig").Widget(Event);
layout: @import("../layout.zig").Layout(Event), const Lay = @import("../layout.zig").Layout(Event);
widget: @import("../widget.zig").Widget(Event), const Element = union(enum) {
layout: Lay,
widget: Widget,
}; };
const Elements = std.ArrayList(Element); const Elements = std.ArrayList(Element);
const Events = std.ArrayList(Event); const Events = std.ArrayList(Event);
@@ -26,11 +28,30 @@ pub fn Layout(comptime Event: type) type {
elements: Elements = undefined, elements: Elements = undefined,
events: Events = undefined, events: Events = undefined,
// TODO: optional verdic argument for `Element`? pub fn init(allocator: std.mem.Allocator, children: anytype) @This() {
pub fn init(allocator: std.mem.Allocator) @This() { const ArgsType = @TypeOf(children);
const args_type_info = @typeInfo(ArgsType);
if (args_type_info != .Struct) {
@compileError("expected tuple or struct argument, found " ++ @typeName(ArgsType));
}
const fields_info = args_type_info.Struct.fields;
var elements = Elements.initCapacity(allocator, fields_info.len) catch @panic("OOM");
inline for (comptime fields_info) |field| {
const child = @field(children, field.name);
const ChildType = @TypeOf(child);
if (ChildType == Widget) {
elements.append(.{ .widget = child }) catch {};
continue;
}
if (ChildType == Lay) {
elements.append(.{ .layout = child }) catch {};
continue;
}
@compileError("child: " ++ field.name ++ " is not of type " ++ @typeName(Lay) ++ " or " ++ @typeName(Widget) ++ " but " ++ @typeName(ChildType));
}
return .{ return .{
.contents = Contents.init(allocator), .contents = Contents.init(allocator),
.elements = Elements.init(allocator), .elements = elements,
.events = Events.init(allocator), .events = Events.init(allocator),
}; };
} }
@@ -38,72 +59,75 @@ pub fn Layout(comptime Event: type) type {
pub fn deinit(this: *@This()) void { pub fn deinit(this: *@This()) void {
this.events.deinit(); this.events.deinit();
this.contents.deinit(); this.contents.deinit();
if (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |l| { .layout => |*layout| {
l.deinit(); layout.deinit();
}, },
.widget => |w| { .widget => |*widget| {
w.deinit(); widget.deinit();
}, },
} }
} }
this.elements.deinit(); this.elements.deinit();
} }
pub fn handle(this: *@This(), event: Event) !*Event { pub fn handle(this: *@This(), event: Event) !*Events {
this.events.clearRetainingCapacity(); this.events.clearRetainingCapacity();
// order is important // order is important
switch (event) { switch (event) {
.resize => |size| { .resize => |size| {
this.size = size; this.size = size;
// adjust size according to the containing elements // adjust size according to the containing elements
for (this.elements.items) |element| { for (this.elements.items) |*element| {
const sub_event = event; const sub_event = event;
switch (element) { switch (element.*) {
.layout => |l| { .layout => |*layout| {
this.events.appendSlice(l.handle(sub_event).items); const events = try layout.handle(sub_event);
try this.events.appendSlice(events.items);
}, },
.widget => |w| { .widget => |*widget| {
if (w.handle(sub_event)) |e| { if (widget.handle(sub_event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
} }
}, },
else => { else => {
for (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |layout| { .layout => |*layout| {
this.events.appendSlice(layout.handle(event).items); const events = try layout.handle(event);
try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(event)) |e| { if (widget.handle(event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
} }
}, },
} }
return &this.events;
} }
pub fn content(this: *@This()) !*Contents { pub fn content(this: *@This()) !*Contents {
this.contents.clearRetainingCapacity(); this.contents.clearRetainingCapacity();
// TODO: concat contents accordingly to create a vertical stack // TODO: concat contents accordingly to create a vertical stack
for (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |layout| { .layout => |*layout| {
const layout_content = try layout.content(); const layout_content = try layout.content();
try this.contents.appendSlice(layout_content.items); try this.contents.appendSlice(layout_content.items);
}, },
.widget => |widget| { .widget => |*widget| {
try this.contents.appendSlice(try widget.content()); try this.contents.appendSlice(try widget.content());
}, },
} }
} }
return &this.c; return &this.contents;
} }
}; };
} }

46
src/layout/Padding.zig
View File

@@ -12,7 +12,7 @@ pub fn Layout(comptime Event: type) type {
if (!isTaggedUnion(Event)) { if (!isTaggedUnion(Event)) {
@compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`."); @compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`.");
} }
const Element = union { const Element = union(enum) {
layout: @import("../layout.zig").Layout(Event), layout: @import("../layout.zig").Layout(Event),
widget: @import("../widget.zig").Widget(Event), widget: @import("../widget.zig").Widget(Event),
}; };
@@ -34,11 +34,18 @@ pub fn Layout(comptime Event: type) type {
pub fn deinit(this: *@This()) void { pub fn deinit(this: *@This()) void {
this.contents.deinit(); this.contents.deinit();
this.element.deinit();
this.events.deinit(); this.events.deinit();
switch ((&this.element).*) {
.layout => |*layout| {
layout.deinit();
},
.widget => |*widget| {
widget.deinit();
},
}
} }
pub fn handle(this: *@This(), event: Event) !*Event { pub fn handle(this: *@This(), event: Event) !*Events {
this.events.clearRetainingCapacity(); this.events.clearRetainingCapacity();
// order is important // order is important
switch (event) { switch (event) {
@@ -46,47 +53,48 @@ pub fn Layout(comptime Event: type) type {
this.size = size; this.size = size;
// adjust size according to the containing elements // adjust size according to the containing elements
const sub_event = event; const sub_event = event;
switch (this.element) { switch ((&this.element).*) {
.layout => |layout| { .layout => |*layout| {
this.events.appendSlice(layout.handle(sub_event).items); const events = try layout.handle(sub_event);
try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(sub_event)) |e| { if (widget.handle(sub_event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
}, },
else => { else => {
for (this.elements.items) |element| { switch ((&this.element).*) {
switch (element) { .layout => |*layout| {
.layout => |layout| { const events = try layout.handle(event);
this.events.appendSlice(layout.handle(event).items); try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(event)) |e| { if (widget.handle(event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
}
}, },
} }
return &this.events;
} }
pub fn content(this: *@This()) !*Contents { pub fn content(this: *@This()) !*Contents {
this.contents.clearRetainingCapacity(); this.contents.clearRetainingCapacity();
// TODO: padding contents accordingly // TODO: padding contents accordingly
switch (this.element) { switch ((&this.element).*) {
.layout => |layout| { .layout => |*layout| {
const layout_content = try layout.content(); const layout_content = try layout.content();
try this.contents.appendSlice(layout_content.items); try this.contents.appendSlice(layout_content.items);
}, },
.widget => |widget| { .widget => |*widget| {
try this.contents.appendSlice(try widget.content()); try this.contents.appendSlice(try widget.content());
}, },
} }
return &this.c; return &this.contents;
} }
}; };
} }

86
src/layout/VStack.zig
View File

@@ -12,9 +12,11 @@ pub fn Layout(comptime Event: type) type {
if (!isTaggedUnion(Event)) { if (!isTaggedUnion(Event)) {
@compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`."); @compileError("Provided user event `Event` for `Layout(comptime Event: type)` is not of type `union(enum)`.");
} }
const Element = union { const Widget = @import("../widget.zig").Widget(Event);
layout: @import("../layout.zig").Layout(Event), const Lay = @import("../layout.zig").Layout(Event);
widget: @import("../widget.zig").Widget(Event), const Element = union(enum) {
layout: Lay,
widget: Widget,
}; };
const Elements = std.ArrayList(Element); const Elements = std.ArrayList(Element);
const Events = std.ArrayList(Event); const Events = std.ArrayList(Event);
@@ -26,11 +28,30 @@ pub fn Layout(comptime Event: type) type {
elements: Elements = undefined, elements: Elements = undefined,
events: Events = undefined, events: Events = undefined,
// TODO: optional verdic argument for `Element`? pub fn init(allocator: std.mem.Allocator, children: anytype) @This() {
pub fn init(allocator: std.mem.Allocator) @This() { const ArgsType = @TypeOf(children);
const args_type_info = @typeInfo(ArgsType);
if (args_type_info != .Struct) {
@compileError("expected tuple or struct argument, found " ++ @typeName(ArgsType));
}
const fields_info = args_type_info.Struct.fields;
var elements = Elements.initCapacity(allocator, fields_info.len) catch @panic("OOM");
inline for (comptime fields_info) |field| {
const child = @field(children, field.name);
const ChildType = @TypeOf(child);
if (ChildType == Widget) {
elements.append(.{ .widget = child }) catch {};
continue;
}
if (ChildType == Lay) {
elements.append(.{ .layout = child }) catch {};
continue;
}
@compileError("child: " ++ field.name ++ " is not of type " ++ @typeName(Lay) ++ " or " ++ @typeName(Widget) ++ " but " ++ @typeName(ChildType));
}
return .{ return .{
.contents = Contents.init(allocator), .contents = Contents.init(allocator),
.elements = Elements.init(allocator), .elements = elements,
.events = Events.init(allocator), .events = Events.init(allocator),
}; };
} }
@@ -38,72 +59,75 @@ pub fn Layout(comptime Event: type) type {
pub fn deinit(this: *@This()) void { pub fn deinit(this: *@This()) void {
this.events.deinit(); this.events.deinit();
this.contents.deinit(); this.contents.deinit();
if (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |l| { .layout => |*layout| {
l.deinit(); layout.deinit();
}, },
.widget => |w| { .widget => |*widget| {
w.deinit(); widget.deinit();
}, },
} }
} }
this.elements.deinit(); this.elements.deinit();
} }
pub fn handle(this: *@This(), event: Event) !*Event { pub fn handle(this: *@This(), event: Event) !*Events {
this.events.clearRetainingCapacity(); this.events.clearRetainingCapacity();
// order is important // order is important
switch (event) { switch (event) {
.resize => |size| { .resize => |size| {
this.size = size; this.size = size;
// adjust size according to the containing elements // adjust size according to the containing elements
for (this.elements.items) |element| { for (this.elements.items) |*element| {
const sub_event = event; const sub_event = event;
switch (element) { switch (element.*) {
.layout => |l| { .layout => |*layout| {
this.events.appendSlice(l.handle(sub_event).items); const events = try layout.handle(sub_event);
try this.events.appendSlice(events.items);
}, },
.widget => |w| { .widget => |*widget| {
if (w.handle(sub_event)) |e| { if (widget.handle(sub_event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
} }
}, },
else => { else => {
for (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |layout| { .layout => |*layout| {
this.events.appendSlice(layout.handle(event).items); const events = try layout.handle(event);
try this.events.appendSlice(events.items);
}, },
.widget => |widget| { .widget => |*widget| {
if (widget.handle(event)) |e| { if (widget.handle(event)) |e| {
this.events.append(e); try this.events.append(e);
} }
}, },
} }
} }
}, },
} }
return &this.events;
} }
pub fn content(this: *@This()) !*Contents { pub fn content(this: *@This()) !*Contents {
this.contents.clearRetainingCapacity(); this.contents.clearRetainingCapacity();
// TODO: concat contents accordingly to create a vertical stack // TODO: concat contents accordingly to create a vertical stack
for (this.elements.items) |element| { for (this.elements.items) |*element| {
switch (element) { switch (element.*) {
.layout => |layout| { .layout => |*layout| {
const layout_content = try layout.content(); const layout_content = try layout.content();
try this.contents.appendSlice(layout_content.items); try this.contents.appendSlice(layout_content.items);
}, },
.widget => |widget| { .widget => |*widget| {
try this.contents.appendSlice(try widget.content()); try this.contents.appendSlice(try widget.content());
}, },
} }
} }
return &this.c; return &this.contents;
} }
}; };
} }

16
src/main.zig
View File

@@ -31,11 +31,21 @@ pub fn main() !void {
const file = try std.fs.cwd().openFile("./src/main.zig", .{}); const file = try std.fs.cwd().openFile("./src/main.zig", .{});
var rawText = App.Widget.RawText.init(allocator, file); var rawText = App.Widget.RawText.init(allocator, file);
const widget = App.Widget.createFrom(&rawText);
var layout = App.Layout.Pane.init(allocator, widget);
defer layout.deinit(); // deinitializes the contained widget
file.close(); file.close();
var framing = App.Layout.Framing.init(allocator, .{
.widget = App.Widget.createFrom(&rawText),
});
var vstack = App.Layout.VStack.init(allocator, .{
App.Layout.createFrom(&framing),
});
var hstack = App.Layout.HStack.init(allocator, .{
App.Layout.createFrom(&vstack),
});
var layout = App.Layout.createFrom(&hstack);
defer layout.deinit();
try app.start(); try app.start();
defer app.stop() catch unreachable; defer app.stop() catch unreachable;