bool
HttpClient::readStatus()
{
LineReader reader(_conn->stream());
if (reader.readLine(_line) && (splitstr(_line, "\t ", _split) >= 2)) {
if (_split[0] == "HTTP/1.0") {
_header.version = 0;
} else if (_split[0] == "HTTP/1.1") {
_header.version = 1;
} else {
_handler.handleFailure(strfmt("unknown HTTP version: '%s'", _split[0].c_str()));
return false;
}
_header.status = atoi(_split[1].c_str());
if (_header.status != 200) {
_handler.handleFailure(strfmt("HTTP status not 200: '%s'", _split[1].c_str()));
return false;
}
return true;
}
if (_conn->stream().tainted()) {
_handler.handleFailure(strfmt("Connection error: %s",
_conn->stream().tainted().reason().c_str()));
} else {
_handler.handleFailure(strfmt("could not parse HTTP status line: '%s'", _line.c_str()));
}
return false;
}
void Zshow_config(void)
{
int i;
char line[STRMAX * 2];
zbuff_t *tbuff = cmakebuff(CONFBUFF, NULL);
if (!tbuff)
return;
bempty(Bbuff);
for (i = 0; i < NUMVARS; ++i) {
if (Vars[i].vtype == V_STRING) {
if (VARSTR(i))
strfmt(line, sizeof(line), "%-15s %s\n",
Vars[i].vname, VARSTR(i));
else
strfmt(line, sizeof(line), "#%-15s\n",
Vars[i].vname);
} else if (Vars[i].vtype == V_DECIMAL)
strfmt(line, sizeof(line), "%-15s %d\n",
Vars[i].vname, VAR(i));
else if (Vars[i].vtype == V_FLAG)
strfmt(line, sizeof(line), "%-15s %s\n",
Vars[i].vname,
VAR(i) ? "true" : "false");
binstr(Bbuff, line);
}
tbuff->buff->bmodf = false;
btostart(Bbuff);
cswitchto(tbuff);
}
std::string create_summary(const grt::ListRef<GrtObject> &objects)
{
std::map<std::string, Summary> schema_summary;
std::string summary= _("Summary of Reverse Engineered Objects:\n\n");
for(grt::ListRef<GrtObject>::const_iterator iter= objects.begin();
iter != objects.end(); ++iter)
{
std::string owner_name= (*iter)->owner()->name();
if ((*iter).is_instance<db_Schema>())
{
if (schema_summary.find((*iter)->id()) == schema_summary.end())
{
Summary s;
schema_summary[(*iter)->name()]= s;
}
}
else if ((*iter).is_instance<db_Table>())
schema_summary[owner_name].tables++;
else if ((*iter).is_instance<db_View>())
schema_summary[owner_name].views++;
else if ((*iter).is_instance<db_Routine>())
schema_summary[owner_name].routines++;
}
for (std::map<std::string,Summary>::const_iterator iter= schema_summary.begin();
iter != schema_summary.end(); ++iter)
{
if (iter->second.tables == 0 && iter->second.views == 0 && iter->second.routines == 0)
summary.append(strfmt(_(" - empty schema '%s'\n"), iter->first.c_str()));
else
{
summary.append(" - ");
std::string sep= "";
if (iter->second.tables > 0)
{
summary.append(strfmt(_("%i tables"), iter->second.tables));
sep= ", ";
}
if (iter->second.views > 0)
{
summary.append(strfmt(_("%s%i views"), sep.c_str(), iter->second.views));
sep= ", ";
}
if (iter->second.routines > 0)
{
summary.append(strfmt(_("%s%i routines"), sep.c_str(), iter->second.routines));
sep= ", ";
}
summary.append(strfmt(_(" from schema '%s'\n"), iter->first.c_str()));
}
}
return summary;
}
static void load_packages(const char *dir, const char *unionmp) {
// go over the packages in dir in alphapetical order and merge them into unionmp
// e.g. files in 00-aaa.zip will be shadowed by files in 99-zzz.zip
size_t numpaks = 0;
char **paklist = vfs_dir_list_sorted(dir, &numpaks, vfs_dir_list_order_ascending, NULL);
if(!paklist) {
log_fatal("VFS error: %s", vfs_get_error());
}
for(size_t i = 0; i < numpaks; ++i) {
const char *entry = paklist[i];
struct pkg_loader_t *loader = find_loader(entry);
if(loader == NULL) {
continue;
}
log_info("Adding package: %s", entry);
assert(loader->mount != NULL);
char *tmp = strfmt("%s/%s", dir, entry);
if(!loader->mount(unionmp, tmp)) {
log_error("VFS error: %s", vfs_get_error());
}
free(tmp);
}
vfs_dir_list_free(paklist, numpaks);
}
static void get_core_paths(char **res, char **storage, char **cache) {
if(*(*res = (char*)env_get("TAISEI_RES_PATH", ""))) {
*res = strdup(*res);
} else {
*res = get_default_res_path();
}
if(*(*storage = (char*)env_get("TAISEI_STORAGE_PATH", ""))) {
*storage = strdup(*storage);
} else {
*storage = SDL_GetPrefPath("", "taisei");
}
if(*(*cache = (char*)env_get("TAISEI_CACHE_PATH", ""))) {
*cache = strdup(*cache);
} else {
// TODO: follow XDG on linux
if(*storage != NULL) {
*cache = strfmt("%s%ccache", *storage, vfs_get_syspath_separator());
} else {
*cache = NULL;
}
}
if(*res) vfs_syspath_normalize_inplace(*res);
if(*storage) vfs_syspath_normalize_inplace(*storage);
if(*cache) vfs_syspath_normalize_inplace(*cache);
}
//--------------------------------------------------------------------------------
void DbMySQLTableEditorIndexPage::cell_editing_done(GtkCellEditable *ce) {
if (_editing_done_id != 0 && _editable_cell != 0) {
g_signal_handler_disconnect(_editable_cell, _editing_done_id);
_editing_done_id = 0;
_editable_cell = 0;
}
// If it's Gtk::Entry, we try to find out if maybe user leave edit field empty,
// if so we revert it to the last known value or to the default one.
if (GTK_IS_ENTRY(ce)) {
GtkEntry *entry_widget = GTK_ENTRY(ce);
if (entry_widget) {
Gtk::Entry *entry = Glib::wrap(entry_widget);
if (entry && entry->get_text_length() == 0) {
Gtk::TreeModel::Path path;
Gtk::TreeView::Column *column(0);
_indexes_tv->get_cursor(path, column);
bec::NodeId node(path.to_string());
if (node.is_valid()) {
std::string name = _user_index_name;
if (name.empty())
name = strfmt("index%i", path[0] + 1);
_be->get_indexes()->set_field(node, MySQLTableIndexListBE::Name, name);
entry->set_text(name);
}
}
}
}
}
static char* vfs_zipfile_repr(VFSNode *node) {
VFSZipFileData *zdata = node->data1;
char *srcrepr = vfs_node_repr(zdata->source, false);
char *ziprepr = strfmt("zip archive %s", srcrepr);
free(srcrepr);
return ziprepr;
}
static char *fq_to_s(Query *self, Symbol default_field)
{
FilteredQuery *fq = FQQ(self);
char *filter_str = fq->filter->to_s(fq->filter);
char *query_str = fq->query->to_s(fq->query, default_field);
char *buffer;
if (self->boost == 1.0) {
buffer = strfmt("FilteredQuery(query:%s, filter:%s)",
query_str, filter_str);
} else {
buffer = strfmt("FilteredQuery(query:%s, filter:%s)^%f",
query_str, filter_str, self->boost);
}
free(filter_str);
free(query_str);
return buffer;;
}
char *maq_to_s(Query *self, const char *field)
{
(void)field;
if (self->boost == 1.0) {
return estrdup("*");
} else {
return strfmt("*^%f", self->boost);
}
}
static int save_img(enum fmt fmt, const GP_Context *img, const char *name)
{
char buf[256];
snprintf(buf, sizeof(buf), "%s.%s", name, strfmt(fmt));
switch (fmt) {
case PNG:
return GP_SavePNG(img, buf, NULL);
case JPG:
return GP_SaveJPG(img, buf, NULL);
case BMP:
return GP_SaveBMP(img, buf, NULL);
default:
tst_err("Trying to save %s image", strfmt(fmt));
exit(TST_UNTESTED);
}
}
bool findfile(char *path)
{
char tbname[BUFNAMMAX + 1];
zbuff_t *tbuff;
zbuff_t *was = Curbuff;
Arg = 0;
/* limit name to BUFNAMMAX */
strncpy(tbname, lastpart(path), BUFNAMMAX);
tbname[BUFNAMMAX] = '\0';
/* If is this file already in a buffer - use it.
* At startup, we are done.
*/
foreachbuff(tbuff)
if (tbuff->fname && strcmp(path, tbuff->fname) == 0) {
zswitchto(tbuff);
if (Initializing)
return true;
set_last_bufname(was);
break;
}
if (!tbuff) {
if (cfindbuff(tbname)) {
/* Resolve buffer name collisions by creating
* a unique name */
char *p;
int i;
i = strlen(tbname);
p = &tbname[i < BUFNAMMAX - 3 ? i : BUFNAMMAX - 3];
/* We cannot use 100 here due to a bug in gcc 7.3.0 */
for (i = 0; i < 99; ++i) {
strfmt(p, 4, ".%d", i);
if (!cfindbuff(tbname))
break;
}
if (cfindbuff(tbname))
return false;
}
if (!readone(tbname, path))
return false;
}
if (!Initializing) {
cswitchto(Curbuff);
reframe();
} else if (!*Fname)
strcpy(Fname, path);
return true;
}
virtual void do_refresh_form_data()
{
Gtk::Entry *entry;
int w, h;
_be.get_size(w, h);
_xml->get_widget("width_entry", entry);
entry->set_text(strfmt("%i", w));
_xml->get_widget("height_entry", entry);
entry->set_text(strfmt("%i", h));
Gtk::CheckButton *check;
_xml->get_widget("aspect_check", check);
check->set_active(_be.get_keep_aspect_ratio());
Glib::RefPtr<Gdk::Pixbuf> pixbuf(Gdk::Pixbuf::create_from_file(_be.get_attached_image_path()));
if (pixbuf)
_image->set(pixbuf);
else
g_message("ImageEditorFE: can not set image from %s[%s]", _be.get_filename().c_str(), _be.get_attached_image_path().c_str());
}
static GP_Context *load(enum fmt fmt, const char *name)
{
char buf[256];
snprintf(buf, sizeof(buf), "%s.%s", name, strfmt(fmt));
switch (fmt) {
case PNG:
return GP_LoadPNG(buf, NULL);
case JPG:
return GP_LoadJPG(buf, NULL);
case GIF:
return GP_LoadGIF(buf, NULL);
case BMP:
return GP_LoadBMP(buf, NULL);
default:
tst_err("Trying to load %s image", strfmt(fmt));
exit(TST_UNTESTED);
}
}
static int load_eacces(enum fmt fmt)
{
char buf[256];
GP_Context *img;
snprintf(buf, sizeof(buf), "test.%s", strfmt(fmt));
FILE *f = fopen(buf, "w");
if (f == NULL) {
tst_err("Failed to create file 'test': %s", strerror(errno));
return TST_UNTESTED;
}
fclose(f);
if (chmod(buf, 200)) {
tst_err("chmod failed: %s", strerror(errno));
return TST_UNTESTED;
}
img = load(fmt, "test");
if (img != NULL) {
tst_msg("Test succedded unexpectedly");
return TST_FAILED;
}
if (errno == ENOSYS) {
tst_msg("Load %s: ENOSYS", strfmt(fmt));
return TST_SKIPPED;
}
if (errno != EACCES) {
tst_msg("Expected errno = EACCES, have %s",
strerror(errno));
return TST_FAILED;
}
return TST_SUCCESS;
}
int xstrtoken(char strg[], int pos, int len, int dp, char *tokens[], int xkey)
{
if ((xkey >= strcount(tokens)) || (xkey < 0))
{
buffer[0] = 0;
}
else
{
sprintf(buffer,strfmt(len,dp,'s'),tokens[xkey]);
}
return xstr_____s(strg,pos,len,buffer);
}
/* format_submsg: replace placeholders in format string with data */
int TwitchBot::format_submsg(char *out, size_t size, const char *format,
const char *nick, const char *months)
{
struct format fmtchars[] = {
{ 'N', nick, atnick },
{ 'b', bot_name, dupstr },
{ 'c', bot_channel + 1, dupstr },
{ 'm', months, dupstr },
{ 'n', nick, dupstr },
{ 0, 0, 0 }
};
return strfmt(out, size, format, fmtchars);
}
static int save_load(enum fmt fmt, GP_Size w, GP_Size h)
{
GP_Context *img, *res;
img = GP_ContextAlloc(w, h, GP_PIXEL_RGB888);
if (img == NULL) {
tst_warn("GP_ContextAlloc failed");
return TST_UNTESTED;
}
int ret = save_img(fmt, img, "test");
if (ret) {
if (errno == ENOSYS) {
tst_msg("Save %s: ENOSYS", strfmt(fmt));
return TST_SKIPPED;
}
tst_msg("Failed to save %s: %s",
strfmt(fmt), strerror(errno));
return TST_FAILED;
}
res = load(fmt, "test");
if (res == NULL) {
tst_msg("Failed to load %s: %s",
strfmt(fmt), strerror(errno));
return TST_FAILED;
}
GP_ContextFree(img);
GP_ContextFree(res);
return TST_SUCCESS;
}
bool
HttpClient::readContent(size_t len) {
Input &input = _conn->stream();
while (len > 0) {
Memory mem = input.obtain();
mem.size = std::min(len, mem.size);
if (mem.size == 0) {
_handler.handleFailure(strfmt("short read: missing %zu bytes", len));
return false;
}
_handler.handleContent(mem);
input.evict(mem.size);
len -= mem.size;
}
return true;
}
/* format: format a response for cmd */
char *CustomHandler::format(const Json::Value *cmd, const char *nick)
{
int uses = (*cmd)["uses"].asInt();
const char *resp = (*cmd)["response"].asCString();
struct format fmtchars[] = {
{ 'N', nick, atnick },
{ 'b', bot_name, dupstr },
{ 'c', bot_channel, dupstr },
{ 'n', nick, dupstr },
{ 'u', &uses, commanum },
{ 0, 0, 0 }
};
if (strfmt(fmtresp, MAX_MSG, resp, fmtchars) != 0)
return NULL;
return fmtresp;
}
void critical_error_handler(int signum)
{
namespace st = boost::stacktrace;
::signal(signum, SIG_DFL);
passwd *pwd = getpwuid(getuid());
std::ofstream out(strfmt("/tmp/cathook-%s-%d-segfault.log", pwd->pw_name, getpid()).get());
Dl_info info;
if (!dladdr(reinterpret_cast<void *>(hack::ExecuteCommand), &info))
return;
unsigned int baseaddr = (unsigned int) info.dli_fbase - 1;
for (auto i : st::stacktrace())
{
unsigned int offset = (unsigned int) (i.address()) - baseaddr;
Dl_info info2;
out << (void *) offset;
if (!dladdr(i.address(), &info2))
{
out << std::endl;
continue;
}
out << " " << info2.dli_fname << ": ";
if (info2.dli_sname)
{
int status = -4;
char *realname = abi::__cxa_demangle(info2.dli_sname, nullptr, nullptr, &status);
if (status == 0)
{
out << realname << std::endl;
free(realname);
}
else
out << info2.dli_sname << std::endl;
}
else
out << "No Symbol" << std ::endl;
}
out.close();
::raise(SIGABRT);
}
MainWindow::MainWindow(int w, int h)
: width(w)
, height(h)
, gameClickSound(Resources::GetSound("game_click.mp3"))
, mainSwitchButtonFrame(NULL)
, currentTvFrame(NULL)
, currentDrcFrame(NULL)
, launchingGame(false)
{
for(int i = 0; i < 4; i++)
{
std::string filename = strfmt("player%i_point.png", i+1);
pointerImgData[i] = Resources::GetImageData(filename.c_str());
pointerImg[i] = new GuiImage(pointerImgData[i]);
pointerImg[i]->setScale(1.5f);
pointerValid[i] = false;
}
SetupMainView();
}
static int gamepad_load_mappings(const char *vpath, int warn_noexist) {
char *repr = vfs_repr(vpath, true);
char *errstr = NULL;
const char *const_errstr = NULL;
SDL_RWops *mappings = vfs_open(vpath, VFS_MODE_READ | VFS_MODE_SEEKABLE);
int num_loaded = -1;
LogLevel loglvl = LOG_WARN;
if(!mappings) {
if(!warn_noexist) {
VFSInfo vinfo = vfs_query(vpath);
if(!vinfo.error && !vinfo.exists && !vinfo.is_dir) {
loglvl = LOG_INFO;
const_errstr = errstr = strfmt("Custom mappings file '%s' does not exist (this is ok)", repr);
goto cleanup;
}
}
const_errstr = vfs_get_error();
goto cleanup;
}
if((num_loaded = SDL_GameControllerAddMappingsFromRW(mappings, true)) < 0) {
const_errstr = SDL_GetError();
}
cleanup:
if(const_errstr) {
log_custom(loglvl, "Couldn't load mappings: %s", const_errstr);
} else if(num_loaded >= 0) {
log_info("Loaded %i mappings from '%s'", num_loaded, repr);
}
free(repr);
free(errstr);
return num_loaded;
}
bool
HttpClient::readContent()
{
if (_header.contentLengthGiven) {
return readContent(_header.contentLength);
} else if (_header.chunkedEncodingGiven) {
size_t chunkSize = 0;
for (bool first = true; readChunkSize(first, chunkSize); first = false) {
if (chunkSize == 0) {
return skipTrailers();
}
if (!readContent(chunkSize)) {
return false;
}
}
_handler.handleFailure("error reading HTTP chunk size");
return false;
} else { // data terminated by eof
if (serverKeepAlive()) {
_handler.handleFailure("server indicated keep-alive, "
"but we need eof to terminate data");
return false;
}
Input &input = _conn->stream();
for (;;) {
Memory mem = input.obtain();
if (mem.size == 0) {
if (_conn->stream().tainted()) {
_handler.handleFailure(strfmt("read error: '%s'",
_conn->stream().tainted().reason().c_str()));
}
return true;
}
_handler.handleContent(mem);
input.evict(mem.size);
}
}
}
long dtofix(int dp, double temp)
{
char tstrg[35];
int i;
int zlen;
if (dp > 9)
dp = 9;
if (dp < 0)
dp = 0;
if (temp > 999999999)
temp = 999999999;
if (temp < -999999999)
temp = -999999999;
zlen = dp;
if (zlen < 1)
zlen = 1;
sprintf(tstrg,strfmt((13+zlen),zlen,'F'),temp);
for (i=12; i<27; i++)
{
tstrg[i] = tstrg[i+1];
}
return strl(tstrg,dp,12);
}
static int load_enoent(enum fmt fmt)
{
GP_Context *img;
img = load(fmt, "nonexistent");
if (img != NULL) {
tst_msg("Test succedded unexpectedly");
return TST_FAILED;
}
if (errno == ENOSYS) {
tst_msg("Load %s: ENOSYS", strfmt(fmt));
return TST_SKIPPED;
}
if (errno != ENOENT) {
tst_msg("Expected errno = ENOENT, have %s", strerror(errno));
return TST_FAILED;
}
return TST_SUCCESS;
}
void Zset_variable(void)
{
char pstr[STRMAX], arg[STRMAX];
int rc = getplete("Variable: ", NULL, (char **)Vars,
sizeof(struct avar), NUMVARS);
if (rc == -1)
return;
if (!Argp || Vars[rc].vtype == V_STRING) {
strconcat(pstr, sizeof(pstr), Vars[rc].vname, ": ", NULL);
if (Vars[rc].vtype == V_STRING)
if (VARSTR(rc))
strlcpy(arg, VARSTR(rc), sizeof(arg));
else
*arg = '\0';
else
strfmt(arg, sizeof(arg), "%d", VAR(rc));
if (getarg(pstr, arg, STRMAX))
return;
strconcat(pstr, sizeof(pstr), Vars[rc].vname, " ", arg, NULL);
setavar(pstr, true);
} else
setavar(Vars[rc].vname, true);
}
int xstrxi(char strg[], int pos, int len, int dp, int xint)
{
sprintf(buffer,strfmt(len,dp,'x'),xint);
return xstr_____s(strg,pos,len,buffer);
}
int xstrf(char strg[], int pos, int len, int dp, float xfloat)
{
sprintf(buffer,strfmt(len,dp,'f'),xfloat);
return xstr_____s(strg,pos,len,buffer);
}
int xstrui(char strg[], int pos, int len, int dp, unsigned int xint)
{
sprintf(buffer,strfmt(len,dp,'u'),xint);
return xstr_____s(strg,pos,len,buffer);
}
GameLauncherMenu::GameLauncherMenu(int gameIdx)
: GuiFrame(0,0)
, gameIdx(gameIdx)
, bgImage(500, 500, (GX2Color){0, 0, 0, 255})
, bgBlur(1280, 720, (GX2Color){0, 0, 0, 255})
, noCover(Resources::GetFile("noCover.png"), Resources::GetFileSize("noCover.png"))
, buttonClickSound(Resources::GetSound("settings_click_2.mp3"))
, quitImageData(Resources::GetImageData("quitButton.png"))
, quitImage(quitImageData)
, quitSelectedImageData(Resources::GetImageData("quitButtonSelected.png"))
, quitSelectedImage(quitSelectedImageData)
, quitButton(quitImage.getWidth(), quitImage.getHeight())
, okImageData(Resources::GetImageData("emptyRoundButton.png"))
, okImage(okImageData)
, okSelectedImageData(Resources::GetImageData("emptyRoundButtonSelected.png"))
, okSelectedImage(okSelectedImageData)
, okButton(okImage.getWidth(), okImage.getHeight())
, okText("O.K.", 46, glm::vec4(0.1f, 0.1f, 0.1f, 1.0f))
, titleImageData(Resources::GetImageData("settingsTitle.png"))
, titleImage(titleImageData)
, extraSaveText(tr("Extra Save:"), 40, glm::vec4(0.8f, 0.8f, 0.8f, 1.0f))
, dlcEnableText(tr("Enable DLC Support:"), 40, glm::vec4(0.8f, 0.8f, 0.8f, 1.0f))
, frameImageData(Resources::GetImageData("gameSettingsFrame.png"))
, frameImage(frameImageData)
, touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH)
, wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A)
, buttonATrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_A, true)
, buttonBTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_B, true)
, buttonLTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_L, true)
, buttonRTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_R, true)
, buttonLeftTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_LEFT | GuiTrigger::STICK_L_LEFT, true)
, buttonRightTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_RIGHT | GuiTrigger::STICK_L_RIGHT, true)
, buttonUpTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_UP | GuiTrigger::STICK_L_UP, true)
, buttonDownTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_DOWN | GuiTrigger::STICK_L_DOWN, true)
, leftArrowImageData(Resources::GetImageData("leftArrow.png"))
, rightArrowImageData(Resources::GetImageData("rightArrow.png"))
, leftArrowImage(leftArrowImageData)
, rightArrowImage(rightArrowImageData)
, leftArrowButton(leftArrowImage.getWidth(), leftArrowImage.getHeight())
, rightArrowButton(rightArrowImage.getWidth(), rightArrowImage.getHeight())
, DPADButtons(0,0)
, extraSaveBox(false)
, dlcEnableBox(false)
, progresswindow("")
, pathSelectBox(tr("Update Folder"),NULL)
, saveModeSelectBox(tr("Save Mode"),NULL)
, launchModeSelectBox(tr("Launch Mode"),NULL)
, bgUsedImageDataAsync(NULL)
, bgNewImageDataAsync(NULL)
, bgFadingImageDataAsync(NULL)
{
bFocusChanged = true;
gamelauncherelementfocus = GamelaunchermenuFocus::OK;
//Settings up the values for the selectboxes that don't change
savemode_size = sizeof(ValueGameSaveModes) / sizeof(ValueGameSaveModes[0]);
saveModeNames[tr("<Settings Default>")] = strfmt("%d", GAME_SAVES_DEFAULT);
for(int i = 0; i < savemode_size; i++){
saveModeNames[ValueGameSaveModes[i].name] = strfmt("%d",ValueGameSaveModes[i].value);
}
launchmode_size = sizeof(ValueLaunchMode) / sizeof(ValueLaunchMode[0]);
launchModeNames[tr("<Settings Default>")] = strfmt("%d", LOADIINE_MODE_DEFAULT);
for(int i = 0; i < launchmode_size; i++){
launchModeNames[ValueLaunchMode[i].name] = strfmt("%d",ValueLaunchMode[i].value);
}
progresswindow.setVisible(false);
Application::instance()->getMainWindow()->gameLauncherMenuNextClicked.connect(this,&GameLauncherMenu::OnGotHeaderFromMain);
CVideo * video = Application::instance()->getVideo();
width = video->getTvWidth()*windowScale;
height = video->getTvHeight()*windowScale;
gameLauncherMenuFrame = GuiFrame(width, height);
bgImage.setSize(width,height);
frameImage.setScale(windowScale);
bgBlur.setAlpha(0.85f);
append(&bgBlur);
append(&bgImage);
append(&frameImage);
titleImage.setScale(windowScale);
titleText.setColor(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
titleText.setFontSize(46);
titleText.setPosition(0, 10);
titleText.setBlurGlowColor(5.0f, glm::vec4(0.0, 0.0, 0.0f, 1.0f));
append(&titleImage);
append(&titleText);
titleText.setParent(&titleImage);
titleImage.setAlignment(ALIGN_MIDDLE | ALIGN_TOP);
quitButton.setImage(&quitImage);
quitButton.setIconOver(&quitSelectedImage);
quitButton.setAlignment(ALIGN_BOTTOM | ALIGN_LEFT);
quitButton.clicked.connect(this, &GameLauncherMenu::OnQuitButtonClick);
quitButton.setTrigger(&touchTrigger);
quitButton.setTrigger(&wpadTouchTrigger);
quitButton.setEffectGrow();
quitButton.setSoundClick(buttonClickSound);
quitButton.setScale(windowScale*0.8);
quitButton.setPosition((1.0/30.0)*width,(1.0/30.0)*width);
gameLauncherMenuFrame.append(&quitButton);
okText.setPosition(10, -10);
okButton.setLabel(&okText);
okButton.setImage(&okImage);
okButton.setIconOver(&okSelectedImage);
okButton.setAlignment(ALIGN_BOTTOM | ALIGN_RIGHT);
okButton.clicked.connect(this, &GameLauncherMenu::OnOKButtonClick);
okButton.setTrigger(&touchTrigger);
okButton.setTrigger(&wpadTouchTrigger);
okButton.setSoundClick(buttonClickSound);
okButton.setEffectGrow();
okButton.setScale(windowScale*0.8);
okButton.setPosition(-(1.0/30.0)*width,(1.0/30.0)*width);
gameLauncherMenuFrame.append(&okButton);
leftArrowButton.setImage(&leftArrowImage);
leftArrowButton.setEffectGrow();
leftArrowButton.setPosition(-120, 0);
leftArrowButton.setAlignment(ALIGN_LEFT | ALIGN_MIDDLE);
leftArrowButton.setTrigger(&touchTrigger);
leftArrowButton.setTrigger(&wpadTouchTrigger);
leftArrowButton.setSoundClick(buttonClickSound);
leftArrowButton.clicked.connect(this, &GameLauncherMenu::OnLeftArrowClick);
gameLauncherMenuFrame.append(&leftArrowButton);
rightArrowButton.setImage(&rightArrowImage);
rightArrowButton.setEffectGrow();
rightArrowButton.setPosition(120, 0);
rightArrowButton.setAlignment(ALIGN_RIGHT | ALIGN_MIDDLE);
rightArrowButton.setTrigger(&touchTrigger);
rightArrowButton.setTrigger(&wpadTouchTrigger);
rightArrowButton.setSoundClick(buttonClickSound);
rightArrowButton.clicked.connect(this, &GameLauncherMenu::OnRightArrowClick);
gameLauncherMenuFrame.append(&rightArrowButton);
DPADButtons.setTrigger(&buttonDownTrigger);
DPADButtons.setTrigger(&buttonATrigger);
DPADButtons.setTrigger(&buttonBTrigger);
DPADButtons.setTrigger(&buttonLTrigger);
DPADButtons.setTrigger(&buttonRTrigger);
DPADButtons.setTrigger(&buttonLeftTrigger);
DPADButtons.setTrigger(&buttonRightTrigger);
DPADButtons.setTrigger(&buttonUpTrigger);
DPADButtons.clicked.connect(this, &GameLauncherMenu::OnDPADClick);
gameLauncherMenuFrame.append(&DPADButtons);
f32 buttonscale = 3.8f/3.0f;
extraSaveBox.setTrigger(&touchTrigger);
extraSaveBox.setTrigger(&wpadTouchTrigger);
extraSaveBox.setSoundClick(buttonClickSound);
extraSaveBox.valueChanged.connect(this, &GameLauncherMenu::OnExtraSaveValueChanged);
gameLauncherMenuFrame.append(&extraSaveBox);
dlcEnableBox.setTrigger(&touchTrigger);
dlcEnableBox.setTrigger(&wpadTouchTrigger);
dlcEnableBox.setSoundClick(buttonClickSound);
dlcEnableBox.valueChanged.connect(this, &GameLauncherMenu::OnDLCEnableValueChanged);
gameLauncherMenuFrame.append(&dlcEnableBox);
f32 xpos = 0.11f;
f32 yOffset = -(0.3 * height);
dlcEnableBox.setScale(buttonscale*windowScale);
saveModeSelectBox.setScale(buttonscale*windowScale);
launchModeSelectBox.setScale(buttonscale*windowScale);
extraSaveBox.setScale(buttonscale*windowScale);
extraSaveText.setScale(buttonscale*windowScale);
dlcEnableText.setScale(buttonscale*windowScale);
pathSelectBox.setScale(buttonscale* windowScale);
dlcEnableBox.setPosition(xpos*width + (saveModeSelectBox.getTopValueWidth()*saveModeSelectBox.getScale() /2.0) - (dlcEnableBox.getWidth()*dlcEnableBox.getScale()/2.0), yOffset);
dlcEnableText.setPosition(xpos*width - (saveModeSelectBox.getTopValueWidth()*saveModeSelectBox.getScale() /2.0)+ (dlcEnableText.getTextWidth()/2.0), yOffset);
yOffset += saveModeSelectBox.getTopValueHeight() * saveModeSelectBox.getScale();
saveModeSelectBox.setPosition(xpos*width, yOffset);
yOffset += saveModeSelectBox.getTopValueHeight() * saveModeSelectBox.getScale();
launchModeSelectBox.setPosition(xpos*width, yOffset);
yOffset += saveModeSelectBox.getTopValueHeight() * saveModeSelectBox.getScale() * 1.2f;
extraSaveBox.setPosition(xpos*width + (saveModeSelectBox.getTopValueWidth()*saveModeSelectBox.getScale() /2.0) - (extraSaveBox.getWidth()*extraSaveBox.getScale()/2.0), yOffset);
extraSaveText.setPosition(xpos*width - (saveModeSelectBox.getTopValueWidth()*saveModeSelectBox.getScale() /2.0)+ (extraSaveText.getTextWidth()/2.0), yOffset);
yOffset += saveModeSelectBox.getTopValueHeight() * saveModeSelectBox.getScale() * 1.2f;
pathSelectBox.setPosition(xpos*width, yOffset);
yOffset += saveModeSelectBox.getTopValueHeight() * saveModeSelectBox.getScale() * 1.2f;
pathSelectBox.showhide.connect(this, &GameLauncherMenu::OnSelectBoxShowHide);
launchModeSelectBox.showhide.connect(this, &GameLauncherMenu::OnSelectBoxShowHide),
saveModeSelectBox.showhide.connect(this, &GameLauncherMenu::OnSelectBoxShowHide);
pathSelectBox.valueChanged.connect(this, &GameLauncherMenu::OnSelectBoxValueChanged);
launchModeSelectBox.valueChanged.connect(this, &GameLauncherMenu::OnSelectBoxValueChanged),
saveModeSelectBox.valueChanged.connect(this, &GameLauncherMenu::OnSelectBoxValueChanged);
gameLauncherMenuFrame.append(&dlcEnableText);
gameLauncherMenuFrame.append(&extraSaveText);
gameLauncherMenuFrame.append(&saveModeSelectBox);
gameLauncherMenuFrame.append(&pathSelectBox);
gameLauncherMenuFrame.append(&launchModeSelectBox);
selectBoxes.push_back(&pathSelectBox);
selectBoxes.push_back(&launchModeSelectBox);
selectBoxes.push_back(&saveModeSelectBox);
append(&gameLauncherMenuFrame);
append(&progresswindow);
focusElements[GamelaunchermenuFocus::ExtraSave] = &extraSaveBox;
focusElements[GamelaunchermenuFocus::EnableDLC] = &dlcEnableBox;
focusElements[GamelaunchermenuFocus::Quit] = &quitButton;
focusElements[GamelaunchermenuFocus::UpdatePath] = &pathSelectBox;
focusElements[GamelaunchermenuFocus::SaveMethod] = &saveModeSelectBox;
focusElements[GamelaunchermenuFocus::LaunchMethod] = &launchModeSelectBox;
focusElements[GamelaunchermenuFocus::OK] = &okButton;
setHeader(GameList::instance()->at(gameIdx));
}
