void ListenerAdapter::polkit_qt_listener_initiate_authentication(PolkitAgentListener *listener, const gchar *action_id, const gchar *message, const gchar *icon_name, PolkitDetails *details, const gchar *cookie, GList *identities, GCancellable *cancellable, GSimpleAsyncResult *result) { qDebug() << "polkit_qt_listener_initiate_authentication callback for " << listener; PolkitQt1::Identity::List idents; PolkitQt1::Details dets(details); Listener *list = findListener(listener); for (GList *identity = g_list_first(identities); identity != NULL; identity = g_list_next(identity)) { idents.append(PolkitQt1::Identity((PolkitIdentity *)identity->data)); } list->initiateAuthentication(QString::fromUtf8(action_id), QString::fromUtf8(message), QString::fromUtf8(icon_name), dets, QString::fromUtf8(cookie), idents, new AsyncResult(result)); }
SoundContext::SoundContext(const Misc::ConfigurationFileSection& configFileSection,VruiState* sVruiState) :vruiState(sVruiState), #ifdef VRUI_USE_OPENAL alDevice(0),alContext(0), #endif contextData(0), listener(findListener(configFileSection.retrieveString("./listenerName").c_str())) { #ifdef VRUI_USE_OPENAL /* Open the OpenAL device: */ std::string alDeviceName=configFileSection.retrieveValue<std::string>("./deviceName","Default"); alDevice=alcOpenDevice(alDeviceName!="Default"?alDeviceName.c_str():0); if(alDevice==0) Misc::throwStdErr("SoundContext::SoundContext: Could not open OpenAL sound device %s",alDeviceName.c_str()); /* Create an OpenAL context: */ alContext=alcCreateContext(alDevice,0); if(alContext==0) { alcCloseDevice(alDevice); Misc::throwStdErr("SoundContext::SoundContext: Could not create OpenAL context for sound device %s",alDeviceName.c_str()); } #endif /* Create an AL context data object: */ contextData=new ALContextData(101); /* Initialize the sound context's OpenAL context: */ makeCurrent(); /* Initialize application sound state: */ if(vruiState->perSoundInitFunction!=0) vruiState->perSoundInitFunction(*contextData,vruiState->perSoundInitFunctionData); }
void ListenerAdapter::cancelled_cb(PolkitAgentListener *listener) { qDebug() << "cancelled_cb for " << listener; Listener *list = findListener(listener); list->cancelAuthentication(); }
bool StreamingDevice::processMessage(ClientConn& client, string& cmd, JSONNode& n){ if (cmd == "listen"){ cancelListen(findListener(&client, jsonIntProp(n, "id"))); addListener(makeStreamListener(this, &client, n)); }else if (cmd == "cancelListen"){ cancelListen(findListener(&client, jsonIntProp(n, "id"))); }else if (cmd == "configure"){ int mode = jsonIntProp(n, "mode"); unsigned samples = jsonIntProp(n, "samples"); double sampleTime = jsonFloatProp(n, "sampleTime"); bool continuous = jsonBoolProp(n, "continuous", false); bool raw = jsonBoolProp(n, "raw", false); configure(mode, sampleTime, samples, continuous, raw); }else if (cmd == "startCapture"){ start_capture(); }else if (cmd == "pauseCapture"){ pause_capture(); }else if (cmd == "set"){ Channel *channel = channelById(jsonStringProp(n, "channel")); if (!channel) throw ErrorStringException("Channel not found"); setOutput(channel, makeSource(n)); }else if (cmd == "setGain"){ Channel *channel = channelById(jsonStringProp(n, "channel")); if (!channel) throw ErrorStringException("Channel not found"); Stream *stream = findStream( jsonStringProp(n, "channel"), jsonStringProp(n, "stream")); double gain = jsonFloatProp(n, "gain", 1); setGain(channel, stream, gain); }else if (cmd == "setCurrentLimit"){ unsigned limit = jsonFloatProp(n, "currentLimit"); setCurrentLimit(limit); }else{ return false; } return true; }
static bool removeListenerFromVector(EventListenerVector& listeners, EventListener& listener, bool useCapture) { size_t indexOfRemovedListener = findListener(listeners, listener, useCapture); if (UNLIKELY(indexOfRemovedListener == notFound)) return false; listeners[indexOfRemovedListener]->markAsRemoved(); listeners.remove(indexOfRemovedListener); return true; }
// ---------------------------------------------------------------------------- // bool SpotifyEngine::unregisterEventListener( IPlayerEventCallback* listener ) { CSingleLock lock( &m_event_lock, TRUE ); auto it = findListener( listener ); if ( it == m_event_listeners.end() ) return false; m_event_listeners.erase( it ); return true; }
// ---------------------------------------------------------------------------- // bool SpotifyEngine::registerEventListener( IPlayerEventCallback* listener ) { CSingleLock lock( &m_event_lock, TRUE ); if ( findListener( listener ) != m_event_listeners.end() ) return false; m_event_listeners.push_back( listener ); return true; }
void EventListenerMap::replace(const AtomicString& eventType, EventListener& oldListener, Ref<EventListener>&& newListener, const RegisteredEventListener::Options& options) { assertNoActiveIterators(); auto* listeners = find(eventType); ASSERT(listeners); size_t index = findListener(*listeners, oldListener, options.capture); ASSERT(index != notFound); auto& registeredListener = listeners->at(index); registeredListener->markAsRemoved(); registeredListener = RegisteredEventListener::create(WTFMove(newListener), options); }
bool EventListenerMap::add(const AtomicString& eventType, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options) { assertNoActiveIterators(); if (auto* listeners = find(eventType)) { if (findListener(*listeners, listener, options.capture) != notFound) return false; // Duplicate listener. listeners->append(RegisteredEventListener::create(WTFMove(listener), options)); return true; } auto listeners = std::make_unique<EventListenerVector>(); listeners->uncheckedAppend(RegisteredEventListener::create(WTFMove(listener), options)); m_entries.append({ eventType, WTFMove(listeners) }); return true; }
bool ossimListenerManager::addListener(ossimListener* listener) { if(theFireEventFlag) { theDelayedAdd.push_back(listener); } else { if(!findListener(listener)) { theListenerList.push_back(listener); } } return true; }
void LocalConnection_as::update() { // Check whether local connection is disabled(!): brilliant choice of // function name. if (rcfile.getLocalConnection()) { log_security("Attempting to write to disabled LocalConnection!"); movie_root& mr = getRoot(owner()); mr.removeAdvanceCallback(this); return; } // No-op if already attached. Nothing to do if it fails, but we // should probably stop trying. if (!_shm.attach()) { log_error("Failed to attach shared memory segment"); return; } // We need the lock to prevent simultaneous reads/writes from other // processes. SharedMem::Lock lock(_shm); if (!lock.locked()) { log_debug("Failed to get shm lock"); return; } SharedMem::iterator ptr = _shm.begin(); // First check timestamp data. // These are not network byte order by default, but not sure about // host byte order. const boost::uint32_t timestamp = readLong(ptr + 8); const boost::uint32_t size = readLong(ptr + 12); // As long as there is a timestamp in the shared memory, we mustn't // write anything. // // We check if this is data we are listening for. If it is, read it and // mark for overwriting. // // If not, we keep checking until the data has been overwritten by // another listener or until it's expired. If it's expired, we // mark for overwriting. if (timestamp) { // Start after 16-byte header. const boost::uint8_t* b = ptr + 16; // End at reported size of AMF sequence. const boost::uint8_t* end = b + size; amf::Reader rd(b, end, getGlobal(owner())); as_value a; // Get the connection name. That's all we need to remove expired // data. if (!rd(a)) { log_error("Invalid connection name data"); return; } const std::string& connection = a.to_string(); // Now check if data we wrote has expired. There's no really // reliable way of checking that we genuinely wrote it. if (_lastTime == timestamp) { const size_t timeout = 4 * 1000; VM& vm = getVM(owner()); const boost::uint32_t timeNow = getTimestamp(vm); if (timeNow - timestamp > timeout) { log_debug("Data %s expired at %s. Removing its target " "as a listener", timestamp, timeNow); removeListener(connection, _shm); markRead(_shm); _lastTime = 0; } } // If we are listening and the data is for us, get the rest of it // and call the method. if (_connected && connection == _domain + ":" + _name) { executeAMFFunction(owner(), rd); // Zero the timestamp bytes to signal that the shared memory // can be written again. markRead(_shm); } else { // The data has not expired and we didn't read it. Leave it // alone until it's expired or someone else has read it. return; } } // If we have no data to send, there's nothing more to do. if (_queue.empty()) { // ...except remove the callback if we aren't listening for anything. if (!_connected) { movie_root& mr = getRoot(owner()); mr.removeAdvanceCallback(this); } return; } // Get the first buffer. boost::shared_ptr<ConnectionData> cd = _queue.front(); _queue.pop_front(); // If the correct listener isn't there, iterate until we find one or // there aren't any left. while (!findListener(_domain + ":" + cd->name, _shm)) { if (_queue.empty()) { // Make sure we send the empty header later. cd->ts = 0; break; } cd = _queue.front(); _queue.pop_front(); } // Yes, there is data to send. const char i[] = { 1, 0, 0, 0, 1, 0, 0, 0 }; std::copy(i, i + arraySize(i), ptr); SimpleBuffer& buf = cd->data; SharedMem::iterator tmp = ptr + 8; writeLong(tmp, cd->ts); writeLong(tmp, cd->ts ? buf.size() : 0); std::copy(buf.data(), buf.data() + buf.size(), tmp); // Note the timestamp of our last send. We will keep calling update() // until the data has expired or been read. _lastTime = cd->ts; }
SoundContext::SoundContext(const Misc::ConfigurationFileSection& configFileSection,VruiState* sVruiState) :vruiState(sVruiState), #if ALSUPPORT_CONFIG_HAVE_OPENAL alDevice(0),alContext(0), #endif contextData(0), listener(findListener(configFileSection.retrieveString("./listenerName").c_str())), speedOfSound(float(getMeterFactor())*343.0f), dopplerFactor(1.0f), distanceAttenuationModel(CONSTANT) { /* Set sound context parameters from configuration file: */ speedOfSound=configFileSection.retrieveValue<float>("./speedOfSound",speedOfSound); dopplerFactor=configFileSection.retrieveValue<float>("./dopplerFactor",dopplerFactor); distanceAttenuationModel=configFileSection.retrieveValue<DistanceAttenuationModel>("./distanceAttenuationModel",distanceAttenuationModel); #if ALSUPPORT_CONFIG_HAVE_OPENAL /* Open the OpenAL device: */ std::string alDeviceName=configFileSection.retrieveValue<std::string>("./deviceName","Default"); alDevice=alcOpenDevice(alDeviceName!="Default"?alDeviceName.c_str():0); if(alDevice==0) Misc::throwStdErr("SoundContext::SoundContext: Could not open OpenAL sound device \"%s\"",alDeviceName.c_str()); /* Create a list of context attributes: */ ALCint alContextAttributes[9]; ALCint* attPtr=alContextAttributes; if(configFileSection.hasTag("./mixerFrequency")) { *(attPtr++)=ALC_FREQUENCY; *(attPtr++)=configFileSection.retrieveValue<ALCint>("./mixerFrequency"); } if(configFileSection.hasTag("./refreshFrequency")) { *(attPtr++)=ALC_REFRESH; *(attPtr++)=configFileSection.retrieveValue<ALCint>("./refreshFrequency"); } if(configFileSection.hasTag("./numMonoSources")) { *(attPtr++)=ALC_MONO_SOURCES; *(attPtr++)=configFileSection.retrieveValue<ALCint>("./numMonoSources"); } if(configFileSection.hasTag("./numStereoSources")) { *(attPtr++)=ALC_STEREO_SOURCES; *(attPtr++)=configFileSection.retrieveValue<ALCint>("./numStereoSources"); } *(attPtr++)=ALC_INVALID; /* Create an OpenAL context: */ alContext=alcCreateContext(alDevice,alContextAttributes); if(alContext==0) { alcCloseDevice(alDevice); Misc::throwStdErr("SoundContext::SoundContext: Could not create OpenAL context for sound device %s",alDeviceName.c_str()); } #endif /* Create an AL context data object: */ contextData=new ALContextData(101); /* Initialize the sound context's OpenAL context: */ makeCurrent(); #if ALSUPPORT_CONFIG_HAVE_OPENAL /* Set global OpenAL parameters: */ alSpeedOfSound(speedOfSound); alDopplerFactor(dopplerFactor); switch(distanceAttenuationModel) { case CONSTANT: alDistanceModel(AL_NONE); break; case INVERSE: alDistanceModel(AL_INVERSE_DISTANCE); break; case INVERSE_CLAMPED: alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); break; case LINEAR: alDistanceModel(AL_LINEAR_DISTANCE); break; case LINEAR_CLAMPED: alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED); break; case EXPONENTIAL: alDistanceModel(AL_EXPONENT_DISTANCE); break; case EXPONENTIAL_CLAMPED: alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED); break; } #endif }