Compare commits

...
Author SHA1 Message Date
Vinzenz Schroeter
82696b2d1a add slice modifier
Some checks failed
Rust / build-gnu-apt (pull_request) Successful in 2m7s
Rust / build-size-gnu-unstable (pull_request) Failing after 2m48s
2025-06-26 19:26:41 +02:00
Vinzenz Schroeter
39c7c27c86 implement return modifiers 2025-06-26 18:59:46 +02:00
Vinzenz Schroeter
0968605d0b cleanups, add semicolon everywhere 2025-06-26 17:29:03 +02:00
Vinzenz Schroeter
e8f11c08ea add parameter modifiers 2025-06-23 23:28:30 +02:00
Vinzenz Schroeter
664625402f move where the modifier is 2025-06-23 21:36:01 +02:00
Vinzenz Schroeter
5a849a87c7 fix missing renames 2025-06-23 21:16:22 +02:00
Vinzenz Schroeter
323ba6128e add move fn to dsl, rename SPCommand to GenericCommand, remove DisplayBitVec command 2025-06-23 20:26:22 +02:00
Vinzenz Schroeter
e434130784 unifiy special handling of params and return 2025-06-23 19:43:52 +02:00
Vinzenz Schroeter
92ce27af68 simplify property exports 2025-06-23 19:43:23 +02:00
Vinzenz Schroeter
7a836783e1 rename function to ...try to indicate possible null return 2025-06-22 13:00:32 +02:00
Vinzenz Schroeter
b4730ffdf3 container macro code dedup 2025-06-22 12:52:53 +02:00
Vinzenz Schroeter
5ecb84ed16 derive try_into_packet automatically 2025-06-22 12:28:37 +02:00
Vinzenz Schroeter
8116375fd0 more type name based naming 2025-06-22 12:28:37 +02:00
Vinzenz Schroeter
8f13ba61f0 remove _ from type names in function names 2025-06-22 00:14:06 +02:00
Vinzenz Schroeter
500cbbc872 add prefix centrally 2025-06-21 23:51:10 +02:00
Vinzenz Schroeter
1eb59d986a wrap_command macro 2025-06-21 23:47:42 +02:00
Vinzenz Schroeter
18f0be072a fix docs, misc tweaks 2025-06-19 18:32:07 +02:00
30 changed files with 1768 additions and 1720 deletions

View file

@ -96,7 +96,7 @@ endif
# ADD NEW EXAMPLES HERE
_c_src := src/announce.c src/brightness_tester.c src/header_logger.c \
src/moving_line.c src/random_stuff.c src/wiping_clear.c
src/moving_line.c src/random_stuff.c src/wiping_clear.c src/undefined.c
_programs := $(basename $(notdir $(_c_src)))
_bins := $(_programs)
_unstripped_bins := $(addsuffix _unstripped, $(_bins))

View file

@ -3,27 +3,27 @@
int main(void) {
sock_init();
sp_udp_send_header(sock, (Header) {.command_code = COMMAND_CODE_CLEAR});
sp_udpsocket_send_header(sock, (Header) {.command_code = COMMAND_CODE_CLEAR});
CharGrid *grid = sp_char_grid_new(5, 2);
CharGrid *grid = sp_chargrid_new(5, 2);
if (grid == NULL)
return 1;
sp_char_grid_set(grid, 0, 0, 'H');
sp_char_grid_set(grid, 1, 0, 'e');
sp_char_grid_set(grid, 2, 0, 'l');
sp_char_grid_set(grid, 3, 0, 'l');
sp_char_grid_set(grid, 4, 0, 'o');
sp_char_grid_set(grid, 0, 1, 'W');
sp_char_grid_set(grid, 1, 1, 'o');
sp_char_grid_set(grid, 2, 1, 'r');
sp_char_grid_set(grid, 3, 1, 'l');
sp_char_grid_set(grid, 4, 1, 'd');
sp_chargrid_set(grid, 0, 0, 'H');
sp_chargrid_set(grid, 1, 0, 'e');
sp_chargrid_set(grid, 2, 0, 'l');
sp_chargrid_set(grid, 3, 0, 'l');
sp_chargrid_set(grid, 4, 0, 'o');
sp_chargrid_set(grid, 0, 1, 'W');
sp_chargrid_set(grid, 1, 1, 'o');
sp_chargrid_set(grid, 2, 1, 'r');
sp_chargrid_set(grid, 3, 1, 'l');
sp_chargrid_set(grid, 4, 1, 'd');
Packet *packet = sp_char_grid_into_packet(grid, 0, 0);
Packet *packet = sp_chargrid_try_into_packet(grid, 0, 0);
if (packet == NULL)
return 1;
sp_udp_send_packet(sock, packet);
sp_udpsocket_send_packet(sock, packet);
return 0;
}

View file

@ -5,14 +5,14 @@ void enable_all_pixels(void) {
Bitmap *all_on = sp_bitmap_new_max_sized();
sp_bitmap_fill(all_on, true);
BitmapCommand *bitmapCommand = sp_cmd_bitmap_from_bitmap(all_on);
Packet *packet = sp_cmd_bitmap_try_into_packet(bitmapCommand);
BitmapCommand *bitmapCommand = sp_bitmapcommand_from_bitmap(all_on);
Packet *packet = sp_bitmapcommand_try_into_packet(bitmapCommand);
if (packet != NULL)
sp_udp_send_packet(sock, packet);
sp_udpsocket_send_packet(sock, packet);
}
void make_brightness_pattern(BrightnessGrid *grid) {
ByteSlice slice = sp_brightness_grid_data_ref_mut(grid);
ByteSlice slice = sp_brightnessgrid_data_ref_mut(grid);
for (size_t index = 0; index < slice.length; index++) {
slice.start[index] = (uint8_t)(index % ((size_t) Brightness_MAX));
}
@ -23,13 +23,13 @@ int main(void) {
enable_all_pixels();
BrightnessGrid *grid = sp_brightness_grid_new(TILE_WIDTH, TILE_HEIGHT);
BrightnessGrid *grid = sp_brightnessgrid_new(TILE_WIDTH, TILE_HEIGHT);
make_brightness_pattern(grid);
Packet *packet = sp_cmd_brightness_grid_into_packet(sp_cmd_brightness_grid_from_grid(grid));
Packet *packet = sp_brightnessgridcommand_try_into_packet(sp_brightnessgridcommand_from_grid(grid));
if (packet == NULL)
return -2;
sp_udp_send_packet(sock, packet);
sp_udpsocket_send_packet(sock, packet);
return 0;
}

View file

@ -15,8 +15,8 @@ void handle_error(const char *msg) {
exit(EXIT_FAILURE);
}
bool log_command(struct Command command) {
switch (command.tag) {
bool log_command(struct GenericCommand *command) {
switch (command->tag) {
case COMMAND_TAG_INVALID: {
printf("-> this is an invalid command\n");
break;
@ -26,14 +26,14 @@ bool log_command(struct Command command) {
return true;
}
case COMMAND_TAG_BITMAP: {
BitmapCommand *bitmapCommand = command.data.bitmap;
BitmapCommand *bitmapCommand = command->data.bitmap;
CompressionCode compression = sp_cmd_bitmap_get_compression(bitmapCommand);
CompressionCode compression = sp_bitmapcommand_get_compression(bitmapCommand);
size_t x, y;
sp_cmd_bitmap_get_origin(bitmapCommand, &x, &y);
sp_bitmapcommand_get_origin(bitmapCommand, &x, &y);
Bitmap *bitmap = sp_cmd_bitmap_get(bitmapCommand);
Bitmap *bitmap = sp_bitmapcommand_get_bitmap_mut(bitmapCommand);
size_t w = sp_bitmap_width(bitmap);
size_t h = sp_bitmap_height(bitmap);
@ -42,54 +42,54 @@ bool log_command(struct Command command) {
break;
}
case COMMAND_TAG_BRIGHTNESS_GRID: {
BrightnessGridCommand *gridCommand = command.data.brightness_grid;
BrightnessGridCommand *gridCommand = command->data.brightness_grid;
size_t x, y;
sp_cmd_brightness_grid_get_origin(gridCommand, &x, &y);
sp_brightnessgridcommand_get_origin(gridCommand, &x, &y);
BrightnessGrid *grid = sp_cmd_brightness_grid_get(gridCommand);
size_t w = sp_brightness_grid_width(grid);
size_t h = sp_brightness_grid_height(grid);
BrightnessGrid *grid = sp_brightnessgridcommand_get_grid_mut(gridCommand);
size_t w = sp_brightnessgrid_width(grid);
size_t h = sp_brightnessgrid_height(grid);
printf("-> BrightnessGridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
x, y, w, h);
break;
}
case COMMAND_TAG_CHAR_GRID: {
CharGridCommand *gridCommand = command.data.char_grid;
CharGridCommand *gridCommand = command->data.char_grid;
size_t x, y;
sp_cmd_char_grid_get_origin(gridCommand, &x, &y);
sp_chargridcommand_get_origin(gridCommand, &x, &y);
CharGrid *grid = sp_cmd_char_grid_get(gridCommand);
size_t w = sp_char_grid_width(grid);
size_t h = sp_char_grid_height(grid);
CharGrid *grid = sp_chargridcommand_get_grid_mut(gridCommand);
size_t w = sp_chargrid_width(grid);
size_t h = sp_chargrid_height(grid);
printf("-> CharGridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
x, y, w, h);
break;
}
case COMMAND_TAG_CP437_GRID: {
Cp437GridCommand *gridCommand = command.data.cp437_grid;
Cp437GridCommand *gridCommand = command->data.cp437_grid;
size_t x, y;
sp_cmd_cp437_grid_get_origin(gridCommand, &x, &y);
sp_cp437gridcommand_get_origin(gridCommand, &x, &y);
Cp437Grid *grid = sp_cmd_cp437_grid_get(gridCommand);
size_t w = sp_cp437_grid_width(grid);
size_t h = sp_cp437_grid_height(grid);
Cp437Grid *grid = sp_cp437gridcommand_get_grid_mut(gridCommand);
size_t w = sp_cp437grid_width(grid);
size_t h = sp_cp437grid_height(grid);
printf("-> Cp437GridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
x, y, w, h);
break;
}
case COMMAND_TAG_BIT_VEC: {
BitVecCommand *bitvecCommand = command.data.bitvec;
BitVecCommand *bitvecCommand = command->data.bit_vec;
size_t offset = sp_cmd_bitvec_get_offset(bitvecCommand);
CompressionCode compression = sp_cmd_bitvec_get_compression(bitvecCommand);
size_t offset = sp_bitveccommand_get_offset(bitvecCommand);
CompressionCode compression = sp_bitveccommand_get_compression(bitvecCommand);
BinaryOperation operation = sp_cmd_bitvec_get_operation(bitvecCommand);
BinaryOperation operation = sp_bitveccommand_get_operation(bitvecCommand);
char *operationText;
switch (operation) {
case BINARY_OPERATION_AND:
@ -109,8 +109,8 @@ bool log_command(struct Command command) {
break;
}
BitVec *bitvec = sp_cmd_bitvec_get(bitvecCommand);
size_t len = sp_bitvec_len(bitvec);
DisplayBitVec *bitvec = sp_bitveccommand_get_bitvec_mut(bitvecCommand);
size_t len = sp_displaybitvec_len(bitvec);
printf("-> BitVecCommand with params: offset=%zu, length=%zu, compression=%hu, operation=%s\n",
offset, len, compression, operationText);
@ -129,12 +129,12 @@ bool log_command(struct Command command) {
break;
}
case COMMAND_TAG_GLOBAL_BRIGHTNESS: {
Brightness brightness = sp_cmd_brightness_global_get_brightness(command.data.global_brightness);
Brightness brightness = sp_globalbrightnesscommand_get_brightness(command->data.global_brightness);
printf("-> GlobalBrightnessCommand with params: brightness=%hu\n", brightness);
break;
}
default: {
printf("-> unknown command tag %d\n", command.tag);
printf("-> unknown command tag %d\n", command->tag);
break;
}
}
@ -198,10 +198,10 @@ int main(int argc, char **argv) {
header->command_code, header->a, header->b, header->c, header->d,
payload.start, payload.length);
struct Command command = sp_cmd_generic_try_from_packet(packet);
struct GenericCommand *command = sp_genericcommand_try_from_packet(packet);
done = log_command(command);
sp_cmd_generic_free(command);
sp_genericcommand_free(command);
}
close(udp_socket);

View file

@ -10,12 +10,12 @@
static UdpSocket *sock = NULL;
void sock_free() {
sp_udp_free(sock);
sp_udpsocket_free(sock);
}
void sock_init() {
//sock = sp_udp_open_ipv4(127, 0, 0, 1, 2342);
sock = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
sock = sp_udpsocket_open_ipv4(127, 0, 0, 1, 2342);
//sock = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
if (sock == NULL)
exit(-1);
atexit(sock_free);

View file

@ -13,14 +13,14 @@ int main(void) {
sp_bitmap_set(bitmap, (y + x) % PIXEL_WIDTH, y, true);
}
BitmapCommand *command = sp_cmd_bitmap_from_bitmap(sp_bitmap_clone(bitmap));
Packet *packet = sp_cmd_bitmap_try_into_packet(command);
BitmapCommand *command = sp_bitmapcommand_from_bitmap(sp_bitmap_clone(bitmap));
Packet *packet = sp_bitmapcommand_try_into_packet(command);
if (packet == NULL) {
result = -2;
goto exit;
}
if (!sp_udp_send_packet(sock, packet)) {
if (!sp_udpsocket_send_packet(sock, packet)) {
result = -3;
goto exit;
}

View file

@ -11,13 +11,13 @@ int main(void) {
sp_bitmap_fill(pixels, true);
Packet *packet = sp_bitmap_into_packet(pixels, 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
Packet *packet = sp_bitmap_try_into_packet(pixels, 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
if (packet == NULL)
return 1;
Header *header = sp_packet_get_header_mut(packet);
printf("[%d, %d, %d, %d, %d]\n", header->command_code, header->a, header->b, header->c, header->d);
sp_udp_send_packet(sock, packet);
sp_udpsocket_send_packet(sock, packet);
return 0;
}

22
example/src/undefined.c Normal file
View file

@ -0,0 +1,22 @@
#include <stdio.h>
#include "servicepoint.h"
#include "helpers.h"
/// DO NOT DO ANY OF THIS!
int main(void) {
BitmapCommand *bmcmd = sp_bitmapcommand_new(sp_bitmap_new_max_sized(), 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
BitVecCommand *bvcmd = (BitVecCommand *) bmcmd;
sp_bitveccommand_free(bvcmd);
uint8_t *data = calloc(1024, 1);
struct GenericCommand generic = {
.tag = COMMAND_TAG_BRIGHTNESS_GRID,
.data = {.null = data},
};
sock_init();
sp_udpsocket_send_command(sock, &generic);
return 0;
}

View file

@ -13,14 +13,14 @@ int main() {
sp_bitmap_set(enabled_pixels, x, y, false);
}
BitVec *bitvec = sp_bitmap_into_bitvec(sp_bitmap_clone(enabled_pixels));
BitVecCommand *command = sp_cmd_bitvec_new(bitvec, 0, BINARY_OPERATION_AND, COMPRESSION_CODE_LZMA);
Packet *packet = sp_cmd_bitvec_try_into_packet(command);
DisplayBitVec *bitvec = sp_bitmap_into_bitvec(sp_bitmap_clone(enabled_pixels));
BitVecCommand *command = sp_bitveccommand_new(bitvec, 0, BINARY_OPERATION_AND, COMPRESSION_CODE_LZMA);
Packet *packet = sp_bitveccommand_try_into_packet(command);
if (packet == NULL) {
result = -2;
goto exit;
}
if (!sp_udp_send_packet(sock, packet)) {
if (!sp_udpsocket_send_packet(sock, packet)) {
result = -3;
goto exit;
}

File diff suppressed because it is too large Load diff

View file

@ -1,56 +1,43 @@
use crate::{
commands::wrap_origin_accessors,
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
commands::{wrap_command, wrap_origin_accessors},
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{Bitmap, BitmapCommand, CompressionCode, Origin, Packet};
use servicepoint::{Bitmap, BitmapCommand, CompressionCode, Origin};
use std::ptr::NonNull;
wrap_clone!(sp_cmd_bitmap::BitmapCommand);
wrap_free!(sp_cmd_bitmap::BitmapCommand);
wrap_command!(Bitmap);
wrap_fields!(sp_cmd_bitmap::BitmapCommand;
prop bitmap: Bitmap { mut get(); move set(value); };
prop compression: CompressionCode { get(); set(value); };
wrap_fields!(BitmapCommand;
prop bitmap: Bitmap { get mut; set move; };
prop compression: CompressionCode { get; set; };
);
wrap_origin_accessors!(sp_cmd_bitmap::BitmapCommand);
wrap_origin_accessors!(BitmapCommand);
wrap_functions!(sp_cmd_bitmap;
wrap_functions!(associate BitmapCommand;
/// Sets a window of pixels to the specified values.
///
/// The passed [Bitmap] gets consumed.
///
/// Returns: a new [BitmapCommand] instance.
fn new(
bitmap: NonNull<Bitmap>,
origin_x: usize,
origin_y: usize,
compression: CompressionCode,
) -> NonNull<BitmapCommand> {
heap_move_nonnull(BitmapCommand {
bitmap: unsafe { heap_remove(bitmap) },
bitmap: move NonNull<Bitmap>,
origin_x: val usize,
origin_y: val usize,
compression: val CompressionCode,
) -> move NonNull<BitmapCommand> {
BitmapCommand {
bitmap,
origin: Origin::new(origin_x, origin_y),
compression,
})
}
}
};
/// Move the provided [Bitmap] into a new [BitmapCommand],
/// leaving other fields as their default values.
///
/// Rust equivalent: `BitmapCommand::from(bitmap)`
fn from_bitmap(
bitmap: NonNull<Bitmap>,
) -> NonNull<BitmapCommand> {
heap_move_nonnull(unsafe { heap_remove(bitmap) }.into())
}
/// Tries to turn a [BitmapCommand] into a [Packet].
///
/// Returns: NULL or a [Packet] containing the command.
fn try_into_packet(
command: NonNull<BitmapCommand>,
) -> *mut Packet {
heap_move_ok(unsafe { heap_remove(command) }.try_into())
}
fn from_bitmap(bitmap: move NonNull<Bitmap>) -> move NonNull<BitmapCommand> {
bitmap.into()
};
);

View file

@ -1,25 +1,22 @@
use crate::{
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
commands::wrap_command,
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{
BinaryOperation, BitVecCommand, CompressionCode, DisplayBitVec, Offset,
Packet,
};
use std::ptr::NonNull;
wrap_clone!(sp_cmd_bitvec::BitVecCommand);
wrap_free!(sp_cmd_bitvec::BitVecCommand);
wrap_command!(BitVec);
wrap_fields!(sp_cmd_bitvec::BitVecCommand;
prop bitvec: DisplayBitVec { mut get(); move set(value); };
prop offset: Offset { get(); set(value); };
prop operation: BinaryOperation { get(); set(value); };
prop compression: CompressionCode { get(); set(value); };
wrap_fields!(BitVecCommand;
prop bitvec: DisplayBitVec { get mut; set move; };
prop offset: Offset { get; set; };
prop operation: BinaryOperation { get; set; };
prop compression: CompressionCode { get; set; };
);
wrap_functions!(sp_cmd_bitvec;
wrap_functions!(associate BitVecCommand;
/// Set pixel data starting at the pixel offset on screen.
///
/// The screen will continuously overwrite more pixel data without regarding the offset, meaning
@ -33,26 +30,16 @@ wrap_functions!(sp_cmd_bitvec;
///
/// The contained [`DisplayBitVec`] is always uncompressed.
fn new(
bitvec: NonNull<DisplayBitVec>,
offset: usize,
operation: BinaryOperation,
compression: CompressionCode,
) -> NonNull<BitVecCommand> {
heap_move_nonnull(BitVecCommand {
bitvec: unsafe { heap_remove(bitvec) },
bitvec: move NonNull<DisplayBitVec>,
offset: val usize,
operation: val BinaryOperation,
compression: val CompressionCode,
) -> move NonNull<BitVecCommand> {
BitVecCommand {
bitvec,
offset,
operation,
compression,
})
}
/// Tries to turn a [BitVecCommand] into a [Packet].
///
/// Returns: NULL or a [Packet] containing the command.
fn try_into_packet(
command: NonNull<BitVecCommand>,
) -> *mut Packet {
heap_move_ok(unsafe { heap_remove(command) }.try_into())
}
}
};
);

View file

@ -1,53 +1,38 @@
use crate::{
commands::wrap_origin_accessors,
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
commands::{wrap_command, wrap_origin_accessors},
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{BrightnessGrid, BrightnessGridCommand, Origin, Packet};
use servicepoint::{BrightnessGrid, BrightnessGridCommand, Origin};
use std::ptr::NonNull;
wrap_clone!(sp_cmd_brightness_grid::BrightnessGridCommand);
wrap_free!(sp_cmd_brightness_grid::BrightnessGridCommand);
wrap_command!(BrightnessGrid);
wrap_fields!(sp_cmd_brightness_grid::BrightnessGridCommand;
prop grid: BrightnessGrid { mut get(); move set(grid); };
wrap_fields!(BrightnessGridCommand;
prop grid: BrightnessGrid { get mut; set move; };
);
wrap_origin_accessors!(sp_cmd_brightness_grid::BrightnessGridCommand);
wrap_functions!(sp_cmd_brightness_grid;
wrap_origin_accessors!(BrightnessGridCommand);
wrap_functions!(associate BrightnessGridCommand;
/// Set the brightness of individual tiles in a rectangular area of the display.
///
/// The passed [BrightnessGrid] gets consumed.
///
/// Returns: a new [BrightnessGridCommand] instance.
fn new(
grid: NonNull<BrightnessGrid>,
origin_x: usize,
origin_y: usize,
) -> NonNull<BrightnessGridCommand> {
heap_move_nonnull(BrightnessGridCommand {
grid: unsafe { heap_remove(grid) },
grid: move NonNull<BrightnessGrid>,
origin_x: val usize,
origin_y: val usize
) -> move NonNull<BrightnessGridCommand> {
BrightnessGridCommand {
grid,
origin: Origin::new(origin_x, origin_y),
})
}
}
};
/// Moves the provided [BrightnessGrid] into a new [BrightnessGridCommand],
/// leaving other fields as their default values.
fn from_grid(
grid: NonNull<BrightnessGrid>,
) -> NonNull<BrightnessGridCommand> {
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
}
/// Tries to turn a [BrightnessGridCommand] into a [Packet].
///
/// Returns: NULL or a [Packet] containing the command.
fn into_packet(
command: NonNull<BrightnessGridCommand>,
) -> *mut Packet {
heap_move_ok(unsafe { heap_remove(command) }.try_into())
}
fn from_grid(grid: move NonNull<BrightnessGrid>) -> move NonNull<BrightnessGridCommand> {
grid.into()
};
);

View file

@ -1,37 +1,38 @@
use crate::{
macros::{wrap_free, wrap_functions},
mem::heap_move_nonnull,
};
use crate::{commands::wrap_command, macros::wrap_functions};
use servicepoint::{ClearCommand, FadeOutCommand, HardResetCommand};
use std::ptr::NonNull;
macro_rules! wrap_cc_only {
($prefix:ident :: $typ:ident ; $(#[$meta:meta])*) => {
wrap_functions!($prefix;
$(#[$meta])*
///
#[doc = concat!(" Returns: a new [`",stringify!($typ),"`] instance.")]
fn new() -> NonNull<$typ> {
heap_move_nonnull($typ)
}
);
($(#[$meta:meta])* $command:ident) => {
::paste::paste!{
wrap_command!($command);
wrap_free!($prefix :: $typ);
wrap_functions!(associate [< $command Command >];
$(#[$meta])*
///
#[doc = " Returns: a new [`" [< $command Command >] "`] instance."]
fn new() -> move ::core::ptr::NonNull<[< $command Command >]> {
[< $command Command >]
};
);
}
};
}
wrap_cc_only!(sp_cmd_clear::ClearCommand;
wrap_cc_only!(
/// Set all pixels to the off state.
///
/// Does not affect brightness.
Clear
);
wrap_cc_only!(sp_cmd_hard_reset::HardResetCommand;
wrap_cc_only!(
/// Kills the udp daemon on the display, which usually results in a restart.
///
/// Please do not send this in your normal program flow.
HardReset
);
wrap_cc_only!(sp_cmd_fade_out::FadeOutCommand;
wrap_cc_only!(
/// A yet-to-be-tested command.
FadeOut
);

View file

@ -1,53 +1,38 @@
use crate::{
commands::wrap_origin_accessors,
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
commands::{wrap_command, wrap_origin_accessors},
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{CharGrid, CharGridCommand, Origin, Packet};
use servicepoint::{CharGrid, CharGridCommand, Origin};
use std::ptr::NonNull;
wrap_clone!(sp_cmd_char_grid::CharGridCommand);
wrap_free!(sp_cmd_char_grid::CharGridCommand);
wrap_command!(CharGrid);
wrap_fields!(sp_cmd_char_grid::CharGridCommand;
prop grid: CharGrid { mut get(); move set(grid); };
wrap_fields!(CharGridCommand;
prop grid: CharGrid { get mut; set move; };
);
wrap_origin_accessors!(sp_cmd_char_grid::CharGridCommand);
wrap_functions!(sp_cmd_char_grid;
wrap_origin_accessors!(CharGridCommand);
wrap_functions!(associate CharGridCommand;
/// Show UTF-8 encoded text on the screen.
///
/// The passed [CharGrid] gets consumed.
///
/// Returns: a new [CharGridCommand] instance.
fn new(
grid: NonNull<CharGrid>,
origin_x: usize,
origin_y: usize,
) -> NonNull<CharGridCommand> {
heap_move_nonnull(CharGridCommand {
grid: unsafe { heap_remove(grid) },
grid: move NonNull<CharGrid>,
origin_x: val usize,
origin_y: val usize,
) -> move NonNull<CharGridCommand> {
CharGridCommand {
grid,
origin: Origin::new(origin_x, origin_y),
})
}
}
};
/// Moves the provided [CharGrid] into a new [CharGridCommand],
/// leaving other fields as their default values.
fn from_grid(
grid: NonNull<CharGrid>,
) -> NonNull<CharGridCommand> {
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
}
/// Tries to turn a [CharGridCommand] into a [Packet].
///
/// Returns: NULL or a [Packet] containing the command.
fn try_into_packet(
command: NonNull<CharGridCommand>,
) -> *mut Packet {
heap_move_ok(unsafe { heap_remove(command) }.try_into())
}
fn from_grid(grid: move NonNull<CharGrid>) -> move NonNull<CharGridCommand> {
grid.into()
};
);

View file

@ -1,53 +1,38 @@
use crate::{
commands::wrap_origin_accessors,
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
commands::{wrap_command, wrap_origin_accessors},
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{Cp437Grid, Cp437GridCommand, Origin, Packet};
use servicepoint::{Cp437Grid, Cp437GridCommand, Origin};
use std::ptr::NonNull;
wrap_clone!(sp_cmd_cp437_grid::Cp437GridCommand);
wrap_free!(sp_cmd_cp437_grid::Cp437GridCommand);
wrap_command!(Cp437Grid);
wrap_fields!(sp_cmd_cp437_grid::Cp437GridCommand;
prop grid: Cp437Grid { mut get(); move set(grid); };
wrap_fields!(Cp437GridCommand;
prop grid: Cp437Grid { get mut; set move; };
);
wrap_origin_accessors!(sp_cmd_cp437_grid::Cp437GridCommand);
wrap_functions!(sp_cmd_cp437_grid;
wrap_origin_accessors!(Cp437GridCommand);
wrap_functions!(associate Cp437GridCommand;
/// Show text on the screen.
///
/// The text is sent in the form of a 2D grid of [CP-437] encoded characters.
///
/// The origin is relative to the top-left of the display.
fn new(
grid: NonNull<Cp437Grid>,
origin_x: usize,
origin_y: usize,
) -> NonNull<Cp437GridCommand> {
heap_move_nonnull(Cp437GridCommand {
grid: unsafe { heap_remove(grid) },
grid: move NonNull<Cp437Grid>,
origin_x: val usize,
origin_y: val usize,
) -> move NonNull<Cp437GridCommand> {
Cp437GridCommand {
grid,
origin: Origin::new(origin_x, origin_y),
})
}
}
};
/// Moves the provided [Cp437Grid] into a new [Cp437GridCommand],
/// leaving other fields as their default values.
fn from_grid(
grid: NonNull<Cp437Grid>,
) -> NonNull<Cp437GridCommand> {
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
}
/// Tries to turn a [Cp437GridCommand] into a [Packet].
///
/// Returns: NULL or a [Packet] containing the command.
fn try_into_packet(
command: NonNull<Cp437GridCommand>,
) -> *mut Packet {
heap_move_ok(unsafe { heap_remove(command) }.try_into())
}
fn from_grid(grid: move NonNull<Cp437Grid>) -> move NonNull<Cp437GridCommand> {
grid.into()
};
);

View file

@ -1,5 +1,5 @@
use crate::{
macros::wrap_functions,
macros::{derive_clone, derive_free, wrap_functions, wrap_methods},
mem::{
heap_clone, heap_drop, heap_move, heap_move_nonnull, heap_move_ok,
heap_remove,
@ -18,7 +18,7 @@ use std::ptr::{null_mut, NonNull};
pub union CommandUnion {
pub null: *mut u8,
pub bitmap: NonNull<BitmapCommand>,
pub bitvec: NonNull<BitVecCommand>,
pub bit_vec: NonNull<BitVecCommand>,
pub brightness_grid: NonNull<BrightnessGridCommand>,
pub char_grid: NonNull<CharGridCommand>,
pub cp437_grid: NonNull<Cp437GridCommand>,
@ -55,221 +55,214 @@ pub enum CommandTag {
///
/// Rust equivalent: [TypedCommand].
#[repr(C)]
pub struct SPCommand {
pub struct GenericCommand {
/// Specifies which kind of command struct is contained in `data`
pub tag: CommandTag,
/// The pointer to the command struct
pub data: CommandUnion,
}
impl SPCommand {
const INVALID: SPCommand = SPCommand {
impl GenericCommand {
pub(crate) const INVALID: GenericCommand = GenericCommand {
tag: CommandTag::Invalid,
data: CommandUnion { null: null_mut() },
};
}
wrap_functions!(sp_cmd_generic;
derive_clone!(GenericCommand);
/// Tries to turn a [Packet] into a [SPCommand].
impl Clone for GenericCommand {
fn clone(&self) -> Self {
unsafe {
match self.tag {
CommandTag::Clear => GenericCommand {
tag: CommandTag::Clear,
data: CommandUnion {
clear: heap_clone(self.data.clear),
},
},
CommandTag::CharGrid => GenericCommand {
tag: CommandTag::CharGrid,
data: CommandUnion {
char_grid: heap_clone(self.data.char_grid),
},
},
CommandTag::Cp437Grid => GenericCommand {
tag: CommandTag::Cp437Grid,
data: CommandUnion {
cp437_grid: heap_clone(self.data.cp437_grid),
},
},
CommandTag::Bitmap => GenericCommand {
tag: CommandTag::Bitmap,
data: CommandUnion {
bitmap: heap_clone(self.data.bitmap),
},
},
CommandTag::GlobalBrightness => GenericCommand {
tag: CommandTag::GlobalBrightness,
data: CommandUnion {
global_brightness: heap_clone(
self.data.global_brightness,
),
},
},
CommandTag::BrightnessGrid => GenericCommand {
tag: CommandTag::BrightnessGrid,
data: CommandUnion {
brightness_grid: heap_clone(self.data.brightness_grid),
},
},
CommandTag::BitVec => GenericCommand {
tag: CommandTag::BitVec,
data: CommandUnion {
bit_vec: heap_clone(self.data.bit_vec),
},
},
CommandTag::HardReset => GenericCommand {
tag: CommandTag::HardReset,
data: CommandUnion {
hard_reset: heap_clone(self.data.hard_reset),
},
},
CommandTag::FadeOut => GenericCommand {
tag: CommandTag::FadeOut,
data: CommandUnion {
fade_out: heap_clone(self.data.fade_out),
},
},
#[allow(deprecated)]
CommandTag::BitmapLegacy => GenericCommand {
tag: CommandTag::BitmapLegacy,
data: CommandUnion {
bitmap_legacy: heap_clone(self.data.bitmap_legacy),
},
},
CommandTag::Invalid => GenericCommand::INVALID,
}
}
}
}
derive_free!(GenericCommand);
impl Drop for GenericCommand {
fn drop(&mut self) {
unsafe {
match self.tag {
CommandTag::Invalid => (),
CommandTag::Bitmap => heap_drop(self.data.bitmap),
CommandTag::BitVec => heap_drop(self.data.bit_vec),
CommandTag::BrightnessGrid => {
heap_drop(self.data.brightness_grid)
}
CommandTag::CharGrid => heap_drop(self.data.char_grid),
CommandTag::Cp437Grid => heap_drop(self.data.cp437_grid),
CommandTag::GlobalBrightness => {
heap_drop(self.data.global_brightness)
}
CommandTag::Clear => heap_drop(self.data.clear),
CommandTag::HardReset => heap_drop(self.data.hard_reset),
CommandTag::FadeOut => heap_drop(self.data.fade_out),
CommandTag::BitmapLegacy => heap_drop(self.data.bitmap_legacy),
}
}
*self = Self::INVALID;
}
}
wrap_functions!(associate GenericCommand;
/// Tries to turn a [Packet] into a [GenericCommand].
///
/// The packet is dropped in the process.
///
/// Returns: pointer to new [SPCommand] instance or NULL if parsing failed.
fn try_from_packet(
packet: NonNull<Packet>,
) -> SPCommand {
let packet = *unsafe { Box::from_raw(packet.as_ptr()) };
/// Returns: pointer to new [GenericCommand] instance or NULL if parsing failed.
fn try_from_packet(packet: move NonNull<Packet>) -> move NonNull<GenericCommand> {
servicepoint::TypedCommand::try_from(packet)
.map(|value| match value {
TypedCommand::Clear(clear) => SPCommand {
TypedCommand::Clear(clear) => GenericCommand {
tag: CommandTag::Clear,
data: CommandUnion {
clear: heap_move_nonnull(clear),
},
},
TypedCommand::CharGrid(char_grid) => SPCommand {
TypedCommand::CharGrid(char_grid) => GenericCommand {
tag: CommandTag::CharGrid,
data: CommandUnion {
char_grid: heap_move_nonnull(char_grid),
},
},
TypedCommand::Cp437Grid(cp437_grid) => SPCommand {
TypedCommand::Cp437Grid(cp437_grid) => GenericCommand {
tag: CommandTag::Cp437Grid,
data: CommandUnion {
cp437_grid: heap_move_nonnull(cp437_grid),
},
},
TypedCommand::Bitmap(bitmap) => SPCommand {
TypedCommand::Bitmap(bitmap) => GenericCommand {
tag: CommandTag::Bitmap,
data: CommandUnion {
bitmap: heap_move_nonnull(bitmap),
},
},
TypedCommand::Brightness(global_brightness) => SPCommand {
TypedCommand::Brightness(global_brightness) => GenericCommand {
tag: CommandTag::GlobalBrightness,
data: CommandUnion {
global_brightness: heap_move_nonnull(global_brightness),
},
},
TypedCommand::BrightnessGrid(brightness_grid) => SPCommand {
TypedCommand::BrightnessGrid(brightness_grid) => GenericCommand {
tag: CommandTag::BrightnessGrid,
data: CommandUnion {
brightness_grid: heap_move_nonnull(brightness_grid),
},
},
TypedCommand::BitVec(bitvec) => SPCommand {
TypedCommand::BitVec(bitvec) => GenericCommand {
tag: CommandTag::BitVec,
data: CommandUnion {
bitvec: heap_move_nonnull(bitvec),
bit_vec: heap_move_nonnull(bitvec),
},
},
TypedCommand::HardReset(hard_reset) => SPCommand {
TypedCommand::HardReset(hard_reset) => GenericCommand {
tag: CommandTag::HardReset,
data: CommandUnion {
hard_reset: heap_move_nonnull(hard_reset),
},
},
TypedCommand::FadeOut(fade_out) => SPCommand {
TypedCommand::FadeOut(fade_out) => GenericCommand {
tag: CommandTag::FadeOut,
data: CommandUnion {
fade_out: heap_move_nonnull(fade_out),
},
},
#[allow(deprecated)]
TypedCommand::BitmapLegacy(bitmap_legacy) => SPCommand {
TypedCommand::BitmapLegacy(bitmap_legacy) => GenericCommand {
tag: CommandTag::BitmapLegacy,
data: CommandUnion {
bitmap_legacy: heap_move_nonnull(bitmap_legacy),
},
},
})
.unwrap_or_else(move |_| SPCommand {
.unwrap_or_else(move |_| GenericCommand {
tag: CommandTag::Invalid,
data: CommandUnion { null: null_mut() },
})
}
};
);
/// Clones an [SPCommand] instance.
///
/// returns: a new [SPCommand] instance.
fn clone(command: SPCommand) -> SPCommand {
unsafe {
match command.tag {
CommandTag::Clear => SPCommand {
tag: CommandTag::Clear,
data: CommandUnion {
clear: heap_clone(command.data.clear),
},
},
CommandTag::CharGrid => SPCommand {
tag: CommandTag::CharGrid,
data: CommandUnion {
char_grid: heap_clone(command.data.char_grid),
},
},
CommandTag::Cp437Grid => SPCommand {
tag: CommandTag::Cp437Grid,
data: CommandUnion {
cp437_grid: heap_clone(command.data.cp437_grid),
},
},
CommandTag::Bitmap => SPCommand {
tag: CommandTag::Bitmap,
data: CommandUnion {
bitmap: heap_clone(command.data.bitmap),
},
},
CommandTag::GlobalBrightness => SPCommand {
tag: CommandTag::GlobalBrightness,
data: CommandUnion {
global_brightness: heap_clone(
command.data.global_brightness,
),
},
},
CommandTag::BrightnessGrid => SPCommand {
tag: CommandTag::BrightnessGrid,
data: CommandUnion {
brightness_grid: heap_clone(command.data.brightness_grid),
},
},
CommandTag::BitVec => SPCommand {
tag: CommandTag::BitVec,
data: CommandUnion {
bitvec: heap_clone(command.data.bitvec),
},
},
CommandTag::HardReset => SPCommand {
tag: CommandTag::HardReset,
data: CommandUnion {
hard_reset: heap_clone(command.data.hard_reset),
},
},
CommandTag::FadeOut => SPCommand {
tag: CommandTag::FadeOut,
data: CommandUnion {
fade_out: heap_clone(command.data.fade_out),
},
},
#[allow(deprecated)]
CommandTag::BitmapLegacy => SPCommand {
tag: CommandTag::BitmapLegacy,
data: CommandUnion {
bitmap_legacy: heap_clone(command.data.bitmap_legacy),
},
},
CommandTag::Invalid => SPCommand::INVALID,
}
}
}
/// Deallocates an [SPCommand].
///
/// Commands with an invalid `tag` do not have to be freed as the `data` pointer should be null.
///
/// # Examples
///
/// ```C
/// SPCommand c = sp_cmd_clear_into_generic(sp_cmd_clear_new());
/// sp_command_free(c);
/// ```
fn free(command: SPCommand) {
unsafe {
match command.tag {
CommandTag::Invalid => (),
CommandTag::Bitmap => heap_drop(command.data.bitmap),
CommandTag::BitVec => heap_drop(command.data.bitvec),
CommandTag::BrightnessGrid => {
heap_drop(command.data.brightness_grid)
}
CommandTag::CharGrid => heap_drop(command.data.char_grid),
CommandTag::Cp437Grid => heap_drop(command.data.cp437_grid),
CommandTag::GlobalBrightness => {
heap_drop(command.data.global_brightness)
}
CommandTag::Clear => heap_drop(command.data.clear),
CommandTag::HardReset => heap_drop(command.data.hard_reset),
CommandTag::FadeOut => heap_drop(command.data.fade_out),
CommandTag::BitmapLegacy => heap_drop(command.data.bitmap_legacy),
}
}
}
/// Tries to turn a [SPCommand] into a [Packet].
/// The [SPCommand] gets consumed.
wrap_methods! { GenericCommand;
/// Tries to turn a [GenericCommand] into a [Packet].
/// The [GenericCommand] gets consumed.
///
/// Returns tag [CommandTag::Invalid] in case of an error.
fn into_packet(
command: SPCommand,
) -> *mut Packet {
fn try_into_packet(move command) -> val *mut Packet {
match command.tag {
CommandTag::Invalid => null_mut(),
CommandTag::Bitmap => {
heap_move_ok(unsafe { heap_remove(command.data.bitmap).try_into() })
}
CommandTag::BitVec => {
heap_move_ok(unsafe { heap_remove(command.data.bitvec).try_into() })
heap_move_ok(unsafe { heap_remove(command.data.bit_vec).try_into() })
}
CommandTag::BrightnessGrid => heap_move_ok(unsafe {
heap_remove(command.data.brightness_grid).try_into()
@ -296,6 +289,5 @@ wrap_functions!(sp_cmd_generic;
heap_move(unsafe { heap_remove(command.data.bitmap_legacy).into() })
}
}
}
);
};
}

View file

@ -1,33 +1,21 @@
use crate::{
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
mem::{heap_move_nonnull, heap_remove},
commands::wrap_command,
macros::{wrap_fields, wrap_functions},
};
use servicepoint::{Brightness, GlobalBrightnessCommand, Packet};
use servicepoint::{Brightness, GlobalBrightnessCommand};
use std::ptr::NonNull;
wrap_functions!(sp_cmd_brightness_global;
wrap_functions!(associate GlobalBrightnessCommand;
/// Set the brightness of all tiles to the same value.
///
/// Returns: a new [GlobalBrightnessCommand] instance.
fn new(brightness: Brightness) -> NonNull<GlobalBrightnessCommand> {
heap_move_nonnull(GlobalBrightnessCommand::from(brightness))
}
/// Turns the command into a packet
fn into_packet(command: NonNull<GlobalBrightnessCommand>) -> NonNull<Packet> {
heap_move_nonnull(unsafe { heap_remove(command) }.into())
}
);
wrap_clone!(sp_cmd_brightness_global::GlobalBrightnessCommand);
wrap_free!(sp_cmd_brightness_global::GlobalBrightnessCommand);
wrap_fields!(
sp_cmd_brightness_global::GlobalBrightnessCommand;
prop brightness: Brightness {
get();
set(value);
fn new(brightness: val Brightness) -> move NonNull<GlobalBrightnessCommand> {
GlobalBrightnessCommand::from(brightness)
};
);
wrap_command!(GlobalBrightness);
wrap_fields!(GlobalBrightnessCommand;
prop brightness: Brightness { get; set; };
);

View file

@ -15,33 +15,76 @@ pub use cp437_grid_command::*;
pub use generic_command::*;
macro_rules! wrap_origin_accessors {
( $prefix:ident :: $object_type:ty ) => {
$crate::macros::wrap_functions!($prefix;
#[doc = concat!(" Reads the origin field of the [`", stringify!($object_type), "`].")]
fn get_origin(
command: NonNull<$object_type>,
origin_x: NonNull<usize>,
origin_y: NonNull<usize>,
) {
unsafe {
let origin = &command.as_ref().origin;
*origin_x.as_ptr() = origin.x;
*origin_y.as_ptr() = origin.y;
}
}
( $object_type:ident ) => {
::paste::paste! {
$crate::macros::wrap_methods!($object_type;
#[doc = " Reads the origin field of the [`" $object_type "`]."]
fn get_origin(
ref command,
origin_x: mut ::core::ptr::NonNull<usize>,
origin_y: mut ::core::ptr::NonNull<usize>
) {
let origin = command.origin;
*origin_x = origin.x;
*origin_y = origin.y;
};
#[doc = concat!(" Overwrites the origin field of the [`", stringify!($object_type), "`].")]
fn set_origin(
command: NonNull<$object_type>,
origin_x: usize,
origin_y: usize,
) {
unsafe {
$crate::macros::nonnull_as_mut!(command).origin = ::servicepoint::Origin::new(origin_x, origin_y);
}
}
);
#[doc = " Overwrites the origin field of the [`" $object_type "`]."]
fn set_origin(mut command, origin_x: val usize, origin_y: val usize) {
command.origin = ::servicepoint::Origin::new(origin_x, origin_y);
};
);
}
};
}
pub(crate) use wrap_origin_accessors;
macro_rules! derive_command_from {
($command:ident) => {
::paste::paste! {
impl From<::servicepoint::[< $command Command >]> for $crate::commands::GenericCommand {
fn from(command: ::servicepoint::[< $command Command >]) -> Self {
Self {
tag: $crate::commands::CommandTag::$command,
data: $crate::commands::CommandUnion {
[< $command:snake >]: $crate::mem::heap_move_nonnull(command)
},
}
}
}
}
};
}
macro_rules! derive_command_into_packet {
($command_type:ident) => {
::paste::paste! {
$crate::macros::wrap_method!($command_type;
#[doc = "Tries to turn a [`" $command_type "`] into a [Packet]."]
///
/// Returns: NULL or a [Packet] containing the command.
fn try_into_packet(move instance) -> move_ok *mut ::servicepoint::Packet {
instance.try_into()
};
);
}
}
}
macro_rules! wrap_command {
($command:ident, $object_type:ident) => {
$crate::macros::derive_clone!($object_type);
$crate::macros::derive_free!($object_type);
$crate::commands::derive_command_from!($command);
$crate::commands::derive_command_into_packet!($object_type);
};
($command:ident) => {
::paste::paste! {
$crate::commands::wrap_command!($command, [< $command Command >]);
}
};
}
pub(crate) use {
derive_command_from, derive_command_into_packet, wrap_command,
wrap_origin_accessors,
};

View file

@ -1,7 +1,6 @@
use crate::{
containers::ByteSlice,
macros::{wrap_clone, wrap_free, wrap_functions, wrap_methods},
mem::{heap_move_nonnull, heap_move_ok, heap_move_some, heap_remove},
containers::{wrap_grid, ByteSlice},
macros::{wrap_functions, wrap_methods},
};
use servicepoint::{
Bitmap, BitmapCommand, CompressionCode, DataRef, DisplayBitVec, Grid,
@ -9,11 +8,9 @@ use servicepoint::{
};
use std::ptr::NonNull;
wrap_clone!(sp_bitmap::Bitmap);
wrap_free!(sp_bitmap::Bitmap);
wrap_functions!(sp_bitmap;
wrap_grid!(Bitmap, bool);
wrap_functions!(associate Bitmap;
/// Creates a new [Bitmap] with the specified dimensions.
///
/// # Arguments
@ -37,16 +34,16 @@ wrap_functions!(sp_bitmap;
/// sp_bitmap_set(grid, 0, 0, false);
/// sp_bitmap_free(grid);
/// ```
fn new(width: usize, height: usize) -> *mut Bitmap {
heap_move_some(Bitmap::new(width, height))
}
fn new(width: val usize, height: val usize) -> move_some *mut Bitmap {
Bitmap::new(width, height)
};
/// Creates a new [Bitmap] with a size matching the screen.
///
/// returns: [Bitmap] initialized to all pixels off.
fn new_max_sized() -> NonNull<Bitmap> {
heap_move_nonnull(Bitmap::max_sized())
}
fn new_max_sized() -> move NonNull<Bitmap> {
Bitmap::max_sized()
};
/// Loads a [Bitmap] with the specified dimensions from the provided data.
///
@ -57,13 +54,12 @@ wrap_functions!(sp_bitmap;
///
/// returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
fn load(
width: usize,
height: usize,
data: ByteSlice,
) -> *mut Bitmap {
let data = unsafe { data.as_slice() };
heap_move_ok(Bitmap::load(width, height, data))
}
width: val usize,
height: val usize,
data: slice ByteSlice,
) -> move_ok *mut Bitmap {
Bitmap::load(width, height, data)
};
/// Tries to convert the BitVec to a Bitmap.
///
@ -71,84 +67,34 @@ wrap_functions!(sp_bitmap;
///
/// Returns NULL in case of error.
fn from_bitvec(
width: usize,
bitvec: NonNull<DisplayBitVec>,
) -> *mut Bitmap {
let bitvec = unsafe { heap_remove(bitvec) };
heap_move_ok(Bitmap::from_bitvec(width, bitvec))
}
width: val usize,
bitvec: move NonNull<DisplayBitVec>,
) -> move_ok *mut Bitmap {
Bitmap::from_bitvec(width, bitvec)
};
);
wrap_methods!(Bitmap;
/// Consumes the Bitmap and returns the contained BitVec.
fn into_bitvec(
bitmap: NonNull<Bitmap>
) -> NonNull<DisplayBitVec> {
let bitmap = unsafe { heap_remove(bitmap) };
heap_move_nonnull(bitmap.into())
}
fn into_bitvec(move bitmap) -> move NonNull<DisplayBitVec> {
bitmap.into()
};
/// Creates a [BitmapCommand] and immediately turns that into a [Packet].
///
/// The provided [Bitmap] gets consumed.
///
/// Returns NULL in case of an error.
fn into_packet(
bitmap: NonNull<Bitmap>,
x: usize,
y: usize,
compression: CompressionCode,
) -> *mut Packet {
let bitmap = unsafe { heap_remove(bitmap) };
heap_move_ok(Packet::try_from(BitmapCommand {
fn try_into_packet(move bitmap, x: val usize, y: val usize, compression: val CompressionCode) -> move_ok *mut Packet {
Packet::try_from(BitmapCommand {
bitmap,
origin: Origin::new(x, y),
compression,
}))
}
);
wrap_methods!(
sp_bitmap::Bitmap;
/// Gets the current value at the specified position.
///
/// # Arguments
///
/// - `x` and `y`: position of the cell to read
///
/// # Panics
///
/// - when accessing `x` or `y` out of bounds
ref fn get(x: usize, y: usize) -> bool;
/// Sets the value of the specified position.
///
/// # Arguments
///
/// - `x` and `y`: position of the cell
/// - `value`: the value to write to the cell
///
/// # Panics
///
/// - when accessing `x` or `y` out of bounds
mut fn set(x: usize, y: usize, value: bool);
/// Sets the state of all pixels in the [Bitmap].
///
/// # Arguments
///
/// - `value`: the value to set all pixels to
mut fn fill(value: bool);
/// Gets the width in pixels.
ref fn width() -> usize;
/// Gets the height in pixels.
ref fn height() -> usize;
})
};
/// Gets an unsafe reference to the data of the [Bitmap] instance.
///
/// The returned memory is valid for the lifetime of the bitmap.
mut fn data_ref_mut() -> ByteSlice {
return(slice) { unsafe { ByteSlice::from_slice(slice) } };
};
fn data_ref_mut(mut instance) -> slice ByteSlice;
);

Some files were not shown because too many files have changed in this diff Show more