Skip to content

Commit eae1d33

Browse files
abensoabenso
committed
refurbish ui
1 parent 1b5907d commit eae1d33

10 files changed

Lines changed: 466 additions & 175 deletions

File tree

‎app/src/parser.c‎

Lines changed: 35 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,7 @@
2626
#include "crypto.h"
2727
#include "parser_common.h"
2828
#include "parser_impl.h"
29+
#include "render.h"
2930
#include "ui_item_manager.h"
3031

3132
parser_error_t parser_init_context(parser_context_t *ctx, const uint8_t *buffer, uint16_t bufferSize) {
@@ -65,7 +66,7 @@ parser_error_t parser_validate(parser_tx_t *txObj) {
6566
}
6667

6768
parser_error_t parser_getNumItems(const parser_tx_t *txObj, uint8_t *num_items) {
68-
*num_items = txObj->ui_items.qty;
69+
*num_items = txObj->ui_items_new.qty;
6970
if (*num_items == 0) {
7071
return parser_unexpected_number_items;
7172
}
@@ -112,11 +113,12 @@ parser_error_t page_title(char *outKey, uint16_t outKeyLen, const char *inValue)
112113
return parser_ok;
113114
}
114115

115-
parser_error_t page_item(char *outValue, uint16_t outValueLen, const char *title, const char *data, uint8_t pageIdx,
116-
uint8_t *pageCount) {
116+
parser_error_t page_item(const parser_tx_t *txObj, char *outValue, uint16_t outValueLen, const char *title,
117+
primitive_t *primitive, parser_context_t *data_context, uint8_t pageIdx, uint8_t *pageCount) {
117118
CHECK_INPUT(outValue);
118119
CHECK_INPUT(title);
119-
CHECK_INPUT(data);
120+
CHECK_INPUT(primitive);
121+
CHECK_INPUT(data_context);
120122
CHECK_INPUT(pageCount);
121123

122124
MEMZERO(outValue, outValueLen);
@@ -127,30 +129,43 @@ parser_error_t page_item(char *outValue, uint16_t outValueLen, const char *title
127129
}
128130
outValueLen--;
129131

130-
uint16_t dataLen = strlen(data);
131-
if (dataLen == 0) {
132-
return parser_no_data;
133-
}
134-
135132
clear_item_title_buffer();
136133
init_item_title_buffer(title);
137134

138135
uint8_t items_qty = 0;
139136
CHECK_ERROR(get_title_item_qty(&items_qty))
140137

138+
char ui_buffer[200] = {0};
139+
uint8_t page_count_title = 0;
141140
if (items_qty > 1) {
142-
char title_str[200] = {0};
143-
CHECK_ERROR(create_item_title(0, items_qty - 1, title_str, sizeof(title_str)));
144-
strncat(title_str, ":", 1);
141+
CHECK_ERROR(create_item_title(0, items_qty - 1, ui_buffer, sizeof(ui_buffer)));
142+
strncat(ui_buffer, ":", 1);
143+
page_count_title = (uint8_t)(strlen(ui_buffer) / outValueLen);
144+
const uint16_t lastChunkLen_title = (strlen(ui_buffer) % outValueLen);
145+
if (lastChunkLen_title > 0) {
146+
page_count_title++;
147+
}
148+
}
145149

146-
pageString(outValue, outValueLen, title_str, pageIdx, pageCount);
150+
uint8_t page_count_content = 0;
151+
char ui_data_buffer[200] = {0};
152+
CHECK_ERROR(render_primitive(data_context, txObj, primitive, ui_data_buffer, sizeof(ui_data_buffer)));
153+
data_context->offset = 0;
154+
page_count_content = (uint8_t)(strlen(ui_data_buffer) / outValueLen);
155+
const uint16_t lastChunkLen_content = (strlen(ui_data_buffer) % outValueLen);
156+
if (lastChunkLen_content > 0) {
157+
page_count_content++;
147158
}
148159

149-
(*pageCount)++;
150-
if (pageIdx == *pageCount - 1) {
151-
strncat(outValue, data, dataLen);
160+
uint16_t aux = 0;
161+
if (pageIdx < page_count_title) {
162+
pageString(outValue, outValueLen, ui_buffer, pageIdx, &aux);
163+
} else {
164+
pageString(outValue, outValueLen, ui_data_buffer, pageIdx - page_count_title, &aux);
152165
}
153166

167+
*pageCount = page_count_title + page_count_content;
168+
154169
return parser_ok;
155170
}
156171

@@ -165,9 +180,10 @@ parser_error_t parser_getItem(const parser_tx_t *txObj, uint8_t displayIdx, char
165180
CHECK_ERROR(checkSanity(numItems, displayIdx))
166181
cleanOutput(outKey, outKeyLen, outVal, outValLen);
167182

168-
CHECK_ERROR(page_title(outKey, outKeyLen, txObj->ui_items.items[displayIdx].title))
169-
CHECK_ERROR(page_item(outVal, outValLen, txObj->ui_items.items[displayIdx].title, txObj->ui_items.items[displayIdx].data,
170-
pageIdx, pageCount))
183+
CHECK_ERROR(page_title(outKey, outKeyLen, txObj->ui_items_new.items[displayIdx].title))
184+
CHECK_ERROR(page_item(txObj, outVal, outValLen, txObj->ui_items_new.items[displayIdx].title,
185+
&txObj->ui_items_new.items[displayIdx].primitive,
186+
&txObj->ui_items_new.items[displayIdx].data_context, pageIdx, pageCount))
171187

172188
return parser_ok;
173189
}

‎app/src/parser_impl.c‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,10 +19,14 @@
1919
#include "borsh.h"
2020
#include "schema_display.h"
2121
#include "schema_reader.h"
22+
#include "stack_manager.h"
2223
#include "unsigned_transaction_reader.h"
2324
#include "zxerror.h"
2425

2526
parser_error_t _read(parser_context_t *c, parser_tx_t *v) {
27+
checkStack();
28+
ZEMU_LOGF(50, "ANDYYYYYY!\n")
29+
2630
CHECK_ERROR(schema_merkle_proofs_read(c, v));
2731
CHECK_ERROR(schema_extra_data_read(c, v));
2832
CHECK_ERROR(schema_parser_transaction(c, v));

‎app/src/render.c‎

Lines changed: 46 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -14,26 +14,24 @@
1414
* limitations under the License.
1515
********************************************************************************/
1616

17-
#include "schema_display.h"
18-
1917
#include "app_mode.h"
2018
#include "bech32.h"
2119
#include "borsh.h"
20+
#include "schema_display.h"
2221
#include "schema_helper.h"
2322
#include "schema_reader.h"
24-
#include "ui_item_manager.h"
2523
#include "ui_utils.h"
2624
#include "zxerror.h"
2725
#include "zxformat.h"
2826

29-
char item_data[MAX_STRING_LENGTH] = {0};
30-
3127
#define NONE_STRING "None"
3228

33-
parser_error_t find_name_registry(parser_tx_t *txObj, bytes_t *name, bytes_t *input_token) {
29+
parser_error_t find_name_registry(parser_tx_t *txObj, bytes_t *name, bytes_t *input_token, char *outValue,
30+
uint16_t outValueLen) {
3431
CHECK_INPUT(txObj);
3532
CHECK_INPUT(name);
3633
CHECK_INPUT(input_token);
34+
CHECK_INPUT(outValue);
3735

3836
name_registries_t registries = txObj->schema.chain_data.name_registries;
3937
for (uint32_t i = 0; i < registries.qty; i++) {
@@ -45,9 +43,8 @@ parser_error_t find_name_registry(parser_tx_t *txObj, bytes_t *name, bytes_t *in
4543
CHECK_ERROR(read_registry(&name_registry.registry, &registry));
4644
if (registry.data.len == input_token->len &&
4745
MEMCMP(registry.data.ptr, input_token->ptr, input_token->len) == 0) {
48-
MEMZERO(item_data, sizeof(item_data));
49-
MEMCPY(item_data, registry.name.ptr, registry.name.len);
50-
append_item_data(item_data, registry.name.len);
46+
MEMZERO(outValue, outValueLen);
47+
MEMCPY(outValue, registry.name.ptr, registry.name.len);
5148
return parser_ok;
5249
}
5350
}
@@ -57,10 +54,10 @@ parser_error_t find_name_registry(parser_tx_t *txObj, bytes_t *name, bytes_t *in
5754
return parser_name_registry_not_found;
5855
}
5956

60-
parser_error_t render_fixed_point(parser_context_t *ctx, parser_tx_t *txObj, fixed_point_display_t display,
61-
uint128_t value) {
57+
parser_error_t render_fixed_point(parser_context_t *ctx, fixed_point_display_t display, uint128_t value, char *outValue,
58+
uint16_t outValueLen) {
6259
CHECK_INPUT(ctx);
63-
CHECK_INPUT(txObj);
60+
CHECK_INPUT(outValue);
6461

6562
switch (display.type) {
6663
case FIXED_POINT_DISPLAY_DECIMALS:
@@ -74,90 +71,100 @@ parser_error_t render_fixed_point(parser_context_t *ctx, parser_tx_t *txObj, fix
7471
}
7572
uint8_t offset = ctx->buffer.ptr[ctx->offset + display.from_sibling_field.byte_offset];
7673

77-
MEMZERO(item_data, sizeof(item_data));
78-
CHECK_ERROR(render_number(value.hi, value.lo, offset, "", "", item_data, sizeof(item_data)));
79-
append_item_data(item_data, strlen(item_data));
74+
MEMZERO(outValue, outValueLen);
75+
CHECK_ERROR(render_number(value.hi, value.lo, offset, "", "", outValue, outValueLen));
8076

8177
return parser_ok;
8278
default:
8379
return parser_unexpected_type;
8480
}
8581
}
8682

87-
parser_error_t render_primitive_integer(parser_context_t *ctx, parser_tx_t *txObj, integer_display_t display,
88-
uint128_t value) {
83+
parser_error_t render_primitive_integer(parser_context_t *ctx, integer_display_t display, uint128_t value, char *outValue,
84+
uint16_t outValueLen) {
8985
CHECK_INPUT(ctx);
90-
CHECK_INPUT(txObj);
86+
CHECK_INPUT(outValue);
9187

9288
switch (display.type) {
9389
case INTEGER_DISPLAY_HEX:
9490
// TODO: Implement me
9591
print_string("render_primitive_integer IMPLEMENT ME 0");
9692
return parser_unexpected_type;
9793
case INTEGER_DISPLAY_DECIMAL:
98-
MEMZERO(item_data, sizeof(item_data));
99-
CHECK_ERROR(render_number(value.hi, value.lo, 0, "", "", item_data, sizeof(item_data)));
100-
append_item_data(item_data, strlen(item_data));
94+
MEMZERO(outValue, outValueLen);
95+
print_u8("INTEGER_DISPLAY_DECIMAL: ", display.type);
96+
CHECK_ERROR(render_number(value.hi, value.lo, 0, "", "", outValue, outValueLen));
10197
break;
10298
case INTEGER_DISPLAY_FIXED_POINT:
103-
CHECK_ERROR(render_fixed_point(ctx, txObj, display.fixed_point, value));
99+
print_u8("INTEGER_DISPLAY_FIXED_POINT: ", display.type);
100+
CHECK_ERROR(render_fixed_point(ctx, display.fixed_point, value, outValue, outValueLen));
104101
break;
105102
default:
106103
return parser_unexpected_type;
107104
}
108105

106+
print_u8("render_primitive_integer finished: ", display.type);
107+
109108
return parser_ok;
110109
}
111110

112-
parser_error_t render_integer(parser_context_t *ctx, parser_tx_t *txObj, primitive_integer_t *primitive) {
111+
parser_error_t render_integer(parser_context_t *ctx, primitive_integer_t *primitive, char *outValue, uint16_t outValueLen) {
113112
CHECK_INPUT(ctx);
114-
CHECK_INPUT(txObj);
115113
CHECK_INPUT(primitive);
116114

117115
uint128_t value = {0};
118116
switch (primitive->type) {
119117
case INTEGER_I8:
120118
case INTEGER_U8: {
119+
print_u8("INTEGER_U8: ", primitive->type);
121120
uint8_t *ptr = (uint8_t *)&value;
122121
CHECK_ERROR(read_u8(ctx, ptr));
123122
break;
124123
}
125124
case INTEGER_I16:
126125
case INTEGER_U16: {
126+
print_u8("INTEGER_U16: ", primitive->type);
127127
uint16_t *ptr = (uint16_t *)&value;
128128
CHECK_ERROR(read_u16(ctx, ptr));
129129
break;
130130
}
131131
case INTEGER_I32:
132132
case INTEGER_U32: {
133+
print_u8("INTEGER_U32: ", primitive->type);
133134
uint32_t *ptr = (uint32_t *)&value;
134135
CHECK_ERROR(read_u32(ctx, ptr));
135136
break;
136137
}
137138
case INTEGER_I64:
138139
case INTEGER_U64: {
140+
print_u8("INTEGER_U64: ", primitive->type);
139141
CHECK_ERROR(read_u64(ctx, &value.lo));
140142
break;
141143
}
142144
case INTEGER_I128:
143145
case INTEGER_U128: {
146+
print_u8("INTEGER_U128_1: ", primitive->type);
147+
print_buffer(&ctx->buffer, "INTEGER_U128 buffer!!!!!!!!!!!!!!");
144148
CHECK_ERROR(read_u64(ctx, &value.lo));
149+
print_u8("INTEGER_U128_2: ", primitive->type);
145150
CHECK_ERROR(read_u64(ctx, &value.hi));
146151
break;
147152
}
148153
default:
149154
return parser_unexpected_type;
150155
}
151156

152-
CHECK_ERROR(render_primitive_integer(ctx, txObj, primitive->display, value));
157+
CHECK_ERROR(render_primitive_integer(ctx, primitive->display, value, outValue, outValueLen));
153158

154159
return parser_ok;
155160
}
156161

157-
parser_error_t render_byte_array(parser_context_t *ctx, parser_tx_t *txObj, primitive_byte_array_t *byte_array) {
162+
parser_error_t render_byte_array(parser_context_t *ctx, parser_tx_t *txObj, primitive_byte_array_t *byte_array,
163+
char *outValue, uint16_t outValueLen) {
158164
CHECK_INPUT(ctx);
159165
CHECK_INPUT(txObj);
160166
CHECK_INPUT(byte_array);
167+
CHECK_INPUT(outValue);
161168

162169
bytes_t array = {0};
163170
array.len = byte_array->len;
@@ -166,7 +173,7 @@ parser_error_t render_byte_array(parser_context_t *ctx, parser_tx_t *txObj, prim
166173

167174
if (byte_array->has_name_registry) {
168175
// check if name registry exist
169-
CHECK_ERROR(find_name_registry(txObj, &byte_array->name_registry, &array));
176+
CHECK_ERROR(find_name_registry(txObj, &byte_array->name_registry, &array, outValue, outValueLen));
170177
return parser_ok;
171178
}
172179

@@ -189,10 +196,9 @@ parser_error_t render_byte_array(parser_context_t *ctx, parser_tx_t *txObj, prim
189196
return parser_unexpected_type;
190197
case BYTE_DISPLAY_BECH32M: {
191198
const char *hrp = (char *)byte_array->display.bech32m.prefix.prefix.ptr;
192-
MEMZERO(item_data, sizeof(item_data));
199+
MEMZERO(outValue, outValueLen);
193200
MAP_ZXERR_TO_PARSER_ERR(
194-
bech32EncodeFromBytes(item_data, sizeof(item_data), hrp, array.ptr, array.len, 1, BECH32_ENCODING_BECH32M));
195-
append_item_data(item_data, strlen(item_data));
201+
bech32EncodeFromBytes(outValue, outValueLen, hrp, array.ptr, array.len, 1, BECH32_ENCODING_BECH32M));
196202
break;
197203
}
198204
case BYTE_DISPLAY_BASE58:
@@ -206,25 +212,25 @@ parser_error_t render_byte_array(parser_context_t *ctx, parser_tx_t *txObj, prim
206212
return parser_ok;
207213
}
208214

209-
parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primitive_t *primitive) {
215+
parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primitive_t *primitive, char *outValue,
216+
uint16_t outValueLen) {
210217
CHECK_INPUT(ctx);
211218
CHECK_INPUT(txObj);
219+
CHECK_INPUT(outValue);
212220

213221
uint16_t primitive_size = sizeof(primitive);
214222
print_u16("Primitive size: ", primitive_size);
215223

216-
set_primitive(primitive);
217-
218224
switch (primitive->type) {
219225
case PRIMITIVE_INTEGER:
220226
primitive_size = sizeof(primitive->integer);
221-
print_u16("Primitive size integer: ", primitive_size);
222-
CHECK_ERROR(render_integer(ctx, txObj, &primitive->integer));
227+
print_u16("Primitive size integer_1: ", primitive_size);
228+
CHECK_ERROR(render_integer(ctx, &primitive->integer, outValue, outValueLen));
223229
break;
224230
case PRIMITIVE_BYTE_ARRAY:
225231
primitive_size = sizeof(primitive->byte_array);
226232
print_u16("Primitive size byte_array: ", primitive_size);
227-
CHECK_ERROR(render_byte_array(ctx, txObj, &primitive->byte_array));
233+
CHECK_ERROR(render_byte_array(ctx, txObj, &primitive->byte_array, outValue, outValueLen));
228234
break;
229235
case PRIMITIVE_BYTE_VEC:
230236
// TODO: Implement me
@@ -239,9 +245,8 @@ parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primi
239245
print_string("render_primitive IMPLEMENT ME 2");
240246
return parser_unexpected_type;
241247
case PRIMITIVE_STRING:
242-
// TODO: Implement me
243-
print_string("render_primitive IMPLEMENT ME 3");
244-
return parser_unexpected_type;
248+
MEMCPY(outValue, ctx->buffer.ptr, ctx->buffer.len);
249+
break;
245250
case PRIMITIVE_BOOLEAN:
246251
// TODO: Implement me
247252
print_string("render_primitive IMPLEMENT ME 4");
@@ -251,5 +256,7 @@ parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primi
251256
return parser_unexpected_type;
252257
}
253258

259+
print_u8("render_primitive finished: ", primitive->type);
260+
254261
return parser_ok;
255262
}

‎app/src/render.h‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,8 @@ extern "C" {
2222

2323
#include "parser_common.h"
2424

25-
parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primitive_t *primitive);
25+
parser_error_t render_primitive(parser_context_t *ctx, parser_tx_t *txObj, primitive_t *primitive, char *outValue,
26+
uint16_t outValueLen);
2627

2728
#ifdef __cplusplus
2829
}

0 commit comments

Comments
 (0)