The-Homebrew-Cloud/N64FlashcartMenu
2
0
Fork 0
mirror of https://github.com/Polprzewodnikowy/N64FlashcartMenu.git synced 2024-11-22 02:29:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove libdragon-extensions

Browse Source
This commit is contained in:
Robin Jones 2023-03-01 02:14:58 +00:00
parent bae2ace376
commit 2581e7e1f3
13 changed files with 16 additions and 941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -18,11 +18,10 @@ SRCS = \
flashcart/sc64/sc64.c \
menu/menu_main.c \
menu/menu_info.c \
menu/menu_test.c \
menu/menu_fileinfo.c \
menu/settings.c \
utils/fs.c \
libs/toml/toml.c \
libs/menu_utils/src/menu.c \
main.c
OBJS = $(addprefix $(BUILD_DIR)/, $(addsuffix .o,$(basename $(SRCS))))

13
src/libs/menu_utils/README.md
View File

@ -1,13 +0,0 @@
# Source
https://github.com/stefanmielke/libdragon-extensions
# License
MIT
# Description
Used for generating the menu GUI
# Notes
It might be preferable to change to a submodule.
Changed rdp_detach_display() to rdp_detach()
Changed rdp_attach_display(disp) to rdp_attach(disp) as per deprecated warnings.

49
src/libs/menu_utils/include/mem_pool.h
View File

@ -1,49 +0,0 @@
#pragma once
#include <malloc.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief A contiguous zone where memory can be allocated.
*/
typedef struct {
/// Pointer to current free space position.
char *pos;
/// Pointer to start of zone.
char *start;
/// Pointer to end of zone.
char *end;
} MemZone;
/**
* @brief Allocate a memory zone with the given size.
*
* @param memory_zone MemZone to use.
* @param size Size in bytes that the MemZone will have. (eg.: '1*1024*1024' for 1MB)
*/
void mem_zone_init(MemZone *memory_zone, size_t size);
/**
* @brief Allocate memory from the zone.
*
* @param memory_zone MemZone to use.
* @param size Size in bytes of the memory. (eg.: sizeof(int))
*
* @return the memory allocated.
*/
void *mem_zone_alloc(MemZone *memory_zone, size_t size);
/**
* @brief Free all objects in the zone.
*
* @param memory_zone MemZone to use.
*/
void mem_zone_free_all(MemZone *memory_zone);
#ifdef __cplusplus
}
#endif

6
src/libs/menu_utils/include/memory_alloc.h
View File

@ -1,6 +0,0 @@
#include "mem_pool.h"
/**
* @brief Used to allocate an object using either a MemZone or malloc according to the parameters.
*/
#define MEM_ALLOC(SIZE, MEMPOOL) ((MEMPOOL) ? mem_zone_alloc((MEMPOOL), (SIZE)) : malloc(SIZE))

331
src/libs/menu_utils/include/menu.h
View File

@ -1,331 +0,0 @@
#pragma once
#include <libdragon.h>
#include "mem_pool.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Enum with the order of the background sprites in a texture. Any texture has to have this
* order.
*/
typedef enum MenuBackgroundSprite {
SPRITE_menu_bottom,
SPRITE_menu_bottom_left,
SPRITE_menu_bottom_right,
SPRITE_menu_center,
SPRITE_menu_left,
SPRITE_menu_right,
SPRITE_menu_top,
SPRITE_menu_top_left,
SPRITE_menu_top_right,
SPRITE_menu_SPRITES_MAX
} MenuBackgroundSprite;
/**
* @brief Enum that contains the state of a given item in relation with the current selected item.
*/
typedef enum MenuItemState {
/// The item is inside the menu.
MSIS_Inside,
/// The item is on the edge of the menu.
MSIS_OnBorder,
/// The item is outside of the range of displayed items and will not be rendered.
MSIS_Outside,
} MenuItemState;
/**
* @brief Struct that represents an item inside the menu. Used internally when using
* 'menu_add_item*' functions.
*/
typedef struct MenuItem {
/// Text that will be rendered. Not used when is an image.
char *text;
/// Sprite that will be rendered. Used only when an image.
sprite_t *sprite;
/// Index of the sprite that will be rendered. Used only when an image.
int sprite_index;
/// X position of this item. Calculated whenever the state of the menu changes.
int x;
/// Y position of this item. Calculated whenever the state of the menu changes.
int y;
/// If the item is enabled. An enabled item can be used.
bool enabled;
/// If the item has custom colors. If false, will use the default colors. Default colors can be
/// changed using 'menu_global_set_default_colors'.
bool has_custom_colors;
/// Color for when this item is enabled. Used when 'has_custom_colors' is true.
uint32_t color_enabled;
/// Color for when this item is disabled ('enabled' == false). Used when 'has_custom_colors' is
/// true.
uint32_t color_disabled;
/// Color for when this item is selected. Used when 'has_custom_colors' is true.
uint32_t color_selected;
/// State of the item in relation to the menu. @see MenuItemState
MenuItemState state;
/// Custom object that is set by the user when creating the item.
void *object;
} MenuItem;
/**
* @brief Optional callback for when an item is used.
*
* @param[in] option
* The index of the used item.
* @param[in] menu_item
* A reference to the used menu item. @see MenuItem
*/
typedef void (*fnMenuCallback)(int option, MenuItem *menu_item);
/**
* @brief Struct used to hold a Menu. Created by the 'menu_init' function.
*/
typedef struct Menu {
/// Array of items of this menu.
MenuItem *items;
/// Maximum amount of items this menu can have. Also the size of 'items'.
uint8_t total_items;
/// Current index when inserting new MenuItems. Has the current amount of used items.
uint8_t current_add_index;
/// Current selected menu item index.
int current_menu_option;
/// Current active submenu. If '-1', no submenu is active.
int active_submenu;
/// Array with references to all submenus.
struct Menu **submenus;
/// If this menu should be rendered even when a submenu is active.
bool display_when_on_submenu;
/// If this menu should display a background. Configured using 'menu_global_set_sprites' and
/// 'menu_set_background'.
bool display_background;
/// Width of the background. Configured using 'menu_set_background'.
int menu_width;
/// If the hand should be displayed for this menu
bool display_hand;
/// X position of the hand cursor. Configured using 'menu_global_set_sprites' and
/// 'menu_set_hand'.
int hand_position_x;
/// Y offset for the hand cursor. Configured using 'menu_global_set_sprites' and
/// 'menu_set_hand'.
int hand_position_y_offset;
/// Amount of items that can be displayed at once.
uint8_t item_vertical_limit;
/// Height of each item inside the menu. Used to calculate Y position of items.
uint8_t item_height;
/// Y position of the menu.
int top;
/// X position of the menu.
int left;
/// Index of the item currently at the top of rendered menu.
uint8_t cur_top_item;
/// Index of the item currently at the bottom of rendered menu.
uint8_t cur_bottom_item;
/// Callback function for when an item is used. @see fnMenuCallback
fnMenuCallback callback;
} Menu;
/**
* @brief Allocates and returns a new Menu object.
*
* @param memory_pool
* The memory pool to be used. If NULL will use malloc.
* @param total_items
* Total items that can be created inside the Menu.
* @param max_items
* Count of items that will be displayed at once.
* @param top
* Y position of the menu.
* @param left
* X position of the menu.
* @param item_height
* Height of each item inside the menu.
* @param callback
* Callback function for when an item is used. @see fnMenuCallback
*
* @return A new Menu object.
*/
Menu *menu_init(MemZone *memory_pool, uint8_t total_items, uint8_t max_items, int top, int left,
uint8_t item_height, fnMenuCallback callback);
/**
* @brief Set the background for the Menu. Should only be called after calling
* 'menu_global_set_sprites' at least once in the game.
*
* @param menu
* Reference to the menu object.
* @param menu_width
* Width of the background.
*/
void menu_set_background(Menu *menu, int menu_width);
/**
* @brief Resets the items inside a menu. After calling this method you can add items to refill it.
*
* @param menu
* Reference to the menu object.
*/
void menu_reset_items(Menu *menu);
/**
* @brief Set the hand cursor for the Menu. Should only be called after calling
* 'menu_global_set_sprites' at least once in the game.
*
* @param menu
* Reference to the menu object.
* @param hand_position_x
* X position for the hand cursor.
* @param hand_position_y_offset
* Y position offset for the hand cursor.
*/
void menu_set_hand(Menu *menu, int hand_position_x, int hand_position_y_offset);
/**
* @brief Ticks the menu. Should be called every frame.
*
* @param menu
* Reference to the menu object.
* @param keys_down
* Reference to the controller data for the current frame. You can get this data using the
* 'get_keys_down()' function.
*
* @return Index of the item used, or '-1' is none.
*/
int menu_tick(Menu *menu, struct controller_data *keys_down);
/**
* @brief Add a new text item to the menu without any custom colors.
*
* @param menu
* Reference to the menu object.
* @param text
* Text that will be rendered.
* @param enabled
* If the item will start enabled.
* @param object
* Reference to a custom object that can be used later by the user.
*/
void menu_add_item(Menu *menu, char *text, bool enabled, void *object);
/**
* @brief Add a new image item to the menu.
*
* @param menu
* Reference to the menu object.
* @param sprite
* Sprite that will be used by this item.
* @param sprite_index
* Index inside the sprite.
* @param enabled
* If the item will start enabled.
* @param object
* Reference to a custom object that can be used later by the user.
*/
void menu_add_item_image(Menu *menu, sprite_t *sprite, int sprite_index, bool enabled,
void *object);
/**
* @brief Add a new text item to the menu with custom colors.
*
* @param menu
* Reference to the menu object.
* @param text
* Text that will be rendered.
* @param enabled
* If the item will start enabled.
* @param color_selected
* Color for this object when selected.
* @param color_enabled
* Color for this object when enabled and not selected.
* @param color_disabled
* Color for this object when disabled and not selected.
* @param object
* Reference to a custom object that can be used later by the user.
*/
void menu_add_item_colored(Menu *menu, char *text, bool enabled, uint32_t color_selected,
uint32_t color_enabled, uint32_t color_disabled, void *object);
/**
* @brief Render the menu.
*
* @param menu
* Reference to the menu object.
* @param disp
* The display context used in the game.
*/
void menu_render(Menu *menu, display_context_t disp);
/**
* @brief Allocates and initializes submenus for the menu.
*
* @param menu
* Reference to the menu object.
* @param memory_pool
* The memory pool to be used. If NULL will use malloc.
* @param total_submenus
* Total count of submenus that will be created.
* @param display_when_on_submenu
* If the menu will be displayed even when a submenu is active.
*/
void menu_init_submenus(Menu *menu, MemZone *memory_pool, uint8_t total_submenus,
bool display_when_on_submenu);
/**
* @brief Method that will render the borders of the menu.
*/
void menu_draw_background_borders(display_context_t disp, int top, int left, int bottom, int right);
/**
* @brief Method that will render the center of the menu.
*/
void menu_draw_background_center(display_context_t disp, int top, int left, int bottom, int right);
/**
* @brief Initializes the menu default colors
*/
void menu_global_init();
/**
* @brief Set the sprite used by the background menu
*
* @param menu_sprite
* Sprite that will be used. See `sample_assets/menu.png` for example.
* Order should be according to enum `MenuBackgroundSprite`.
* @param hand_sprite
* Sprite that will be used as the 'hand'.
* @param hand_sprite_offset
* Offset of the sprite (used by `graphics_draw_sprite_trans_stride`).
*/
void menu_global_set_sprites(sprite_t *menu_sprite, sprite_t *hand_sprite,
uint8_t hand_sprite_offset);
/**
* @brief Set the default colors for all menus when the item doesn't have any set.
*
* @param selected
* Color used when the item is the current selected one. Default is {0,0,255,255}
* @param enabled
* Color used when the item is enabled but not selected. Default is {255,255,255,255}
* @param disabled
* Color used when the item is disabled. Default is {100,100,255,255}
* @param background
* Color used for the background of the text. Default is {0,0,0,0}
* @param out_of_bounds
* Color used when the item is out of the bounds of the menu (when scrolling). Default is
* {0,0,0,255}
* @param menu_background
* Color used for the background. Due to 32 bits issue, we do not use the background from the
* sprite.
*/
void menu_global_set_default_colors(uint32_t selected, uint32_t enabled, uint32_t disabled,
uint32_t background, uint32_t out_of_bounds,
uint32_t menu_background);
#ifdef __cplusplus
}
#endif

BIN
src/libs/menu_utils/sample_assets/menu.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 184 B

42
src/libs/menu_utils/src/mem_pool.c
View File

@ -1,42 +0,0 @@
#include "../include/mem_pool.h"
#include <string.h>
#include <libdragon.h>
void mem_zone_init(MemZone *z, size_t size) {
disable_interrupts();
void *ptr = malloc(size);
if (ptr == NULL) {
abort(); // Put your error handling here.
}
z->pos = (char *)ptr;
z->start = z->pos;
z->end = z->start + size;
memset(z->start, 0, size);
enable_interrupts();
}
void *mem_zone_alloc(MemZone *z, size_t size) {
if (size == 0) {
return NULL;
}
// Round up to multiple of 16 bytes.
size = (size + 15) & ~(size_t)15;
// How much free space remaining in zone?
size_t rem = z->end - z->pos;
if (rem < size) {
return NULL; // Out of memory. Put your error handling here.
}
void *ptr = (void *)z->pos;
z->pos += size;
return ptr;
}
void mem_zone_free_all(MemZone *z) {
z->pos = z->start;
}

415
src/libs/menu_utils/src/menu.c
View File

@ -1,415 +0,0 @@
#include "../include/menu.h"
#include "../include/memory_alloc.h"
void menu_scroll_up(Menu *menu);
void menu_scroll_down(Menu *menu);
uint32_t MENU_C_SELECTED;
uint32_t MENU_C_ENABLED;
uint32_t MENU_C_DISABLED;
uint32_t MENU_C_BACKGROUND;
uint32_t MENU_C_MENU_BACKGROUND;
uint32_t MENU_C_OUT_OF_BOUNDS;
sprite_t *menu_background_sprite;
sprite_t *menu_hand_sprite;
uint8_t menu_hand_sprite_offset;
void menu_global_init() {
MENU_C_SELECTED = graphics_make_color(0, 0, 255, 255);
MENU_C_ENABLED = graphics_make_color(255, 255, 255, 255);
MENU_C_DISABLED = graphics_make_color(100, 100, 255, 255);
MENU_C_BACKGROUND = graphics_make_color(0, 0, 0, 0);
MENU_C_OUT_OF_BOUNDS = graphics_make_color(0, 0, 0, 255);
MENU_C_MENU_BACKGROUND = graphics_make_color(255, 255, 255, 255);
}
void menu_global_set_default_colors(uint32_t selected, uint32_t enabled, uint32_t disabled,
uint32_t background, uint32_t out_of_bounds,
uint32_t menu_background) {
MENU_C_SELECTED = selected;
MENU_C_ENABLED = enabled;
MENU_C_DISABLED = disabled;
MENU_C_BACKGROUND = background;
MENU_C_OUT_OF_BOUNDS = out_of_bounds;
MENU_C_MENU_BACKGROUND = menu_background;
}
void menu_global_set_sprites(sprite_t *menu_sprite, sprite_t *hand_sprite,
uint8_t hand_sprite_offset) {
menu_background_sprite = menu_sprite;
menu_hand_sprite = hand_sprite;
menu_hand_sprite_offset = hand_sprite_offset;
}
Menu *menu_init(MemZone *memory_pool, uint8_t total_items, uint8_t max_items, int top, int left,
uint8_t item_height, fnMenuCallback callback) {
Menu *menu = MEM_ALLOC(sizeof(Menu), memory_pool);
menu->total_items = total_items;
menu->items = MEM_ALLOC(sizeof(MenuItem) * total_items, memory_pool);
menu->current_menu_option = 0;
menu_reset_items(menu);
menu->active_submenu = -1;
menu->submenus = NULL;
menu->display_when_on_submenu = false;
menu->display_background = false;
menu->menu_width = 0;
menu->item_vertical_limit = max_items;
menu->item_height = item_height;
menu->top = top;
menu->left = left;
menu->cur_top_item = 0;
menu->cur_bottom_item = 0;
menu->callback = callback;
menu->display_hand = false;
menu->hand_position_x = 0;
menu->hand_position_y_offset = 0;
return menu;
}
void menu_set_background(Menu *menu, int menu_width) {
menu->display_background = true;
menu->menu_width = menu_width;
}
void menu_reset_items(Menu *menu) {
menu->current_add_index = 0;
for (uint8_t i = 0; i < menu->total_items; ++i) {
menu->items[i].enabled = false;
menu->items[i].text = NULL;
menu->items[i].x = 0;
menu->items[i].y = 0;
}
}
void menu_set_hand(Menu *menu, int hand_position_x, int hand_position_y_offset) {
menu->display_hand = true;
menu->hand_position_x = hand_position_x;
menu->hand_position_y_offset = hand_position_y_offset;
}
void menu_add_item(Menu *menu, char *text, bool enabled, void *object) {
if (menu->current_add_index >= menu->total_items)
return;
MenuItem *item = &menu->items[menu->current_add_index];
item->text = text;
item->x = menu->left;
item->y = menu->top + (menu->item_height * menu->current_add_index);
item->enabled = enabled;
item->has_custom_colors = false;
item->sprite_index = -1;
item->object = object;
if (menu->current_add_index == menu->item_vertical_limit)
item->state = MSIS_OnBorder;
else if (menu->current_add_index > menu->item_vertical_limit)
item->state = MSIS_Outside;
else
item->state = MSIS_Inside;
menu->current_add_index++;
menu->cur_bottom_item = menu->current_add_index >= menu->item_vertical_limit
? menu->item_vertical_limit - 1
: menu->current_add_index - 1;
}
void menu_add_item_image(Menu *menu, sprite_t *sprite, int sprite_index, bool enabled,
void *object) {
if (menu->current_add_index >= menu->total_items)
return;
MenuItem *item = &menu->items[menu->current_add_index];
item->sprite = sprite;
item->sprite_index = sprite_index;
item->x = menu->left;
item->y = menu->top + (menu->item_height * menu->current_add_index);
item->enabled = enabled;
item->has_custom_colors = false;
item->object = object;
if (menu->current_add_index == menu->item_vertical_limit)
item->state = MSIS_OnBorder;
else if (menu->current_add_index > menu->item_vertical_limit)
item->state = MSIS_Outside;
else
item->state = MSIS_Inside;
menu->current_add_index++;
menu->cur_bottom_item = menu->current_add_index >= menu->item_vertical_limit
? menu->item_vertical_limit - 1
: menu->current_add_index - 1;
}
void menu_add_item_colored(Menu *menu, char *text, bool enabled, uint32_t color_selected,
uint32_t color_enabled, uint32_t color_disabled, void *object) {
if (menu->current_add_index >= menu->total_items)
return;
MenuItem *item = &menu->items[menu->current_add_index];
item->text = text;
item->x = menu->left;
item->y = menu->top + (menu->item_height * menu->current_add_index);
item->enabled = enabled;
item->has_custom_colors = true;
item->sprite_index = -1;
item->object = object;
item->color_selected = color_selected;
item->color_enabled = color_enabled;
item->color_disabled = color_disabled;
if (menu->current_add_index == menu->item_vertical_limit)
item->state = MSIS_OnBorder;
else if (menu->current_add_index > menu->item_vertical_limit)
item->state = MSIS_Outside;
else
item->state = MSIS_Inside;
menu->current_add_index++;
menu->cur_bottom_item = menu->current_add_index >= menu->item_vertical_limit
? menu->item_vertical_limit - 1
: menu->current_add_index - 1;
}
int menu_tick(Menu *menu, struct controller_data *keys_down) {
if (menu->active_submenu >= 0 && menu->submenus) {
Menu **menus = menu->submenus;
Menu *active_submenu = menus[menu->active_submenu];
int option = menu_tick(active_submenu, keys_down);
// go back from submenu
if (option == -2) {
menu->active_submenu = -1;
return -1;
}
return option;
}
if (menu->current_add_index <= 0)
return -1;
if (keys_down->c[0].up) {
if (menu->current_menu_option > 0) {
menu->current_menu_option -= 1;
menu_scroll_up(menu);
}
} else if (keys_down->c[0].down) {
if (menu->current_menu_option < menu->current_add_index - 1) {
menu->current_menu_option += 1;
menu_scroll_down(menu);
}
} else if (keys_down->c[0].A || keys_down->c[0].start) {
if (menu->items[menu->current_menu_option].enabled) {
if (menu->callback) {
menu->callback(menu->current_menu_option, &menu->items[menu->current_menu_option]);
}
return menu->current_menu_option;
}
} else if (keys_down->c[0].B) {
return -2;
}
return -1;
}
void menu_render(Menu *menu, display_context_t disp) {
if (menu->active_submenu >= 0 && menu->submenus) {
Menu *active_submenu = menu->submenus[menu->active_submenu];
menu_render(active_submenu, disp);
if (!menu->display_when_on_submenu)
return;
}
// render window background
if (menu->display_background) {
const int item_count = menu->current_add_index < menu->item_vertical_limit
? menu->current_add_index
: menu->item_vertical_limit;
const int menu_left = menu->left - 8;
const int menu_top = menu->top - menu->item_height;
const int menu_bottom = menu->top + (menu->item_height * item_count);
const int menu_right = menu->left + menu->menu_width;
menu_draw_background_center(disp, menu_top, menu_left, menu_bottom, menu_right);
}
for (uint8_t i = 0; i < menu->current_add_index; ++i) {
if (menu->items[i].state == MSIS_Outside)
continue;
if (menu->items[i].sprite_index == -1) {
if (menu->items[i].state == MSIS_Inside) {
if (i == menu->current_menu_option) {
if (menu->items[i].has_custom_colors) {
graphics_set_color(menu->items[i].color_selected, MENU_C_BACKGROUND);
} else {
graphics_set_color(MENU_C_SELECTED, MENU_C_BACKGROUND);
}
} else if (menu->items[i].enabled) {
if (menu->items[i].has_custom_colors) {
graphics_set_color(menu->items[i].color_enabled, MENU_C_BACKGROUND);
} else {
graphics_set_color(MENU_C_ENABLED, MENU_C_BACKGROUND);
}
} else {
if (menu->items[i].has_custom_colors) {
graphics_set_color(menu->items[i].color_disabled, MENU_C_BACKGROUND);
} else {
graphics_set_color(MENU_C_DISABLED, MENU_C_BACKGROUND);
}
}
} else {
graphics_set_color(MENU_C_OUT_OF_BOUNDS, MENU_C_BACKGROUND);
}
graphics_draw_text(disp, menu->items[i].x, menu->items[i].y, menu->items[i].text);
} else {
graphics_draw_sprite_trans_stride(disp, menu->items[i].x, menu->items[i].y,
menu->items[i].sprite, menu->items[i].sprite_index);
}
}
if (menu->display_background) {
const int item_count = menu->current_add_index < menu->item_vertical_limit
? menu->current_add_index
: menu->item_vertical_limit;
const int menu_left = menu->left - 8;
const int menu_top = menu->top - menu->item_height;
const int menu_bottom = menu->top + (menu->item_height * item_count);
const int menu_right = menu->left + menu->menu_width;
menu_draw_background_borders(disp, menu_top, menu_left, menu_bottom, menu_right);
}
// render hand icon
if (menu->display_hand && menu->current_add_index > 0) {
int option = menu->current_menu_option;
if (menu->current_add_index > 0)
graphics_draw_sprite_trans_stride(disp, menu->hand_position_x,
menu->items[option].y + menu->hand_position_y_offset,
menu_hand_sprite, menu_hand_sprite_offset);
}
}
void menu_init_submenus(Menu *menu, MemZone *memory_pool, uint8_t total_submenus,
bool display_when_on_submenu) {
// do not recreate submenus
if (menu->submenus)
return;
menu->submenus = MEM_ALLOC(sizeof(Menu *) * total_submenus, memory_pool);
menu->display_when_on_submenu = display_when_on_submenu;
}
void menu_draw_background_borders(display_context_t disp, int top, int left, int bottom,
int right) {
graphics_draw_sprite_trans_stride(disp, left, top, menu_background_sprite,
SPRITE_menu_top_left);
graphics_draw_sprite_trans_stride(disp, left, bottom, menu_background_sprite,
SPRITE_menu_bottom_left);
graphics_draw_sprite_trans_stride(disp, right, top, menu_background_sprite,
SPRITE_menu_top_right);
graphics_draw_sprite_trans_stride(disp, right, bottom, menu_background_sprite,
SPRITE_menu_bottom_right);
const int repeat_x = (right - left - 8) / 8;
for (size_t i = 0; i < repeat_x; ++i) {
graphics_draw_sprite_trans_stride(disp, left + 8 + (i * 8), top, menu_background_sprite,
SPRITE_menu_top);
graphics_draw_sprite_trans_stride(disp, left + 8 + (i * 8), bottom, menu_background_sprite,
SPRITE_menu_bottom);
}
const int repeat_y = ((bottom - top) / 8) - 1;
for (size_t i = 0; i < repeat_y; ++i) {
graphics_draw_sprite_trans_stride(disp, left, top + 8 + (i * 8), menu_background_sprite,
SPRITE_menu_left);
graphics_draw_sprite_trans_stride(disp, right, top + 8 + (i * 8), menu_background_sprite,
SPRITE_menu_right);
}
}
void menu_draw_background_center(display_context_t disp, int top, int left, int bottom, int right) {
// TODO: remove this "hack" and properly render the texture. Cause: libdragon issue with 32 bits
left += 8;
top += 8;
rdp_sync(SYNC_PIPE);
rdp_attach(disp);
rdp_enable_blend_fill();
rdp_set_default_clipping();
rdp_sync(SYNC_PIPE);
rdp_set_blend_color(MENU_C_MENU_BACKGROUND);
rdp_draw_filled_triangle(left, top, right, top, right, bottom);
rdp_draw_filled_triangle(left, top, left, bottom, right, bottom);
rdp_detach();
}
void menu_scroll_fix_y(Menu *menu) {
if (menu->cur_top_item > 0) {
menu->items[menu->cur_top_item - 1].y = menu->top - menu->item_height;
}
for (size_t ix = menu->cur_top_item, i = 0; i <= menu->cur_bottom_item; ++i, ++ix) {
menu->items[ix].y = menu->top + (i * menu->item_height);
}
if (menu->cur_bottom_item + 1 < menu->current_add_index) {
menu->items[menu->cur_bottom_item + 1].y = menu->top +
(menu->item_vertical_limit * menu->item_height);
}
}
void menu_scroll_up(Menu *menu) {
if (menu->current_menu_option < menu->cur_top_item) {
if (menu->cur_bottom_item + 1 < menu->current_add_index)
menu->items[menu->cur_bottom_item + 1].state = MSIS_Outside;
menu->items[menu->cur_bottom_item].state = MSIS_OnBorder;
if (menu->cur_top_item - 2 >= 0)
menu->items[menu->cur_top_item - 2].state = MSIS_OnBorder;
menu->items[menu->current_menu_option].state = MSIS_Inside;
menu->cur_top_item--;
menu->cur_bottom_item--;
menu_scroll_fix_y(menu);
}
}
void menu_scroll_down(Menu *menu) {
if (menu->current_menu_option > menu->cur_bottom_item) {
if (menu->cur_top_item > 0)
menu->items[menu->cur_top_item - 1].state = MSIS_Outside;
menu->items[menu->cur_top_item].state = MSIS_OnBorder;
menu->items[menu->current_menu_option].state = MSIS_Inside;
if (menu->current_menu_option + 1 < menu->current_add_index)
menu->items[menu->current_menu_option + 1].state = MSIS_OnBorder;
menu->cur_top_item++;
menu->cur_bottom_item++;
menu_scroll_fix_y(menu);
}
}

7
src/menu/menu_fileinfo.c Normal file
View File

@ -0,0 +1,7 @@
#include <libdragon.h>
#include "menu_fileinfo.h"
void menu_fileinfo(void) {
}

6
src/menu/menu_fileinfo.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef MENU_FILEINFO_H__
#define MENU_FILEINFO_H__
void menu_fileinfo(void);
#endif

4
src/menu/menu_main.c
View File

@ -11,7 +11,7 @@
#include "settings.h"
#include "menu_main.h"
#include "menu_info.h"
#include "menu_test.h"
#include "menu_fileinfo.h"
// FIXME: use newlib rather than fatfs to do this!
FRESULT scan_file_path (char* path) {
@ -95,7 +95,7 @@ void menu_main_init (settings_t *settings) {
}
if (joypad.c[0].B) {
console_clear();
menu_test();
menu_fileinfo();
menu_main_refresh(settings->last_state.current_directory);
}
}

75
src/menu/menu_test.c
View File

@ -1,75 +0,0 @@
#include <libdragon.h>
#include "libs/menu_utils/include/menu.h"
#include "menu_test.h"
void menu_test(void) {
// display_init(RESOLUTION_512x240, DEPTH_16_BPP, 3, GAMMA_NONE, ANTIALIAS_RESAMPLE);
// display_context_t disp = display_lock();
// -- initializing global variables used by every menu --
// main init function
// (required to set default colors, can omit if setting colors using `menu_global_set_default_colors` or setting colors for items)
// menu_global_init();
// // initializes the sprites and offsets used. only required if using them (when creating the menu)
// // !!!menu_global_set_sprites(menu_sprite, hand_sprite, hand_sprite_offset);
// // optionally overriding the default colors
// //uint32_t selected = graphics_make_color(0, 0, 0, 255);
// //... ommiting the other colors, but you can use the function above to set each color
// // !!!menu_global_set_default_colors(selected, enabled, disabled, background, out_of_bounds, menu_background);
// // -- now to create the menu... --
// // // callback to be used. it's optional, but improves code legibility when using sub-menus.
// // void menu_callback(int option, MenuItem* item);
// Menu* menu;
// // create a new menu (memory_pool can be NULL if not using it)
// uint8_t total_items = 10; // max items that the menu can have
// uint8_t max_items = 5; // max items that will be displayed at any time (if more than this, there will be scrolling)
// int top = 100, left = 100; // positions on-screen of the menu
// uint8_t item_height = 16; // height in pixels that each item will have (used to calculate background bottom and scrolling)
// menu = menu_init(NULL, total_items, max_items, top, left, item_height, NULL); // not using callbacks
// //menu = menu_init(NULL, total_items, max_items, top, left, item_height, &menu_callback); // using callbacks
// // add items
// //bool enabled = true; // if the item can be selected or not. color can differ baed on colors set.
// //void *object = &my_custom_object; // this can be held to be retrieved later for custom actions baed on selected item.
// // adding simple text items
// //menu_add_item(menu, "Item 1", enabled, object); // with object
// menu_add_item(menu, "Item 2", false, NULL); // no object here, forcing disabled
// // adding colored item (can use different colors for each item)
// //uint32_t color_selected = graphics_make_color(0, 0, 0, 255);
// // omitting other colors...
// //menu_add_item_colored(menu, "Item 3", enabled, color_selected, color_enabled, color_disabled, object);
// // // adding item as an image instead of text
// // sprite_t *custom_image_sprite; // custom sprite to be used by the item
// // int sprite_index = 2; // index for the custom sprite
// // menu_add_item_image(menu, custom_image_sprite, sprite_index, enabled, object);
// // ticks the menu to calculate changes to its state. should only be called when the menu is active.
// //struct controller_data keys_down = get_keys_down(); // you should do this only once per frame in your normal code
// //int selected_option = menu_tick(menu, &keys_down);
// // if 'selected_option >= 0' then the corresponding item was selected and you can act accordingly.
// // if using callbacks, 'selected_option' can also be '>= 0', but the function will also be called.
// // render the menu
// menu_render(menu, disp);
// // -- optional set-up steps: --
// // // add hand cursor
// // int hand_position_x = 105; // X position of the hand. this will never change.
// // int hand_position_y_offset = 5; // offset in pixels to be applied to the sprite when rendering the hand.
// // menu_set_hand(menu, hand_position_x, hand_position_y_offset);
// // add background
// int menu_width = 200; // width in pixels of the menu. this will be the same regardless of the item width.
// menu_set_background(menu, menu_width);
}

6
src/menu/menu_test.h
View File

@ -1,6 +0,0 @@
#ifndef MENU_TEST_H__
#define MENU_TEST_H__
void menu_test(void);
#endif