void CGUIDialogPeripheralSettings::ResetDefaultSettings(void)
{
if (m_item)
{
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (!peripheral)
return;
/* reset the settings in the peripheral */
peripheral->ResetDefaultSettings();
CSingleLock lock(g_graphicsContext);
/* clear the settings */
m_boolSettings.clear();
m_intSettings.clear();
m_intTextSettings.clear();
m_floatSettings.clear();
m_stringSettings.clear();
m_settings.clear();
/* reinit the window */
CreateSettings();
SetupPage(); // will clear the previous controls first
}
}
void CPeripherals::GetSettingsFromMapping(CPeripheral &peripheral) const
{
/* check all mappings in the order in which they are defined in peripherals.xml */
for (unsigned int iMappingPtr = 0; iMappingPtr < m_mappings.size(); iMappingPtr++)
{
const PeripheralDeviceMapping *mapping = &m_mappings.at(iMappingPtr);
bool bProductMatch = false;
if (mapping->m_PeripheralID.size() == 0)
{
bProductMatch = true;
}
else
{
for (unsigned int i = 0; i < mapping->m_PeripheralID.size(); i++)
if (mapping->m_PeripheralID[i].m_iVendorId == peripheral.VendorId() && mapping->m_PeripheralID[i].m_iProductId == peripheral.ProductId())
bProductMatch = true;
}
bool bBusMatch = (mapping->m_busType == PERIPHERAL_BUS_UNKNOWN || mapping->m_busType == peripheral.GetBusType());
bool bClassMatch = (mapping->m_class == PERIPHERAL_UNKNOWN || mapping->m_class == peripheral.Type());
if (bBusMatch && bProductMatch && bClassMatch)
{
for (map<CStdString, CSetting *>::const_iterator itr = mapping->m_settings.begin(); itr != mapping->m_settings.end(); itr++)
peripheral.AddSetting((*itr).first, (*itr).second);
}
}
}
bool PeripheralScanResult::operator ==(const CPeripheral &right) const
{
return m_iVendorId == right.VendorId() &&
m_iProductId == right.ProductId() &&
m_type == right.Type() &&
m_strLocation.Equals(right.Location());
}
bool CPeripheralBusAddon::InitializeProperties(CPeripheral& peripheral)
{
if (!CPeripheralBus::InitializeProperties(peripheral))
return false;
bool bSuccess = false;
PeripheralAddonPtr addon;
unsigned int index;
if (SplitLocation(peripheral.Location(), addon, index))
{
switch (peripheral.Type())
{
case PERIPHERAL_JOYSTICK:
bSuccess = addon->GetJoystickProperties(index, static_cast<CPeripheralJoystick&>(peripheral));
break;
default:
break;
}
}
return bSuccess;
}
void CPeripherals::GetSettingsFromMapping(CPeripheral &peripheral) const
{
CSingleLock lock(m_critSectionMappings);
/* check all mappings in the order in which they are defined in peripherals.xml */
for (const auto& mapping : m_mappings)
{
bool bProductMatch = false;
if (mapping.m_PeripheralID.empty())
bProductMatch = true;
else
{
for (const auto& peripheralID : mapping.m_PeripheralID)
if (peripheralID.m_iVendorId == peripheral.VendorId() && peripheralID.m_iProductId == peripheral.ProductId())
bProductMatch = true;
}
bool bBusMatch = (mapping.m_busType == PERIPHERAL_BUS_UNKNOWN || mapping.m_busType == peripheral.GetBusType());
bool bClassMatch = (mapping.m_class == PERIPHERAL_UNKNOWN || mapping.m_class == peripheral.Type());
if (bBusMatch && bProductMatch && bClassMatch)
{
for (auto itr = mapping.m_settings.begin(); itr != mapping.m_settings.end(); ++itr)
peripheral.AddSetting((*itr).first, (*itr).second.m_setting, (*itr).second.m_order);
}
}
}
bool CGUIDialogPeripheralManager::CurrentItemHasSettings(void) const
{
CSingleLock lock(g_graphicsContext);
CFileItemPtr currentItem = GetCurrentListItem();
if (!currentItem)
return false;
CPeripheral *peripheral = g_peripherals.GetByPath(currentItem.get()->GetPath());
return peripheral && peripheral->HasConfigurableSettings();
}
void CGUIDialogPeripheralSettings::Save()
{
if (m_item == NULL || m_initialising)
return;
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral == NULL)
return;
peripheral->PersistSettings();
}
void CGUIDialogPeripheralSettings::OnResetSettings()
{
if (m_item == NULL)
return;
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral == NULL)
return;
if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{10041}, CVariant{10042}))
return;
// reset the settings in the peripheral
peripheral->ResetDefaultSettings();
// re-create all settings and their controls
SetupView();
}
void CPeripheralBus::UnregisterRemovedDevices(const PeripheralScanResults &results)
{
CSingleLock lock(m_critSection);
for (int iDevicePtr = (int) m_peripherals.size() - 1; iDevicePtr >= 0; iDevicePtr--)
{
CPeripheral *peripheral = m_peripherals.at(iDevicePtr);
PeripheralScanResult updatedDevice;
if (!results.GetDeviceOnLocation(peripheral->Location(), &updatedDevice) ||
updatedDevice != *peripheral)
{
/* device removed */
if (peripheral->Type() != PERIPHERAL_UNKNOWN)
CLog::Log(LOGNOTICE, "%s - device removed from %s/%s: %s (%s:%s)", __FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()), peripheral->Location().c_str(), peripheral->DeviceName().c_str(), peripheral->VendorIdAsString(), peripheral->ProductIdAsString());
m_peripherals.erase(m_peripherals.begin() + iDevicePtr);
lock.Leave();
m_manager->OnDeviceDeleted(*this, peripheral->FileLocation());
delete peripheral;
}
}
}
void CPeripheralBus::UnregisterRemovedDevices(const PeripheralScanResults &results)
{
CSingleLock lock(m_critSection);
std::vector<CPeripheral *> removedPeripherals;
for (int iDevicePtr = (int) m_peripherals.size() - 1; iDevicePtr >= 0; iDevicePtr--)
{
CPeripheral *peripheral = m_peripherals.at(iDevicePtr);
PeripheralScanResult updatedDevice(m_type);
if (!results.GetDeviceOnLocation(peripheral->Location(), &updatedDevice) ||
*peripheral != updatedDevice)
{
/* device removed */
removedPeripherals.push_back(peripheral);
m_peripherals.erase(m_peripherals.begin() + iDevicePtr);
}
}
lock.Leave();
for (unsigned int iDevicePtr = 0; iDevicePtr < removedPeripherals.size(); iDevicePtr++)
{
CPeripheral *peripheral = removedPeripherals.at(iDevicePtr);
std::vector<PeripheralFeature> features;
peripheral->GetFeatures(features);
bool peripheralHasFeatures = features.size() > 1 || (features.size() == 1 && features.at(0) != FEATURE_UNKNOWN);
if (peripheral->Type() != PERIPHERAL_UNKNOWN || peripheralHasFeatures)
{
CLog::Log(LOGNOTICE, "%s - device removed from %s/%s: %s (%s:%s)", __FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()), peripheral->Location().c_str(), peripheral->DeviceName().c_str(), peripheral->VendorIdAsString(), peripheral->ProductIdAsString());
peripheral->OnDeviceRemoved();
}
m_manager->OnDeviceDeleted(*this, *peripheral);
delete peripheral;
}
}
void CPeripherals::OnDeviceDeleted(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
OnDeviceChanged();
bool bNotify = true;
// don't show a notification for emulated peripherals
if (peripheral.Type() == PERIPHERAL_JOYSTICK_EMULATION) //! @todo Change to peripheral.IsEmulated()
bNotify = false;
if (bNotify)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35006), peripheral.DeviceName());
}
bool CPeripheralBus::InitializeProperties(CPeripheral& peripheral)
{
if (peripheral.Type() == PERIPHERAL_JOYSTICK)
{
// Ensure an add-on is present to translate input
if (!m_manager.GetAddonWithButtonMap(&peripheral))
{
CLog::Log(LOGWARNING, "Button mapping add-on not present for %s (%s), skipping", peripheral.Location().c_str(), peripheral.DeviceName().c_str());
return false;
}
}
return true;
}
void CGUIDialogPeripheralSettings::UpdatePeripheralSettings(void)
{
if (!m_item || m_bIsInitialising)
return;
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (!peripheral)
return;
map<CStdString, bool>::iterator boolItr = m_boolSettings.begin();
while (boolItr != m_boolSettings.end())
{
peripheral->SetSetting((*boolItr).first, (*boolItr).second);
++boolItr;
}
map<CStdString, float>::iterator intItr = m_intSettings.begin();
while (intItr != m_intSettings.end())
{
peripheral->SetSetting((*intItr).first, (int) (*intItr).second);
++intItr;
}
map<CStdString, int>::iterator intTextItr = m_intTextSettings.begin();
while (intTextItr != m_intTextSettings.end())
{
peripheral->SetSetting((*intTextItr).first, (*intTextItr).second);
++intTextItr;
}
map<CStdString, float>::iterator floatItr = m_floatSettings.begin();
while (floatItr != m_floatSettings.end())
{
peripheral->SetSetting((*floatItr).first, (*floatItr).second);
++floatItr;
}
map<CStdString, CStdString>::iterator stringItr = m_stringSettings.begin();
while (stringItr != m_stringSettings.end())
{
peripheral->SetSetting((*stringItr).first, (*stringItr).second);
++stringItr;
}
peripheral->PersistSettings();
}
void CPeripherals::OnDeviceAdded(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
OnDeviceChanged();
//! @todo Improve device notifications in v18
#if 0
bool bNotify = true;
// don't show a notification for devices detected during the initial scan
if (!bus.IsInitialised())
bNotify = false;
// don't show a notification for emulated peripherals
if (peripheral.Type() == PERIPHERAL_JOYSTICK_EMULATION) //! @todo Change to peripheral.IsEmulated()
bNotify = false;
if (bNotify)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35005), peripheral.DeviceName());
#endif
}
void CGUIDialogPeripheralSettings::CreateSettings()
{
m_bIsInitialising = true;
m_usePopupSliders = g_SkinInfo->HasSkinFile("DialogSlider.xml");
if (m_item)
{
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral)
{
vector<CSetting *> settings = peripheral->GetSettings();
for (size_t iPtr = 0; iPtr < settings.size(); iPtr++)
{
CSetting *setting = settings[iPtr];
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
switch(setting->GetType())
{
case SettingTypeBool:
{
CSettingBool *boolSetting = (CSettingBool *) setting;
if (boolSetting)
{
m_boolSettings.insert(make_pair(CStdString(boolSetting->GetId()), boolSetting->GetValue()));
AddBool(m_settingId++, boolSetting->GetLabel(), &m_boolSettings[boolSetting->GetId()], true);
}
}
break;
case SettingTypeInteger:
{
CSettingInt *intSetting = (CSettingInt *) setting;
if (intSetting)
{
if (intSetting->GetControl()->GetFormat() == "integer")
{
m_intSettings.insert(make_pair(CStdString(intSetting->GetId()), (float) intSetting->GetValue()));
AddSlider(m_settingId++, intSetting->GetLabel(), &m_intSettings[intSetting->GetId()], (float)intSetting->GetMinimum(), (float)intSetting->GetStep(), (float)intSetting->GetMaximum(), CGUIDialogVideoSettings::FormatInteger, false);
}
else if (intSetting->GetControl()->GetFormat() == "string")
{
m_intTextSettings.insert(make_pair(CStdString(intSetting->GetId()), intSetting->GetValue()));
vector<pair<int, int> > entries;
StaticIntegerSettingOptions::const_iterator entriesItr = intSetting->GetOptions().begin();
while (entriesItr != intSetting->GetOptions().end())
{
entries.push_back(make_pair(entriesItr->first, entriesItr->second));
++entriesItr;
}
AddSpin(m_settingId++, intSetting->GetLabel(), &m_intTextSettings[intSetting->GetId()], entries);
}
}
}
break;
case SettingTypeNumber:
{
CSettingNumber *floatSetting = (CSettingNumber *) setting;
if (floatSetting)
{
m_floatSettings.insert(make_pair(CStdString(floatSetting->GetId()), (float)floatSetting->GetValue()));
AddSlider(m_settingId++, floatSetting->GetLabel(), &m_floatSettings[floatSetting->GetId()], (float)floatSetting->GetMinimum(), (float)floatSetting->GetStep(), (float)floatSetting->GetMaximum(), CGUIDialogVideoSettings::FormatFloat, false);
}
}
break;
case SettingTypeString:
{
CSettingString *stringSetting = (CSettingString *) setting;
if (stringSetting)
{
m_stringSettings.insert(make_pair(CStdString(stringSetting->GetId()), stringSetting->GetValue()));
AddString(m_settingId++, stringSetting->GetLabel(), &m_stringSettings[stringSetting->GetId()]);
}
}
break;
default:
//TODO add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
}
}
else
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
}
}
m_bIsInitialising = false;
}
void CPeripherals::OnDeviceDeleted(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
CGUIDialogPeripheralManager *dialog = (CGUIDialogPeripheralManager *)g_windowManager.GetWindow(WINDOW_DIALOG_PERIPHERAL_MANAGER);
if (dialog && dialog->IsActive())
dialog->Update();
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35006), peripheral.DeviceName());
}
CPeripheral *CPeripherals::CreatePeripheral(CPeripheralBus &bus, const PeripheralType type, const CStdString &strLocation, int iVendorId /* = 0 */, int iProductId /* = 0 */)
{
CPeripheral *peripheral = NULL;
/* check whether there's something mapped in peripherals.xml */
PeripheralType mappedType = type;
CStdString strDeviceName;
int iMappingPtr = GetMappingForDevice(bus, type, iVendorId, iProductId);
bool bHasMapping(iMappingPtr >= 0);
if (bHasMapping)
{
mappedType = m_mappings[iMappingPtr].m_mappedTo;
strDeviceName = m_mappings[iMappingPtr].m_strDeviceName;
}
else
{
/* don't create instances for devices that aren't mapped in peripherals.xml */
return NULL;
}
switch(mappedType)
{
case PERIPHERAL_HID:
peripheral = new CPeripheralHID(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_NIC:
peripheral = new CPeripheralNIC(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_DISK:
peripheral = new CPeripheralDisk(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_NYXBOARD:
peripheral = new CPeripheralNyxboard(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_TUNER:
peripheral = new CPeripheralTuner(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_BLUETOOTH:
peripheral = new CPeripheralBluetooth(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
break;
case PERIPHERAL_CEC:
#if defined(HAVE_LIBCEC)
peripheral = new CPeripheralCecAdapter(type, bus.Type(), strLocation, strDeviceName, iVendorId, iProductId);
#else
if (!m_bMissingLibCecWarningDisplayed)
{
m_bMissingLibCecWarningDisplayed = true;
CLog::Log(LOGWARNING, "%s - libCEC support has not been compiled in, so the CEC adapter cannot be used.", __FUNCTION__);
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(36000), g_localizeStrings.Get(36017));
}
#endif
break;
default:
break;
}
if (peripheral)
{
/* try to initialise the new peripheral
* Initialise() will make sure that each device is only initialised once */
if (peripheral->Initialise())
{
if (!bHasMapping)
peripheral->SetHidden(true);
bus.Register(peripheral);
}
else
{
CLog::Log(LOGDEBUG, "%s - failed to initialise peripheral on '%s'", __FUNCTION__, strLocation.c_str());
delete peripheral;
peripheral = NULL;
}
}
return peripheral;
}
void CGUIDialogPeripheralSettings::CreateSettings()
{
m_bIsInitialising = true;
m_usePopupSliders = g_SkinInfo->HasSkinFile("DialogSlider.xml");
if (m_item)
{
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral)
{
vector<CSetting *> settings = peripheral->GetSettings();
for (size_t iPtr = 0; iPtr < settings.size(); iPtr++)
{
CSetting *setting = settings[iPtr];
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
switch(setting->GetType())
{
case SETTINGS_TYPE_BOOL:
{
CSettingBool *boolSetting = (CSettingBool *) setting;
if (boolSetting)
{
m_boolSettings.insert(make_pair(CStdString(boolSetting->GetSetting()), boolSetting->GetData()));
AddBool(boolSetting->GetOrder(), boolSetting->GetLabel(), &m_boolSettings[boolSetting->GetSetting()], true);
}
}
break;
case SETTINGS_TYPE_INT:
{
CSettingInt *intSetting = (CSettingInt *) setting;
if (intSetting)
{
if (intSetting->GetControlType() == SPIN_CONTROL_INT)
{
m_intSettings.insert(make_pair(CStdString(intSetting->GetSetting()), (float) intSetting->GetData()));
AddSlider(intSetting->GetOrder(), intSetting->GetLabel(), &m_intSettings[intSetting->GetSetting()], (float)intSetting->m_iMin, (float)intSetting->m_iStep, (float)intSetting->m_iMax, CGUIDialogVideoSettings::FormatInteger, false);
}
else if (intSetting->GetControlType() == SPIN_CONTROL_TEXT)
{
m_intTextSettings.insert(make_pair(CStdString(intSetting->GetSetting()), intSetting->GetData()));
vector<pair<int, int> > entries;
map<int, int>::iterator entriesItr = intSetting->m_entries.begin();
while (entriesItr != intSetting->m_entries.end())
{
entries.push_back(make_pair(entriesItr->first, entriesItr->second));
++entriesItr;
}
AddSpin(intSetting->GetOrder(), intSetting->GetLabel(), &m_intTextSettings[intSetting->GetSetting()], entries);
}
}
}
break;
case SETTINGS_TYPE_FLOAT:
{
CSettingFloat *floatSetting = (CSettingFloat *) setting;
if (floatSetting)
{
m_floatSettings.insert(make_pair(CStdString(floatSetting->GetSetting()), floatSetting->GetData()));
AddSlider(floatSetting->GetOrder(), floatSetting->GetLabel(), &m_floatSettings[floatSetting->GetSetting()], floatSetting->m_fMin, floatSetting->m_fStep, floatSetting->m_fMax, CGUIDialogVideoSettings::FormatFloat, false);
}
}
break;
case SETTINGS_TYPE_STRING:
{
CSettingString *stringSetting = (CSettingString *) setting;
if (stringSetting)
{
m_stringSettings.insert(make_pair(CStdString(stringSetting->GetSetting()), stringSetting->GetData()));
AddString(stringSetting->GetOrder(), stringSetting->GetLabel(), &m_stringSettings[stringSetting->GetSetting()]);
}
}
break;
default:
//TODO add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
}
}
else
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
}
}
m_bIsInitialising = false;
}
void CPeripherals::OnDeviceAdded(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
CGUIDialogPeripheralManager *dialog = (CGUIDialogPeripheralManager *)g_windowManager.GetWindow(WINDOW_DIALOG_PERIPHERAL_MANAGER);
if (dialog && dialog->IsActive())
dialog->Update();
// refresh settings (peripherals manager could be enabled now)
CGUIMessage msg(GUI_MSG_UPDATE, WINDOW_SETTINGS_SYSTEM, 0);
g_windowManager.SendThreadMessage(msg, WINDOW_SETTINGS_SYSTEM);
SetChanged();
// don't show a notification for devices detected during the initial scan
if (bus.IsInitialised())
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35005), peripheral.DeviceName());
}
CPeripheral *CPeripherals::CreatePeripheral(CPeripheralBus &bus, const PeripheralScanResult& result)
{
CPeripheral *peripheral = NULL;
PeripheralScanResult mappedResult = result;
if (mappedResult.m_busType == PERIPHERAL_BUS_UNKNOWN)
mappedResult.m_busType = bus.Type();
/* check whether there's something mapped in peripherals.xml */
if (!GetMappingForDevice(bus, mappedResult))
{
/* don't create instances for devices that aren't mapped in peripherals.xml */
return NULL;
}
switch(mappedResult.m_mappedType)
{
case PERIPHERAL_HID:
peripheral = new CPeripheralHID(mappedResult);
break;
case PERIPHERAL_NIC:
peripheral = new CPeripheralNIC(mappedResult);
break;
case PERIPHERAL_DISK:
peripheral = new CPeripheralDisk(mappedResult);
break;
case PERIPHERAL_NYXBOARD:
peripheral = new CPeripheralNyxboard(mappedResult);
break;
case PERIPHERAL_TUNER:
peripheral = new CPeripheralTuner(mappedResult);
break;
case PERIPHERAL_BLUETOOTH:
peripheral = new CPeripheralBluetooth(mappedResult);
break;
case PERIPHERAL_CEC:
#if defined(HAVE_LIBCEC)
if (bus.Type() == PERIPHERAL_BUS_CEC)
peripheral = new CPeripheralCecAdapter(mappedResult);
#else
if (!m_bMissingLibCecWarningDisplayed)
{
m_bMissingLibCecWarningDisplayed = true;
CLog::Log(LOGWARNING, "%s - libCEC support has not been compiled in, so the CEC adapter cannot be used.", __FUNCTION__);
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(36000), g_localizeStrings.Get(36017));
}
#endif
break;
case PERIPHERAL_IMON:
peripheral = new CPeripheralImon(mappedResult);
break;
default:
break;
}
if (peripheral)
{
/* try to initialise the new peripheral
* Initialise() will make sure that each device is only initialised once */
if (peripheral->Initialise())
{
bus.Register(peripheral);
}
else
{
CLog::Log(LOGDEBUG, "%s - failed to initialise peripheral on '%s'", __FUNCTION__, mappedResult.m_strLocation.c_str());
delete peripheral;
peripheral = NULL;
}
}
return peripheral;
}
void CGUIDialogPeripheralSettings::InitializeSettings()
{
if (m_item == NULL)
{
m_initialising = false;
return;
}
m_initialising = true;
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
CPeripheral *peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (peripheral == NULL)
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
m_initialising = false;
return;
}
m_settingsMap.clear();
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("peripheralsettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
CSettingGroup *group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
std::vector<CSetting*> settings = peripheral->GetSettings();
for (std::vector<CSetting*>::iterator itSetting = settings.begin(); itSetting != settings.end(); ++itSetting)
{
CSetting *setting = *itSetting;
if (setting == NULL)
continue;
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
// we need to create a copy of the setting because the CSetting instances
// are destroyed when leaving the dialog
CSetting *settingCopy = NULL;
switch(setting->GetType())
{
case SettingTypeBool:
{
CSettingBool *settingBool = new CSettingBool(setting->GetId(), *static_cast<CSettingBool*>(setting));
settingBool->SetControl(GetCheckmarkControl());
settingCopy = static_cast<CSetting*>(settingBool);
break;
}
case SettingTypeInteger:
{
CSettingInt *intSetting = static_cast<CSettingInt*>(setting);
if (intSetting == NULL)
break;
CSettingInt *settingInt = new CSettingInt(setting->GetId(), *intSetting);
if (settingInt->GetOptions().empty())
settingInt->SetControl(GetSliderControl("integer", false, -1, usePopup, -1, "%i"));
else
settingInt->SetControl(GetSpinnerControl("string"));
settingCopy = static_cast<CSetting*>(settingInt);
break;
}
case SettingTypeNumber:
{
CSettingNumber *settingNumber = new CSettingNumber(setting->GetId(), *static_cast<CSettingNumber*>(setting));
settingNumber->SetControl(GetSliderControl("number", false, -1, usePopup, -1, "%2.2f"));
settingCopy = static_cast<CSetting*>(settingNumber);
break;
}
case SettingTypeString:
{
CSettingString *settingString = new CSettingString(setting->GetId(), *static_cast<CSettingString*>(setting));
settingString->SetControl(GetEditControl("string"));
settingCopy = static_cast<CSetting*>(settingString);
break;
}
default:
// TODO: add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
if (settingCopy != NULL && settingCopy->GetControl() != NULL)
{
settingCopy->SetLevel(SettingLevelBasic);
group->AddSetting(settingCopy);
m_settingsMap.insert(std::make_pair(setting->GetId(), setting));
}
}
m_initialising = false;
}
void CPeripherals::OnDeviceDeleted(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
OnDeviceChanged();
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35006), peripheral.DeviceName());
}
void CPeripherals::OnDeviceAdded(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
OnDeviceChanged();
//! @todo Improve device notifications in v18
#if 0
// don't show a notification for devices detected during the initial scan
if (bus.IsInitialised())
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35005), peripheral.DeviceName());
#endif
}
void CPeripherals::OnDeviceDeleted(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
CGUIDialogPeripheralManager *dialog = (CGUIDialogPeripheralManager *)g_windowManager.GetWindow(WINDOW_DIALOG_PERIPHERAL_MANAGER);
if (dialog && dialog->IsActive())
dialog->Update();
// refresh settings (peripherals manager could be disabled now)
CGUIMessage msg(GUI_MSG_UPDATE, WINDOW_SETTINGS_SYSTEM, 0);
g_windowManager.SendThreadMessage(msg, WINDOW_SETTINGS_SYSTEM);
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35006), peripheral.DeviceName());
}
void CPeripherals::OnSettingAction(const CSetting *setting)
{
if (setting == nullptr)
return;
const std::string &settingId = setting->GetId();
if (settingId == CSettings::SETTING_INPUT_PERIPHERALS)
{
CGUIDialogSelect* pDialog = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
CFileItemList items;
GetDirectory("peripherals://all/", items);
int iPos = -1;
do
{
pDialog->Reset();
pDialog->SetHeading(CVariant{35000});
pDialog->SetUseDetails(true);
pDialog->SetItems(items);
pDialog->SetSelected(iPos);
pDialog->Open();
iPos = pDialog->IsConfirmed() ? pDialog->GetSelectedItem() : -1;
if (iPos >= 0)
{
CFileItemPtr pItem = items.Get(iPos);
// show an error if the peripheral doesn't have any settings
CPeripheral *peripheral = GetByPath(pItem->GetPath());
if (peripheral == nullptr || peripheral->GetSettings().empty())
{
CGUIDialogOK::ShowAndGetInput(CVariant{35000}, CVariant{35004});
continue;
}
CGUIDialogPeripheralSettings *pSettingsDialog = (CGUIDialogPeripheralSettings *)g_windowManager.GetWindow(WINDOW_DIALOG_PERIPHERAL_SETTINGS);
if (pItem && pSettingsDialog)
{
// pass peripheral item properties to settings dialog so skin authors
// can use it to show more detailed information about the device
pSettingsDialog->SetProperty("vendor", pItem->GetProperty("vendor"));
pSettingsDialog->SetProperty("product", pItem->GetProperty("product"));
pSettingsDialog->SetProperty("bus", pItem->GetProperty("bus"));
pSettingsDialog->SetProperty("location", pItem->GetProperty("location"));
pSettingsDialog->SetProperty("class", pItem->GetProperty("class"));
pSettingsDialog->SetProperty("version", pItem->GetProperty("version"));
// open settings dialog
pSettingsDialog->SetFileItem(pItem.get());
pSettingsDialog->Open();
}
}
} while (pDialog->IsConfirmed());
}
else if (settingId == CSettings::SETTING_INPUT_CONTROLLERCONFIG)
g_windowManager.ActivateWindow(WINDOW_DIALOG_GAME_CONTROLLERS);
else if (settingId == CSettings::SETTING_INPUT_TESTRUMBLE)
TestFeature(FEATURE_RUMBLE);
}
void CPeripherals::OnDeviceDeleted(const CPeripheralBus &bus, const CPeripheral &peripheral)
{
OnDeviceChanged();
//! @todo Improve device notifications in v18
#if 0
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(35006), peripheral.DeviceName());
#endif
}