Example #1
0
void QQuickDragAttachedPrivate::deliverLeaveEvent()
{
    if (window) {
        QDragLeaveEvent event;
        deliverEvent(window, &event);
        window = 0;
    }
}
Example #2
0
// Deliver CPG message.
void Cluster::deliver(
    cpg_handle_t /*handle*/,
    const cpg_name* /*group*/,
    uint32_t nodeid,
    uint32_t pid,
    void* msg,
    int msg_len)
{
    MemberId from(nodeid, pid);
    framing::Buffer buf(static_cast<char*>(msg), msg_len);
    Event e(Event::decodeCopy(from, buf));
    deliverEvent(e);
}
Example #3
0
void TransformReactor::process(const EventPtr& e)
{
	EventPtr new_e;
	// Create new event; either same type (if UNDEFINED) or defined type
	m_event_factory.create(new_e, m_event_type == Vocabulary::UNDEFINED_TERM_REF ? e->getType() : m_event_type);

	// Copy terms over from original
	switch (m_copy_original) {
		case COPY_ALL:				// Copy all terms over from original event
			*new_e += *e;
			break;
		case COPY_UNCHANGED:		// Copy ONLY terms, that are not defined in transformations...
			*new_e += *e;			// First copy all terms...
			// Then remove all the ones with transformations...
			for (TransformChain::iterator i = m_transforms.begin(); i != m_transforms.end(); i++)
				(*i)->removeTerm(new_e);
			// TODO: Which is more efficient? Only copying the ones that are not transformed, or this?
			break;
		case COPY_NONE:				// Do not copy terms from original event
			break;
	}

	try {
		for (TransformChain::iterator i = m_transforms.begin(); i != m_transforms.end(); i++)
			(*i)->transform(new_e, e);		// transform   d <- s
	} catch (std::exception& e) {
		// Likely Boost.regex throw
		PION_LOG_ERROR(m_logger, "reactor_id: " << getId() << " - " << e.what() << " - handled");
	}

	deliverEvent(new_e);			// Deliver the modified event

	// Transformation is done, deliver original event?
	if (m_deliver_original != DO_NEVER)
	 	deliverEvent(e);
}
Example #4
0
void QQuickDragAttachedPrivate::deliverMoveEvent()
{
    Q_Q(QQuickDragAttached);

    itemMoved = false;
    if (window) {
        QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
        QDragMoveEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
        QQuickDropEventEx::setProposedAction(&event, proposedAction);
        deliverEvent(window, &event);
        if (target != dragGrabber.target()) {
            target = dragGrabber.target();
            emit q->targetChanged();
        }
    }
}
Example #5
0
void FissionReactor::process(const EventPtr& e)
{
	if (e->getType() == m_input_event_type.term_ref) {
		// used for generating new events
		EventFactory event_factory;
		EventPtr new_ptr;
		bool read_result;

		// iterate through each value defined for the input event term
		Event::ValuesRange range = e->equal_range(m_input_event_term.term_ref);
		for (Event::ConstIterator it = range.first; it != range.second; ++it) {

			// create an input stream based upon the term value
			const Event::BlobType& ss = boost::get<const Event::BlobType&>(it->value);
			boost::iostreams::stream<boost::iostreams::array_source> input_stream(ss.get(), ss.size());

			// read Event(s) from the input stream
			while ( isRunning() && !input_stream.eof() ) {

				// only allow one thread to use the codec at a time
				boost::mutex::scoped_lock codec_lock(m_codec_mutex);
				event_factory.create(new_ptr, m_codec_ptr->getEventType());
				read_result = m_codec_ptr->read(input_stream, *new_ptr);
				codec_lock.unlock();
				if (! read_result)
					break;

				// copy terms from original event ?
				if (m_copy_all_terms) {
					// copy all terms from original event
					*new_ptr += *e;
				} else if (! m_copy_terms.empty() ) {
					// copy some terms from original event
					for (TermVector::const_iterator term_it = m_copy_terms.begin();
						term_it != m_copy_terms.end(); ++term_it)
					{
						new_ptr->copyValues(*e, term_it->term_ref);
					}
				}

				// deliver the event
				deliverEvent(new_ptr);
			}
		}
	}
}
Example #6
0
void QQuickDragAttachedPrivate::deliverEnterEvent()
{
    dragRestarted = false;
    itemMoved = false;

    window = attachedItem->window();

    mimeData->m_source = source;
    if (!overrideActions)
        mimeData->m_supportedActions = supportedActions;
    mimeData->m_keys = keys;

    if (window) {
        QPoint scenePos = attachedItem->mapToScene(hotSpot).toPoint();
        QDragEnterEvent event(scenePos, mimeData->m_supportedActions, mimeData, Qt::NoButton, Qt::NoModifier);
        QQuickDropEventEx::setProposedAction(&event, proposedAction);
        deliverEvent(window, &event);
    }
}
Example #7
0
// CPG config-change callback.
void Cluster::configChange (
    cpg_handle_t /*handle*/,
    const cpg_name */*group*/,
    const cpg_address *members, int nMembers,
    const cpg_address *left, int nLeft,
    const cpg_address *joined, int nJoined)
{
    Mutex::ScopedLock l(lock);
    string membersStr, leftStr, joinedStr;
    // Encode members and enqueue as an event so the config change can
    // be executed in the correct thread.
    for (const cpg_address* p = members; p < members+nMembers; ++p)
        membersStr.append(MemberId(*p).str());
    for (const cpg_address* p = left; p < left+nLeft; ++p)
        leftStr.append(MemberId(*p).str());
    for (const cpg_address* p = joined; p < joined+nJoined; ++p)
        joinedStr.append(MemberId(*p).str());
    deliverEvent(Event::control(ClusterConfigChangeBody(
                                    ProtocolVersion(), membersStr, leftStr, joinedStr),
                                self));
}
Example #8
0
void FilterReactor::process(const EventPtr& e)
{
	if ( m_rules(e) )		
		deliverEvent(e);
}