// retrieve either the hostname or FQDN depending on platform (caller must
// check whether it's one or the other, this is why this function is for
// private use only)
static bool wxGetHostNameInternal(wxChar *buf, int sz)
{
wxCHECK_MSG( buf, false, wxT("NULL pointer in wxGetHostNameInternal") );
*buf = wxT('\0');
// we're using uname() which is POSIX instead of less standard sysinfo()
#if defined(HAVE_UNAME)
struct utsname uts;
bool ok = uname(&uts) != -1;
if ( ok )
{
wxStrlcpy(buf, wxSafeConvertMB2WX(uts.nodename), sz);
}
#elif defined(HAVE_GETHOSTNAME)
char cbuf[sz];
bool ok = gethostname(cbuf, sz) != -1;
if ( ok )
{
wxStrlcpy(buf, wxSafeConvertMB2WX(cbuf), sz);
}
#else // no uname, no gethostname
wxFAIL_MSG(wxT("don't know host name for this machine"));
bool ok = false;
#endif // uname/gethostname
if ( !ok )
{
wxLogSysError(_("Cannot get the hostname"));
}
return ok;
}
bool MidiIOPrefs::Commit()
{
ShuttleGui S(this, eIsSavingToPrefs);
PopulateOrExchange(S);
const PmDeviceInfo *info;
info = (const PmDeviceInfo *) mPlay->GetClientData(mPlay->GetSelection());
if (info) {
gPrefs->Write(wxT("/MidiIO/PlaybackDevice"),
wxString::Format(wxT("%s: %s"),
wxString(wxSafeConvertMB2WX(info->interf)),
wxString(wxSafeConvertMB2WX(info->name))));
}
#ifdef EXPERIMENTAL_MIDI_IN
info = (const PmDeviceInfo *) mRecord->GetClientData(mRecord->GetSelection());
if (info) {
gPrefs->Write(wxT("/MidiIO/RecordingDevice"),
wxString::Format(wxT("%s: %s"),
wxString(wxSafeConvertMB2WX(info->interf)),
wxString(wxSafeConvertMB2WX(info->name))));
}
#endif
return gPrefs->Flush();
}
static void FillHostDeviceInfo(DeviceSourceMap *map, const PaDeviceInfo *info, int deviceIndex, int isInput)
{
wxString hostapiName = wxSafeConvertMB2WX(Pa_GetHostApiInfo(info->hostApi)->name);
wxString infoName = wxSafeConvertMB2WX(info->name);
map->deviceIndex = deviceIndex;
map->hostIndex = info->hostApi;
map->deviceString = infoName;
map->hostString = hostapiName;
map->numChannels = isInput ? info->maxInputChannels : info->maxOutputChannels;
}
bool wxGetFullHostName(wxChar *buf, int sz)
{
bool ok = wxGetHostNameInternal(buf, sz);
if ( ok )
{
if ( !wxStrchr(buf, wxT('.')) )
{
struct hostent *host = gethostbyname(wxSafeConvertWX2MB(buf));
if ( !host )
{
wxLogSysError(_("Cannot get the official hostname"));
ok = false;
}
else
{
// the canonical name
wxStrlcpy(buf, wxSafeConvertMB2WX(host->h_name), sz);
}
}
//else: it's already a FQDN (BSD behaves this way)
}
return ok;
}
wxString wxGetUserHome( const wxString &user )
{
struct passwd *who = (struct passwd *) NULL;
if ( !user )
{
wxChar *ptr;
if ((ptr = wxGetenv(wxT("HOME"))) != NULL)
{
return ptr;
}
if ((ptr = wxGetenv(wxT("USER"))) != NULL ||
(ptr = wxGetenv(wxT("LOGNAME"))) != NULL)
{
who = getpwnam(wxSafeConvertWX2MB(ptr));
}
// make sure the user exists!
if ( !who )
{
who = getpwuid(getuid());
}
}
else
{
who = getpwnam (user.mb_str());
}
return wxSafeConvertMB2WX(who ? who->pw_dir : 0);
}
// Get user name e.g. Julian Smart
bool wxGetUserName(wxChar *buf, int maxSize)
{
*buf = wxT('\0');
// buffer allocation
MemHandle handle = MemHandleNew(maxSize-1);
if( handle == NULL )
return false;
// lock the buffer
char *id = (char *)MemHandleLock(handle);
if( id == NULL )
return false;
// get user's name
if( DlkGetSyncInfo(NULL, NULL, NULL, id, NULL, NULL) != errNone )
{
MemPtrUnlock(id);
return false;
}
wxStrlcpy(buf, wxSafeConvertMB2WX(id), maxSize);
// free the buffer
MemPtrUnlock(id);
return true;
}
static void AddSources(int deviceIndex, int rate, std::vector<DeviceSourceMap> *maps, int isInput)
{
int error = 0;
DeviceSourceMap map;
const PaDeviceInfo *info = Pa_GetDeviceInfo(deviceIndex);
// This tries to open the device with the samplerate worked out above, which
// will be the highest available for play and record on the device, or
// 44.1kHz if the info cannot be fetched.
PaStream *stream = NULL;
PaStreamParameters parameters;
parameters.device = deviceIndex;
parameters.sampleFormat = paFloat32;
parameters.hostApiSpecificStreamInfo = NULL;
parameters.channelCount = 1;
// If the device is for input, open a stream so we can use portmixer to query
// the number of inputs. We skip this for outputs because there are no 'sources'
// and some platforms (e.g. XP) have the same device for input and output, (while
// Vista/Win7 seperate these into two devices with the same names (but different
// portaudio indecies)
// Also, for mapper devices we don't want to keep any sources, so check for it here
if (isInput && !IsInputDeviceAMapperDevice(info)) {
if (info)
parameters.suggestedLatency = info->defaultLowInputLatency;
else
parameters.suggestedLatency = 10.0;
error = Pa_OpenStream(&stream,
¶meters,
NULL,
rate, paFramesPerBufferUnspecified,
paClipOff | paDitherOff,
DummyPaStreamCallback, NULL);
}
if (stream && !error) {
AddSourcesFromStream(deviceIndex, info, maps, stream);
Pa_CloseStream(stream);
} else {
map.sourceIndex = -1;
map.totalSources = 0;
FillHostDeviceInfo(&map, info, deviceIndex, isInput);
maps->push_back(map);
}
if(error) {
wxLogDebug(wxT("PortAudio stream error creating device list: ") +
map.hostString + wxT(":") + map.deviceString + wxT(": ") +
wxString(wxSafeConvertMB2WX(Pa_GetErrorText((PaError)error))));
}
}
bool wxGetUserId(wxChar *buf, int sz)
{
struct passwd *who;
*buf = wxT('\0');
if ((who = getpwuid(getuid ())) != NULL)
{
wxStrlcpy (buf, wxSafeConvertMB2WX(who->pw_name), sz);
return true;
}
return false;
}
/// Gets the lists of names and lists of labels which are
/// used in the choice controls.
/// The names are what the user sees in the wxChoice.
/// The corresponding labels are what gets stored.
void MidiIOPrefs::GetNamesAndLabels() {
// Gather list of hosts. Only added hosts that have devices attached.
Pm_Terminate(); // close and open to refresh device lists
Pm_Initialize();
int nDevices = Pm_CountDevices();
for (int i = 0; i < nDevices; i++) {
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
if (info->output || info->input) { //should always happen
wxString name = wxSafeConvertMB2WX(info->interf);
if (mHostNames.Index(name) == wxNOT_FOUND) {
mHostNames.Add(name);
mHostLabels.Add(name);
}
}
}
}
static void AddSourcesFromStream(int deviceIndex, const PaDeviceInfo *info, std::vector<DeviceSourceMap> *maps, PaStream *stream)
{
#ifdef USE_PORTMIXER
int i;
#endif
DeviceSourceMap map;
map.sourceIndex = -1;
map.totalSources = 0;
// Only inputs have sources, so we call FillHostDeviceInfo with a 1 to indicate this
FillHostDeviceInfo(&map, info, deviceIndex, 1);
#ifdef USE_PORTMIXER
PxMixer *portMixer = Px_OpenMixer(stream, 0);
if (!portMixer) {
maps->push_back(map);
return;
}
//if there is only one source, we don't need to concatenate the source
//or enumerate, because it is something meaningless like 'master'
//(as opposed to 'mic in' or 'line in'), and the user doesn't have any choice.
//note that some devices have no input sources at all but are still valid.
//the behavior we do is the same for 0 and 1 source cases.
map.totalSources = Px_GetNumInputSources(portMixer);
#endif
if (map.totalSources <= 1) {
map.sourceIndex = 0;
maps->push_back(map);
}
#ifdef USE_PORTMIXER
else {
//open up a stream with the device so portmixer can get the info out of it.
for (i = 0; i < map.totalSources; i++) {
map.sourceIndex = i;
map.sourceString = wxString(wxSafeConvertMB2WX(Px_GetInputSourceName(portMixer, i)));
maps->push_back(map);
}
}
Px_CloseMixer(portMixer);
#endif
}
bool wxGetUserName(wxChar *buf, int sz)
{
#ifdef HAVE_PW_GECOS
struct passwd *who;
*buf = wxT('\0');
if ((who = getpwuid (getuid ())) != NULL)
{
char *comma = strchr(who->pw_gecos, ',');
if (comma)
*comma = '\0'; // cut off non-name comment fields
wxStrlcpy(buf, wxSafeConvertMB2WX(who->pw_gecos), sz);
return true;
}
return false;
#else // !HAVE_PW_GECOS
return wxGetUserId(buf, sz);
#endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
}
String
strutil_expandpath(const String &ipath)
{
#ifdef OS_UNIX
String path;
if(strutil_isempty(ipath))
return wxEmptyString;
if(ipath[0u]=='~')
{
if(ipath[1u] == DIR_SEPARATOR)
{
path = wxGetenv(_T("HOME"));
path << (ipath.c_str() + 1);
return path;
}
else
{
String user =
strutil_before(String(ipath.c_str()+1), DIR_SEPARATOR);
struct passwd *entry;
do
{
entry = getpwent();
if(entry && entry->pw_name == user)
break;
} while(entry);
if(entry)
path << wxSafeConvertMB2WX(entry->pw_dir);
else
path << DIR_SEPARATOR << _T("home") << DIR_SEPARATOR << user; // improvise!
path << DIR_SEPARATOR
<< strutil_after(String(ipath.c_str()+1), DIR_SEPARATOR);
return path;
}
}
else
#endif // Unix
return ipath;
}
void MidiIOPrefs::OnHost(wxCommandEvent & WXUNUSED(e))
{
wxString itemAtIndex;
int index = mHost->GetCurrentSelection();
if (index >= 0 && index < (int)mHostNames.Count())
itemAtIndex = mHostNames.Item(index);
int nDevices = Pm_CountDevices();
if (nDevices == 0) {
mHost->Clear();
mHost->Append(_("No MIDI interfaces"), (void *) NULL);
mHost->SetSelection(0);
}
mPlay->Clear();
#ifdef EXPERIMENTAL_MIDI_IN
mRecord->Clear();
#endif
wxArrayString playnames;
wxArrayString recordnames;
for (int i = 0; i < nDevices; i++) {
const PmDeviceInfo *info = Pm_GetDeviceInfo(i);
wxString interf = wxSafeConvertMB2WX(info->interf);
if (itemAtIndex.IsSameAs(interf)) {
wxString name = wxSafeConvertMB2WX(info->name);
wxString device = wxString::Format(wxT("%s: %s"),
interf,
name);
int index;
if (info->output) {
playnames.Add(name);
index = mPlay->Append(name, (void *) info);
if (device == mPlayDevice) {
mPlay->SetSelection(index);
}
}
#ifdef EXPERIMENTAL_MIDI_IN
if (info->input) {
recordnames.Add(name);
index = mRecord->Append(name, (void *) info);
if (device == mRecordDevice) {
mRecord->SetSelection(index);
}
}
#endif
}
}
if (mPlay->GetCount() == 0) {
playnames.Add(_("No devices found"));
mPlay->Append(playnames[0], (void *) NULL);
}
#ifdef EXPERIMENTAL_MIDI_IN
if (mRecord->GetCount() == 0) {
recordnames.Add(_("No devices found"));
mRecord->Append(recordnames[0], (void *) NULL);
}
#endif
if (mPlay->GetCount() && mPlay->GetSelection() == wxNOT_FOUND) {
mPlay->SetSelection(0);
}
#ifdef EXPERIMENTAL_MIDI_IN
if (mRecord->GetCount() && mRecord->GetSelection() == wxNOT_FOUND) {
mRecord->SetSelection(0);
}
#endif
ShuttleGui S(this, eIsCreating);
S.SetSizeHints(mPlay, playnames);
#ifdef EXPERIMENTAL_MIDI_IN
S.SetSizeHints(mRecord, recordnames);
#endif
// OnDevice(e);
}