TimerEvent Timer::QueueCallback(const QSharedPointer<TimerCallback> &callback,
     int due_time, int period)
 {
   TimerEvent te(callback, due_time, period);
   QueueEvent(te);
   return te;
 }

HRESULT PpboxStream::Start(const PROPVARIANT& varStart)
{
    SourceLock lock(m_pSource);

    HRESULT hr = S_OK;

    hr = CheckShutdown();

    // Queue the stream-started event.
    if (SUCCEEDED(hr))
    {
        hr = QueueEvent(MEStreamStarted, GUID_NULL, S_OK, &varStart);
    }

    if (SUCCEEDED(hr))
    {
        m_state = STATE_STARTED;
    }

    // If we are restarting from paused, there may be
    // queue sample requests. Dispatch them now.
    if (SUCCEEDED(hr))
    {
        hr = DispatchSamples();
    }
    return hr;
}

HRESULT MPEG1Stream::Start(const PROPVARIANT& varStart)
{
    SourceLock lock(m_pSource);

    HRESULT hr = S_OK;

    CHECK_HR(hr = CheckShutdown());

    // Queue the stream-started event.
    CHECK_HR(hr = QueueEvent(
        MEStreamStarted,
        GUID_NULL,
        S_OK,
        &varStart
        ));

    m_state = STATE_STARTED;

    // If we are restarting from paused, there may be 
    // queue sample requests. Dispatch them now.
    CHECK_HR(hr = DispatchSamples());

done:
    return hr;
}

	void Viewer::AddNotification(const CacheNotification& notification) {
		std::unique_lock<std::mutex> l(m_mutexNotification);
		m_cacheNotifications.push_back(notification);
		l.unlock();

		QueueEvent(new wxCommandEvent(ImageLoadEvent));
	}

void CAsyncRequestQueue::TriggerProcessing()
{
	if (m_inside_request)
		return;

	QueueEvent(new wxCommandEvent(fzEVT_PROCESSASYNCREQUESTQUEUE));
}

void PyloadDataStore::setQueuePackages(const std::vector<PackageData>& queuePackages) {
    boost::unique_lock<boost::shared_mutex> lock(m_mutex);
    m_queuePackages = queuePackages;
    lock.unlock();
    wxCommandEvent* event = new wxCommandEvent(wxEVT_NETWORK, ID_QUEUE_PACKAGES);
    QueueEvent(event);
}

void wxMediaBackendCommonBase::NotifyMovieLoaded()
{
    NotifyMovieSizeChanged();

    // notify about movie being fully loaded
    QueueEvent(wxEVT_MEDIA_LOADED);
}

void CContextControl::OnTabClosing(wxAuiNotebookEvent& event)
{
	// Need to defer event, wxAUI would write to free'd memory
	// if we'd actually delete tab and potenially the notebook with it
	QueueEvent(new wxCommandEvent(fzEVT_TAB_CLOSING_DEFERRED, event.GetSelection()));

	event.Veto();
}

void CMPEG1Stream::Pause()
{
    ThrowIfError(CheckShutdown());

    m_state = STATE_PAUSED;

    ThrowIfError(QueueEvent(MEStreamPaused, GUID_NULL, S_OK, nullptr));
}

void
Clock::SetClockState (ClockState state)
{
#if CLOCK_DEBUG
	const char *states[] = { "Active", "Filling", "Stopped" };
	printf ("Setting clock %p state to %s\n", this, states[state]);
#endif
	this->state = state;
	QueueEvent (CURRENT_STATE_INVALIDATED);
}

void ProgressIndicator::mouseDown(wxMouseEvent &event)
{
	this->value = (float)event.GetPosition().x / (float)width;
	// Repaint directly - gives a nicer feedback to the user
	paintNow();

	wxCommandEvent pressEvent = wxCommandEvent(PI_SCROLL_CHANGED);
	
	QueueEvent(pressEvent.Clone());
}

bool	CMultiXWSStream::CallServiceNoWait(CMultiXAppMsg	&Msg)
{
	if(!IsRunning())
		if(!Start())
			return	false;
	CMultiXWSStreamEvent	*Ev	=	new	CMultiXWSStreamEvent(CMultiXWSStreamEvent::CallServiceFromMessage);
	Msg.Keep();
	Ev->m_MsgID	=	Msg.ID();
	QueueEvent(Ev);
	return	true;
}

void MainFrame::myMessageBoxDelayed(const wxString &message,
	const wxString &caption, int style, wxWindow *parent, int x, int y)
{
	if (wxThread::IsMain())
		wxMessageBox(message, caption, style, parent, x, y);

	myMessageBoxEvent *event = new myMessageBoxEvent(
		MY_MESSAGEBOX, message, caption, style, parent, x, y );

	QueueEvent(event);
}

void gxSubject::Fire( gxEvent &aEvent, gxCallback aCallback )
{    
    if ( mFiringMode == on )
    {
        // If a specific callback was requested then only fire that one,
        // otherwise Fire() will fire all callbacks.
        aCallback.empty() ? aEvent.Fire() : aEvent.Fire( aCallback );
    } else if ( mFiringMode == queue ) {
        QueueEvent( aEvent );
    } // Otherwise FiringMode is off
}

void SjMyMusicConfigPage::OnListKeyDown(wxListEvent& event)
{
	switch( event.GetKeyCode() )
	{
		case WXK_DELETE:
		case WXK_BACK:
		{
			QueueEvent(new wxCommandEvent(wxEVT_COMMAND_MENU_SELECTED, IDC_IDXDELSOURCE));
		}
		break;
	}
}

HRESULT FlvStream::Start(UINT64 nanosec, BOOL isseek) {
  SourceLock lock(source);
  _prop_variant_t starttime(nanosec);
  auto hr = CheckShutdown();
  if (ok(hr) && isseek) {
    samples.clear();// abandon previsou cached samples, but keep tokens
    QueueEvent(MEStreamSeeked, GUID_NULL, hr, &starttime);
  } else if (ok(hr)) {// Queue the stream-started event.
    hr = QueueEvent(MEStreamStarted, GUID_NULL, S_OK, &starttime);
  }

  if (ok(hr)) {
    m_state = SourceState::STATE_STARTED;
  }

  // If we are restarting from paused, there may be
  // queue sample requests. Dispatch them now.
  if (ok(hr)) {
    hr = DispatchSamples();
  }
  return hr;
}

void CAsyncRequestQueue::OnProcessQueue(wxCommandEvent &)
{
	if (m_inside_request)
		return;

	m_inside_request = true;
	bool success = ProcessNextRequest();
	m_inside_request = false;

	if (success && !m_requestList.empty()) {
		QueueEvent(new wxCommandEvent(fzEVT_PROCESSASYNCREQUESTQUEUE));
	}
}

void NetworkManager::Connect(Connection target) {
    //Logger::Get().Info("New Connection : " + QString::fromStdString(target.GetIPAddress().ToString()));
    // remember target
    uint16_t id = mConnectionsManager.AddConnection(&target);
    // Connection* c = mConnectionsManager.GetConnection(id);

    // send handshake
    std::shared_ptr<HandshakeEvent> h(new HandshakeEvent());
    h->ClearRecipients();
    h->AddRecipient(id);
    QueueEvent(h);

}

HRESULT WavStream::DeliverQueuedSamples()
{
    HRESULT hr = S_OK;
    IMFSample *pSample = NULL;

    EnterCriticalSection(&m_critSec);

    // If we already reached the end of the stream, send the MEEndStream 
    // event again.
    if (m_EOS)
    {
        hr = QueueEvent(MEEndOfStream, GUID_NULL, S_OK, NULL);
    }

    if (SUCCEEDED(hr))
    {   
        // Deliver any queued samples. 
        while (!m_sampleQueue.IsEmpty())
        {
            hr = m_sampleQueue.Dequeue(&pSample);
            if (FAILED(hr))
            {
                break;
            }

            hr = DeliverSample(pSample);
            if (FAILED(hr))
            {
                break;
            }

            SafeRelease(&pSample);
        }
    }

    LeaveCriticalSection(&m_critSec);

    // If we reached the end of the stream, send the end-of-presentation event from
    // the media source.
    if (SUCCEEDED(hr))
    {   
        if (m_EOS)
        {
            hr = m_pSource->QueueEvent(MEEndOfPresentation, GUID_NULL, S_OK, NULL);
        }
    }

    SafeRelease(&pSample);
    return hr;
}

bool CAsyncRequestQueue::AddRequest(CFileZillaEngine *pEngine, std::unique_ptr<CAsyncRequestNotification> && pNotification)
{
	ClearPending(pEngine);

	if (ProcessDefaults(pEngine, pNotification))
		return false;

	m_requestList.emplace_back(pEngine, std::move(pNotification));

	if (m_requestList.size() == 1) {
		QueueEvent(new wxCommandEvent(fzEVT_PROCESSASYNCREQUESTQUEUE));
	}

	return true;
}