void InputConfigDialog::UpdateProfileComboBox()
{
std::string pname(File::GetUserPath(D_CONFIG_IDX));
pname += PROFILES_PATH;
pname += m_plugin.profile_name;
CFileSearch::XStringVector exts;
exts.push_back("*.ini");
CFileSearch::XStringVector dirs;
dirs.push_back(pname);
CFileSearch cfs(exts, dirs);
const CFileSearch::XStringVector& sv = cfs.GetFileNames();
wxArrayString strs;
CFileSearch::XStringVector::const_iterator si = sv.begin(),
se = sv.end();
for (; si!=se; ++si)
{
std::string str(si->begin() + si->find_last_of('/') + 1 , si->end() - 4) ;
strs.push_back(WXSTR_FROM_STR(str));
}
std::vector< GamepadPage* >::iterator i = m_padpages.begin(),
e = m_padpages.end();
for (; i != e; ++i)
{
(*i)->profile_cbox->Clear();
(*i)->profile_cbox->Append(strs);
}
}
HX_RESULT CHXString::SetFromHFSUniStr255(const HFSUniStr255& uniName,
CFStringEncoding encoding)
{
CHXCFString cfs(uniName);
if (cfs.IsSet())
{
SetFromCFString(cfs, encoding);
return HXR_OK;
}
return HXR_FAIL;
}
HX_RESULT CHXString::MakeHFSUniStr255(HFSUniStr255& outUniName, CFStringEncoding encoding) const
{
if (GetLength() < 256)
{
CHXCFString cfs((const char*)(*this), encoding);
if (cfs.IsSet())
{
outUniName = (HFSUniStr255) cfs;
return HXR_OK;
}
}
return HXR_FAIL;
}
CString TextCodecMac::encode(const UChar* characters, size_t length, UnencodableHandling handling)
{
// FIXME: We should really use TEC here instead of CFString for consistency with the other direction.
// FIXME: Since there's no "force ASCII range" mode in CFString, we change the backslash into a yen sign.
// Encoding will change the yen sign back into a backslash.
String copy(characters, length);
copy.replace('\\', m_backslashAsCurrencySymbol);
RetainPtr<CFStringRef> cfs(AdoptCF, copy.createCFString());
CFIndex startPos = 0;
CFIndex charactersLeft = CFStringGetLength(cfs.get());
Vector<char> result;
size_t size = 0;
UInt8 lossByte = handling == QuestionMarksForUnencodables ? '?' : 0;
while (charactersLeft > 0) {
CFRange range = CFRangeMake(startPos, charactersLeft);
CFIndex bufferLength;
CFStringGetBytes(cfs.get(), range, m_encoding, lossByte, false, NULL, 0x7FFFFFFF, &bufferLength);
result.grow(size + bufferLength);
unsigned char* buffer = reinterpret_cast<unsigned char*>(result.data() + size);
CFIndex charactersConverted = CFStringGetBytes(cfs.get(), range, m_encoding, lossByte, false, buffer, bufferLength, &bufferLength);
size += bufferLength;
if (charactersConverted != charactersLeft) {
unsigned badChar = CFStringGetCharacterAtIndex(cfs.get(), startPos + charactersConverted);
++charactersConverted;
if ((badChar & 0xFC00) == 0xD800 && charactersConverted != charactersLeft) { // is high surrogate
UniChar low = CFStringGetCharacterAtIndex(cfs.get(), startPos + charactersConverted);
if ((low & 0xFC00) == 0xDC00) { // is low surrogate
badChar <<= 10;
badChar += low;
badChar += 0x10000 - (0xD800 << 10) - 0xDC00;
++charactersConverted;
}
}
UnencodableReplacementArray entity;
int entityLength = getUnencodableReplacement(badChar, handling, entity);
result.grow(size + entityLength);
memcpy(result.data() + size, entity, entityLength);
size += entityLength;
}
startPos += charactersConverted;
charactersLeft -= charactersConverted;
}
return CString(result.data(), size);
}
SixAxisNavigationToolFactory::SixAxisNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("SixAxisNavigationTool",toolManager)
{
/* Initialize tool layout: */
layout.setNumValuators(7);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs(toolManager.getToolClassSection(getClassName()));
config.load(cfs);
/* Set tool class' factory pointer: */
SixAxisNavigationTool::factory=this;
}
void InterfaceConfigPane::LoadThemes()
{
CFileSearch::XStringVector theme_dirs;
theme_dirs.push_back(File::GetUserPath(D_THEMES_IDX));
theme_dirs.push_back(File::GetSysDirectory() + THEMES_DIR);
CFileSearch cfs(CFileSearch::XStringVector(1, "*"), theme_dirs);
auto const& sv = cfs.GetFileNames();
for (const std::string& filename : sv)
{
std::string name, ext;
SplitPath(filename, nullptr, &name, &ext);
name += ext;
const wxString wxname = StrToWxStr(name);
if (-1 == m_theme_choice->FindString(wxname))
m_theme_choice->Append(wxname);
}
m_theme_choice->SetStringSelection(StrToWxStr(SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name));
}
int test_main( int, char*[] )
{
{ // basic_filebuf runtime results are ignored; as long as they don't crash
// or throw we are satisfied
fs::basic_filebuf<char> bfb;
fs::filebuf cfb;
bfb.open( "fstream_test_bffoo", std::ios_base::in );
cfb.open( "fstream_test_bffoo", std::ios_base::in );
# ifndef BOOST_NO_STD_WSTRING
fs::wfilebuf wfb;
wfb.open( "fstream_test_bffoo", std::ios_base::in );
# endif
}
std::remove( "fstream_test_bfoo" );
std::remove( "fstream_test_cfoo" );
# ifndef BOOST_NO_STD_WSTRING
std::remove( "fstream_test_wfoo" );
# endif
{
fs::basic_ofstream<char> bofs( "fstream_test_bfoo" );
fs::ofstream cofs( "fstream_test_cfoo" );
BOOST_CHECK( bofs.is_open() );
BOOST_CHECK( cofs.is_open() );
bofs << "fstream_test_bfoo";
cofs << "fstream_test_cfoo";
// these will fail, but they still test the interface
bofs.open( "fstream_test_bfoo" );
cofs.open( "fstream_test_cfoo" );
# ifndef BOOST_NO_STD_WSTRING
fs::wofstream wofs( "fstream_test_wfoo" );
BOOST_CHECK( wofs.is_open() );
wofs << L"fstream_test_wfoo";
wofs.open( "fstream_test_wfoo" ); // expected to fail
# endif
}
{
fs::basic_ifstream<char> bifs( "fstream_test_bfoo" );
fs::ifstream cifs( "fstream_test_cfoo" );
BOOST_CHECK( bifs.is_open() );
BOOST_CHECK( cifs.is_open() );
std::string b;
std::string c;
bifs >> b;
cifs >> c;
BOOST_CHECK( b == "fstream_test_bfoo" );
BOOST_CHECK( c == "fstream_test_cfoo" );
// these will fail, but they still test the interface
bifs.open( "fstream_test_bfoo" );
cifs.open( "fstream_test_cfoo" );
# ifndef BOOST_NO_STD_WSTRING
fs::wifstream wifs( "fstream_test_wfoo" );
BOOST_CHECK( wifs.is_open() );
std::wstring w;
wifs >> w;
BOOST_CHECK( w == L"fstream_test_wfoo" );
wifs.open( "fstream_test_wfoo" ); // expected to fail
# endif
}
{
fs::basic_fstream<char> bfs( "fstream_test_bfoo" );
fs::fstream cfs( "fstream_test_cfoo" );
BOOST_CHECK( bfs.is_open() );
BOOST_CHECK( cfs.is_open() );
std::string b;
std::string c;
bfs >> b;
cfs >> c;
BOOST_CHECK( b == "fstream_test_bfoo" );
BOOST_CHECK( c == "fstream_test_cfoo" );
// these will fail, but they still test the interface
bfs.open( "fstream_test_bfoo" );
cfs.open( "fstream_test_cfoo" );
# ifndef BOOST_NO_STD_WSTRING
fs::wfstream wfs( "fstream_test_wfoo" );
BOOST_CHECK( wfs.is_open() );
std::wstring w;
wfs >> w;
BOOST_CHECK( w == L"fstream_test_wfoo" );
wfs.open( "fstream_test_wfoo" ); // expected to fail
# endif
}
// std::remove( "fstream_test_bfoo" );
// std::remove( "fstream_test_cfoo" );
// # ifndef BOOST_NO_STD_WSTRING
// std::remove( "fstream_test_wfoo" );
// # endif
return 0;
}
void CConfigMain::CreateGUIControls()
{
InitializeGUILists();
// Create the notebook and pages
Notebook = new wxNotebook(this, ID_NOTEBOOK);
wxPanel* const GeneralPage = new wxPanel(Notebook, ID_GENERALPAGE);
wxPanel* const DisplayPage = new wxPanel(Notebook, ID_DISPLAYPAGE);
wxPanel* const AudioPage = new wxPanel(Notebook, ID_AUDIOPAGE);
wxPanel* const GamecubePage = new wxPanel(Notebook, ID_GAMECUBEPAGE);
wxPanel* const WiiPage = new wxPanel(Notebook, ID_WIIPAGE);
PathsPage = new wxPanel(Notebook, ID_PATHSPAGE);
Notebook->AddPage(GeneralPage, _("General"));
Notebook->AddPage(DisplayPage, _("Interface"));
Notebook->AddPage(AudioPage, _("Audio"));
Notebook->AddPage(GamecubePage, _("GameCube"));
Notebook->AddPage(WiiPage, _("Wii"));
Notebook->AddPage(PathsPage, _("Paths"));
// General page
// Core Settings - Basic
CPUThread = new wxCheckBox(GeneralPage, ID_CPUTHREAD, _("Enable Dual Core (speedup)"));
SkipIdle = new wxCheckBox(GeneralPage, ID_IDLESKIP, _("Enable Idle Skipping (speedup)"));
EnableCheats = new wxCheckBox(GeneralPage, ID_ENABLECHEATS, _("Enable Cheats"));
// Framelimit
Framelimit = new wxChoice(GeneralPage, ID_FRAMELIMIT, wxDefaultPosition, wxDefaultSize, arrayStringFor_Framelimit);
// Core Settings - Advanced
CPUEngine = new wxRadioBox(GeneralPage, ID_CPUENGINE, _("CPU Emulator Engine"), wxDefaultPosition, wxDefaultSize, arrayStringFor_CPUEngine, 0, wxRA_SPECIFY_ROWS);
_NTSCJ = new wxCheckBox(GeneralPage, ID_NTSCJ, _("Force Console as NTSC-J"));
// Populate the General settings
wxBoxSizer* sFramelimit = new wxBoxSizer(wxHORIZONTAL);
sFramelimit->Add(TEXT_BOX(GeneralPage, _("Framelimit:")), 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM, 5);
sFramelimit->Add(Framelimit, 0, wxLEFT | wxRIGHT | wxBOTTOM | wxEXPAND, 5);
wxStaticBoxSizer* const sbBasic = new wxStaticBoxSizer(wxVERTICAL, GeneralPage, _("Basic Settings"));
sbBasic->Add(CPUThread, 0, wxALL, 5);
sbBasic->Add(SkipIdle, 0, wxALL, 5);
sbBasic->Add(EnableCheats, 0, wxALL, 5);
sbBasic->Add(sFramelimit);
wxStaticBoxSizer* const sbAdvanced = new wxStaticBoxSizer(wxVERTICAL, GeneralPage, _("Advanced Settings"));
sbAdvanced->Add(CPUEngine, 0, wxALL, 5);
sbAdvanced->Add(_NTSCJ, 0, wxALL, 5);
wxBoxSizer* const sGeneralPage = new wxBoxSizer(wxVERTICAL);
sGeneralPage->Add(sbBasic, 0, wxEXPAND | wxALL, 5);
sGeneralPage->Add(sbAdvanced, 0, wxEXPAND | wxALL, 5);
GeneralPage->SetSizer(sGeneralPage);
// Interface Language
InterfaceLang = new wxChoice(DisplayPage, ID_INTERFACE_LANG, wxDefaultPosition, wxDefaultSize, arrayStringFor_InterfaceLang);
// Hotkey configuration
HotkeyConfig = new wxButton(DisplayPage, ID_HOTKEY_CONFIG, _("Hotkeys"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
// Interface settings
ConfirmStop = new wxCheckBox(DisplayPage, ID_INTERFACE_CONFIRMSTOP, _("Confirm on Stop"));
UsePanicHandlers = new wxCheckBox(DisplayPage, ID_INTERFACE_USEPANICHANDLERS, _("Use Panic Handlers"));
OnScreenDisplayMessages = new wxCheckBox(DisplayPage, ID_INTERFACE_ONSCREENDISPLAYMESSAGES, _("On-Screen Display Messages"));
wxBoxSizer* sInterface = new wxBoxSizer(wxHORIZONTAL);
sInterface->Add(TEXT_BOX(DisplayPage, _("Language:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sInterface->Add(InterfaceLang, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sInterface->AddStretchSpacer();
sInterface->Add(HotkeyConfig, 0, wxALIGN_RIGHT | wxALL, 5);
// theme selection
auto const theme_selection = new wxChoice(DisplayPage, wxID_ANY);
CFileSearch::XStringVector theme_dirs;
theme_dirs.push_back(File::GetUserPath(D_THEMES_IDX));
theme_dirs.push_back(File::GetSysDirectory() + THEMES_DIR);
CFileSearch cfs(CFileSearch::XStringVector(1, "*"), theme_dirs);
auto const& sv = cfs.GetFileNames();
std::for_each(sv.begin(), sv.end(), [theme_selection](const std::string& filename)
{
std::string name, ext;
SplitPath(filename, nullptr, &name, &ext);
name += ext;
auto const wxname = StrToWxStr(name);
if (-1 == theme_selection->FindString(wxname))
theme_selection->Append(wxname);
});
theme_selection->SetStringSelection(StrToWxStr(SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name));
// std::function = avoid error on msvc
theme_selection->Bind(wxEVT_CHOICE, std::function<void(wxEvent&)>([theme_selection](wxEvent&)
{
SConfig::GetInstance().m_LocalCoreStartupParameter.theme_name = WxStrToStr(theme_selection->GetStringSelection());
main_frame->InitBitmaps();
main_frame->UpdateGameList();
}));
auto const scInterface = new wxBoxSizer(wxHORIZONTAL);
scInterface->Add(TEXT_BOX(DisplayPage, _("Theme:")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
scInterface->Add(theme_selection, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
scInterface->AddStretchSpacer();
sbInterface = new wxStaticBoxSizer(wxVERTICAL, DisplayPage, _("Interface Settings"));
sbInterface->Add(ConfirmStop, 0, wxALL, 5);
sbInterface->Add(UsePanicHandlers, 0, wxALL, 5);
sbInterface->Add(OnScreenDisplayMessages, 0, wxALL, 5);
sbInterface->Add(scInterface, 0, wxEXPAND | wxALL, 5);
sbInterface->Add(sInterface, 0, wxEXPAND | wxALL, 5);
sDisplayPage = new wxBoxSizer(wxVERTICAL);
sDisplayPage->Add(sbInterface, 0, wxEXPAND | wxALL, 5);
DisplayPage->SetSizer(sDisplayPage);
// Audio page
DSPEngine = new wxRadioBox(AudioPage, ID_DSPENGINE, _("DSP Emulator Engine"), wxDefaultPosition, wxDefaultSize, arrayStringFor_DSPEngine, 0, wxRA_SPECIFY_ROWS);
DSPThread = new wxCheckBox(AudioPage, ID_DSPTHREAD, _("DSPLLE on Separate Thread"));
DumpAudio = new wxCheckBox(AudioPage, ID_DUMP_AUDIO, _("Dump Audio"));
DPL2Decoder = new wxCheckBox(AudioPage, ID_DPL2DECODER, _("Dolby Pro Logic II decoder"));
VolumeSlider = new wxSlider(AudioPage, ID_VOLUME, 0, 1, 100, wxDefaultPosition, wxDefaultSize, wxSL_VERTICAL|wxSL_INVERSE);
VolumeText = new wxStaticText(AudioPage, wxID_ANY, "");
BackendSelection = new wxChoice(AudioPage, ID_BACKEND, wxDefaultPosition, wxDefaultSize, wxArrayBackends, 0, wxDefaultValidator, wxEmptyString);
Latency = new wxSpinCtrl(AudioPage, ID_LATENCY, "", wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 30);
Latency->Bind(wxEVT_SPINCTRL, &CConfigMain::AudioSettingsChanged, this);
if (Core::GetState() != Core::CORE_UNINITIALIZED)
{
Latency->Disable();
BackendSelection->Disable();
DPL2Decoder->Disable();
}
// Create sizer and add items to dialog
wxStaticBoxSizer *sbAudioSettings = new wxStaticBoxSizer(wxVERTICAL, AudioPage, _("Sound Settings"));
sbAudioSettings->Add(DSPEngine, 0, wxALL | wxEXPAND, 5);
sbAudioSettings->Add(DSPThread, 0, wxALL, 5);
sbAudioSettings->Add(DumpAudio, 0, wxALL, 5);
sbAudioSettings->Add(DPL2Decoder, 0, wxALL, 5);
wxStaticBoxSizer *sbVolume = new wxStaticBoxSizer(wxVERTICAL, AudioPage, _("Volume"));
sbVolume->Add(VolumeSlider, 1, wxLEFT|wxRIGHT, 13);
sbVolume->Add(VolumeText, 0, wxALIGN_CENTER|wxALL, 5);
wxGridBagSizer *sBackend = new wxGridBagSizer();
sBackend->Add(TEXT_BOX(AudioPage, _("Audio Backend:")), wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sBackend->Add(BackendSelection, wxGBPosition(0, 1), wxDefaultSpan, wxALL, 5);
sBackend->Add(TEXT_BOX(AudioPage, _("Latency:")), wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sBackend->Add(Latency, wxGBPosition(1, 1), wxDefaultSpan, wxALL, 5);
wxStaticBoxSizer *sbBackend = new wxStaticBoxSizer(wxHORIZONTAL, AudioPage, _("Backend Settings"));
sbBackend->Add(sBackend, 0, wxEXPAND);
wxBoxSizer *sAudio = new wxBoxSizer(wxHORIZONTAL);
sAudio->Add(sbAudioSettings, 1, wxEXPAND|wxALL, 5);
sAudio->Add(sbVolume, 0, wxEXPAND|wxALL, 5);
sAudioPage = new wxBoxSizer(wxVERTICAL);
sAudioPage->Add(sAudio, 0, wxALL|wxEXPAND);
sAudioPage->Add(sbBackend, 0, wxALL|wxEXPAND, 5);
AudioPage->SetSizerAndFit(sAudioPage);
// GameCube page
// IPL settings
GCSystemLang = new wxChoice(GamecubePage, ID_GC_SRAM_LNG, wxDefaultPosition, wxDefaultSize, arrayStringFor_GCSystemLang);
GCAlwaysHLE_BS2 = new wxCheckBox(GamecubePage, ID_GC_ALWAYS_HLE_BS2, _("Skip BIOS"));
// Device settings
// EXI Devices
wxStaticText* GCEXIDeviceText[3];
GCEXIDeviceText[0] = TEXT_BOX(GamecubePage, _("Slot A"));
GCEXIDeviceText[1] = TEXT_BOX(GamecubePage, _("Slot B"));
GCEXIDeviceText[2] = TEXT_BOX(GamecubePage, "SP1");
GCEXIDevice[0] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SLOTA);
GCEXIDevice[1] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SLOTB);
GCEXIDevice[2] = new wxChoice(GamecubePage, ID_GC_EXIDEVICE_SP1);
GCMemcardPath[0] = new wxButton(GamecubePage, ID_GC_EXIDEVICE_SLOTA_PATH, "...",
wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
GCMemcardPath[1] = new wxButton(GamecubePage, ID_GC_EXIDEVICE_SLOTB_PATH, "...",
wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
//SI Devices
wxStaticText* GCSIDeviceText[4];
GCSIDeviceText[0] = TEXT_BOX(GamecubePage, _("Port 1"));
GCSIDeviceText[1] = TEXT_BOX(GamecubePage, _("Port 2"));
GCSIDeviceText[2] = TEXT_BOX(GamecubePage, _("Port 3"));
GCSIDeviceText[3] = TEXT_BOX(GamecubePage, _("Port 4"));
GCSIDevice[0] = new wxChoice(GamecubePage, ID_GC_SIDEVICE0);
GCSIDevice[1] = new wxChoice(GamecubePage, ID_GC_SIDEVICE1);
GCSIDevice[2] = new wxChoice(GamecubePage, ID_GC_SIDEVICE2);
GCSIDevice[3] = new wxChoice(GamecubePage, ID_GC_SIDEVICE3);
// Populate the GameCube page
sGamecubeIPLSettings = new wxGridBagSizer();
sGamecubeIPLSettings->Add(GCAlwaysHLE_BS2, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5);
sGamecubeIPLSettings->Add(TEXT_BOX(GamecubePage, _("System Language:")),
wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxBOTTOM, 5);
sGamecubeIPLSettings->Add(GCSystemLang, wxGBPosition(1, 1), wxDefaultSpan, wxLEFT|wxRIGHT|wxBOTTOM, 5);
sbGamecubeIPLSettings = new wxStaticBoxSizer(wxVERTICAL, GamecubePage, _("IPL Settings"));
sbGamecubeIPLSettings->Add(sGamecubeIPLSettings);
wxStaticBoxSizer *sbGamecubeDeviceSettings = new wxStaticBoxSizer(wxVERTICAL, GamecubePage, _("Device Settings"));
wxGridBagSizer* sbGamecubeEXIDevSettings = new wxGridBagSizer(10, 10);
for (int i = 0; i < 3; ++i)
{
sbGamecubeEXIDevSettings->Add(GCEXIDeviceText[i], wxGBPosition(i, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
sbGamecubeEXIDevSettings->Add(GCEXIDevice[i], wxGBPosition(i, 1), wxGBSpan(1, (i < 2)?1:2), wxALIGN_CENTER_VERTICAL);
if (i < 2) sbGamecubeEXIDevSettings->Add(GCMemcardPath[i], wxGBPosition(i, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
if (NetPlay::IsNetPlayRunning())
GCEXIDevice[i]->Disable();
}
sbGamecubeDeviceSettings->Add(sbGamecubeEXIDevSettings, 0, wxALL, 5);
wxFlexGridSizer* sbGamecubeDevSettings = new wxFlexGridSizer(2, 10, 10);
for (int i = 0; i < 4; ++i)
{
sbGamecubeDevSettings->Add(GCSIDeviceText[i], 1, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxBOTTOM, 0);
sbGamecubeDevSettings->Add(GCSIDevice[i], 1, wxEXPAND|wxLEFT|wxRIGHT|wxBOTTOM, 0);
if (NetPlay::IsNetPlayRunning() || Movie::IsRecordingInput() || Movie::IsPlayingInput())
{
GCSIDevice[i]->Disable();
}
}
sbGamecubeDeviceSettings->Add(sbGamecubeDevSettings, 0, wxALL, 5);
sGamecubePage = new wxBoxSizer(wxVERTICAL);
sGamecubePage->Add(sbGamecubeIPLSettings, 0, wxEXPAND|wxALL, 5);
sGamecubePage->Add(sbGamecubeDeviceSettings, 0, wxEXPAND|wxALL, 5);
GamecubePage->SetSizer(sGamecubePage);
// Wii page
// Misc Settings
WiiScreenSaver = new wxCheckBox(WiiPage, ID_WII_IPL_SSV, _("Enable Screen Saver"));
WiiEuRGB60 = new wxCheckBox(WiiPage, ID_WII_IPL_E60, _("Use EuRGB60 Mode (PAL60)"));
WiiAspectRatio = new wxChoice(WiiPage, ID_WII_IPL_AR, wxDefaultPosition, wxDefaultSize, arrayStringFor_WiiAspectRatio);
WiiSystemLang = new wxChoice(WiiPage, ID_WII_IPL_LNG, wxDefaultPosition, wxDefaultSize, arrayStringFor_WiiSystemLang);
// Device Settings
WiiSDCard = new wxCheckBox(WiiPage, ID_WII_SD_CARD, _("Insert SD Card"));
WiiKeyboard = new wxCheckBox(WiiPage, ID_WII_KEYBOARD, _("Connect USB Keyboard"));
// Populate the Wii Page
sWiiIPLSettings = new wxGridBagSizer();
sWiiIPLSettings->Add(WiiScreenSaver, wxGBPosition(0, 0), wxGBSpan(1, 2), wxALL, 5);
sWiiIPLSettings->Add(WiiEuRGB60, wxGBPosition(1, 0), wxGBSpan(1, 2), wxALL, 5);
sWiiIPLSettings->Add(TEXT_BOX(WiiPage, _("Aspect Ratio:")),
wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sWiiIPLSettings->Add(WiiAspectRatio, wxGBPosition(2, 1), wxDefaultSpan, wxALL, 5);
sWiiIPLSettings->Add(TEXT_BOX(WiiPage, _("System Language:")),
wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sWiiIPLSettings->Add(WiiSystemLang, wxGBPosition(3, 1), wxDefaultSpan, wxALL, 5);
sbWiiIPLSettings = new wxStaticBoxSizer(wxVERTICAL, WiiPage, _("Misc Settings"));
sbWiiIPLSettings->Add(sWiiIPLSettings);
sbWiiDeviceSettings = new wxStaticBoxSizer(wxVERTICAL, WiiPage, _("Device Settings"));
sbWiiDeviceSettings->Add(WiiSDCard, 0, wxALL, 5);
sbWiiDeviceSettings->Add(WiiKeyboard, 0, wxALL, 5);
sWiiPage = new wxBoxSizer(wxVERTICAL);
sWiiPage->Add(sbWiiIPLSettings, 0, wxEXPAND|wxALL, 5);
sWiiPage->Add(sbWiiDeviceSettings, 0, wxEXPAND|wxALL, 5);
WiiPage->SetSizer(sWiiPage);
// Paths page
ISOPaths = new wxListBox(PathsPage, ID_ISOPATHS, wxDefaultPosition, wxDefaultSize, arrayStringFor_ISOPaths, wxLB_SINGLE);
RecursiveISOPath = new wxCheckBox(PathsPage, ID_RECURSIVEISOPATH, _("Search Subfolders"));
AddISOPath = new wxButton(PathsPage, ID_ADDISOPATH, _("Add..."));
RemoveISOPath = new wxButton(PathsPage, ID_REMOVEISOPATH, _("Remove"));
RemoveISOPath->Enable(false);
DefaultISO = new wxFilePickerCtrl(PathsPage, ID_DEFAULTISO, wxEmptyString, _("Choose a default ISO:"),
_("All GC/Wii images (gcm, iso, wbfs, ciso, gcz)") + wxString::Format("|*.gcm;*.iso;*.wbfs;*.ciso;*.gcz|%s", wxGetTranslation(wxALL_FILES)),
wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL|wxFLP_OPEN);
DVDRoot = new wxDirPickerCtrl(PathsPage, ID_DVDROOT, wxEmptyString, _("Choose a DVD root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL);
ApploaderPath = new wxFilePickerCtrl(PathsPage, ID_APPLOADERPATH, wxEmptyString, _("Choose file to use as apploader: (applies to discs constructed from directories only)"),
_("apploader (.img)") + wxString::Format("|*.img|%s", wxGetTranslation(wxALL_FILES)),
wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL|wxFLP_OPEN);
NANDRoot = new wxDirPickerCtrl(PathsPage, ID_NANDROOT, wxEmptyString, _("Choose a NAND root directory:"), wxDefaultPosition, wxDefaultSize, wxDIRP_USE_TEXTCTRL);
// Populate the settings
wxBoxSizer* sISOButtons = new wxBoxSizer(wxHORIZONTAL);
sISOButtons->Add(RecursiveISOPath, 0, wxALL|wxALIGN_CENTER, 0);
sISOButtons->AddStretchSpacer();
sISOButtons->Add(AddISOPath, 0, wxALL, 0);
sISOButtons->Add(RemoveISOPath, 0, wxALL, 0);
sbISOPaths = new wxStaticBoxSizer(wxVERTICAL, PathsPage, _("ISO Directories"));
sbISOPaths->Add(ISOPaths, 1, wxEXPAND|wxALL, 0);
sbISOPaths->Add(sISOButtons, 0, wxEXPAND|wxALL, 5);
sOtherPaths = new wxGridBagSizer();
sOtherPaths->Add(TEXT_BOX(PathsPage, _("Default ISO:")),
wxGBPosition(0, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sOtherPaths->Add(DefaultISO, wxGBPosition(0, 1), wxDefaultSpan, wxEXPAND|wxALL, 5);
sOtherPaths->Add(TEXT_BOX(PathsPage, _("DVD Root:")),
wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sOtherPaths->Add(DVDRoot, wxGBPosition(1, 1), wxDefaultSpan, wxEXPAND|wxALL, 5);
sOtherPaths->Add(TEXT_BOX(PathsPage, _("Apploader:")),
wxGBPosition(2, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sOtherPaths->Add(ApploaderPath, wxGBPosition(2, 1), wxDefaultSpan, wxEXPAND|wxALL, 5);
sOtherPaths->Add(TEXT_BOX(PathsPage, _("Wii NAND Root:")),
wxGBPosition(3, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL|wxALL, 5);
sOtherPaths->Add(NANDRoot, wxGBPosition(3, 1), wxDefaultSpan, wxEXPAND|wxALL, 5);
sOtherPaths->AddGrowableCol(1);
// Populate the Paths page
sPathsPage = new wxBoxSizer(wxVERTICAL);
sPathsPage->Add(sbISOPaths, 1, wxEXPAND|wxALL, 5);
sPathsPage->Add(sOtherPaths, 0, wxEXPAND|wxALL, 5);
PathsPage->SetSizer(sPathsPage);
wxBoxSizer* sMain = new wxBoxSizer(wxVERTICAL);
sMain->Add(Notebook, 1, wxEXPAND|wxALL, 5);
sMain->Add(CreateButtonSizer(wxOK), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
InitializeGUIValues();
InitializeGUITooltips();
UpdateGUI();
SetSizerAndFit(sMain);
Center();
SetFocus();
}
void test_solver(BfmSolver solver,LatticeFermion &src)
{
g5dParams parms;
int Ls=8;
double M5=1.8;
double mq=0.01;
double wilson_lo = 0.05;
double wilson_hi = 6.8;
double shamir_lo = 0.025;
double shamir_hi = 1.7;
double ht_scale=2.0;
double hw_scale=1.0;
if ( solver == HtCayleyTanh ) {
Printf("Testing HtCayleyTanh aka DWF\n");
parms.ShamirCayleyTanh(mq,M5,Ls);
} else if ( solver == HmCayleyTanh ) {
parms.ScaledShamirCayleyTanh(mq,M5,Ls,ht_scale);
Printf("Testing HmCayleyTanh Moebius\n");
} else if ( solver == HwCayleyTanh ) {
parms.WilsonCayleyTanh(mq,M5,Ls,hw_scale);
Printf("Testing HwCayleyTanh aka Borici\n");
} else {
exit(-1);
}
multi1d<LatticeColorMatrix> u(4);
HotSt(u);
multi1d<LatticeFermion> X(Ls);
multi1d<LatticeFermion> Y(Ls);
for(int s=0;s<Ls;s++){
gaussian(X[s]);
gaussian(Y[s]);
}
multi1d<LatticeColorMatrix> Fb(4);
multi1d<LatticeColorMatrix> F (4);
int lx = QDP::Layout::subgridLattSize()[0];
int ly = QDP::Layout::subgridLattSize()[1];
int lz = QDP::Layout::subgridLattSize()[2];
int lt = QDP::Layout::subgridLattSize()[3];
multi1d<int> procs = QDP::Layout::logicalSize();
/********************************************************
* Setup DWF operator
********************************************************
*/
bfmarg dwfa;
dwfa.node_latt[0] = lx;
dwfa.node_latt[1] = ly;
dwfa.node_latt[2] = lz;
dwfa.node_latt[3] = lt;
for(int mu=0;mu<4;mu++){
if ( procs[mu]>1 ) {
dwfa.local_comm[mu] = 0;
} else {
dwfa.local_comm[mu] = 1;
}
}
bfm_qmp dwf_qmp;
dwfa.mass = parms.mass;
dwfa.M5 = parms.M5;
dwfa.Csw = 0.0;
dwfa.precon_5d=0;
dwfa.residual=1.0e-5;
dwfa.max_iter=5000;
dwfa.Ls = parms.Ls;
dwfa.solver= parms.solver;
dwfa.zolo_lo = parms.zolo_lo;
dwfa.zolo_hi = parms.zolo_hi;
dwfa.mobius_scale = parms.mobius_scale;
dwf_qmp.init(dwfa);
dwf_qmp.importGauge(u);
Fermion_t X_t;
Fermion_t Y_t;
Matrix_t Force_t[2];
X_t = dwf_qmp.allocFermion();
Y_t = dwf_qmp.allocFermion();
for(int cb=0;cb<2;cb++){
Force_t[cb] = dwf_qmp.allocMatrix();
printf("Force_t pointer %lx\n",Force_t[cb]);
}
multi1d<int> bcs(Nd); bcs[0] = bcs[1] = bcs[2] = bcs[3] = 1;
Handle<FermBC<T,U,U> > fbc(new SimpleFermBC< T, U, U >(bcs));
Handle<CreateFermState<T,U,U> > cfs( new CreateSimpleFermState<T,U,U>(fbc));
Handle<FermState<T,U,U> > fs ((*cfs)(u));
//! Params for NEFF
EvenOddPrecKNOFermActArrayParams kparams;
Real scale = dwf_qmp.mobius_scale;
kparams.OverMass = dwf_qmp.M5;
kparams.Mass = dwf_qmp.mass;
kparams.a5 = 1.0;
kparams.coefs.resize(Ls);
for(int s=0;s<Ls;s++)
kparams.coefs[s] = scale;
kparams.N5 = dwf_qmp.Ls;
EvenOddPrecKNOFermActArray FA(cfs,kparams);
Handle< DiffLinearOperatorArray<Phi,P,Q> > M(FA.linOp(fs));
for( int dag=0;dag<2;dag++){
Fb=zero;
F=zero;
dwf_qmp.importFermion(X,X_t,1);
dwf_qmp.importFermion(Y,Y_t,1);
dwf_qmp.zeroMatrix(Force_t[0]);
dwf_qmp.zeroMatrix(Force_t[1]);
dwf_qmp.MprecDeriv(X_t,Y_t,Force_t,dag);
for(int cb=0;cb<2;cb++)
dwf_qmp.exportForce(Force_t[cb],Fb,cb);
Printf("Calling S_f deriv\n");
if( dag==1 )
M->deriv(F, X, Y, MINUS);
else
M->deriv(F, X, Y, PLUS);
for(int mu=0;mu<4;mu++){
QDPIO::cout << "dag "<< dag<<"mu "<<mu<<" n2diff " << norm2(Fb[mu]-F[mu])<<endl;
}
#if 0
QDPIO::cout << "Calling force term" << endl;
dwf_qmp.zeroMatrix(Force_t[0]);
dwf_qmp.zeroMatrix(Force_t[1]);
dwf_qmp.TwoFlavorRatioForce(X_t,Force_t,1.0,dwf_qmp.mass);
for(int cb=0;cb<2;cb++)
dwf_qmp.exportForce(Force_t[cb],Fb,cb);
for(int mu=0;mu<4;mu++){
QDPIO::cout << "dag "<< dag<<"mu "<<mu<<" TwoFlavorForce " << norm2(Fb[mu])<<endl;
}
#endif
// {
// EvenOddPrecConstDetTwoFlavorRatioConvConvWilsonTypeFermMonomial5D Monomial();
// }
}
dwf_qmp.freeMatrix(Force_t[0]);
dwf_qmp.freeMatrix(Force_t[1]);
exit(0);
}
void ARMultiPublisher::getTransformationCallback(const sensor_msgs::ImageConstPtr & image_msg)
{
// Get the image from ROSTOPIC
// NOTE: the dataPtr format is BGR because the ARToolKit library was
// build with V4L, dataPtr format change according to the
// ARToolKit configure option (see config.h).
try
{
capture_ = bridge_.imgMsgToCv(image_msg, "bgr8");
}
catch (sensor_msgs::CvBridgeException & e)
{
ROS_ERROR ("Could not convert from >%s< to 'bgr8'.", image_msg->encoding.c_str ());
}
// cvConvertImage(capture,capture,CV_CVTIMG_FLIP);
ARUint8* data_ptr = (ARUint8 *)capture_->imageData;
// detect the markers in the video frame
if (arDetectMarker(data_ptr, threshold_, &marker_info_, &num_detected_marker_) < 0)
{
argCleanup();
ROS_BREAK ();
}
ROS_DEBUG("Detected >%i< of >%i< markers.", num_detected_marker_, num_total_markers_);
double error = 0.0;
if ((error = arMultiGetTransMat(marker_info_, num_detected_marker_, multi_marker_config_)) < 0)
{
// ROS_ERROR("Could not get transformation. This should never happen.");
ROS_WARN("Could not get transformation.");
return;
}
ROS_DEBUG("Error is >%f<.", error);
for (int i = 0; i < num_detected_marker_; i++)
{
ROS_DEBUG("multi_marker_config_->prevF: %i", multi_marker_config_->prevF);
ROS_DEBUG("%s: (%i) pos: %f %f id: %i cf: %f", marker_frame_.c_str(), i, marker_info_[i].pos[0], marker_info_[i].pos[1], marker_info_[i].id, marker_info_[i].cf);
}
// choose those with the highest confidence
std::vector<double> cfs(num_total_markers_, 0.0);
marker_indizes_.clear();
for (int i = 0; i < num_total_markers_; ++i)
{
marker_indizes_.push_back(-1);
}
for (int i = 0; i < num_total_markers_; ++i)
{
for (int j = 0; j < num_detected_marker_; j++)
{
if (!(marker_info_[j].id < 0))
{
if (marker_info_[j].cf > cfs[marker_info_[j].id])
{
cfs[marker_info_[j].id] = marker_info_[j].cf;
marker_indizes_[marker_info_[j].id] = j;
}
}
}
}
double ar_quat[4], ar_pos[3];
arUtilMat2QuatPos(multi_marker_config_->trans, ar_quat, ar_pos);
tf::Quaternion rotation(-ar_quat[0], -ar_quat[1], -ar_quat[2], ar_quat[3]);
tf::Vector3 origin(ar_pos[0] * AR_TO_ROS, ar_pos[1] * AR_TO_ROS, ar_pos[2] * AR_TO_ROS);
tf::Transform transform(rotation, origin);
if (multi_marker_config_->prevF && publish_tf_)
{
if(error < error_threshold_)
{
ROS_DEBUG("%f %f %f | %f %f %f %f | %f", origin.getX(), origin.getY(), origin.getZ(), rotation.getX(), rotation.getY(), rotation.getZ(), rotation.getW(), image_msg->header.stamp.toSec());
tf::StampedTransform cam_to_marker(transform, image_msg->header.stamp, camera_frame_, marker_frame_);
tf_broadcaster_.sendTransform(cam_to_marker);
}
publishErrorMarker(error, image_msg->header.stamp);
}
if(publish_visual_markers_)
{
for (int i = 0; i < num_total_markers_; i++)
{
if (marker_indizes_[i] >= 0)
{
tf::Transform marker_transform;
getTransform(i, marker_transform);
tf::Transform marker = transform * marker_transform;
publishMarker(i, marker, image_msg->header.stamp);
last_transform_ = marker;
}
// else
// {
// publishMarker(i, last_transform_, image_msg->header.stamp);
// }
}
}
}
