commit 8071c825750c415b9e5502cdff34efc9c6dfeab7 · pci.express/flanterm.zig

+2 -1

.gitignore

+17

README.zig.md

···

       1
       1
       +
       # Flanterm

     

       2
       2
       +
       Adapted from [https://codeberg.org/Mintsuki/Flanterm](https://codeberg.org/Mintsuki/Flanterm)

     

       3
       3
       +
       for Zig. Read the C code and original README for more information.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Usage

     

       6
       6
       +
       First, add the package to your build.zig.zon:

     

       7
       7
       +
       `zig fetch --save git+https://tangled.sh/@sydney.blue/flanterm.zig#trunk`

     

       8
       8
       +
       Then, add the following to your build.zig:

     

       9
       9
       +
       ```zig

     

       10
       10
       +
       const flanterm_dep = b.dependency("flanterm", .{});

     

       11
       11
       +
       const flanterm_mod = flanterm.module("flanterm");

     

       12
       12
       +
       exe.root_module.addImport("flanterm", flanterm_mod);

     

       13
       13
       +
       ```

     

       14
       14
       +
       

     

       15
       15
       +
       Now, you can import the `flanterm` module and use the helpers. More

     

       16
       16
       +
       bindings will be added as needed, feel free to contribute anything

     

       17
       17
       +
       you would find useful.

+17

build.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn build(b: *std.Build) void {

     

       4
       4
       +
           // Create the exported module

     

       5
       5
       +
           const mod = b.addModule("flanterm", .{

     

       6
       6
       +
               .root_source_file = b.path("src/root.zig"),

     

       7
       7
       +
           });

     

       8
       8
       +
       

     

       9
       9
       +
           // Add the C source files and includes

     

       10
       10
       +
           mod.addIncludePath(b.path("src"));

     

       11
       11
       +
           mod.addCSourceFiles(.{

     

       12
       12
       +
               .files = &.{

     

       13
       13
       +
                   "src/flanterm.c",

     

       14
       14
       +
                   "src/flanterm_backends/fb.c",

     

       15
       15
       +
               },

     

       16
       16
       +
           });

     

       17
       17
       +
       }

+15

build.zig.zon

···

       1
       1
       +
       .{

     

       2
       2
       +
           .name = .flanterm,

     

       3
       3
       +
           .version = "2.0.0",

     

       4
       4
       +
           .fingerprint = 0x5e517d869e9f7b42, // Changing this has security and trust implications.

     

       5
       5
       +
           .minimum_zig_version = "0.15.1",

     

       6
       6
       +
           .dependencies = .{},

     

       7
       7
       +
           .paths = .{

     

       8
       8
       +
               "build.zig",

     

       9
       9
       +
               "build.zig.zon",

     

       10
       10
       +
               "src",

     

       11
       11
       +
               "LICENSE",

     

       12
       12
       +
               "README.md",

     

       13
       13
       +
               ".gitignore",

     

       14
       14
       +
           },

     

       15
       15
       +
       }

+60

src/colors.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       

     

       3
       3
       +
       pub const Palette = extern struct {

     

       4
       4
       +
           black: u32,

     

       5
       5
       +
           red: u32,

     

       6
       6
       +
           green: u32,

     

       7
       7
       +
           yellow: u32,

     

       8
       8
       +
           blue: u32,

     

       9
       9
       +
           magenta: u32,

     

       10
       10
       +
           cyan: u32,

     

       11
       11
       +
           white: u32,

     

       12
       12
       +
       };

     

       13
       13
       +
       

     

       14
       14
       +
       /// Used for escape sequences

     

       15
       15
       +
       pub const Color = enum(u8) {

     

       16
       16
       +
           black = 30,

     

       17
       17
       +
           red = 31,

     

       18
       18
       +
           green = 32,

     

       19
       19
       +
           yellow = 33,

     

       20
       20
       +
           blue = 34,

     

       21
       21
       +
           magenta = 35,

     

       22
       22
       +
           cyan = 36,

     

       23
       23
       +
           white = 37,

     

       24
       24
       +
           default = 39,

     

       25
       25
       +
           bright_black = 90,

     

       26
       26
       +
           bright_red = 91,

     

       27
       27
       +
           bright_green = 92,

     

       28
       28
       +
           bright_yellow = 93,

     

       29
       29
       +
           bright_blue = 94,

     

       30
       30
       +
           bright_magenta = 95,

     

       31
       31
       +
           bright_cyan = 96,

     

       32
       32
       +
           bright_white = 97,

     

       33
       33
       +
       

     

       34
       34
       +
           pub fn esc_seq(comptime self: Color) []const u8 {

     

       35
       35
       +
               if (self == .default) return "\x1b[0m";

     

       36
       36
       +
               return std.fmt.comptimePrint("\x1b[{}m", .{@intFromEnum(self)});

     

       37
       37
       +
           }

     

       38
       38
       +
       };

     

       39
       39
       +
       

     

       40
       40
       +
       pub var default_colors: Palette = .{

     

       41
       41
       +
           .black = 0x000000,

     

       42
       42
       +
           .red = 0xff0000,

     

       43
       43
       +
           .green = 0x37dd21,

     

       44
       44
       +
           .yellow = 0xfee409,

     

       45
       45
       +
           .blue = 0x1460d2,

     

       46
       46
       +
           .magenta = 0xff005d,

     

       47
       47
       +
           .cyan = 0x00bbbb,

     

       48
       48
       +
           .white = 0xbbbbbb,

     

       49
       49
       +
       };

     

       50
       50
       +
       

     

       51
       51
       +
       pub var default_bold_colors: Palette = .{

     

       52
       52
       +
           .black = 0x545454,

     

       53
       53
       +
           .red = 0xf40d17,

     

       54
       54
       +
           .green = 0x3bcf1d,

     

       55
       55
       +
           .yellow = 0xecc809,

     

       56
       56
       +
           .blue = 0x5555ff,

     

       57
       57
       +
           .magenta = 0xff55ff,

     

       58
       58
       +
           .cyan = 0x6ae3f9,

     

       59
       59
       +
           .white = 0xffffff,

     

       60
       60
       +
       };

+92

src/root.zig

···

       1
       1
       +
       pub const Colors = @import("colors.zig");

     

       2
       2
       +
       const std = @import("std");

     

       3
       3
       +
       const c = @cImport({

     

       4
       4
       +
           @cInclude("flanterm.h");

     

       5
       5
       +
           @cInclude("flanterm_backends/fb.h");

     

       6
       6
       +
       });

     

       7
       7
       +
       

     

       8
       8
       +
       pub const Context = struct {

     

       9
       9
       +
           backing: ?*c.struct_flanterm_context,

     

       10
       10
       +
       

     

       11
       11
       +
           const Self = @This();

     

       12
       12
       +
       

     

       13
       13
       +
           /// Initialize the context

     

       14
       14
       +
           pub fn init(

     

       15
       15
       +
               args: struct {

     

       16
       16
       +
                   // Malloc and Free

     

       17
       17
       +
                   malloc: ?*const fn (usize) callconv(.c) ?*anyopaque = null,

     

       18
       18
       +
                   free: ?*const fn (?*anyopaque, usize) callconv(.c) void = null,

     

       19
       19
       +
                   // Framebuffer Info (required)

     

       20
       20
       +
                   fb: [*]u32,

     

       21
       21
       +
                   width: usize,

     

       22
       22
       +
                   height: usize,

     

       23
       23
       +
                   pitch: usize,

     

       24
       24
       +
                   // Framebuffer Color Info

     

       25
       25
       +
                   red_mask_size: u8,

     

       26
       26
       +
                   red_mask_shift: u8,

     

       27
       27
       +
                   green_mask_size: u8,

     

       28
       28
       +
                   green_mask_shift: u8,

     

       29
       29
       +
                   blue_mask_size: u8,

     

       30
       30
       +
                   blue_mask_shift: u8,

     

       31
       31
       +
                   // Canvas (scratch space)

     

       32
       32
       +
                   canvas: ?[*]u32 = null,

     

       33
       33
       +
                   // Color Pointers

     

       34
       34
       +
                   ansi_colours: *Colors.Palette = &Colors.default_colors,

     

       35
       35
       +
                   ansi_bright_colours: *Colors.Palette = &Colors.default_bold_colors,

     

       36
       36
       +
                   // Default Color choices

     

       37
       37
       +
                   default_bg: *u32 = &Colors.default_colors.black,

     

       38
       38
       +
                   default_fg: *u32 = &Colors.default_colors.cyan,

     

       39
       39
       +
                   default_bg_bright: *u32 = &Colors.default_bold_colors.black,

     

       40
       40
       +
                   default_fg_bright: *u32 = &Colors.default_bold_colors.cyan,

     

       41
       41
       +
                   // Font Information

     

       42
       42
       +
                   font: ?*anyopaque = null,

     

       43
       43
       +
                   font_width: usize = 0,

     

       44
       44
       +
                   font_height: usize = 0,

     

       45
       45
       +
                   font_spacing: usize = 1,

     

       46
       46
       +
                   // Font Scale values

     

       47
       47
       +
                   font_scale_x: usize = 0,

     

       48
       48
       +
                   font_scale_y: usize = 0,

     

       49
       49
       +
                   // Margin

     

       50
       50
       +
                   margin: usize = 0,

     

       51
       51
       +
               },

     

       52
       52
       +
           ) Self {

     

       53
       53
       +
               const ansi_colours: [*]u32 = @ptrCast(args.ansi_colours);

     

       54
       54
       +
               const ansi_bright_colours: [*]u32 = @ptrCast(args.ansi_bright_colours);

     

       55
       55
       +
               const ctx = c.flanterm_fb_init(

     

       56
       56
       +
                   args.malloc,

     

       57
       57
       +
                   args.free,

     

       58
       58
       +
                   args.fb,

     

       59
       59
       +
                   args.width,

     

       60
       60
       +
                   args.height,

     

       61
       61
       +
                   args.pitch,

     

       62
       62
       +
                   args.red_mask_size,

     

       63
       63
       +
                   args.red_mask_shift,

     

       64
       64
       +
                   args.green_mask_size,

     

       65
       65
       +
                   args.green_mask_shift,

     

       66
       66
       +
                   args.blue_mask_size,

     

       67
       67
       +
                   args.blue_mask_shift,

     

       68
       68
       +
                   args.canvas,

     

       69
       69
       +
                   ansi_colours,

     

       70
       70
       +
                   ansi_bright_colours,

     

       71
       71
       +
                   args.default_bg,

     

       72
       72
       +
                   args.default_fg,

     

       73
       73
       +
                   args.default_bg_bright,

     

       74
       74
       +
                   args.default_fg_bright,

     

       75
       75
       +
                   args.font,

     

       76
       76
       +
                   args.font_width,

     

       77
       77
       +
                   args.font_height,

     

       78
       78
       +
                   args.font_spacing,

     

       79
       79
       +
                   args.font_scale_x,

     

       80
       80
       +
                   args.font_scale_y,

     

       81
       81
       +
                   args.margin,

     

       82
       82
       +
               );

     

       83
       83
       +
               return .{

     

       84
       84
       +
                   .backing = ctx,

     

       85
       85
       +
               };

     

       86
       86
       +
           }

     

       87
       87
       +
       

     

       88
       88
       +
           /// Write to the console

     

       89
       89
       +
           pub fn write_slice(self: *Self, buf: []u8) void {

     

       90
       90
       +
               c.flanterm_write(self.backing, buf.ptr, buf.len);

     

       91
       91
       +
           }

     

       92
       92
       +
       };