void CGUIDialogPeripheralSettings::Save() { if (m_item == NULL || m_initialising) return; PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath()); if (!peripheral) return; peripheral->PersistSettings(); }
void CGUIDialogPeripheralSettings::OnResetSettings() { if (m_item == NULL) return; PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath()); if (!peripheral) 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(); }
bool CPeripheralAddon::Register(unsigned int peripheralIndex, const PeripheralPtr& peripheral) { if (!peripheral) return false; CSingleLock lock(m_critSection); if (m_peripherals.find(peripheralIndex) == m_peripherals.end()) { if (peripheral->Type() == PERIPHERAL_JOYSTICK) { m_peripherals[peripheralIndex] = std::static_pointer_cast<CPeripheralJoystick>(peripheral); CLog::Log(LOGNOTICE, "%s - new %s device registered on %s->%s: %s", __FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()), PeripheralTypeTranslator::BusTypeToString(PERIPHERAL_BUS_ADDON), peripheral->Location().c_str(), peripheral->DeviceName().c_str()); return true; } } return false; }
void CPeripheralBusAddon::Register(const PeripheralPtr& peripheral) { if (!peripheral) return; PeripheralAddonPtr addon; unsigned int peripheralIndex; CSingleLock lock(m_critSection); if (SplitLocation(peripheral->Location(), addon, peripheralIndex)) { if (addon->Register(peripheralIndex, peripheral)) m_manager.OnDeviceAdded(*this, *peripheral); } }
void CPeripheralBus::Register(const PeripheralPtr& peripheral) { if (!peripheral) return; bool bPeripheralAdded = false; { CSingleLock lock(m_critSection); if (!HasPeripheral(peripheral->Location())) { m_peripherals.push_back(peripheral); bPeripheralAdded = true; } } if (bPeripheralAdded) { CLog::Log(LOGNOTICE, "%s - new %s device registered on %s->%s: %s (%s:%s)", __FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()), PeripheralTypeTranslator::BusTypeToString(m_type), peripheral->Location().c_str(), peripheral->DeviceName().c_str(), peripheral->VendorIdAsString(), peripheral->ProductIdAsString()); m_manager.OnDeviceAdded(*this, *peripheral); } }
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 PeripheralPtr peripheral = GetByPath(pItem->GetPath()); if (!peripheral || 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::CreatePeripheral(CPeripheralBus &bus, const PeripheralScanResult& result) { PeripheralPtr peripheral; PeripheralScanResult mappedResult = result; if (mappedResult.m_busType == PERIPHERAL_BUS_UNKNOWN) mappedResult.m_busType = bus.Type(); /* check whether there's something mapped in peripherals.xml */ GetMappingForDevice(bus, mappedResult); switch(mappedResult.m_mappedType) { case PERIPHERAL_HID: peripheral = PeripheralPtr(new CPeripheralHID(mappedResult, &bus)); break; case PERIPHERAL_NIC: peripheral = PeripheralPtr(new CPeripheralNIC(mappedResult, &bus)); break; case PERIPHERAL_DISK: peripheral = PeripheralPtr(new CPeripheralDisk(mappedResult, &bus)); break; case PERIPHERAL_NYXBOARD: peripheral = PeripheralPtr(new CPeripheralNyxboard(mappedResult, &bus)); break; case PERIPHERAL_TUNER: peripheral = PeripheralPtr(new CPeripheralTuner(mappedResult, &bus)); break; case PERIPHERAL_BLUETOOTH: peripheral = PeripheralPtr(new CPeripheralBluetooth(mappedResult, &bus)); break; case PERIPHERAL_CEC: #if defined(HAVE_LIBCEC) if (bus.Type() == PERIPHERAL_BUS_CEC) peripheral = PeripheralPtr(new CPeripheralCecAdapter(mappedResult, &bus)); #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 = PeripheralPtr(new CPeripheralImon(mappedResult, &bus)); break; case PERIPHERAL_JOYSTICK: peripheral = PeripheralPtr(new CPeripheralJoystick(mappedResult, &bus)); 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()); } } }
void CGUIDialogPeripheralSettings::InitializeSettings() { if (m_item == NULL) { m_initialising = false; return; } m_initialising = true; bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml"); PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath()); if (!peripheral) { 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 *settingInt = new CSettingInt(setting->GetId(), *static_cast<CSettingInt*>(setting)); 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; }
bool CPeripheralAddon::ProcessEvents(void) { if (!m_bProvidesJoysticks) return false; PERIPHERAL_ERROR retVal; unsigned int eventCount = 0; PERIPHERAL_EVENT* pEvents = NULL; LogError(retVal = m_pStruct->GetEvents(&eventCount, &pEvents), "GetEvents()"); if (retVal == PERIPHERAL_NO_ERROR) { for (unsigned int i = 0; i < eventCount; i++) { ADDON::PeripheralEvent event(pEvents[i]); PeripheralPtr device = GetPeripheral(event.PeripheralIndex()); if (!device) continue; switch (device->Type()) { case PERIPHERAL_JOYSTICK: { std::shared_ptr<CPeripheralJoystick> joystickDevice = std::static_pointer_cast<CPeripheralJoystick>(device); switch (event.Type()) { case PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON: { const bool bPressed = (event.ButtonState() == JOYSTICK_STATE_BUTTON_PRESSED); CLog::Log(LOGDEBUG, "Button [ %u ] on %s %s", event.DriverIndex(), joystickDevice->DeviceName().c_str(), bPressed ? "pressed" : "released"); if (joystickDevice->OnButtonMotion(event.DriverIndex(), bPressed)) CLog::Log(LOGDEBUG, "Joystick button event handled"); break; } case PERIPHERAL_EVENT_TYPE_DRIVER_HAT: { const HAT_STATE state = CPeripheralAddonTranslator::TranslateHatState(event.HatState()); CLog::Log(LOGDEBUG, "Hat [ %u ] on %s %s", event.DriverIndex(), joystickDevice->DeviceName().c_str(), CJoystickTranslator::HatStateToString(state)); if (joystickDevice->OnHatMotion(event.DriverIndex(), state)) CLog::Log(LOGDEBUG, "Joystick hat event handled"); break; } case PERIPHERAL_EVENT_TYPE_DRIVER_AXIS: { joystickDevice->OnAxisMotion(event.DriverIndex(), event.AxisState()); break; } default: break; } break; } default: break; } } for (auto it : m_peripherals) { if (it.second->Type() == PERIPHERAL_JOYSTICK) std::static_pointer_cast<CPeripheralJoystick>(it.second)->ProcessAxisMotions(); } m_pStruct->FreeEvents(eventCount, pEvents); return true; } return false; }