void BatteryNotifier::batteryStateChanged(MeeGo::QmBattery::BatteryState state) { switch(state) { case MeeGo::QmBattery::StateFull: stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery"); sendNotification(NotificationChargingComplete); break; case MeeGo::QmBattery::StateOK: stopLowBatteryNotifier(); break; case MeeGo::QmBattery::StateLow: if (qmBattery->getChargingState() != MeeGo::QmBattery::StateCharging) { // The low battery notifications should be sent only if the battery is not charging startLowBatteryNotifier(); } break; case MeeGo::QmBattery::StateEmpty: sendNotification(NotificationRechargeBattery); break; case MeeGo::QmBattery::StateError: break; } }
TokenItem* TokenMenu::addToken(QString text, QString filePath, int size, bool special, GameObject *gameObject) { // Check if the list already contains a token with the same text before insertion. QList<QListWidgetItem*> items = ui->m_tokenList->findItems(text, Qt::MatchExactly); if (items.empty()) { TokenItem *item = new TokenItem(filePath, text, size, special); if (!item->isPixLoaded()) { emit sendNotification(QString("L'image spécifiée par le chemin %1 n'a pas pu être chargée.") .arg(filePath)); } item->setGameObject(gameObject); // push the item into the database RepositoryManager::s_TokenItemRepository.insertTokenItem(item); // add the item to the tokenList ui->m_tokenList->addItem(item); ui->m_tokenList->setCurrentItem(item); // Notifies everyone that an item has been added QString msg = QString("%1").arg(item->id()); m_SenderClient->sendMessageToServer(msg, (quint16) TokenMenuCodes::ADD_TOKEN); return item; } else { emit sendNotification(QString("Un jeton nommé %1 existe déjà.").arg(text)); return NULL; } }
void LoginCommand::execute(Notification& noti) { const string& name=noti.m_strNotiName; void* data=noti.m_pData; if(StringHelper::isEqual(name,LoginFacade::COMMAND_EXIT)) { sendNotification(LoginFacade::NOTIFICATION_CLOSE); } else if(StringHelper::isEqual(name,LoginFacade::COMMAND_LOGIN)) { LoginVO vo=*((LoginVO*)data); IProxy* proxy=getFacade()->getProxy(LoginFacade::PROXY_LOGIN); LoginProxy* lp=dynamic_cast<LoginProxy*>(proxy); if(lp) { bool ret=lp->checkLogin(vo); if(ret) { //±¾µØ¼ì²é sendNotification(LoginFacade::NOTIFICATION_LOGIN_SUCESS); } else { sendNotification(LoginFacade::NOTIFICATION_LOGIN_FAIL); } } } }
void EquipmentCommand::execute(Notification& noti) { const string& name=noti.m_strNotiName; void* data=noti.m_pData; if(StringHelper::isEqual(name,EquipmentFacade::COMMAND_SWITCH_SEARCHPAGE)) { sendNotification(EquipmentFacade::NOTIFICATION_SWITCH_SRH_SUCCESS); } else if(StringHelper::isEqual(name,EquipmentFacade::COMMAND_SWITCH_ARSENALPAGE)) { sendNotification(EquipmentFacade::NOTIFICATION_SWITCH_ARL_SUCCESS); } /** else if(StringHelper::isEqual(name,EquipmentFacade::COMMAND_LOGIN)) { EquipmentVO vo=*((EquipmentVO*)data); IProxy* proxy=getFacade()->getProxy(EquipmentFacade::PROXY_LOGIN); EquipmentProxy* lp=dynamic_cast<EquipmentProxy*>(proxy); if(lp) { bool ret=lp->checkEquipment(vo); if(ret) { //±¾µØ¼ì²é sendNotification(EquipmentFacade::NOTIFICATION_LOGIN_SUCESS); } else { sendNotification(EquipmentFacade::NOTIFICATION_LOGIN_FAIL); } } } */ }
void BatteryNotifier::applyChargingState(QtMobility::QSystemBatteryInfo::ChargingState state) { switch(state) { case QtMobility::QSystemBatteryInfo::Charging: if (batteryInfo->chargerType() == QtMobility::QSystemBatteryInfo::USB_100mACharger) { sendNotification(NotificationNoEnoughPower); } else { // The low battery notifications should not be sent when the battery is charging stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery.removecharger" << "x-nemo.battery.chargingcomplete" << "x-nemo.battery.lowbattery"); sendNotification(NotificationCharging); } break; case QtMobility::QSystemBatteryInfo::NotCharging: removeNotification(QStringList() << "x-nemo.battery"); utiliseLED(false, QString("PatternBatteryCharging")); break; case QtMobility::QSystemBatteryInfo::ChargingError: sendNotification(NotificationChargingNotStarted); break; } }
TTErr TTClock::setDuration(const TTValue& value) { if (value.size() == 1) { if (value[0].type() == kTypeFloat64) { mDuration = value[0]; // update offset if (mDuration < mOffset) { mOffset = mDuration; sendNotification(TTSymbol("ClockOffsetChanged"), mOffset); } mPosition = mOffset / mDuration; mDate = mOffset; sendNotification(TTSymbol("ClockDurationChanged"), mDuration); return kTTErrNone; } } return kTTErrGeneric; }
void BatteryNotifier::chargingStateChanged(MeeGo::QmBattery::ChargingState state) { switch(state) { case MeeGo::QmBattery::StateCharging: if (qmBattery->getChargerType() == MeeGo::QmBattery::USB_100mA) { sendNotification(NotificationNoEnoughPower); } else { // The low battery notifications should not be sent when the battery is charging stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery.removecharger" << "x-nemo.battery.chargingcomplete" << "x-nemo.battery.lowbattery"); sendNotification(NotificationCharging); } break; case MeeGo::QmBattery::StateNotCharging: removeNotification(QStringList() << "x-nemo.battery"); utiliseLED(false, QString("PatternBatteryCharging")); break; case MeeGo::QmBattery::StateChargingFailed: sendNotification(NotificationChargingNotStarted); break; } }
void BatteryNotifier::applyChargingState(int, QBatteryInfo::ChargingState state) { switch(state) { case QBatteryInfo::Charging: if (batteryInfo->chargerType() == QBatteryInfo::USBCharger && batteryInfo->currentFlow(0) <= 100) { sendNotification(NotificationNoEnoughPower); } else { // The low battery notifications should not be sent when the battery is charging stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery.removecharger" << "x-nemo.battery.chargingcomplete" << "x-nemo.battery.lowbattery"); sendNotification(NotificationCharging); } break; case QBatteryInfo::NotCharging: sendNotification(NotificationChargingNotStarted); break; default: removeNotification(QStringList() << "x-nemo.battery"); break; } }
void BatteryNotifier::applyBatteryStatus(int, QBatteryInfo::BatteryStatus status) { switch(status) { case QBatteryInfo::BatteryFull: stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery"); sendNotification(NotificationChargingComplete); break; case QBatteryInfo::BatteryOk: stopLowBatteryNotifier(); break; case QBatteryInfo::BatteryLow: if (batteryInfo->chargingState(0) != QBatteryInfo::Charging) { // The low battery notifications should be sent only if the battery is not charging startLowBatteryNotifier(); } break; case QBatteryInfo::BatteryEmpty: sendNotification(NotificationRechargeBattery); break; default: break; } }
void BatteryNotifier::applyChargingState(QBatteryInfo::ChargingState state) { switch(state) { case QBatteryInfo::Charging: if (batteryInfo->chargerType() == QBatteryInfo::USBCharger && batteryInfo->currentFlow() <= 100) { sendNotification(NotificationNoEnoughPower); } else { // The low battery notifications should not be sent when the battery is charging stopLowBatteryNotifier(); removeNotification(QStringList() << "x-nemo.battery.removecharger" << "x-nemo.battery.chargingcomplete" << "x-nemo.battery.lowbattery"); sendNotification(NotificationCharging); } break; case QBatteryInfo::IdleChargingState: if (batteryInfo->levelStatus() != QBatteryInfo::LevelFull) { sendNotification(NotificationChargingNotStarted); return; } // otherwise fallthrough, not charging because capacity is full default: removeNotification(QStringList() << "x-nemo.battery"); break; } }
void BatteryNotifier::applyPSMState(MeeGo::QmDeviceMode::PSMState psmState) { if (psmState == MeeGo::QmDeviceMode::PSMStateOff) { sendNotification(NotificationExitingPSM); } else if (psmState == MeeGo::QmDeviceMode::PSMStateOn) { sendNotification(NotificationEnteringPSM); } }
void BatteryNotifier::devicePSMStateChanged(MeeGo::QmDeviceMode::PSMState PSMState) { if (PSMState == MeeGo::QmDeviceMode::PSMStateOff) { sendNotification(NotificationExitingPSM); } else if (PSMState == MeeGo::QmDeviceMode::PSMStateOn) { sendNotification(NotificationEnteringPSM); } }
void BatteryNotifier::sendNotification(BatteryNotifier::NotificationID id) { switch(id) { case NotificationCharging: sendNotification("x-nemo.battery", //% "Charging" qtTrId("qtn_ener_charging")); break; case NotificationChargingComplete: sendNotification("x-nemo.battery.chargingcomplete", //% "Charging complete" qtTrId("qtn_ener_charcomp")); break; case NotificationRemoveCharger: sendNotification("x-nemo.battery.removecharger", //% "Disconnect charger from power supply to save energy" qtTrId("qtn_ener_remcha")); break; case NotificationChargingNotStarted: sendNotification("x-nemo.battery.chargingnotstarted", //% "Charging not started. Replace charger." qtTrId("qtn_ener_repcharger")); break; case NotificationRechargeBattery: sendNotification("x-nemo.battery.recharge", //% "Recharge battery" qtTrId("qtn_ener_rebatt")); break; case NotificationEnteringPSM: sendNotification("x-nemo.battery.enterpsm", //% "Entering power save mode" qtTrId("qtn_ener_ent_psnote")); break; case NotificationExitingPSM: sendNotification("x-nemo.battery.exitpsm", //% "Exiting power save mode" qtTrId("qtn_ener_exit_psnote")); break; case NotificationLowBattery: sendNotification("x-nemo.battery.lowbattery", //% "Low battery" qtTrId("qtn_ener_lowbatt")); break; case NotificationNoEnoughPower: sendNotification("x-nemo.battery.notenoughpower", //% "Not enough power to charge" qtTrId("qtn_ener_nopowcharge"), "icon-m-energy-management-insufficient-power"); break; } }
void Listener::notify(NotificationDomain domain, NotificationEvent event, uint32 sequence, const CssmData &data) { Connection ¤t = Server::active().connection(); RefPointer<Notification> message = new Notification(domain, event, sequence, data); if (current.inSequence(message)) { StLock<Mutex> _(setLock); sendNotification(message); while (RefPointer<Notification> next = current.popNotification()) sendNotification(next); } }
void AMCPDevice::parseMultiline(const QString& line) { if (line.length() > 0) this->response.append(line); else if (line.length() == 0 && this->line.length() == 0 && this->previousLine.length() == 0) sendNotification(); }
void NTFCDevice::setConnected() { this->connected = true; this->command = NTFCDevice::CONNECTIONSTATE; sendNotification(); }
QVariant Subscribe::customCommand(const QString &command, const QList<QVariant> &args) { auto assertWhere = QString("Custom command \"%1\" from module \"%2\"") .arg(command).arg(name()).toLocal8Bit(); auto assertWhatInvalidArgs = "Invalid number of arguments!"; auto assertWhatInvalidCommand = "Invalid command"; if (command == "sendNotification") { Q_ASSERT_X(args.size() == 3, assertWhere.data(), assertWhatInvalidArgs); auto gid = args[0].toLongLong(); auto tag = args[1].toString(); auto text = args[2].toString(); sendNotification(gid, tag, text); } else if (command == "sendForward") { Q_ASSERT_X(args.size() == 3, assertWhere.data(), assertWhatInvalidArgs); auto gid = args[0].toLongLong(); auto tag = args[1].toString(); auto msgId = args[2].toLongLong(); sendForward(gid, tag, msgId); } else Q_ASSERT_X(false, assertWhere.data(), assertWhatInvalidCommand); return QVariant(); }
void METKAutoFading::resetAllCurrentOccluders() { Appearance oldValues; string objName = ""; set<string>::iterator iter; for (iter = currentFading.begin(); iter != currentFading.end(); iter++) { objName = *iter; std::cout << "Wiedereinblenden: " << objName << std::endl; if (htOldValues.find(objName)) { oldValues = *(htOldValues.find(objName)); myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_TRANSPARENCY, new double(oldValues.Transparency), omINFOTYPE_DOUBLE, true, false); myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTEWIDTH, new double(oldValues.SilhouetteWidth), omINFOTYPE_DOUBLE, true, false); vec3* tempVec3 = new vec3(oldValues.SilhouetteColor[0],oldValues.SilhouetteColor[1],oldValues.SilhouetteColor[2]); myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTECOLOR, tempVec3, omINFOTYPE_DOUBLE, true, false); delete tempVec3; myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTE, new bool(oldValues.SilhouetteVisible), omINFOTYPE_BOOL, true, false); } else std::cout << "No oldValues found in Hashtable for " << objName << std::endl; htOldValues.remove(objName); } currentFading.clear(); htOldValues.getTable()->clear(); sendNotification(); }
void AMCPDevice::parseTwoline(const QString& line) { if (line.length() > 0) this->response.append(line); else if (line.length() == 0 && this->response.count() > 1) sendNotification(); }
void BatteryNotifier::applyChargerType(QBatteryInfo::ChargerType type) { switch(type) { case QBatteryInfo::UnknownCharger: /* * After the user plugs out the charger from the device, this system * banner is displayed to remind the users to unplug charger from * the power supply for conserving energy. Remove charger * notification should not be shown in case if USB cable is used for * charging the device. */ if (chargerType == QBatteryInfo::WallCharger) { removeNotification(QStringList() << "x-nemo.battery" << "x-nemo.battery.chargingcomplete"); sendNotification(NotificationRemoveCharger); } if (chargerType != QBatteryInfo::UnknownCharger && chargerType != QBatteryInfo::USBCharger && batteryInfo->batteryStatus(0) == QBatteryInfo::BatteryLow && batteryInfo->chargingState(0) != QBatteryInfo::Charging) { // A charger was connected but is no longer connected and the battery is low, so start low battery notifier startLowBatteryNotifier(); } break; default: break; } chargerType = type; }
TTErr TTDictionaryBase::clear() { // mList->clear(); mMap.clear(); sendNotification("change", TTValue()); return kTTErrNone; }
// // Send a notification to all registered listeners // void Listener::notify(NotificationDomain domain, NotificationEvent event, const CssmData &data) { RefPointer<Notification> message = new Notification(domain, event, 0, data); StLock<Mutex> _(setLock); sendNotification(message); }
bool AWActions::runCmd(const QString cmd) const { qCDebug(LOG_AW) << "Cmd" << cmd; sendNotification(QString("Info"), i18n("Run %1", cmd)); return QProcess::startDetached(cmd); }
void AMCPDevice::setDisconnected() { this->connected = false; this->command = AMCPDevice::CONNECTIONSTATE; sendNotification(); QTimer::singleShot(5000, this, SLOT(reconnectDevice())); }
IOReturn PAEngine::performAudioEngineStop() { debugFunctionEnter(); sendNotification(kPAVirtualDeviceUserClientNotificationEngineStopped, 0); return kIOReturnSuccess; }
// Checked: 2010-03-03 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a void RlvBehaviourNotifyHandler::onCommand(const RlvCommand& rlvCmd, ERlvCmdRet eRet, bool fInternal) { if (fInternal) return; switch (rlvCmd.getParamType()) { case RLV_TYPE_ADD: case RLV_TYPE_REMOVE: sendNotification(rlvCmd.asString(), "=" + rlvCmd.getParam()); break; case RLV_TYPE_CLEAR: sendNotification(rlvCmd.asString()); break; default: break; } }
void Listener::notify(NotificationDomain domain, NotificationEvent event, uint32 sequence, const CssmData &data, audit_token_t auditToken) { Connection ¤t = Server::active().connection(); RefPointer<Notification> message = new Notification(domain, event, sequence, data); if (current.inSequence(message)) { StLock<Mutex> _(setLock); // This is a total layer violation, but no better place to put it uid_t uid = audit_token_to_euid(auditToken); gid_t gid = audit_token_to_egid(auditToken); SharedMemoryListener::createDefaultSharedMemoryListener(uid, gid); sendNotification(message); while (RefPointer<Notification> next = current.popNotification()) sendNotification(next); } }
void LiftRightExecutor::SensorDriverCallback(int _id, bool _detected){ std::cout << "LIRT RIGHT" << std::endl; LiftProgressNotification* liftNotification = new LiftProgressNotification(LiftProgressNotification::ProgressType::SENSOR_TRIGGERED); sendNotification(liftNotification); Command* cmd = ActuatorAction::LiftRight(CALLBACK_GET_RIGHT); commandQueueLock.lock(); commandsToProcess.push(Instruction(cmd)); commandQueueLock.unlock(); queueNotEmpty.notify_one(); }
void NTFCDevice::disconnectDevice() { this->socket->blockSignals(true); this->socket->disconnectFromHost(); this->socket->blockSignals(false); this->connected = false; this->command = NTFCDevice::CONNECTIONSTATE; sendNotification(); }
void ExampleExecutor::onTimeout(const boost::system::error_code &e, deadline_timer *t, void *obj, bool repeat){ if (repeat){ totalCounter++; sendNotification(new TimePassedNotification(ExampleExecutor::NAME, totalCounter)); t->expires_at(t->expires_at() + boost::posix_time::milliseconds(SLEEP_TIMER)); t->async_wait(boost::bind(&TimerCallback::onTimeout, this, boost::asio::placeholders::error, t, obj, repeat)); }else{ CountdownCommand* cc=static_cast<CountdownCommand*>(obj); sendResponseFromCommand(cc); } }