mirror of
https://github.com/libretro/RetroArch.git
synced 2024-11-29 11:10:27 +00:00
1185 lines
40 KiB
Objective-C
1185 lines
40 KiB
Objective-C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2013-2014 - Jason Fetters
|
|
*
|
|
* 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 <objc/runtime.h>
|
|
#include "../common/RetroArch_Apple.h"
|
|
#include "../../input/input_common.h"
|
|
#include "../../input/apple_input.h"
|
|
#include "menu.h"
|
|
|
|
/*********************************************/
|
|
/* RunActionSheet */
|
|
/* Creates and displays a UIActionSheet with */
|
|
/* buttons pulled from a RetroArch */
|
|
/* string_list structure. */
|
|
/*********************************************/
|
|
static const void* const associated_delegate_key = &associated_delegate_key;
|
|
|
|
typedef void (^RAActionSheetCallback)(UIActionSheet*, NSInteger);
|
|
|
|
@interface RARunActionSheetDelegate : NSObject<UIActionSheetDelegate>
|
|
@property (nonatomic, copy) RAActionSheetCallback callbackBlock;
|
|
@end
|
|
|
|
@implementation RARunActionSheetDelegate
|
|
|
|
- (id)initWithCallbackBlock:(RAActionSheetCallback)callback
|
|
{
|
|
if ((self = [super init]))
|
|
_callbackBlock = callback;
|
|
return self;
|
|
}
|
|
|
|
- (void)actionSheet:(UIActionSheet *)actionSheet willDismissWithButtonIndex:(NSInteger)buttonIndex
|
|
{
|
|
if (self.callbackBlock)
|
|
self.callbackBlock(actionSheet, buttonIndex);
|
|
}
|
|
|
|
@end
|
|
|
|
static void RunActionSheet(const char* title, const struct string_list* items, UIView* parent, RAActionSheetCallback callback)
|
|
{
|
|
int i;
|
|
RARunActionSheetDelegate* delegate = [[RARunActionSheetDelegate alloc] initWithCallbackBlock:callback];
|
|
UIActionSheet* actionSheet = [UIActionSheet new];
|
|
|
|
actionSheet.title = BOXSTRING(title);
|
|
actionSheet.delegate = delegate;
|
|
|
|
for (i = 0; i < items->size; i ++)
|
|
[actionSheet addButtonWithTitle:BOXSTRING(items->elems[i].data)];
|
|
|
|
actionSheet.cancelButtonIndex = [actionSheet addButtonWithTitle:BOXSTRING("Cancel")];
|
|
|
|
objc_setAssociatedObject(actionSheet, associated_delegate_key, delegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
|
|
|
|
[actionSheet showInView:parent];
|
|
}
|
|
|
|
|
|
/*********************************************/
|
|
/* RAMenuBase */
|
|
/* A menu class that displays RAMenuItemBase */
|
|
/* objects. */
|
|
/*********************************************/
|
|
@implementation RAMenuBase
|
|
|
|
- (id)initWithStyle:(UITableViewStyle)style
|
|
{
|
|
if ((self = [super initWithStyle:style]))
|
|
_sections = [NSMutableArray array];
|
|
return self;
|
|
}
|
|
|
|
- (NSInteger)numberOfSectionsInTableView:(UITableView*)tableView
|
|
{
|
|
return self.sections.count;
|
|
}
|
|
|
|
- (NSString*)tableView:(UITableView*)tableView titleForHeaderInSection:(NSInteger)section
|
|
{
|
|
return self.hidesHeaders ? nil : self.sections[section][0];
|
|
}
|
|
|
|
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
|
|
{
|
|
return [self.sections[section] count] - 1;
|
|
}
|
|
|
|
- (id)itemForIndexPath:(NSIndexPath*)indexPath
|
|
{
|
|
return self.sections[indexPath.section][indexPath.row + 1];
|
|
}
|
|
|
|
- (UITableViewCell*)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
|
|
{
|
|
return [[self itemForIndexPath:indexPath] cellForTableView:tableView];
|
|
}
|
|
|
|
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
|
|
{
|
|
[[self itemForIndexPath:indexPath] wasSelectedOnTableView:tableView ofController:self];
|
|
}
|
|
|
|
- (void)willReloadData
|
|
{
|
|
|
|
}
|
|
|
|
- (void)reloadData
|
|
{
|
|
[self willReloadData];
|
|
[[self tableView] reloadData];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemBasic */
|
|
/* A simple menu item that displays a text */
|
|
/* description and calls a block object when */
|
|
/* selected. */
|
|
/*********************************************/
|
|
@implementation RAMenuItemBasic
|
|
|
|
+ (RAMenuItemBasic*)itemWithDescription:(NSString*)description action:(void (^)())action
|
|
{
|
|
return [self itemWithDescription:description action:action detail:Nil];
|
|
}
|
|
|
|
+ (RAMenuItemBasic*)itemWithDescription:(NSString*)description action:(void (^)())action detail:(NSString* (^)())detail
|
|
{
|
|
return [self itemWithDescription:description association:nil action:action detail:detail];
|
|
}
|
|
|
|
+ (RAMenuItemBasic*)itemWithDescription:(NSString*)description association:(id)userdata action:(void (^)())action detail:(NSString* (^)())detail
|
|
{
|
|
RAMenuItemBasic* item = [RAMenuItemBasic new];
|
|
item.description = description;
|
|
item.userdata = userdata;
|
|
item.action = action;
|
|
item.detail = detail;
|
|
return item;
|
|
}
|
|
|
|
- (UITableViewCell*)cellForTableView:(UITableView*)tableView
|
|
{
|
|
static NSString* const cell_id = @"text";
|
|
|
|
UITableViewCell* result = [tableView dequeueReusableCellWithIdentifier:cell_id];
|
|
if (!result)
|
|
result = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:cell_id];
|
|
|
|
result.selectionStyle = UITableViewCellSelectionStyleNone;
|
|
result.textLabel.text = self.description;
|
|
result.detailTextLabel.text = self.detail ? self.detail(self.userdata) : nil;
|
|
return result;
|
|
}
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
if (self.action)
|
|
self.action(self.userdata);
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemGeneralSetting */
|
|
/* A simple menu item that displays the */
|
|
/* state, and allows editing, of a string or */
|
|
/* numeric setting. */
|
|
/*********************************************/
|
|
@interface RAMenuItemGeneralSetting() <UIAlertViewDelegate>
|
|
@property (nonatomic) RANumberFormatter* formatter;
|
|
@end
|
|
|
|
@implementation RAMenuItemGeneralSetting
|
|
|
|
+ (id)itemForSetting:(rarch_setting_t*)setting
|
|
{
|
|
switch (setting->type)
|
|
{
|
|
case ST_BOOL:
|
|
return [[RAMenuItemBooleanSetting alloc] initWithSetting:setting];
|
|
case ST_PATH:
|
|
return [[RAMenuItemPathSetting alloc] initWithSetting:setting];
|
|
case ST_BIND:
|
|
return [[RAMenuItemBindSetting alloc] initWithSetting:setting];
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (setting->type == ST_STRING && setting->values)
|
|
return [[RAMenuItemEnumSetting alloc] initWithSetting:setting];
|
|
|
|
RAMenuItemGeneralSetting* item = [[RAMenuItemGeneralSetting alloc] initWithSetting:setting];
|
|
|
|
if (item.setting->type == ST_INT || item.setting->type == ST_UINT || item.setting->type == ST_FLOAT)
|
|
item.formatter = [[RANumberFormatter alloc] initWithSetting:item.setting];
|
|
|
|
return item;
|
|
}
|
|
|
|
- (id)initWithSetting:(rarch_setting_t*)setting
|
|
{
|
|
if ((self = [super init]))
|
|
_setting = setting;
|
|
return self;
|
|
}
|
|
|
|
- (UITableViewCell*)cellForTableView:(UITableView*)tableView
|
|
{
|
|
char buffer[256];
|
|
static NSString* const cell_id = @"string_setting";
|
|
|
|
self.parentTable = tableView;
|
|
|
|
UITableViewCell* result = [tableView dequeueReusableCellWithIdentifier:cell_id];
|
|
if (!result)
|
|
{
|
|
result = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:cell_id];
|
|
result.selectionStyle = UITableViewCellSelectionStyleNone;
|
|
}
|
|
|
|
[self attachDefaultingGestureTo:result];
|
|
|
|
result.textLabel.text = BOXSTRING("N/A");
|
|
|
|
if (self.setting)
|
|
{
|
|
if (self.setting->short_description)
|
|
result.textLabel.text = BOXSTRING(self.setting->short_description);
|
|
|
|
result.detailTextLabel.text = BOXSTRING(setting_data_get_string_representation(self.setting, buffer, sizeof(buffer)));
|
|
|
|
if (self.setting->type == ST_PATH)
|
|
result.detailTextLabel.text = [result.detailTextLabel.text lastPathComponent];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
char buffer[256];
|
|
NSString *desc = BOXSTRING("N/A");
|
|
UIAlertView *alertView;
|
|
UITextField *field;
|
|
|
|
if (self.setting && self.setting->short_description)
|
|
desc = BOXSTRING(self.setting->short_description);
|
|
|
|
alertView = [[UIAlertView alloc] initWithTitle:BOXSTRING("Enter new value") message:desc delegate:self cancelButtonTitle:BOXSTRING("Cancel") otherButtonTitles:BOXSTRING("OK"), nil];
|
|
alertView.alertViewStyle = UIAlertViewStylePlainTextInput;
|
|
|
|
field = [alertView textFieldAtIndex:0];
|
|
|
|
field.delegate = self.formatter;
|
|
field.placeholder = BOXSTRING(setting_data_get_string_representation(self.setting, buffer, sizeof(buffer)));
|
|
|
|
[alertView show];
|
|
}
|
|
|
|
- (void)alertView:(UIAlertView*)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
|
|
{
|
|
NSString* text = (NSString*)[alertView textFieldAtIndex:0].text;
|
|
|
|
if (buttonIndex == alertView.firstOtherButtonIndex && text.length)
|
|
{
|
|
setting_data_set_with_string_representation(self.setting, [text UTF8String]);
|
|
[self.parentTable reloadData];
|
|
}
|
|
}
|
|
|
|
- (void)attachDefaultingGestureTo:(UIView*)view
|
|
{
|
|
for (UIGestureRecognizer* i in view.gestureRecognizers)
|
|
[view removeGestureRecognizer:i];
|
|
[view addGestureRecognizer:[[UILongPressGestureRecognizer alloc] initWithTarget:self
|
|
action:@selector(resetValue:)]];
|
|
}
|
|
|
|
- (void)resetValue:(UIGestureRecognizer*)gesture
|
|
{
|
|
if (gesture.state == UIGestureRecognizerStateBegan)
|
|
{
|
|
struct string_list* items;
|
|
RAMenuItemGeneralSetting __weak* weakSelf = self;
|
|
|
|
items = (struct string_list*)string_split("OK", "|");
|
|
RunActionSheet("Really Reset Value?", items, self.parentTable,
|
|
^(UIActionSheet* actionSheet, NSInteger buttonIndex)
|
|
{
|
|
if (buttonIndex != actionSheet.cancelButtonIndex)
|
|
setting_data_reset_setting(self.setting);
|
|
[weakSelf.parentTable reloadData];
|
|
});
|
|
string_list_free(items);
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemBooleanSetting */
|
|
/* A simple menu item that displays the */
|
|
/* state, and allows editing, of a boolean */
|
|
/* setting. */
|
|
/*********************************************/
|
|
@implementation RAMenuItemBooleanSetting
|
|
|
|
- (id)initWithSetting:(rarch_setting_t*)setting
|
|
{
|
|
if ((self = [super init]))
|
|
_setting = setting;
|
|
return self;
|
|
}
|
|
|
|
- (UITableViewCell*)cellForTableView:(UITableView*)tableView
|
|
{
|
|
static NSString* const cell_id = @"boolean_setting";
|
|
|
|
UITableViewCell* result = (UITableViewCell*)[tableView dequeueReusableCellWithIdentifier:cell_id];
|
|
if (!result)
|
|
{
|
|
result = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:cell_id];
|
|
result.selectionStyle = UITableViewCellSelectionStyleNone;
|
|
result.accessoryView = [UISwitch new];
|
|
}
|
|
|
|
result.textLabel.text = BOXSTRING(self.setting->short_description);
|
|
[(id)result.accessoryView removeTarget:nil action:NULL forControlEvents:UIControlEventValueChanged];
|
|
[(id)result.accessoryView addTarget:self action:@selector(handleBooleanSwitch:) forControlEvents:UIControlEventValueChanged];
|
|
|
|
if (self.setting)
|
|
[(id)result.accessoryView setOn:*self.setting->value.boolean];
|
|
return result;
|
|
}
|
|
|
|
- (void)handleBooleanSwitch:(UISwitch*)swt
|
|
{
|
|
if (self.setting)
|
|
*self.setting->value.boolean = swt.on ? true : false;
|
|
}
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemPathSetting */
|
|
/* A menu item that displays and allows */
|
|
/* browsing for a path setting. */
|
|
/*********************************************/
|
|
@interface RAMenuItemPathSetting() @end
|
|
@implementation RAMenuItemPathSetting
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
NSString *path;
|
|
RADirectoryList* list;
|
|
RAMenuItemPathSetting __weak* weakSelf = self;
|
|
|
|
path = [BOXSTRING(self.setting->value.string) stringByDeletingLastPathComponent];
|
|
list = [[RADirectoryList alloc] initWithPath:path extensions:self.setting->values action:
|
|
^(RADirectoryList* list, RADirectoryItem* item)
|
|
{
|
|
if (!list.allowBlank && !item)
|
|
return;
|
|
|
|
if (list.forDirectory && !item.isDirectory)
|
|
return;
|
|
|
|
setting_data_set_with_string_representation(weakSelf.setting, item ? [item.path UTF8String] : "");
|
|
[[list navigationController] popViewControllerAnimated:YES];
|
|
|
|
[weakSelf.parentTable reloadData];
|
|
}];
|
|
|
|
list.allowBlank = (self.setting->flags & SD_FLAG_ALLOW_EMPTY);
|
|
list.forDirectory = (self.setting->flags & SD_FLAG_PATH_DIR);
|
|
|
|
[controller.navigationController pushViewController:list animated:YES];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemEnumSetting */
|
|
/* A menu item that displays and allows */
|
|
/* a setting to be set from a list of */
|
|
/* allowed choices. */
|
|
/*********************************************/
|
|
@implementation RAMenuItemEnumSetting
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
struct string_list* items;
|
|
RAMenuItemEnumSetting __weak* weakSelf = self;
|
|
|
|
items = (struct string_list*)string_split(self.setting->values, "|");
|
|
RunActionSheet(self.setting->short_description, items, self.parentTable,
|
|
^(UIActionSheet* actionSheet, NSInteger buttonIndex)
|
|
{
|
|
if (buttonIndex != actionSheet.cancelButtonIndex)
|
|
{
|
|
setting_data_set_with_string_representation(self.setting, [[actionSheet buttonTitleAtIndex:buttonIndex] UTF8String]);
|
|
[weakSelf.parentTable reloadData];
|
|
}
|
|
});
|
|
string_list_free(items);
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemBindSetting */
|
|
/* A menu item that displays and allows */
|
|
/* mapping of a keybinding. */
|
|
/*********************************************/
|
|
@interface RAMenuItemBindSetting() <UIAlertViewDelegate>
|
|
@property (nonatomic) NSTimer* bindTimer;
|
|
@property (nonatomic) UIAlertView* alert;
|
|
@end
|
|
|
|
@implementation RAMenuItemBindSetting
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView *)tableView ofController:(UIViewController *)controller
|
|
{
|
|
self.alert = [[UIAlertView alloc] initWithTitle:BOXSTRING("RetroArch")
|
|
message:BOXSTRING(self.setting->short_description)
|
|
delegate:self
|
|
cancelButtonTitle:BOXSTRING("Cancel")
|
|
otherButtonTitles:BOXSTRING("Clear Keyboard"), BOXSTRING("Clear Joystick"), BOXSTRING("Clear Axis"), nil];
|
|
|
|
[self.alert show];
|
|
|
|
[self.parentTable reloadData];
|
|
|
|
self.bindTimer = [NSTimer scheduledTimerWithTimeInterval:.1f target:self selector:@selector(checkBind:)
|
|
userInfo:nil repeats:YES];
|
|
}
|
|
|
|
- (void)finishWithClickedButton:(bool)clicked
|
|
{
|
|
if (!clicked)
|
|
[self.alert dismissWithClickedButtonIndex:self.alert.cancelButtonIndex animated:YES];
|
|
self.alert = nil;
|
|
|
|
[self.parentTable reloadData];
|
|
|
|
[self.bindTimer invalidate];
|
|
self.bindTimer = nil;
|
|
|
|
apple_input_reset_icade_buttons();
|
|
}
|
|
|
|
- (void)alertView:(UIAlertView*)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
|
|
{
|
|
if (buttonIndex == alertView.firstOtherButtonIndex)
|
|
BINDFOR(*self.setting).key = RETROK_UNKNOWN;
|
|
else if(buttonIndex == alertView.firstOtherButtonIndex + 1)
|
|
BINDFOR(*self.setting).joykey = NO_BTN;
|
|
else if(buttonIndex == alertView.firstOtherButtonIndex + 2)
|
|
BINDFOR(*self.setting).joyaxis = AXIS_NONE;
|
|
|
|
[self finishWithClickedButton:true];
|
|
}
|
|
|
|
- (void)checkBind:(NSTimer*)send
|
|
{
|
|
int32_t value = 0;
|
|
int32_t index = 0;
|
|
|
|
if (self.setting->index)
|
|
index = self.setting->index - 1;
|
|
|
|
if ((value = apple_input_find_any_key()))
|
|
BINDFOR(*self.setting).key = input_translate_keysym_to_rk(value);
|
|
else if ((value = apple_input_find_any_button(index)) >= 0)
|
|
BINDFOR(*self.setting).joykey = value;
|
|
else if ((value = apple_input_find_any_axis(index)))
|
|
BINDFOR(*self.setting).joyaxis = (value > 0) ? AXIS_POS(value - 1) : AXIS_NEG(abs(value) - 1);
|
|
else
|
|
return;
|
|
|
|
[self finishWithClickedButton:false];
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
/*********************************************/
|
|
/* RAMainMenu */
|
|
/* Menu object that is displayed immediately */
|
|
/* after startup. */
|
|
/*********************************************/
|
|
@implementation RAMainMenu
|
|
|
|
- (id)init
|
|
{
|
|
if ((self = [super initWithStyle:UITableViewStylePlain]))
|
|
self.title = BOXSTRING("RetroArch");
|
|
return self;
|
|
}
|
|
|
|
- (void)viewWillAppear:(BOOL)animated
|
|
{
|
|
[self reloadData];
|
|
}
|
|
|
|
- (void)willReloadData
|
|
{
|
|
NSMutableArray* settings;
|
|
RAMainMenu* __weak weakSelf = self;
|
|
self.sections = [NSMutableArray array];
|
|
|
|
settings = [NSMutableArray arrayWithObjects:BOXSTRING("Settings"),
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Frontend")
|
|
action:^{ [weakSelf.navigationController pushViewController:[RAFrontendSettingsMenu new] animated:YES]; }],
|
|
nil];
|
|
|
|
if (g_extern.main_is_init)
|
|
{
|
|
[self.sections addObject:[NSArray arrayWithObjects:BOXSTRING("Actions"),
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Reset Content") action:^{ [weakSelf performBasicAction:RARCH_CMD_RESET]; }],
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Close Content") action:^{ [weakSelf performBasicAction:RARCH_CMD_QUIT]; }],
|
|
nil]];
|
|
|
|
[self.sections addObject:[NSArray arrayWithObjects:BOXSTRING("States"),
|
|
[RAMenuItemStateSelect new],
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Load State") action:^{ [weakSelf performBasicAction:RARCH_CMD_LOAD_STATE]; }],
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Save State") action:^{ [weakSelf performBasicAction:RARCH_CMD_SAVE_STATE]; }],
|
|
nil]];
|
|
|
|
[settings addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING("Core")
|
|
action:^{
|
|
char config_name[PATH_MAX];
|
|
fill_pathname_base(config_name, g_settings.libretro, sizeof(config_name));
|
|
|
|
[weakSelf.navigationController pushViewController:[[RACoreSettingsMenu alloc] initWithCore:BOXSTRING(config_name)] animated:YES];
|
|
}]];
|
|
[settings addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING("Core Options")
|
|
action:^{ [weakSelf.navigationController pushViewController:[RACoreOptionsMenu new] animated:YES]; }]];
|
|
}
|
|
else
|
|
{
|
|
[self.sections addObject:[NSArray arrayWithObjects:BOXSTRING("Content"),
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Choose Core")
|
|
action:^{ [weakSelf chooseCoreWithPath:nil]; }
|
|
detail:^{
|
|
const core_info_t *core = (const core_info_t*)core_info_list_get_by_id(weakSelf.core.UTF8String);
|
|
|
|
if (weakSelf.core)
|
|
{
|
|
return core ? BOXSTRING(core->display_name) : BOXSTRING(weakSelf.core.UTF8String);
|
|
}
|
|
else
|
|
return BOXSTRING("Auto Detect");
|
|
}],
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Load Content") action:^{ [weakSelf loadGame]; }],
|
|
[RAMenuItemBasic itemWithDescription:BOXSTRING("Load Content (History)") action:^{ [weakSelf loadHistory]; }],
|
|
nil]];
|
|
}
|
|
|
|
[self.sections addObject:settings];
|
|
|
|
if (g_extern.main_is_init)
|
|
self.navigationItem.leftBarButtonItem = [[UIBarButtonItem alloc] initWithTitle:BOXSTRING("Resume") style:UIBarButtonItemStyleBordered target:[RetroArch_iOS get] action:@selector(showGameView)];
|
|
else
|
|
self.navigationItem.leftBarButtonItem = nil;
|
|
}
|
|
|
|
- (void)performBasicAction:(unsigned)action
|
|
{
|
|
[[RetroArch_iOS get] showGameView];
|
|
rarch_main_command(action);
|
|
}
|
|
|
|
- (void)chooseCoreWithPath:(NSString*)path
|
|
{
|
|
RAMenuCoreList* list;
|
|
RAMainMenu* __weak weakSelf = self;
|
|
|
|
list = [[RAMenuCoreList alloc] initWithPath:path allowAutoDetect:!path
|
|
action: ^(NSString* core)
|
|
{
|
|
if (path)
|
|
apple_run_core(0, NULL, core.UTF8String, path.UTF8String);
|
|
else
|
|
{
|
|
weakSelf.core = core;
|
|
[weakSelf.tableView reloadData];
|
|
[weakSelf.navigationController popViewControllerAnimated:YES];
|
|
}
|
|
}];
|
|
|
|
// Don't push view controller if it already launched a game
|
|
if (!list.actionRan)
|
|
[self.navigationController pushViewController:list animated:YES];
|
|
}
|
|
|
|
- (void)loadGame
|
|
{
|
|
RADirectoryList* list;
|
|
RAMainMenu __weak* weakSelf = self;
|
|
|
|
list = [[RADirectoryList alloc] initWithPath:[RetroArch_iOS get].documentsDirectory extensions:NULL action:
|
|
^(RADirectoryList *list, RADirectoryItem *item)
|
|
{
|
|
if (item && !item.isDirectory)
|
|
{
|
|
if (weakSelf.core)
|
|
apple_run_core(0, NULL, weakSelf.core.UTF8String, item.path.UTF8String);
|
|
else
|
|
[weakSelf chooseCoreWithPath:item.path];
|
|
}
|
|
}];
|
|
|
|
[self.navigationController pushViewController:list animated:YES];
|
|
}
|
|
|
|
- (void)loadHistory
|
|
{
|
|
char history_path[PATH_MAX];
|
|
fill_pathname_join(history_path, g_defaults.system_dir, ".retroarch-game-history.txt", sizeof(history_path));
|
|
[self.navigationController pushViewController:[[RAHistoryMenu alloc] initWithHistoryPath:history_path] animated:YES];
|
|
}
|
|
|
|
@end
|
|
|
|
/*************************************************/
|
|
/* RAHistoryMenu */
|
|
/* Menu object that displays and allows */
|
|
/* launching a file from the content history. */
|
|
/*************************************************/
|
|
@implementation RAHistoryMenu
|
|
|
|
- (void)dealloc
|
|
{
|
|
if (_history)
|
|
content_history_free(_history);
|
|
}
|
|
|
|
- (id)initWithHistoryPath:(const char*)historyPath
|
|
{
|
|
if ((self = [super initWithStyle:UITableViewStylePlain]))
|
|
{
|
|
_history = content_history_init(historyPath, 100);
|
|
[self reloadData];
|
|
self.navigationItem.rightBarButtonItem = [[UIBarButtonItem alloc] initWithTitle:BOXSTRING("Clear History")
|
|
style:UIBarButtonItemStyleBordered target:self action:@selector(clearHistory)];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)clearHistory
|
|
{
|
|
if (_history)
|
|
content_history_clear(_history);
|
|
[self reloadData];
|
|
}
|
|
|
|
- (void)willReloadData
|
|
{
|
|
int i;
|
|
RAHistoryMenu* __weak weakSelf = self;
|
|
NSMutableArray *section = [NSMutableArray arrayWithObject:BOXSTRING("")];
|
|
|
|
for (i = 0; _history && i < content_history_size(_history); i ++)
|
|
{
|
|
RAMenuItemBasic* item = [RAMenuItemBasic itemWithDescription:BOXSTRING(path_basename(content_history_get_path(weakSelf.history, i)))
|
|
action:^{ apple_run_core(0, NULL, content_history_get_core_path(weakSelf.history, i),
|
|
content_history_get_path(weakSelf.history, i)); }
|
|
detail:^{ return BOXSTRING(content_history_get_core_name(weakSelf.history, i)); }];
|
|
[section addObject:item];
|
|
}
|
|
|
|
self.sections = [NSMutableArray arrayWithObject:section];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RASettingsGroupMenu */
|
|
/* Menu object that displays and allows */
|
|
/* editing of the a group of */
|
|
/* rarch_setting_t structures. */
|
|
/*********************************************/
|
|
@implementation RASettingsGroupMenu
|
|
|
|
- (id)initWithGroup:(rarch_setting_t*)group
|
|
{
|
|
if ((self = [super initWithStyle:UITableViewStyleGrouped]))
|
|
{
|
|
rarch_setting_t *i;
|
|
NSMutableArray* settings = nil;
|
|
|
|
self.title = BOXSTRING(group->name);
|
|
|
|
for (i = group + 1; i->type < ST_END_GROUP; i ++)
|
|
{
|
|
if (i->type == ST_SUB_GROUP)
|
|
settings = [NSMutableArray arrayWithObjects:BOXSTRING(i->name), nil];
|
|
else if (i->type == ST_END_SUB_GROUP)
|
|
{
|
|
if (settings.count)
|
|
[self.sections addObject:settings];
|
|
}
|
|
else
|
|
[settings addObject:[RAMenuItemGeneralSetting itemForSetting:i]];
|
|
}
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
/*********************************************/
|
|
/* RACoreSettingsMenu */
|
|
/* Menu object that displays and allows */
|
|
/* editing of the setting_data list. */
|
|
/*********************************************/
|
|
@interface RACoreSettingsMenu()
|
|
@property (nonatomic, copy) NSString* pathToSave; // < Leave nil to not save
|
|
@property (nonatomic, assign) bool isCustom;
|
|
@end
|
|
|
|
@implementation RACoreSettingsMenu
|
|
|
|
- (id)initWithCore:(NSString*)core
|
|
{
|
|
char buffer[PATH_MAX];
|
|
|
|
RACoreSettingsMenu* __weak weakSelf = self;
|
|
|
|
if ((self = [super initWithStyle:UITableViewStyleGrouped]))
|
|
{
|
|
int i, j;
|
|
rarch_setting_t *setting_data, *setting;
|
|
NSMutableArray* settings;
|
|
|
|
_isCustom = core_info_has_custom_config(core.UTF8String);
|
|
if (_isCustom)
|
|
{
|
|
const core_info_t *tmp = (const core_info_t*)core_info_list_get_by_id(core.UTF8String);
|
|
self.title = tmp ? BOXSTRING(tmp->display_name) : BOXSTRING(core.UTF8String);
|
|
|
|
_pathToSave = BOXSTRING(core_info_get_custom_config(core.UTF8String, buffer, sizeof(buffer)));
|
|
self.navigationItem.rightBarButtonItem = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemTrash target:self action:@selector(deleteCustom)];
|
|
}
|
|
else
|
|
{
|
|
self.title = BOXSTRING("Global Core Config");
|
|
_pathToSave = BOXSTRING(g_defaults.config_path);
|
|
}
|
|
|
|
setting_data = (rarch_setting_t*)setting_data_get_list();
|
|
|
|
setting_data_reset(setting_data);
|
|
setting_data_load_config_path(setting_data, _pathToSave.UTF8String);
|
|
|
|
// HACK: Load the key mapping table
|
|
apple_input_find_any_key();
|
|
|
|
self.core = core;
|
|
|
|
// Add common options
|
|
const char* emula[] = { "General Options", "rewind_enable", "fps_show", 0 };
|
|
const char* video[] = { "Video Options", "video_scale_integer", "video_smooth", 0 };
|
|
const char* audio[] = { "Audio Options", "audio_mute", "audio_rate_control_delta", 0 };
|
|
const char* input[] = { "Input Options", "input_overlay", "input_overlay_opacity", 0 };
|
|
const char** groups[] = { emula, video, audio, input, 0 };
|
|
|
|
for (i = 0; groups[i]; i ++)
|
|
{
|
|
NSMutableArray* section = [NSMutableArray arrayWithObject:BOXSTRING(groups[i][0])];
|
|
[self.sections addObject:section];
|
|
|
|
for (j = 1; groups[i][j]; j ++)
|
|
{
|
|
rarch_setting_t *current = (rarch_setting_t*)setting_data_find_setting(setting_data, groups[i][j]);
|
|
if (current)
|
|
[section addObject:[RAMenuItemGeneralSetting itemForSetting:current]];
|
|
}
|
|
}
|
|
|
|
settings = [NSMutableArray arrayWithObjects:BOXSTRING(""), nil];
|
|
[self.sections addObject:settings];
|
|
|
|
for (setting = &setting_data[0]; setting->type < ST_NONE; setting++)
|
|
if (setting->type == ST_GROUP)
|
|
[settings addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING(setting->name) action:
|
|
^{
|
|
[weakSelf.navigationController pushViewController:[[RASettingsGroupMenu alloc] initWithGroup:setting] animated:YES];
|
|
}]];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
if (self.pathToSave)
|
|
{
|
|
config_file_t* config = (config_file_t*)config_file_new(self.pathToSave.UTF8String);
|
|
|
|
if (config)
|
|
{
|
|
setting_data_save_config(setting_data_get_list(), config);
|
|
config_file_write(config, self.pathToSave.UTF8String);
|
|
config_file_free(config);
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)deleteCustom
|
|
{
|
|
if (self.isCustom && self.pathToSave)
|
|
{
|
|
remove(self.pathToSave.UTF8String);
|
|
self.pathToSave = false;
|
|
[self.navigationController popViewControllerAnimated:YES];
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAFrontendSettingsMenu */
|
|
/* Menu object that displays and allows */
|
|
/* editing of cocoa frontend related */
|
|
/* settings. */
|
|
/*********************************************/
|
|
@interface RAFrontendSettingsMenu()
|
|
@property (nonatomic, retain) NSMutableArray* coreConfigOptions;
|
|
@end
|
|
|
|
@implementation RAFrontendSettingsMenu
|
|
|
|
- (id)init
|
|
{
|
|
rarch_setting_t* frontend_setting_data = (rarch_setting_t*)apple_get_frontend_settings();
|
|
|
|
if ((self = [super initWithGroup:frontend_setting_data]))
|
|
{
|
|
self.title = BOXSTRING("Frontend Settings");
|
|
|
|
_coreConfigOptions = [NSMutableArray array];
|
|
[self.sections addObject:_coreConfigOptions];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
}
|
|
|
|
- (void)willReloadData
|
|
{
|
|
int i;
|
|
const core_info_list_t* core_list;
|
|
RAFrontendSettingsMenu* __weak weakSelf = self;
|
|
NSMutableArray* cores = (NSMutableArray*)self.coreConfigOptions;
|
|
|
|
[cores removeAllObjects];
|
|
|
|
[cores addObject:BOXSTRING("Configurations")];
|
|
[cores addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING("Global Core Config")
|
|
action: ^{ [weakSelf showCoreConfigFor:nil]; }]];
|
|
|
|
[cores addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING("New Config for Core")
|
|
action: ^{ [weakSelf createNewConfig]; }]];
|
|
|
|
if (!(core_list = (const core_info_list_t*)core_info_list_get()))
|
|
return;
|
|
|
|
for (i = 0; i < core_list->count; i ++)
|
|
{
|
|
NSString* core_id = BOXSTRING(core_list->list[i].path);
|
|
|
|
if (core_info_has_custom_config(core_id.UTF8String))
|
|
{
|
|
[cores addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING(core_list->list[i].display_name)
|
|
association:core_id
|
|
action: ^(id userdata) { [weakSelf showCoreConfigFor:userdata]; }
|
|
detail: ^(id userdata) { return BOXSTRING(""); }]];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)viewWillAppear:(BOOL)animated
|
|
{
|
|
[super viewWillAppear:animated];
|
|
[self reloadData];
|
|
}
|
|
|
|
- (void)showCoreConfigFor:(NSString*)core
|
|
{
|
|
[self.navigationController pushViewController:[[RACoreSettingsMenu alloc] initWithCore:core] animated:YES];
|
|
}
|
|
|
|
static bool copy_config(const char *src_path, const char *dst_path)
|
|
{
|
|
char ch;
|
|
FILE *dst;
|
|
FILE *src = fopen(src_path, "r");
|
|
|
|
if (!src)
|
|
return false;
|
|
|
|
dst = fopen(dst_path, "w");
|
|
|
|
if (!dst)
|
|
{
|
|
fclose(src);
|
|
return false;
|
|
}
|
|
|
|
while((ch = fgetc(src)) != EOF)
|
|
fputc(ch, dst);
|
|
|
|
fclose(src);
|
|
fclose(dst);
|
|
|
|
return true;
|
|
}
|
|
|
|
- (void)createNewConfig
|
|
{
|
|
RAFrontendSettingsMenu* __weak weakSelf = self;
|
|
RAMenuCoreList* list = [[RAMenuCoreList alloc] initWithPath:nil allowAutoDetect:false
|
|
action:^(NSString* core)
|
|
{
|
|
if (!core_info_has_custom_config(core.UTF8String))
|
|
{
|
|
char path[PATH_MAX];
|
|
core_info_get_custom_config(core.UTF8String, path, sizeof(path));
|
|
|
|
if (g_defaults.config_path[0] != '\0' && path[0] != '\0')
|
|
{
|
|
if (!copy_config(g_defaults.config_path, path))
|
|
{
|
|
RARCH_WARN("Could not create custom config at %s.", path);
|
|
}
|
|
}
|
|
}
|
|
|
|
[weakSelf.navigationController popViewControllerAnimated:YES];
|
|
}];
|
|
[self.navigationController pushViewController:list animated:YES];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RACoreOptionsMenu */
|
|
/* Menu object that allows editing of */
|
|
/* options specific to the running core. */
|
|
/*********************************************/
|
|
@interface RACoreOptionsMenu()
|
|
@property (nonatomic) uint32_t currentIndex;
|
|
@end
|
|
|
|
@implementation RACoreOptionsMenu
|
|
|
|
- (id)init
|
|
{
|
|
if ((self = [super initWithStyle:UITableViewStyleGrouped]))
|
|
{
|
|
RACoreOptionsMenu* __weak weakSelf = self;
|
|
core_option_manager_t* options = (core_option_manager_t*)g_extern.system.core_options;
|
|
|
|
NSMutableArray* section = (NSMutableArray*)[NSMutableArray arrayWithObject:BOXSTRING("")];
|
|
[self.sections addObject:section];
|
|
|
|
if (options)
|
|
{
|
|
unsigned i;
|
|
for (i = 0; i < core_option_size(options); i ++)
|
|
[section addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING(core_option_get_desc(options, i)) association:nil
|
|
action:^{ [weakSelf editValue:i]; }
|
|
detail:^{ return BOXSTRING(core_option_get_val(options, i)); }]];
|
|
}
|
|
else
|
|
[section addObject:[RAMenuItemBasic itemWithDescription:BOXSTRING("The running core has no options.") action:NULL]];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)editValue:(uint32_t)index
|
|
{
|
|
RACoreOptionsMenu __weak* weakSelf = self;
|
|
self.currentIndex = index;
|
|
|
|
RunActionSheet(core_option_get_desc(g_extern.system.core_options, index), core_option_get_vals(g_extern.system.core_options, index), self.tableView,
|
|
^(UIActionSheet* actionSheet, NSInteger buttonIndex)
|
|
{
|
|
if (buttonIndex != actionSheet.cancelButtonIndex)
|
|
core_option_set_val(g_extern.system.core_options, self.currentIndex, buttonIndex);
|
|
|
|
[weakSelf.tableView reloadData];
|
|
});
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemCoreList */
|
|
/* Menu item that handles display and */
|
|
/* selection of an item in RAMenuCoreList. */
|
|
/* This item will not function on anything */
|
|
/* but an RAMenuCoreList type menu. */
|
|
/*********************************************/
|
|
@implementation RAMenuItemCoreList
|
|
|
|
- (id)initWithCore:(NSString*)core parent:(RAMenuCoreList* __weak)parent
|
|
{
|
|
if ((self = [super init]))
|
|
{
|
|
_core = core;
|
|
_parent = parent;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (UITableViewCell*)cellForTableView:(UITableView*)tableView
|
|
{
|
|
UITableViewCell *result;
|
|
const core_info_t *core = (const core_info_t*)core_info_list_get_by_id(self.core.UTF8String);
|
|
static NSString* const cell_id = @"RAMenuItemCoreList";
|
|
|
|
if (!(result = [tableView dequeueReusableCellWithIdentifier:cell_id]))
|
|
result = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:cell_id];
|
|
|
|
result.textLabel.text = core ? BOXSTRING(core->display_name) : BOXSTRING(self.core.UTF8String);
|
|
return result;
|
|
}
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView*)tableView ofController:(UIViewController*)controller
|
|
{
|
|
[self.parent runAction:self.core];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuCoreList */
|
|
/* Menu object that displays and allows */
|
|
/* selection from a list of cores. */
|
|
/* If the path is not nil, only cores that */
|
|
/* may support the file is listed. */
|
|
/* If the path is nil, an 'Auto Detect' */
|
|
/* entry is added to the menu, when tapped */
|
|
/* the action function will be called with */
|
|
/* nil as the argument. */
|
|
/*********************************************/
|
|
@implementation RAMenuCoreList
|
|
|
|
- (id)initWithPath:(NSString*)path allowAutoDetect:(bool)autoDetect action:(void (^)(NSString *))action
|
|
{
|
|
if ((self = [super initWithStyle:UITableViewStyleGrouped]))
|
|
{
|
|
NSMutableArray* core_section;
|
|
core_info_list_t* core_list = NULL;
|
|
|
|
self.title = BOXSTRING("Choose Core");
|
|
_action = action;
|
|
_path = path;
|
|
|
|
if (autoDetect)
|
|
{
|
|
RAMenuCoreList* __weak weakSelf = self;
|
|
[self.sections addObject: @[BOXSTRING(""), [RAMenuItemBasic itemWithDescription:BOXSTRING("Auto Detect")
|
|
action: ^{ if(weakSelf.action) weakSelf.action(nil); }]]];
|
|
}
|
|
|
|
core_section = (NSMutableArray*)[NSMutableArray arrayWithObject:BOXSTRING("Cores")];
|
|
|
|
[self.sections addObject:core_section];
|
|
|
|
if ((core_list = (core_info_list_t*)core_info_list_get()))
|
|
{
|
|
if (_path)
|
|
{
|
|
const core_info_t* core_support = NULL;
|
|
size_t core_count = 0;
|
|
|
|
core_info_list_get_supported_cores(core_list, _path.UTF8String, &core_support, &core_count);
|
|
|
|
if (core_count == 1 && _action)
|
|
[self runAction:BOXSTRING(core_support[0].path)];
|
|
else if (core_count > 1)
|
|
[self load:(uint32_t)core_count coresFromList:core_support toSection:core_section];
|
|
}
|
|
|
|
if (!_path || [core_section count] == 1)
|
|
[self load:(uint32_t)core_list->count coresFromList:core_list->list toSection:core_section];
|
|
}
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)runAction:(NSString*)coreID
|
|
{
|
|
self.actionRan = true;
|
|
|
|
if (self.action)
|
|
_action(coreID);
|
|
}
|
|
|
|
- (void)load:(uint32_t)count coresFromList:(const core_info_t*)list toSection:(NSMutableArray*)array
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
[array addObject:[[RAMenuItemCoreList alloc] initWithCore:BOXSTRING(list[i].path) parent:self]];
|
|
}
|
|
|
|
@end
|
|
|
|
/*********************************************/
|
|
/* RAMenuItemStateSelect */
|
|
/* Menu item that allows save state slots */
|
|
/* 0-9 to be selected. */
|
|
/*********************************************/
|
|
@implementation RAMenuItemStateSelect
|
|
|
|
- (UITableViewCell*)cellForTableView:(UITableView*)tableView
|
|
{
|
|
static NSString* const cell_id = @"state_slot_setting";
|
|
|
|
UITableViewCell* result = [tableView dequeueReusableCellWithIdentifier:cell_id];
|
|
if (!result)
|
|
{
|
|
result = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:cell_id];
|
|
result.selectionStyle = UITableViewCellSelectionStyleNone;
|
|
|
|
result.textLabel.text = BOXSTRING("Slot");
|
|
|
|
UISegmentedControl* accessory = [[UISegmentedControl alloc] initWithItems:@[@"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9"]];
|
|
[accessory addTarget:[self class] action:@selector(changed:) forControlEvents:UIControlEventValueChanged];
|
|
accessory.segmentedControlStyle = UISegmentedControlStyleBar;
|
|
result.accessoryView = accessory;
|
|
}
|
|
|
|
[(id)result.accessoryView setSelectedSegmentIndex:(g_extern.state_slot < 10) ? g_extern.state_slot : -1];
|
|
|
|
return result;
|
|
}
|
|
|
|
+ (void)changed:(UISegmentedControl*)sender
|
|
{
|
|
g_extern.state_slot = (int)sender.selectedSegmentIndex;
|
|
}
|
|
|
|
- (void)wasSelectedOnTableView:(UITableView *)tableView ofController:(UIViewController *)controller
|
|
{
|
|
|
|
}
|
|
|
|
@end
|