mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-15 13:21:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

(Rgui) Rename SGUI to RGUI

Browse Source
This commit is contained in:
Twinaphex 2012-05-06 04:04:33 +02:00
parent 20a1d5df29
commit 419bfc17ef
7 changed files with 381 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
console/griffin/griffin.c
View File

@ -187,6 +187,6 @@ MENU
#elif defined(_XBOX)
#include "../../360/menu.cpp"
#elif defined(GEKKO)
#include "../sgui/sgui.c"
#include "../sgui/list.c"
#include "../rgui/rgui.c"
#include "../rgui/list.c"
#endif

50
console/sgui/list.c → console/rgui/list.c
View File

@ -18,37 +18,37 @@
#include <stdlib.h>
#include <string.h>
struct sgui_file
struct rgui_file
{
char *path;
sgui_file_type_t type;
rgui_file_type_t type;
};
struct sgui_list
struct rgui_list
{
struct sgui_file *list;
struct rgui_file *list;
size_t capacity;
size_t ptr;
};
sgui_list_t *sgui_list_new(void)
rgui_list_t *rgui_list_new(void)
{
return (sgui_list_t*)calloc(1, sizeof(sgui_list_t));
return (rgui_list_t*)calloc(1, sizeof(rgui_list_t));
}
bool sgui_list_empty(const sgui_list_t *list)
bool rgui_list_empty(const rgui_list_t *list)
{
return list->ptr == 0;
}
void sgui_list_push(sgui_list_t *list, const char *path, sgui_file_type_t type)
void rgui_list_push(rgui_list_t *list, const char *path, rgui_file_type_t type)
{
if (list->ptr >= list->capacity)
{
list->capacity++;
list->capacity *= 2;
list->list = (struct sgui_file*)realloc(list->list, list->capacity * sizeof(struct sgui_file));
list->list = (struct rgui_file*)realloc(list->list, list->capacity * sizeof(struct rgui_file));
}
list->list[list->ptr].path = strdup(path);
@ -56,13 +56,13 @@ void sgui_list_push(sgui_list_t *list, const char *path, sgui_file_type_t type)
list->ptr++;
}
void sgui_list_pop(sgui_list_t *list)
void rgui_list_pop(rgui_list_t *list)
{
if (!sgui_list_empty(list))
if (!rgui_list_empty(list))
free(list->list[--list->ptr].path);
}
void sgui_list_free(sgui_list_t *list)
void rgui_list_free(rgui_list_t *list)
{
for (size_t i = 0; i < list->ptr; i++)
free(list->list[i].path);
@ -70,27 +70,27 @@ void sgui_list_free(sgui_list_t *list)
free(list);
}
void sgui_list_clear(sgui_list_t *list)
void rgui_list_clear(rgui_list_t *list)
{
for (size_t i = 0; i < list->ptr; i++)
free(list->list[i].path);
list->ptr = 0;
}
void sgui_list_back(const sgui_list_t *list,
const char **path, sgui_file_type_t *file_type)
void rgui_list_back(const rgui_list_t *list,
const char **path, rgui_file_type_t *file_type)
{
if (sgui_list_size(list) > 0)
sgui_list_at(list, sgui_list_size(list) - 1, path, file_type);
if (rgui_list_size(list) > 0)
rgui_list_at(list, rgui_list_size(list) - 1, path, file_type);
}
size_t sgui_list_size(const sgui_list_t *list)
size_t rgui_list_size(const rgui_list_t *list)
{
return list->ptr;
}
void sgui_list_at(const sgui_list_t *list, size_t index,
const char **path, sgui_file_type_t *file_type)
void rgui_list_at(const rgui_list_t *list, size_t index,
const char **path, rgui_file_type_t *file_type)
{
if (path)
*path = list->list[index].path;
@ -100,17 +100,17 @@ void sgui_list_at(const sgui_list_t *list, size_t index,
static int list_comp(const void *a_, const void *b_)
{
const struct sgui_file *a = (const struct sgui_file*)a_;
const struct sgui_file *b = (const struct sgui_file*)b_;
const struct rgui_file *a = (const struct rgui_file*)a_;
const struct rgui_file *b = (const struct rgui_file*)b_;
if (a->type != b->type)
return a->type == SGUI_FILE_DIRECTORY ? -1 : 1;
return a->type == RGUI_FILE_DIRECTORY ? -1 : 1;
return strcmp(a->path, b->path);
}
void sgui_list_sort(sgui_list_t *list)
void rgui_list_sort(rgui_list_t *list)
{
qsort(list->list, list->ptr, sizeof(struct sgui_file), list_comp);
qsort(list->list, list->ptr, sizeof(struct rgui_file), list_comp);
}

32
console/sgui/list.h → console/rgui/list.h
View File

@ -13,34 +13,34 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SGUI_LIST_H__
#define SGUI_LIST_H__
#ifndef RGUI_LIST_H__
#define RGUI_LIST_H__
#include "sgui.h"
#include "rgui.h"
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct sgui_list sgui_list_t;
typedef struct rgui_list rgui_list_t;
sgui_list_t *sgui_list_new(void);
void sgui_list_free(sgui_list_t *list);
rgui_list_t *rgui_list_new(void);
void rgui_list_free(rgui_list_t *list);
void sgui_list_push(sgui_list_t *list, const char *path, sgui_file_type_t type);
void sgui_list_pop(sgui_list_t *list);
void sgui_list_clear(sgui_list_t *list);
void rgui_list_push(rgui_list_t *list, const char *path, rgui_file_type_t type);
void rgui_list_pop(rgui_list_t *list);
void rgui_list_clear(rgui_list_t *list);
bool sgui_list_empty(const sgui_list_t *list);
void sgui_list_back(const sgui_list_t *list,
const char **path, sgui_file_type_t *type);
bool rgui_list_empty(const rgui_list_t *list);
void rgui_list_back(const rgui_list_t *list,
const char **path, rgui_file_type_t *type);
size_t sgui_list_size(const sgui_list_t *list);
void sgui_list_at(const sgui_list_t *list, size_t index,
const char **path, sgui_file_type_t *type);
size_t rgui_list_size(const rgui_list_t *list);
void rgui_list_at(const rgui_list_t *list, size_t index,
const char **path, rgui_file_type_t *type);
void sgui_list_sort(sgui_list_t *list);
void rgui_list_sort(rgui_list_t *list);
#ifdef __cplusplus
}

295
console/rgui/rgui.c Normal file
View File

@ -0,0 +1,295 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2012 - Hans-Kristian Arntzen
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "rgui.h"
#include "list.h"
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#define FONT_WIDTH 5
#define FONT_HEIGHT 10
#define FONT_WIDTH_STRIDE (FONT_WIDTH + 1)
#define FONT_HEIGHT_STRIDE (FONT_HEIGHT + 1)
#define TERM_WIDTH (((RGUI_WIDTH - 30) / (FONT_WIDTH_STRIDE)))
#define TERM_HEIGHT (((RGUI_HEIGHT - 30) / (FONT_HEIGHT_STRIDE)))
#define TERM_START_X 15
#define TERM_START_Y 15
struct rgui_handle
{
uint16_t *frame_buf;
size_t frame_buf_pitch;
const uint8_t *font_buf;
rgui_folder_enum_cb_t folder_cb;
void *userdata;
rgui_list_t *path_stack;
rgui_list_t *folder_buf;
size_t directory_ptr;
bool need_refresh;
char path_buf[PATH_MAX];
uint16_t font_white[256][FONT_HEIGHT][FONT_WIDTH];
uint16_t font_green[256][FONT_HEIGHT][FONT_WIDTH];
};
static void copy_glyph(uint16_t glyph_white[FONT_HEIGHT][FONT_WIDTH],
uint16_t glyph_green[FONT_HEIGHT][FONT_WIDTH],
const uint8_t *buf)
{
for (int y = 0; y < FONT_HEIGHT; y++)
{
for (int x = 0; x < FONT_WIDTH; x++)
{
uint32_t col =
((uint32_t)buf[3 * (-y * 256 + x) + 0] << 0) |
((uint32_t)buf[3 * (-y * 256 + x) + 1] << 8) |
((uint32_t)buf[3 * (-y * 256 + x) + 2] << 16);
glyph_white[y][x] = col == 0xff ? 0 : 0x7fff;
glyph_green[y][x] = col == 0xff ? 0 : (5 << 10) | (20 << 5) | (5 << 0);
}
}
}
static void init_font(rgui_handle_t *rgui, const char *path)
{
for (unsigned i = 0; i < 256; i++)
{
unsigned y = i / 16;
unsigned x = i % 16;
copy_glyph(rgui->font_white[i],
rgui->font_green[i],
rgui->font_buf + 54 + 3 * (256 * (255 - 16 * y) + 16 * x));
}
}
rgui_handle_t *rgui_init(const char *base_path,
uint16_t *buf, size_t buf_pitch,
const uint8_t *font_buf,
rgui_folder_enum_cb_t folder_cb, void *userdata)
{
rgui_handle_t *rgui = (rgui_handle_t*)calloc(1, sizeof(*rgui));
rgui->frame_buf = buf;
rgui->frame_buf_pitch = buf_pitch;
rgui->font_buf = font_buf;
rgui->folder_cb = folder_cb;
rgui->userdata = userdata;
rgui->path_stack = rgui_list_new();
rgui->folder_buf = rgui_list_new();
rgui_list_push(rgui->path_stack, base_path, RGUI_FILE_DIRECTORY);
init_font(rgui, "font.bmp");
return rgui;
}
void rgui_free(rgui_handle_t *rgui)
{
rgui_list_free(rgui->path_stack);
rgui_list_free(rgui->folder_buf);
free(rgui);
}
static uint16_t gray_filler(unsigned x, unsigned y)
{
x >>= 1;
y >>= 1;
uint16_t col = ((x + y) & 1) + 1;
col <<= 1;
return (col << 0) | (col << 5) | (col << 10);
}
static uint16_t green_filler(unsigned x, unsigned y)
{
x >>= 1;
y >>= 1;
uint16_t col = ((x + y) & 1) + 1;
col <<= 1;
return (col << 0) | (col << 6) | (col << 10);
}
static void fill_rect(uint16_t *buf, unsigned pitch,
unsigned x, unsigned y,
unsigned width, unsigned height,
uint16_t (*col)(unsigned x, unsigned y))
{
for (unsigned j = y; j < y + height; j++)
for (unsigned i = x; i < x + width; i++)
buf[j * (pitch >> 1) + i] = col(i, j);
}
static void blit_line(rgui_handle_t *rgui,
unsigned x, unsigned y, const char *message, bool green)
{
while (*message)
{
for (unsigned j = 0; j < FONT_HEIGHT; j++)
{
for (unsigned i = 0; i < FONT_WIDTH; i++)
{
uint16_t col = green ?
rgui->font_green[(unsigned char)*message][j][i] :
rgui->font_white[(unsigned char)*message][j][i];
if (col)
rgui->frame_buf[(y + j) * (rgui->frame_buf_pitch >> 1) + (x + i)] = col;
}
}
x += FONT_WIDTH_STRIDE;
message++;
}
}
static void render_text(rgui_handle_t *rgui, size_t begin, size_t end)
{
fill_rect(rgui->frame_buf, rgui->frame_buf_pitch,
0, 0, RGUI_WIDTH, RGUI_HEIGHT, gray_filler);
fill_rect(rgui->frame_buf, rgui->frame_buf_pitch,
5, 5, RGUI_WIDTH - 10, 5, green_filler);
fill_rect(rgui->frame_buf, rgui->frame_buf_pitch,
5, RGUI_HEIGHT - 10, RGUI_WIDTH - 10, 5, green_filler);
fill_rect(rgui->frame_buf, rgui->frame_buf_pitch,
5, 5, 5, RGUI_HEIGHT - 10, green_filler);
fill_rect(rgui->frame_buf, rgui->frame_buf_pitch,
RGUI_WIDTH - 10, 5, 5, RGUI_HEIGHT - 10, green_filler);
unsigned x = TERM_START_X;
unsigned y = TERM_START_Y;
for (size_t i = begin; i < end; i++, y += FONT_HEIGHT_STRIDE)
{
const char *path;
rgui_file_type_t type;
rgui_list_at(rgui->folder_buf, i, &path, &type);
char message[TERM_WIDTH + 1];
snprintf(message, sizeof(message), "%c %-*s %6s\n",
i == rgui->directory_ptr ? '>' : ' ',
TERM_WIDTH - (6 + 1 + 2),
path,
type == RGUI_FILE_PLAIN ? "(FILE)" : "(DIR)");
blit_line(rgui, x, y, message, i == rgui->directory_ptr);
}
}
const char *rgui_iterate(rgui_handle_t *rgui, rgui_action_t action)
{
switch (action)
{
case RGUI_ACTION_UP:
if (rgui->directory_ptr > 0)
rgui->directory_ptr--;
break;
case RGUI_ACTION_DOWN:
if (rgui->directory_ptr + 1 < rgui_list_size(rgui->folder_buf))
rgui->directory_ptr++;
break;
case RGUI_ACTION_LEFT:
case RGUI_ACTION_CANCEL:
if (rgui_list_size(rgui->path_stack) > 1)
{
rgui_list_pop(rgui->path_stack);
rgui->need_refresh = true;
}
break;
case RGUI_ACTION_RIGHT:
case RGUI_ACTION_OK:
{
if (rgui_list_size(rgui->folder_buf) == 0)
return NULL;
const char *path = NULL;
rgui_file_type_t type = RGUI_FILE_PLAIN;
rgui_list_at(rgui->folder_buf, rgui->directory_ptr,
&path, &type);
const char *dir;
rgui_list_back(rgui->path_stack, &dir, NULL);
if (type == RGUI_FILE_DIRECTORY)
{
char cat_path[PATH_MAX];
snprintf(cat_path, sizeof(cat_path), "%s/%s",
strcmp(dir, "/") == 0 ? "" : dir, path);
rgui_list_push(rgui->path_stack, cat_path, RGUI_FILE_DIRECTORY);
rgui->need_refresh = true;
}
else
{
snprintf(rgui->path_buf, sizeof(rgui->path_buf), "%s/%s",
strcmp(dir, "/") == 0 ? "" : dir, path);
return rgui->path_buf;
}
break;
}
case RGUI_ACTION_REFRESH:
rgui->need_refresh = true;
break;
default:
return NULL;
}
if (rgui->need_refresh)
{
rgui->directory_ptr = 0;
rgui_list_clear(rgui->folder_buf);
const char *path = NULL;
rgui_list_back(rgui->path_stack, &path, NULL);
if (!rgui->folder_cb(path,
(rgui_file_enum_cb_t)rgui_list_push,
rgui->userdata, rgui->folder_buf))
return NULL;
rgui_list_sort(rgui->folder_buf);
rgui->need_refresh = false;
}
size_t begin = rgui->directory_ptr >= TERM_HEIGHT / 2 ?
rgui->directory_ptr - TERM_HEIGHT / 2 : 0;
size_t end = rgui->directory_ptr + TERM_HEIGHT <= rgui_list_size(rgui->folder_buf) ?
rgui->directory_ptr + TERM_HEIGHT : rgui_list_size(rgui->folder_buf);
if (end - begin > TERM_HEIGHT)
end = begin + TERM_HEIGHT;
render_text(rgui, begin, end);
return NULL;
}

50
console/sgui/sgui.h → console/rgui/rgui.h
View File

@ -13,8 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SGUI_H__
#define SGUI_H__
#ifndef RGUI_H__
#define RGUI_H__
#include <stdint.h>
#include <stddef.h>
@ -27,40 +27,40 @@ extern "C" {
typedef enum
{
SGUI_FILE_PLAIN,
SGUI_FILE_DIRECTORY
} sgui_file_type_t;
RGUI_FILE_PLAIN,
RGUI_FILE_DIRECTORY
} rgui_file_type_t;
typedef enum
{
SGUI_ACTION_UP,
SGUI_ACTION_DOWN,
SGUI_ACTION_LEFT,
SGUI_ACTION_RIGHT,
SGUI_ACTION_OK,
SGUI_ACTION_CANCEL,
SGUI_ACTION_REFRESH,
SGUI_ACTION_NOOP
} sgui_action_t;
RGUI_ACTION_UP,
RGUI_ACTION_DOWN,
RGUI_ACTION_LEFT,
RGUI_ACTION_RIGHT,
RGUI_ACTION_OK,
RGUI_ACTION_CANCEL,
RGUI_ACTION_REFRESH,
RGUI_ACTION_NOOP
} rgui_action_t;
typedef struct sgui_handle sgui_handle_t;
typedef struct rgui_handle rgui_handle_t;
typedef void (*sgui_file_enum_cb_t)(void *ctx, const char *path,
sgui_file_type_t file_type);
typedef bool (*sgui_folder_enum_cb_t)(const char *directory,
sgui_file_enum_cb_t file_cb, void *userdata, void *ctx);
typedef void (*rgui_file_enum_cb_t)(void *ctx, const char *path,
rgui_file_type_t file_type);
typedef bool (*rgui_folder_enum_cb_t)(const char *directory,
rgui_file_enum_cb_t file_cb, void *userdata, void *ctx);
#define SGUI_WIDTH 320
#define SGUI_HEIGHT 240
#define RGUI_WIDTH 320
#define RGUI_HEIGHT 240
sgui_handle_t *sgui_init(const char *base_path,
rgui_handle_t *rgui_init(const char *base_path,
uint16_t *framebuf, size_t framebuf_pitch,
const uint8_t *font_buf,
sgui_folder_enum_cb_t folder_cb, void *userdata);
rgui_folder_enum_cb_t folder_cb, void *userdata);
const char *sgui_iterate(sgui_handle_t *sgui, sgui_action_t action);
const char *rgui_iterate(rgui_handle_t *rgui, rgui_action_t action);
void sgui_free(sgui_handle_t *sgui);
void rgui_free(rgui_handle_t *rgui);
#ifdef __cplusplus
}

312
console/sgui/sgui.c
View File

@ -1,312 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2012 - Hans-Kristian Arntzen
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "sgui.h"
#include "list.h"
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#define FONT_WIDTH 5
#define FONT_HEIGHT 10
#define FONT_WIDTH_STRIDE (FONT_WIDTH + 1)
#define FONT_HEIGHT_STRIDE (FONT_HEIGHT + 1)
#define TERM_WIDTH (((SGUI_WIDTH - 30) / (FONT_WIDTH_STRIDE)))
#define TERM_HEIGHT (((SGUI_HEIGHT - 30) / (FONT_HEIGHT_STRIDE)))
#define TERM_START_X 15
#define TERM_START_Y 15
struct sgui_handle
{
uint16_t *frame_buf;
size_t frame_buf_pitch;
const uint8_t *font_buf;
sgui_folder_enum_cb_t folder_cb;
void *userdata;
sgui_list_t *path_stack;
sgui_list_t *folder_buf;
size_t directory_ptr;
bool need_refresh;
char path_buf[PATH_MAX];
uint16_t font_white[256][FONT_HEIGHT][FONT_WIDTH];
uint16_t font_green[256][FONT_HEIGHT][FONT_WIDTH];
};
static void copy_glyph(uint16_t glyph_white[FONT_HEIGHT][FONT_WIDTH],
uint16_t glyph_green[FONT_HEIGHT][FONT_WIDTH],
const uint8_t *buf)
{
for (int y = 0; y < FONT_HEIGHT; y++)
{
for (int x = 0; x < FONT_WIDTH; x++)
{
uint32_t col =
((uint32_t)buf[3 * (-y * 256 + x) + 0] << 0) |
((uint32_t)buf[3 * (-y * 256 + x) + 1] << 8) |
((uint32_t)buf[3 * (-y * 256 + x) + 2] << 16);
glyph_white[y][x] = col == 0xff ? 0 : 0x7fff;
glyph_green[y][x] = col == 0xff ? 0 : (5 << 10) | (20 << 5) | (5 << 0);
}
}
}
static void init_font(sgui_handle_t *sgui, const char *path)
{
for (unsigned i = 0; i < 256; i++)
{
unsigned y = i / 16;
unsigned x = i % 16;
copy_glyph(sgui->font_white[i],
sgui->font_green[i],
sgui->font_buf + 54 + 3 * (256 * (255 - 16 * y) + 16 * x));
}
}
sgui_handle_t *sgui_init(const char *base_path,
uint16_t *buf, size_t buf_pitch,
const uint8_t *font_buf,
sgui_folder_enum_cb_t folder_cb, void *userdata)
{
sgui_handle_t *sgui = (sgui_handle_t*)calloc(1, sizeof(*sgui));
sgui->frame_buf = buf;
sgui->frame_buf_pitch = buf_pitch;
sgui->font_buf = font_buf;
sgui->folder_cb = folder_cb;
sgui->userdata = userdata;
sgui->path_stack = sgui_list_new();
sgui->folder_buf = sgui_list_new();
sgui_list_push(sgui->path_stack, base_path, SGUI_FILE_DIRECTORY);
init_font(sgui, "font.bmp");
return sgui;
}
void sgui_free(sgui_handle_t *sgui)
{
sgui_list_free(sgui->path_stack);
sgui_list_free(sgui->folder_buf);
free(sgui);
}
static uint16_t gray_filler(unsigned x, unsigned y)
{
x >>= 1;
y >>= 1;
uint16_t col = ((x + y) & 1) + 1;
col <<= 1;
return (col << 0) | (col << 5) | (col << 10);
}
static uint16_t green_filler(unsigned x, unsigned y)
{
x >>= 1;
y >>= 1;
uint16_t col = ((x + y) & 1) + 1;
col <<= 1;
return (col << 0) | (col << 6) | (col << 10);
}
static void fill_rect(uint16_t *buf, unsigned pitch,
unsigned x, unsigned y,
unsigned width, unsigned height,
uint16_t (*col)(unsigned x, unsigned y))
{
for (unsigned j = y; j < y + height; j++)
for (unsigned i = x; i < x + width; i++)
buf[j * (pitch >> 1) + i] = col(i, j);
}
static void blit_line(sgui_handle_t *sgui,
unsigned x, unsigned y, const char *message, bool green)
{
while (*message)
{
for (unsigned j = 0; j < FONT_HEIGHT; j++)
{
for (unsigned i = 0; i < FONT_WIDTH; i++)
{
uint16_t col = green ?
sgui->font_green[(unsigned char)*message][j][i] :
sgui->font_white[(unsigned char)*message][j][i];
if (col)
sgui->frame_buf[(y + j) * (sgui->frame_buf_pitch >> 1) + (x + i)] = col;
}
}
x += FONT_WIDTH_STRIDE;
message++;
}
}
static void render_text(sgui_handle_t *sgui, size_t begin, size_t end)
{
fill_rect(sgui->frame_buf, sgui->frame_buf_pitch,
0, 0, SGUI_WIDTH, SGUI_HEIGHT, gray_filler);
fill_rect(sgui->frame_buf, sgui->frame_buf_pitch,
5, 5, SGUI_WIDTH - 10, 5, green_filler);
fill_rect(sgui->frame_buf, sgui->frame_buf_pitch,
5, SGUI_HEIGHT - 10, SGUI_WIDTH - 10, 5, green_filler);
fill_rect(sgui->frame_buf, sgui->frame_buf_pitch,
5, 5, 5, SGUI_HEIGHT - 10, green_filler);
fill_rect(sgui->frame_buf, sgui->frame_buf_pitch,
SGUI_WIDTH - 10, 5, 5, SGUI_HEIGHT - 10, green_filler);
unsigned x = TERM_START_X;
unsigned y = TERM_START_Y;
for (size_t i = begin; i < end; i++, y += FONT_HEIGHT_STRIDE)
{
const char *path;
sgui_file_type_t type;
sgui_list_at(sgui->folder_buf, i, &path, &type);
char message[TERM_WIDTH + 1];
snprintf(message, sizeof(message), "%c %-*s %6s\n",
i == sgui->directory_ptr ? '>' : ' ',
TERM_WIDTH - (6 + 1 + 2),
path,
type == SGUI_FILE_PLAIN ? "(FILE)" : "(DIR)");
blit_line(sgui, x, y, message, i == sgui->directory_ptr);
}
}
const char *sgui_iterate(sgui_handle_t *sgui, sgui_action_t action)
{
switch (action)
{
case SGUI_ACTION_UP:
if (sgui->directory_ptr > 0)
sgui->directory_ptr--;
break;
case SGUI_ACTION_DOWN:
if (sgui->directory_ptr + 1 < sgui_list_size(sgui->folder_buf))
sgui->directory_ptr++;
break;
case SGUI_ACTION_LEFT:
case SGUI_ACTION_CANCEL:
if (sgui_list_size(sgui->path_stack) > 1)
{
sgui_list_pop(sgui->path_stack);
sgui->need_refresh = true;
}
break;
case SGUI_ACTION_RIGHT:
case SGUI_ACTION_OK:
{
if (sgui_list_size(sgui->folder_buf) == 0)
return NULL;
const char *path = NULL;
sgui_file_type_t type = SGUI_FILE_PLAIN;
sgui_list_at(sgui->folder_buf, sgui->directory_ptr,
&path, &type);
const char *dir;
sgui_list_back(sgui->path_stack, &dir, NULL);
if (type == SGUI_FILE_DIRECTORY)
{
char cat_path[PATH_MAX];
snprintf(cat_path, sizeof(cat_path), "%s/%s",
strcmp(dir, "/") == 0 ? "" : dir, path);
sgui_list_push(sgui->path_stack, cat_path, SGUI_FILE_DIRECTORY);
sgui->need_refresh = true;
}
else
{
snprintf(sgui->path_buf, sizeof(sgui->path_buf), "%s/%s",
strcmp(dir, "/") == 0 ? "" : dir, path);
return sgui->path_buf;
}
break;
}
case SGUI_ACTION_REFRESH:
sgui->need_refresh = true;
break;
default:
return NULL;
}
if (sgui->need_refresh)
{
sgui->directory_ptr = 0;
sgui_list_clear(sgui->folder_buf);
const char *path = NULL;
sgui_list_back(sgui->path_stack, &path, NULL);
if (!sgui->folder_cb(path,
(sgui_file_enum_cb_t)sgui_list_push,
sgui->userdata, sgui->folder_buf))
return NULL;
sgui_list_sort(sgui->folder_buf);
sgui->need_refresh = false;
}
size_t begin = sgui->directory_ptr >= TERM_HEIGHT / 2 ?
sgui->directory_ptr - TERM_HEIGHT / 2 : 0;
size_t end = sgui->directory_ptr + TERM_HEIGHT <= sgui_list_size(sgui->folder_buf) ?
sgui->directory_ptr + TERM_HEIGHT : sgui_list_size(sgui->folder_buf);
if (end - begin > TERM_HEIGHT)
end = begin + TERM_HEIGHT;
#if 0
printf("========================================\n");
for (size_t i = begin; i < end; i++)
{
const char *path;
sgui_file_type_t type;
sgui_list_at(sgui->folder_buf, i, &path, &type);
printf("%c %-50s %s\n",
i == sgui->directory_ptr ? '>' : ' ',
path,
type == SGUI_FILE_PLAIN ? "(FILE)" : "(DIR)");
}
printf("========================================\n");
#endif
render_text(sgui, begin, end);
return NULL;
}

36
wii/main.c
View File

@ -16,7 +16,7 @@
#undef main
#include <stdbool.h>
#include "../console/sgui/sgui.h"
#include "../console/rgui/rgui.h"
#include "../driver.h"
#include "../general.h"
#include "../libretro.h"
@ -39,9 +39,9 @@
FILE * log_fp;
#endif
static uint16_t menu_framebuf[SGUI_WIDTH * SGUI_HEIGHT];
static uint16_t menu_framebuf[RGUI_WIDTH * RGUI_HEIGHT];
static bool folder_cb(const char *directory, sgui_file_enum_cb_t file_cb,
static bool folder_cb(const char *directory, rgui_file_enum_cb_t file_cb,
void *userdata, void *ctx)
{
(void)userdata;
@ -64,19 +64,19 @@ static bool folder_cb(const char *directory, sgui_file_enum_cb_t file_cb,
file_cb(ctx,
entry->d_name, S_ISDIR(st.st_mode) ?
SGUI_FILE_DIRECTORY : SGUI_FILE_PLAIN);
RGUI_FILE_DIRECTORY : RGUI_FILE_PLAIN);
}
closedir(dir);
return true;
}
static const char *get_rom_path(sgui_handle_t *sgui)
static const char *get_rom_path(rgui_handle_t *rgui)
{
uint16_t old_input_state = 0;
bool can_quit = false;
sgui_iterate(sgui, SGUI_ACTION_REFRESH);
rgui_iterate(rgui, RGUI_ACTION_REFRESH);
for (;;)
{
@ -99,23 +99,23 @@ static const char *get_rom_path(sgui_handle_t *sgui)
uint16_t trigger_state = input_state & ~old_input_state;
sgui_action_t action = SGUI_ACTION_NOOP;
rgui_action_t action = RGUI_ACTION_NOOP;
if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_B))
action = SGUI_ACTION_CANCEL;
action = RGUI_ACTION_CANCEL;
else if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_A))
action = SGUI_ACTION_OK;
action = RGUI_ACTION_OK;
else if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_UP))
action = SGUI_ACTION_UP;
action = RGUI_ACTION_UP;
else if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_DOWN))
action = SGUI_ACTION_DOWN;
action = RGUI_ACTION_DOWN;
const char *ret = sgui_iterate(sgui, action);
const char *ret = rgui_iterate(rgui, action);
if (ret)
return ret;
video_wii.frame(NULL, menu_framebuf,
SGUI_WIDTH, SGUI_HEIGHT,
SGUI_WIDTH * sizeof(uint16_t), NULL);
RGUI_WIDTH, RGUI_HEIGHT,
RGUI_WIDTH * sizeof(uint16_t), NULL);
old_input_state = input_state;
rarch_sleep(10);
@ -138,13 +138,13 @@ int main(void)
wii_video_init();
wii_input_init();
sgui_handle_t *sgui = sgui_init("sd:/",
menu_framebuf, SGUI_WIDTH * sizeof(uint16_t),
rgui_handle_t *rgui = rgui_init("sd:/",
menu_framebuf, RGUI_WIDTH * sizeof(uint16_t),
_binary_console_font_bmp_start, folder_cb, NULL);
const char *rom_path;
int ret = 0;
while ((rom_path = get_rom_path(sgui)) && ret == 0)
while ((rom_path = get_rom_path(rgui)) && ret == 0)
{
g_console.initialize_rarch_enable = true;
strlcpy(g_console.rom_path, rom_path, sizeof(g_console.rom_path));
@ -168,7 +168,7 @@ int main(void)
fclose(log_fp);
#endif
sgui_free(sgui);
rgui_free(rgui);
return ret;
}