Esempio n. 1
0
static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
        ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
{
    DownloadBSC *This = STATUSCLB_THIS(iface);
    HRESULT hres = S_OK;

    TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
            debugstr_w(szStatusText));

    switch(ulStatusCode) {
    case BINDSTATUS_CONNECTING:
    case BINDSTATUS_BEGINDOWNLOADDATA:
    case BINDSTATUS_DOWNLOADINGDATA:
    case BINDSTATUS_ENDDOWNLOADDATA:
    case BINDSTATUS_SENDINGREQUEST:
    case BINDSTATUS_MIMETYPEAVAILABLE:
        hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
        break;

    case BINDSTATUS_CACHEFILENAMEAVAILABLE:
        hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
        This->cache_file = heap_strdupW(szStatusText);
        break;

    case BINDSTATUS_FINDINGRESOURCE: /* FIXME */
        break;

    default:
        FIXME("Unsupported status %u\n", ulStatusCode);
    }

    return hres;
}
Esempio n. 2
0
static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
        ULONG ulStatusCode, LPCWSTR szStatusText)
{
    Binding *This = PROTSINK_THIS(iface);

    TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));

    switch(ulStatusCode) {
    case BINDSTATUS_FINDINGRESOURCE:
        on_progress(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, szStatusText);
        break;
    case BINDSTATUS_CONNECTING:
        on_progress(This, 0, 0, BINDSTATUS_CONNECTING, szStatusText);
        break;
    case BINDSTATUS_REDIRECTING:
        heap_free(This->redirect_url);
        This->redirect_url = heap_strdupW(szStatusText);
        on_progress(This, 0, 0, BINDSTATUS_REDIRECTING, szStatusText);
        break;
    case BINDSTATUS_BEGINDOWNLOADDATA:
        fill_stgmed_buffer(This->stgmed_buf);
        break;
    case BINDSTATUS_SENDINGREQUEST:
        on_progress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, szStatusText);
        break;
    case BINDSTATUS_PROTOCOLCLASSID:
        break;
    case BINDSTATUS_MIMETYPEAVAILABLE:
    case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
        mime_available(This, szStatusText);
        break;
    case BINDSTATUS_CACHEFILENAMEAVAILABLE:
        cache_file_available(This, szStatusText);
        break;
    case BINDSTATUS_DECODING:
        IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_DECODING, szStatusText);
        break;
    case BINDSTATUS_LOADINGMIMEHANDLER:
        on_progress(This, 0, 0, BINDSTATUS_LOADINGMIMEHANDLER, szStatusText);
        break;
    case BINDSTATUS_DIRECTBIND: /* FIXME: Handle BINDSTATUS_DIRECTBIND in BindProtocol */
        This->report_mime = FALSE;
        break;
    case BINDSTATUS_ACCEPTRANGES:
        break;
    default:
        FIXME("Unhandled status code %d\n", ulStatusCode);
        return E_NOTIMPL;
    };

    return S_OK;
}
BOOL MyH323Connection::OnAlerting(const H323SignalPDU & alertingPDU, const PString & username)
{
	if (h323debug) {
	        cout << "\t=-= In OnAlerting for call " << GetCallReference()
	              << ": sessionId=" << sessionId << endl;
                 cout << "\t-- Ringing phone for \"" << username << "\"" << endl;
	}

	if (on_progress) {
		BOOL isInband;
		unsigned alertingPI;

		if (!alertingPDU.GetQ931().GetProgressIndicator(alertingPI)) {
			alertingPI = 0;
		}
		if (h323debug) {
			cout << "\t\t- Progress Indicator: " << alertingPI << endl;
		}
		
		switch(alertingPI) {
		case Q931::ProgressNotEndToEndISDN:
		case Q931::ProgressInbandInformationAvailable:
			isInband = TRUE;
			break;
		default:
			isInband = FALSE;
		}
		on_progress(GetCallReference(), (const char *)GetCallToken(), isInband);
	}
        on_chan_ringing(GetCallReference(), (const char *)GetCallToken() );
        return connectionState != ShuttingDownConnection;
}
BOOL MyH323Connection::OnReceivedProgress(const H323SignalPDU &pdu)
{
	BOOL isInband;
	unsigned pi;

	if (!H323Connection::OnReceivedProgress(pdu)) {
		return FALSE;
	}

	if (!pdu.GetQ931().GetProgressIndicator(pi))
		pi = 0;
	if (h323debug) {
		cout << "\t- Progress Indicator: " << pi << endl;
	}
	
	switch(pi) {
	case Q931::ProgressNotEndToEndISDN:
	case Q931::ProgressInbandInformationAvailable:
		isInband = TRUE;
		break;
	default:
		isInband = FALSE;
	}
	on_progress(GetCallReference(), (const char *)GetCallToken(), isInband);

	return connectionState != ShuttingDownConnection;
}
Esempio n. 5
0
    inline std::size_t operator+=(const std::size_t increment)
    {
      m_count += increment;

      on_progress(count(), expected_count());

      return m_expected_count;
    }
Esempio n. 6
0
/* virtual */
void XMLerLoadFileThread::run ()
{
  QFile xml( fileName() );
  if ( !xml.exists() ) {
    emit error ( tr("File %1 does not exists.").arg( fileName() ) );
    return;
  }

  /* QMap<QString, QString> info = getInformationFromFile(); */

  QXmlSimpleReader reader;
  XMLerInputSource *source = new XMLerInputSource ( &xml );

  /* connect source to slots in model */
  connect ( source, SIGNAL(beginRead(qint64)), this, SLOT(on_beginProgress(qint64)) );
  connect ( source, SIGNAL(readProgress(qint64)), this, SLOT(on_progress(qint64)) );
  connect ( source, SIGNAL(endRead()), this, SLOT(on_endProgress()) );

  reader.setContentHandler ( handler );
  reader.setErrorHandler ( handler );

  bool parseResult = reader.parse ( source, true );

  /* FIXME: this is partial read */
  if ( parseResult ) {
    bool partResult = parseResult;
    while ( partResult )
      partResult = reader.parseContinue();
  }
  if ( !parseResult ) {
    checkExceptionInHandler();
    on_endProgress();
    return;
  }

  /* set addition data (information) in document */
  if ( handler->document() )
    handler->document()->setFileName( fileName() );
  /* CLEANIT
  if ( !info.isEmpty() ) {
    if ( info.contains ( "encoding" ) )
      handler->document()->setCodec ( info.value ( "encoding" ) );
    if ( info.contains ( "version" ) )
      handler->document()->setVersion ( info.value ( "version" ) );
      }*/
  emit done ( handler->document() );
  checkExceptionInHandler ();

  /* clean */
  disconnect ( source, SIGNAL(beginRead(qint64)) );
  disconnect ( source, SIGNAL(readProgress(qint64)) );
  disconnect ( source, SIGNAL(endRead()) );
  delete source;
}
Esempio n. 7
0
void FileLoader::on_progress_impl(size_t size) {
  on_progress(parts_manager_.get_part_count(), static_cast<int32>(parts_manager_.get_part_size()),
              parts_manager_.get_ready_prefix_count(), parts_manager_.ready(), parts_manager_.get_ready_size());
}