skin_parser: simplify skin_buffer_alloc · tsiry-sandratraina.com/rockbox-zig@675f171

+121 -143

1 changed file

expand all

apps

gui

skin_engine

skin_parser.c

+121 -143

apps/gui/skin_engine/skin_parser.c

··· 191 191 break; 192 192 #endif 193 193 } 194 - 194 + 195 195 while (list.linkedlist) 196 196 { 197 197 bool skip = false; ··· 209 209 itemlabel = VP_DEFAULT_LABEL_STRING; 210 210 else 211 211 itemlabel = SKINOFFSETTOPTR(skin_buffer, ((struct skin_viewport *)ret)->label); 212 - skip = !(((struct skin_viewport *)ret)->is_infovp == 212 + skip = !(((struct skin_viewport *)ret)->is_infovp == 213 213 (what==SKIN_FIND_UIVP)); 214 214 break; 215 215 #ifdef HAVE_LCD_BITMAP ··· 230 230 itemlabel = SKINOFFSETTOPTR(skin_buffer, ((struct skin_var *)ret)->label); 231 231 break; 232 232 #endif 233 - 233 + 234 234 } 235 235 if (!skip && itemlabel && !strcmp(itemlabel, label)) 236 236 { ··· 238 238 skin_buffer = old_skin_buffer; 239 239 return ret; 240 240 } 241 - 241 + 242 242 if (isvplist) 243 243 list.vplist = SKINOFFSETTOPTR(skin_buffer, list.vplist->next); 244 244 else ··· 259 259 static struct skin_token_list *new_skin_token_list_item(struct wps_token *token, 260 260 void* token_data) 261 261 { 262 - struct skin_token_list *llitem = 263 - (struct skin_token_list *)skin_buffer_alloc(sizeof(struct skin_token_list)); 262 + struct skin_token_list *llitem = skin_buffer_alloc(sizeof(*llitem)); 264 263 if (!token) 265 - token = (struct wps_token*)skin_buffer_alloc(sizeof(struct wps_token)); 264 + token = skin_buffer_alloc(sizeof(*token)); 266 265 if (!llitem || !token) 267 266 return NULL; 268 267 llitem->next = PTRTOSKINOFFSET(skin_buffer, NULL); ··· 308 307 } 309 308 return 0; 310 309 } 311 - 310 + 312 311 static int get_image_id(int c) 313 312 { 314 313 if(c >= 'a' && c <= 'z') ··· 323 322 char *buf, int buf_size) 324 323 { 325 324 snprintf(buf, buf_size, "%s/%s", bmpdir, start); 326 - 325 + 327 326 return buf; 328 327 } 329 328 ··· 335 334 char sublabel = '\0'; 336 335 int subimage; 337 336 struct gui_img *img; 338 - struct image_display *id = skin_buffer_alloc(sizeof(struct image_display)); 337 + struct image_display *id = skin_buffer_alloc(sizeof(*id)); 339 338 340 339 if (element->params_count == 1 && strlen(label) <= 2) 341 340 { ··· 356 355 { 357 356 token->type = SKIN_TOKEN_IMAGE_DISPLAY_LISTICON; 358 357 } 359 - 358 + 360 359 if (element->params_count > 1) 361 360 { 362 361 if (get_param(element, 1)->type == CODE) ··· 418 417 /* Invalid image ID */ 419 418 return WPS_ERROR_INVALID_PARAM; 420 419 } 421 - img = (struct gui_img*)skin_buffer_alloc(sizeof(struct gui_img)); 420 + img = skin_buffer_alloc(sizeof(*img)); 422 421 if (!img) 423 422 return WPS_ERROR_INVALID_PARAM; 424 423 /* save a pointer to the filename */ ··· 442 441 img->num_subimages = Icon_Last_Themeable; 443 442 img->using_preloaded_icons = true; 444 443 } 445 - 446 - struct skin_token_list *item = 447 - (struct skin_token_list *)new_skin_token_list_item(NULL, img); 444 + 445 + struct skin_token_list *item = new_skin_token_list_item(NULL, img); 448 446 if (!item) 449 447 return WPS_ERROR_INVALID_PARAM; 450 448 add_to_ll_chain(&wps_data->images, item); ··· 466 464 char *filename = get_param_text(element, 1); 467 465 int glyphs; 468 466 char *ptr; 469 - 467 + 470 468 if(element->params_count > 2) 471 469 glyphs = get_param(element, 2)->data.number; 472 470 else 473 471 glyphs = global_settings.glyphs_to_cache; 474 472 if (id < 2) 475 473 { 476 - DEBUGF("font id must be >= 2\n"); 474 + DEBUGF("font id must be >= 2 (%d)\n", id); 477 475 return 1; 478 476 } 479 477 #if defined(DEBUG) || defined(SIMULATOR) ··· 482 480 DEBUGF("font id %d already being used\n", id); 483 481 } 484 482 #endif 485 - /* make sure the filename contains .fnt, 483 + /* make sure the filename contains .fnt, 486 484 * we dont actually use it, but require it anyway */ 487 485 ptr = strchr(filename, '.'); 488 486 if (!ptr || strncmp(ptr, ".fnt", 4)) ··· 502 500 struct wps_data *wps_data) 503 501 { 504 502 (void)wps_data; 505 - struct playlistviewer *viewer = 506 - (struct playlistviewer *)skin_buffer_alloc(sizeof(struct playlistviewer)); 503 + struct playlistviewer *viewer = skin_buffer_alloc(sizeof(*viewer)); 507 504 if (!viewer) 508 505 return WPS_ERROR_INVALID_PARAM; 509 506 viewer->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp); 510 507 viewer->show_icons = true; 511 508 viewer->start_offset = get_param(element, 0)->data.number; 512 509 viewer->line = PTRTOSKINOFFSET(skin_buffer, get_param_code(element, 1)); 513 - 510 + 514 511 token->value.data = PTRTOSKINOFFSET(skin_buffer, (void*)viewer); 515 - 512 + 516 513 return 0; 517 514 } 518 515 #endif ··· 525 522 struct gradient_config *cfg; 526 523 if (element->params_count < 2) /* only start and end are required */ 527 524 return 1; 528 - cfg = (struct gradient_config *)skin_buffer_alloc(sizeof(struct gradient_config)); 525 + cfg = skin_buffer_alloc(sizeof(*cfg)); 529 526 if (!cfg) 530 527 return 1; 531 528 if (!parse_color(curr_screen, get_param_text(element, 0), &cfg->start) || ··· 542 539 } 543 540 544 541 token->value.data = PTRTOSKINOFFSET(skin_buffer, cfg); 545 - return 0; 542 + return 0; 546 543 } 547 544 #endif 548 545 ··· 551 548 struct wps_data *wps_data) 552 549 { 553 550 (void)wps_data; 554 - struct listitem *li = (struct listitem *)skin_buffer_alloc(sizeof(struct listitem)); 551 + struct listitem *li = skin_buffer_alloc(sizeof(*li)); 555 552 if (!li) 556 553 return 1; 557 554 token->value.data = PTRTOSKINOFFSET(skin_buffer, li); ··· 573 570 struct wps_data *wps_data) 574 571 { 575 572 #ifndef __PCTOOL__ 576 - struct listitem_viewport_cfg *cfg = 577 - (struct listitem_viewport_cfg *)skin_buffer_alloc( 578 - sizeof(struct listitem_viewport_cfg)); 573 + struct listitem_viewport_cfg *cfg = skin_buffer_alloc(sizeof(*cfg)); 579 574 if (!cfg) 580 575 return -1; 581 576 cfg->data = wps_data; ··· 604 599 int style; 605 600 char *mode = get_param_text(element, 0); 606 601 unsigned colour; 607 - 602 + 608 603 if (!strcmp(mode, "invert")) 609 604 { 610 605 style = STYLE_INVERT; ··· 614 609 if (element->params_count < 2 || 615 610 !parse_color(curr_screen, get_param_text(element, 1), &colour)) 616 611 return 1; 617 - style = STYLE_COLORED|(STYLE_COLOR_MASK&colour); 612 + style = STYLE_COLORED|(STYLE_COLOR_MASK&colour); 618 613 } 619 614 #ifdef HAVE_LCD_COLOR 620 615 else if (!strcmp(mode, "gradient")) ··· 644 639 struct wps_data *wps_data) 645 640 { 646 641 (void)wps_data; 647 - struct draw_rectangle *rect = 648 - (struct draw_rectangle *)skin_buffer_alloc(sizeof(struct draw_rectangle)); 642 + struct draw_rectangle *rect = skin_buffer_alloc(sizeof(*rect)); 649 643 650 644 if (!rect) 651 645 return -1; ··· 657 651 rect->width = curr_vp->vp.width - rect->x; 658 652 else 659 653 rect->width = get_param(element, 2)->data.number; 660 - 654 + 661 655 if (isdefault(get_param(element, 3))) 662 656 rect->height = curr_vp->vp.height - rect->y; 663 657 else ··· 683 677 684 678 return 0; 685 679 } 686 - 680 + 687 681 static int parse_viewportcolour(struct skin_element *element, 688 682 struct wps_token *token, 689 683 struct wps_data *wps_data) 690 684 { 691 685 (void)wps_data; 692 686 struct skin_tag_parameter *param = get_param(element, 0); 693 - struct viewport_colour *colour = 694 - (struct viewport_colour *)skin_buffer_alloc(sizeof(struct viewport_colour)); 687 + struct viewport_colour *colour = skin_buffer_alloc(sizeof(*colour)); 695 688 if (!colour) 696 689 return -1; 697 690 if (isdefault(param)) ··· 761 754 { 762 755 /* NOTE: both the string validations that happen in here will 763 756 * automatically PASS on checkwps because its too hard to get 764 - * settings_list.c and english.lang built for it. 765 - * If that ever changes remove the #ifndef __PCTOOL__'s here 757 + * settings_list.c and english.lang built for it. 758 + * If that ever changes remove the #ifndef __PCTOOL__'s here 766 759 */ 767 760 (void)wps_data; 768 761 char *temp = get_param_text(element, 0); 769 762 int i; 770 - 763 + 771 764 if (token->type == SKIN_TOKEN_TRANSLATEDSTRING) 772 765 { 773 766 #ifndef __PCTOOL__ ··· 803 796 { 804 797 (void)wps_data; 805 798 char *op = get_param_text(element, 1); 806 - struct logical_if *lif = skin_buffer_alloc(sizeof(struct logical_if)); 799 + struct logical_if *lif = skin_buffer_alloc(sizeof(*lif)); 807 800 if (!lif) 808 801 return -1; 809 802 token->value.data = PTRTOSKINOFFSET(skin_buffer, lif); 810 803 lif->token = get_param_code(element, 0)->data; 811 - 804 + 812 805 if (!strncmp(op, "=", 1)) 813 806 lif->op = IF_EQUALS; 814 807 else if (!strncmp(op, "!=", 2)) ··· 821 814 lif->op = IF_GREATERTHAN; 822 815 else if (!strncmp(op, "<", 1)) 823 816 lif->op = IF_LESSTHAN; 824 - 817 + 825 818 memcpy(&lif->operand, get_param(element, 2), sizeof(lif->operand)); 826 819 if (element->params_count > 3) 827 820 lif->num_options = get_param(element, 3)->data.number; 828 821 else 829 822 lif->num_options = TOKEN_VALUE_ONLY; 830 823 return 0; 831 - 824 + 832 825 } 833 826 834 827 static int parse_timeout_tag(struct skin_element *element, ··· 863 856 struct wps_data *wps_data) 864 857 { 865 858 (void)wps_data; 866 - struct substring *ss = (struct substring*)skin_buffer_alloc(sizeof(struct substring)); 859 + struct substring *ss = skin_buffer_alloc(sizeof(*ss)); 867 860 if (!ss) 868 861 return 1; 869 862 ss->start = get_param(element, 0)->data.number; ··· 890 883 struct skin_tag_parameter *param = get_param(element, 0); 891 884 int curr_param = 0; 892 885 char *image_filename = NULL; 893 - 894 - if (element->params_count == 0 && 886 + 887 + if (element->params_count == 0 && 895 888 element->tag->type != SKIN_TOKEN_PROGRESSBAR) 896 889 return 0; /* nothing to do */ 897 - pb = (struct progressbar*)skin_buffer_alloc(sizeof(struct progressbar)); 898 - 890 + pb = skin_buffer_alloc(sizeof(*pb)); 891 + 899 892 token->value.data = PTRTOSKINOFFSET(skin_buffer, pb); 900 - 893 + 901 894 if (!pb) 902 895 return WPS_ERROR_INVALID_PARAM; 903 896 pb->vp = PTRTOSKINOFFSET(skin_buffer, vp); ··· 909 902 pb->backdrop = PTRTOSKINOFFSET(skin_buffer, NULL); 910 903 pb->invert_fill_direction = false; 911 904 pb->horizontal = true; 912 - 905 + 913 906 if (element->params_count == 0) 914 907 { 915 908 pb->x = 0; ··· 919 912 pb->type = element->tag->type; 920 913 return 0; 921 914 } 922 - 915 + 923 916 /* (x, y, width, height, ...) */ 924 917 if (!isdefault(param)) 925 918 pb->x = param->data.number; 926 919 else 927 920 pb->x = 0; 928 921 param++; 929 - 922 + 930 923 if (!isdefault(param)) 931 924 pb->y = param->data.number; 932 925 else 933 926 pb->y = -1; /* computed at rendering */ 934 927 param++; 935 - 928 + 936 929 if (!isdefault(param)) 937 930 pb->width = param->data.number; 938 931 else 939 932 pb->width = vp->width - pb->x; 940 933 param++; 941 - 934 + 942 935 if (!isdefault(param)) 943 936 { 944 937 /* A zero height makes no sense - reject it */ ··· 961 954 } 962 955 } 963 956 /* optional params, first is the image filename if it isnt recognised as a keyword */ 964 - 957 + 965 958 curr_param = 4; 966 959 if (isdefault(get_param(element, curr_param))) 967 960 { ··· 1012 1005 curr_param++; 1013 1006 param++; 1014 1007 text = SKINOFFSETTOPTR(skin_buffer, param->data.text); 1015 - pb->backdrop = PTRTOSKINOFFSET(skin_buffer, 1008 + pb->backdrop = PTRTOSKINOFFSET(skin_buffer, 1016 1009 skin_find_item(text, SKIN_FIND_IMAGE, wps_data)); 1017 - 1010 + 1018 1011 } 1019 1012 else /* option needs the next param */ 1020 1013 return -1; ··· 1029 1022 pb->horizontal = true; 1030 1023 else if (curr_param == 4) 1031 1024 image_filename = text; 1032 - 1025 + 1033 1026 curr_param++; 1034 1027 } 1035 1028 1036 1029 if (image_filename) 1037 1030 { 1038 - pb->image = PTRTOSKINOFFSET(skin_buffer, 1031 + pb->image = PTRTOSKINOFFSET(skin_buffer, 1039 1032 skin_find_item(image_filename, SKIN_FIND_IMAGE, wps_data)); 1040 1033 if (!SKINOFFSETTOPTR(skin_buffer, pb->image)) /* load later */ 1041 - { 1042 - struct gui_img* img = (struct gui_img*)skin_buffer_alloc(sizeof(struct gui_img)); 1034 + { 1035 + struct gui_img *img = skin_buffer_alloc(sizeof(*img)); 1043 1036 if (!img) 1044 1037 return WPS_ERROR_INVALID_PARAM; 1045 1038 /* save a pointer to the filename */ ··· 1052 1045 img->using_preloaded_icons = false; 1053 1046 img->buflib_handle = -1; 1054 1047 img->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp); 1055 - struct skin_token_list *item = 1056 - (struct skin_token_list *)new_skin_token_list_item(NULL, img); 1048 + struct skin_token_list *item = new_skin_token_list_item(NULL, img); 1057 1049 if (!item) 1058 1050 return WPS_ERROR_INVALID_PARAM; 1059 1051 add_to_ll_chain(&wps_data->images, item); 1060 1052 pb->image = PTRTOSKINOFFSET(skin_buffer, img); 1061 1053 } 1062 - } 1063 - 1054 + } 1055 + 1064 1056 if (token->type == SKIN_TOKEN_VOLUME) 1065 1057 token->type = SKIN_TOKEN_VOLUMEBAR; 1066 1058 else if (token->type == SKIN_TOKEN_BATTERY_PERCENT) ··· 1074 1066 else if (token->type == SKIN_TOKEN_LIST_NEEDS_SCROLLBAR) 1075 1067 token->type = SKIN_TOKEN_LIST_SCROLLBAR; 1076 1068 pb->type = token->type; 1077 - 1069 + 1078 1070 return 0; 1079 - 1071 + 1080 1072 #else 1081 1073 (void)element; 1082 1074 if (token->type == SKIN_TOKEN_PROGRESSBAR || 1083 1075 token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR) 1084 1076 { 1085 - wps_data->full_line_progressbar = 1077 + wps_data->full_line_progressbar = 1086 1078 token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR; 1087 1079 } 1088 1080 return 0; ··· 1098 1090 struct dim dimensions; 1099 1091 int albumart_slot; 1100 1092 bool swap_for_rtl = lang_is_rtl() && follow_lang_direction; 1101 - struct skin_albumart *aa = 1102 - (struct skin_albumart *)skin_buffer_alloc(sizeof(struct skin_albumart)); 1093 + struct skin_albumart *aa = skin_buffer_alloc(sizeof(*aa)); 1103 1094 (void)token; /* silence warning */ 1104 1095 if (!aa) 1105 1096 return -1; ··· 1114 1105 aa->y = get_param(element, 1)->data.number; 1115 1106 aa->width = get_param(element, 2)->data.number; 1116 1107 aa->height = get_param(element, 3)->data.number; 1117 - 1108 + 1118 1109 aa->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp); 1119 1110 aa->draw_handle = -1; 1120 1111 ··· 1142 1133 1143 1134 if (0 <= albumart_slot) 1144 1135 wps_data->playback_aa_slot = albumart_slot; 1145 - 1136 + 1146 1137 if (element->params_count > 4 && !isdefault(get_param(element, 4))) 1147 1138 { 1148 1139 switch (*get_param_text(element, 4)) ··· 1194 1185 struct wps_data *data) 1195 1186 { 1196 1187 struct skin_var* ret = skin_find_item(label, SKIN_VARIABLE, data); 1188 + if (ret) 1189 + return ret; 1190 + 1191 + ret = skin_buffer_alloc(sizeof(*ret)); 1197 1192 if (!ret) 1198 - { 1199 - ret = (struct skin_var*)skin_buffer_alloc(sizeof(struct skin_var)); 1200 - if (!ret) 1201 - return NULL; 1202 - ret->label = PTRTOSKINOFFSET(skin_buffer, label); 1203 - ret->value = 1; 1204 - ret->last_changed = 0xffff; 1205 - struct skin_token_list *item = new_skin_token_list_item(NULL, ret); 1206 - if (!item) 1207 - return NULL; 1208 - add_to_ll_chain(&data->skinvars, item); 1209 - } 1193 + return ret; 1194 + ret->label = PTRTOSKINOFFSET(skin_buffer, label); 1195 + ret->value = 1; 1196 + ret->last_changed = 0xffff; 1197 + struct skin_token_list *item = new_skin_token_list_item(NULL, ret); 1198 + if (!item) 1199 + return NULL; 1200 + add_to_ll_chain(&data->skinvars, item); 1210 1201 return ret; 1211 1202 } 1212 1203 static int parse_skinvar( struct skin_element *element, ··· 1221 1212 { 1222 1213 case SKIN_TOKEN_VAR_GETVAL: 1223 1214 token->value.data = PTRTOSKINOFFSET(skin_buffer, var); 1224 - break; 1215 + return 0; 1225 1216 case SKIN_TOKEN_VAR_SET: 1226 1217 { 1227 - struct skin_var_changer *data = 1228 - (struct skin_var_changer*)skin_buffer_alloc( 1229 - sizeof(struct skin_var_changer)); 1218 + struct skin_var_changer *data = skin_buffer_alloc(sizeof(*data)); 1230 1219 if (!data) 1231 1220 return WPS_ERROR_INVALID_PARAM; 1232 1221 data->var = PTRTOSKINOFFSET(skin_buffer, var); ··· 1255 1244 data->max = get_param(element, 3)->data.number; 1256 1245 token->value.data = PTRTOSKINOFFSET(skin_buffer, data); 1257 1246 } 1258 - break; 1247 + return 0; 1259 1248 case SKIN_TOKEN_VAR_TIMEOUT: 1260 1249 { 1261 - struct skin_var_lastchange *data = 1262 - (struct skin_var_lastchange*)skin_buffer_alloc( 1263 - sizeof(struct skin_var_lastchange)); 1250 + struct skin_var_lastchange *data = skin_buffer_alloc(sizeof(*data)); 1264 1251 if (!data) 1265 1252 return WPS_ERROR_INVALID_PARAM; 1266 1253 data->var = PTRTOSKINOFFSET(skin_buffer, var); ··· 1270 1257 data->timeout *= TIMEOUT_UNIT; 1271 1258 token->value.data = PTRTOSKINOFFSET(skin_buffer, data); 1272 1259 } 1273 - break; 1274 - default: /* kill the warning */ 1275 - break; 1260 + default: 1261 + return 0; 1276 1262 } 1277 - return 0; 1278 1263 } 1279 1264 #endif /* HAVE_SKIN_VARIABLES */ 1280 1265 #ifdef HAVE_TOUCHSCREEN ··· 1282 1267 struct wps_token *token, 1283 1268 struct wps_data *wps_data) 1284 1269 { 1285 - struct touchregion_lastpress *data = 1286 - (struct touchregion_lastpress*)skin_buffer_alloc( 1287 - sizeof(struct touchregion_lastpress)); 1270 + struct touchregion_lastpress *data = skin_buffer_alloc(sizeof(*data)); 1288 1271 int i; 1289 1272 struct touchregion *region = NULL; 1290 1273 if (!data) 1291 1274 return WPS_ERROR_INVALID_PARAM; 1292 - 1275 + 1293 1276 data->timeout = 10; 1294 - 1277 + 1295 1278 for (i=0; i<element->params_count; i++) 1296 1279 { 1297 1280 if (get_param(element, i)->type == STRING) ··· 1316 1299 {"hotkey", ACTION_STD_HOTKEY}, {"select", ACTION_STD_OK }, 1317 1300 {"menu", ACTION_STD_MENU }, {"cancel", ACTION_STD_CANCEL }, 1318 1301 {"contextmenu", ACTION_STD_CONTEXT},{"quickscreen", ACTION_STD_QUICKSCREEN }, 1319 - 1302 + 1320 1303 /* list/tree actions */ 1321 1304 { "resumeplayback", ACTION_TREE_WPS}, /* returns to previous music, WPS/FM */ 1322 1305 /* not really WPS specific, but no equivilant ACTION_STD_* */ 1323 1306 {"voldown", ACTION_WPS_VOLDOWN}, {"volup", ACTION_WPS_VOLUP}, 1324 1307 {"mute", ACTION_TOUCH_MUTE }, 1325 - 1308 + 1326 1309 /* generic settings changers */ 1327 1310 {"setting_inc", ACTION_SETTINGS_INC}, {"setting_dec", ACTION_SETTINGS_DEC}, 1328 - {"setting_set", ACTION_SETTINGS_SET}, 1311 + {"setting_set", ACTION_SETTINGS_SET}, 1329 1312 1330 1313 /* WPS specific actions */ 1331 1314 {"rwd", ACTION_WPS_SEEKBACK }, {"ffwd", ACTION_WPS_SEEKFWD }, ··· 1338 1321 {"listbookmarks", ACTION_WPS_LIST_BOOKMARKS }, 1339 1322 {"createbookmark", ACTION_WPS_CREATE_BOOKMARK }, 1340 1323 1341 - #if CONFIG_TUNER 1324 + #if CONFIG_TUNER 1342 1325 /* FM screen actions */ 1343 1326 /* Also allow browse, play, stop from WPS codes */ 1344 1327 {"mode", ACTION_FM_MODE }, {"record", ACTION_FM_RECORD }, 1345 - {"presets", ACTION_FM_PRESET}, 1328 + {"presets", ACTION_FM_PRESET}, 1346 1329 #endif 1347 1330 }; 1348 1331 ··· 1362 1345 { 1363 1346 char* text; 1364 1347 int temp; 1365 - struct touchsetting *setting = 1348 + struct touchsetting *setting = 1366 1349 &region->setting_data; 1367 1350 if (element->params_count < p+1) 1368 1351 return -1; ··· 1372 1355 { 1373 1356 case F_T_CUSTOM: 1374 1357 setting->value.text = PTRTOSKINOFFSET(skin_buffer, text); 1375 - break; 1358 + break; 1376 1359 case F_T_INT: 1377 1360 case F_T_UINT: 1378 1361 if (settings[j].cfg_vals == NULL) ··· 1382 1365 else if (cfg_string_to_int(j, &temp, text)) 1383 1366 { 1384 1367 if (settings[j].flags&F_TABLE_SETTING) 1385 - setting->value.number = 1368 + setting->value.number = 1386 1369 settings[j].table_setting->values[temp]; 1387 1370 else 1388 1371 setting->value.number = temp; ··· 1423 1406 * if action starts with & the area must be held to happen 1424 1407 */ 1425 1408 1426 - 1427 - region = (struct touchregion*)skin_buffer_alloc(sizeof(struct touchregion)); 1409 + 1410 + region = skin_buffer_alloc(sizeof(*region)); 1428 1411 if (!region) 1429 1412 return WPS_ERROR_INVALID_PARAM; 1430 1413 1431 1414 /* should probably do some bounds checking here with the viewport... but later */ 1432 1415 region->action = ACTION_NONE; 1433 - 1416 + 1434 1417 if (get_param(element, 0)->type == STRING) 1435 1418 { 1436 1419 region->label = PTRTOSKINOFFSET(skin_buffer, get_param_text(element, 0)); ··· 1446 1429 region->label = PTRTOSKINOFFSET(skin_buffer, NULL); 1447 1430 p = 0; 1448 1431 } 1449 - 1432 + 1450 1433 region->x = get_param(element, p++)->data.number; 1451 1434 region->y = get_param(element, p++)->data.number; 1452 1435 region->width = get_param(element, p++)->data.number; ··· 1508 1491 if (!item) 1509 1492 return WPS_ERROR_INVALID_PARAM; 1510 1493 add_to_ll_chain(&wps_data->touchregions, item); 1511 - 1494 + 1512 1495 if (region->action == ACTION_TOUCH_MUTE) 1513 1496 { 1514 1497 region->value = global_settings.volume; 1515 1498 } 1516 - 1517 - 1499 + 1500 + 1518 1501 return 0; 1519 1502 } 1520 1503 #endif ··· 1691 1674 return fd; 1692 1675 } 1693 1676 #ifndef __PCTOOL__ 1694 - size_t buf_size = read_bmp_fd(fd, bitmap, 0, 1677 + size_t buf_size = read_bmp_fd(fd, bitmap, 0, 1695 1678 format|FORMAT_RETURN_SIZE, NULL); 1696 1679 handle = core_alloc_ex(bitmap->data, buf_size, &buflib_ops); 1697 1680 if (handle < 0) 1698 1681 { 1699 - DEBUGF("Not enough skin buffer: need %zd more.\n", 1682 + DEBUGF("Not enough skin buffer: need %zd more.\n", 1700 1683 buf_size - skin_buffer_freespace()); 1701 1684 close(fd); 1702 1685 return handle; ··· 1705 1688 lock_handle(handle); 1706 1689 bitmap->data = core_get_data(handle); 1707 1690 int ret = read_bmp_fd(fd, bitmap, buf_size, format, NULL); 1708 - bitmap->data = NULL; /* do this to force a crash later if the 1691 + bitmap->data = NULL; /* do this to force a crash later if the 1709 1692 caller doesnt call core_get_data() */ 1710 1693 unlock_handle(); 1711 1694 close(fd); ··· 1732 1715 { 1733 1716 struct skin_token_list *list; 1734 1717 bool retval = true; /* return false if a single image failed to load */ 1735 - 1718 + 1736 1719 /* regular images */ 1737 1720 list = SKINOFFSETTOPTR(skin_buffer, wps_data->images); 1738 1721 while (list) ··· 1814 1797 snprintf(path, sizeof path, FONT_DIR "/%s", font->name); 1815 1798 #ifndef __PCTOOL__ 1816 1799 font->id = font_load_ex(path, 0, skinfonts[font_id-2].glyphs); 1817 - 1800 + 1818 1801 #else 1819 1802 font->id = font_load(path); 1820 1803 #endif ··· 1862 1845 #endif /* HAVE_LCD_BITMAP */ 1863 1846 static int convert_viewport(struct wps_data *data, struct skin_element* element) 1864 1847 { 1865 - struct skin_viewport *skin_vp = 1866 - (struct skin_viewport *)skin_buffer_alloc(sizeof(struct skin_viewport)); 1848 + struct skin_viewport *skin_vp = skin_buffer_alloc(sizeof(*skin_vp)); 1867 1849 struct screen *display = &screens[curr_screen]; 1868 - 1850 + 1869 1851 if (!skin_vp) 1870 1852 return CALLBACK_ERROR; 1871 - 1853 + 1872 1854 skin_vp->hidden_flags = 0; 1873 1855 skin_vp->label = PTRTOSKINOFFSET(skin_buffer, NULL); 1874 1856 skin_vp->is_infovp = false; ··· 1880 1862 first_viewport = element; 1881 1863 1882 1864 viewport_set_defaults(&skin_vp->vp, curr_screen); 1883 - 1865 + 1884 1866 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) 1885 1867 skin_vp->output_to_backdrop_buffer = false; 1886 1868 skin_vp->start_fgcolour = skin_vp->vp.fg_pattern; ··· 1891 1873 skin_vp->start_gradient.end = skin_vp->vp.lse_pattern; 1892 1874 skin_vp->start_gradient.text = skin_vp->vp.lst_pattern; 1893 1875 #endif 1894 - 1876 + 1895 1877 1896 1878 struct skin_tag_parameter *param = get_param(element, 0); 1897 1879 if (element->params_count == 0) /* default viewport */ ··· 1901 1883 skin_vp->label = VP_DEFAULT_LABEL; 1902 1884 return CALLBACK_OK; 1903 1885 } 1904 - 1886 + 1905 1887 if (element->params_count == 6) 1906 1888 { 1907 1889 if (element->tag->type == SKIN_TOKEN_UIVIEWPORT_LOAD) ··· 1984 1966 struct wps_data *wps_data = (struct wps_data *)data; 1985 1967 struct wps_token *token; 1986 1968 parse_function function = NULL; 1987 - 1969 + 1988 1970 switch (element->type) 1989 1971 { 1990 1972 /* IMPORTANT: element params are shared, so copy them if needed ··· 1992 1974 */ 1993 1975 case TAG: 1994 1976 { 1995 - token = (struct wps_token*)skin_buffer_alloc(sizeof(struct wps_token)); 1977 + token = skin_buffer_alloc(sizeof(*token)); 1996 1978 memset(token, 0, sizeof(*token)); 1997 1979 token->type = element->tag->type; 1998 1980 token->value.data = INVALID_OFFSET; 1999 - 1981 + 2000 1982 if (element->tag->flags&SKIN_RTC_REFRESH) 2001 1983 { 2002 1984 #if CONFIG_RTC ··· 2007 1989 } 2008 1990 else 2009 1991 curr_line->update_mode |= element->tag->flags&SKIN_REFRESH_ALL; 2010 - 1992 + 2011 1993 element->data = PTRTOSKINOFFSET(skin_buffer, token); 2012 - 1994 + 2013 1995 /* Some tags need special handling for the tag, so add them here */ 2014 1996 switch (token->type) 2015 1997 { ··· 2163 2145 return convert_viewport(wps_data, element); 2164 2146 case LINE: 2165 2147 { 2166 - struct line *line = 2167 - (struct line *)skin_buffer_alloc(sizeof(struct line)); 2168 - line->update_mode = SKIN_REFRESH_STATIC; 2169 - curr_line = line; 2170 - element->data = PTRTOSKINOFFSET(skin_buffer, line); 2148 + curr_line = skin_buffer_alloc(sizeof(*curr_line)); 2149 + curr_line->update_mode = SKIN_REFRESH_STATIC; 2150 + element->data = PTRTOSKINOFFSET(skin_buffer, curr_line); 2171 2151 } 2172 2152 break; 2173 2153 case LINE_ALTERNATOR: 2174 2154 { 2175 - struct line_alternator *alternator = 2176 - (struct line_alternator *)skin_buffer_alloc(sizeof(struct line_alternator)); 2155 + struct line_alternator *alternator = skin_buffer_alloc(sizeof(*alternator)); 2177 2156 alternator->current_line = 0; 2178 2157 #ifndef __PCTOOL__ 2179 2158 alternator->next_change_tick = current_tick; ··· 2183 2162 break; 2184 2163 case CONDITIONAL: 2185 2164 { 2186 - struct conditional *conditional = 2187 - (struct conditional *)skin_buffer_alloc(sizeof(struct conditional)); 2165 + struct conditional *conditional = skin_buffer_alloc(sizeof(*conditional)); 2188 2166 conditional->last_value = -1; 2189 2167 conditional->token = element->data; 2190 2168 element->data = PTRTOSKINOFFSET(skin_buffer, conditional); ··· 2318 2296 } 2319 2297 /* load the bitmaps that were found by the parsing */ 2320 2298 if (!load_skin_bitmaps(wps_data, bmpdir) || 2321 - !skin_load_fonts(wps_data)) 2299 + !skin_load_fonts(wps_data)) 2322 2300 { 2323 2301 skin_data_reset(wps_data); 2324 2302 return false;

Configure Feed

Configure Feed