/// <summary>
/// Creates nsIRequest wrapper
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static Request WrapRequest(nsIRequest request)
{
if (request is nsIChannel)
{
return Channel.WrapChannel((nsIChannel)request);
}
if (request is nsIAsyncStreamCopier)
{
return new AsyncStreamCopier((nsIAsyncStreamCopier)request);
}
if (request is nsILoadGroup)
{
return new LoadGroup((nsILoadGroup)request);
}
if (request is nsIIncrementalDownload)
{
return new IncrementalDownload((nsIIncrementalDownload)request);
}
if (request is imgIRequest)
{
return new ImgRequest((imgIRequest)request);
}
if (request is nsIInputStreamPump)
{
}
if (request is nsIURIChecker)
{
return new UriChecker((nsIURIChecker)request);
}
return new Request(request);
}
public nsIStreamListener DoContent(nsACStringBase aMimeContentType, nsIRequest aRequest, nsIInterfaceRequestor aWindowContext, bool aForceSave)
{
var request = Request.CreateRequest(aRequest);
var lChannel = request as HttpChannel;
try
{
if (lChannel != null)
{
var uri = lChannel.OriginalUri;
var contentType = lChannel.ContentType;
var contentLength = lChannel.ContentLength;
var dispositionFilename = lChannel.ContentDispositionFilename;
// Do your contenttype validation, keeping only what you need.
// Make sure you clean dispositionFilename before using it.
// If you don't want to do anything with that file, you can return null;
return(new MyStreamListener(/* ... */));
}
}
catch (COMException)
{
/* ... */
}
return(null);
}
public static Request CreateRequest(nsIRequest request)
{
if (request is nsIChannel)
{
return(Channel.CreateChannel(( nsIChannel )request));
}
if (request is nsIAsyncStreamCopier)
{
return(new AsyncStreamCopier(( nsIAsyncStreamCopier )request));
}
if (request is nsILoadGroup)
{
return(new LoadGroup(( nsILoadGroup )request));
}
if (request is nsIIncrementalDownload)
{
return(new IncrementalDownload(( nsIIncrementalDownload )request));
}
if (request is imgIRequest)
{
return(new ImgRequest(( imgIRequest )request));
}
if (request is nsIInputStreamPump)
{
}
if (request is nsIURIChecker)
{
return(new UriChecker(( nsIURIChecker )request));
}
return(new Request(request));
}
private void OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint aFlags)
{
if (!_isListening)
{
return;
}
}
Boolean nsIURIContentListener.DoContent(String aContentType, Boolean aIsContentPreferred, nsIRequest aRequest, out nsIStreamListener aContentHandler)
{
Trace.TraceInformation("nsIURIContentListener.DoContent: \"{0}\"", aContentType);
aContentHandler = null;
return false;
}
private void OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState)
{
if (!_isListening)
{
return;
}
}
public void OnSecurityChange(nsIWebProgress progress, nsIRequest request, uint status)
{
SecurityChangedEventHandler eh = (SecurityChangedEventHandler)(owner.Events[WebBrowser.SecurityChangedEvent]);
if (eh != null)
{
SecurityLevel state = SecurityLevel.Insecure;
switch (status)
{
case 4:
state = SecurityLevel.Insecure;
break;
case 1:
state = SecurityLevel.Mixed;
break;
case 2:
state = SecurityLevel.Secure;
break;
}
SecurityChangedEventArgs e = new SecurityChangedEventArgs(state);
eh(this, e);
}
}
void nsIWebProgressListener2.OnProgressChange(
nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress,
int aCurTotalProgress,
int aMaxTotalProgress)
{
OnProgressChange(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress,
aMaxTotalProgress);
}
bool nsIURIContentListener.doContent(string aContentType,
bool aIsContentPreferred,
nsIRequest aRequest,
out nsIStreamListener aContentHandler)
{
aContentHandler = null;
return(true);
}
void nsIRequestObserver.OnStartRequest( nsIRequest aRequest, nsISupports aContext )
{
var started = Started;
if (started != null)
{
started(this, EventArgs.Empty);
}
}
bool nsIURIContentListener.doContent (string aContentType,
bool aIsContentPreferred,
nsIRequest aRequest,
out nsIStreamListener aContentHandler)
{
aContentHandler = null;
return true;
}
public static Request Create(nsIRequest request)
{
if (request is nsIChannel)
{
return(Channel.Create(( nsIChannel )request));
}
return(new Request(request));
}
void nsIRequestObserver.OnStopRequest( nsIRequest aRequest, nsISupports aContext, int aStatusCode )
{
var stopped = Stopped;
if (stopped != null)
{
stopped( this, EventArgs.Empty );
}
}
public void OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
{
nsIWebProgressListener b = (nsIWebProgressListener)_browser;
if (b != null)
{
b.OnProgressChange(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress);
}
}
public void OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
{
nsIWebProgressListener b = (nsIWebProgressListener)_browser;
if (b != null)
{
b.OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
}
}
public void OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint flags)
{
nsIWebProgressListener b = (nsIWebProgressListener)_browser;
if (b != null)
{
b.OnLocationChange(aWebProgress, aRequest, aLocation, flags);
}
}
public void OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState)
{
nsIWebProgressListener b = (nsIWebProgressListener)_browser;
if (b != null)
{
b.OnSecurityChange(aWebProgress, aRequest, aState);
}
}
public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
nsIWebProgressListener b = (nsIWebProgressListener)_browser;
if (b != null)
{
b.OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
}
}
public void OnStartRequest(nsIRequest aRequest, nsISupports aContext)
{
var started = Started;
if (started != null)
{
started(this, EventArgs.Empty);
}
}
public void OnStopRequest(nsIRequest aRequest, nsISupports aContext, int aStatusCode)
{
var stopped = Stopped;
if (stopped != null)
{
stopped(this, EventArgs.Empty);
}
}
public void OnStatusChange(nsIWebProgress progress, nsIRequest request, string message, Int32 status)
{
StatusChangedEventHandler eh = (StatusChangedEventHandler)(owner.Events[WebBrowser.StatusChangedEvent]);
if (eh != null)
{
StatusChangedEventArgs e = new StatusChangedEventArgs(message, status);
eh(this, e);
}
}
/// <summary>Creates a new instance of a <see cref="GeckoNavigatedEventArgs"/> object.</summary>
/// <param name="value"></param>
/// <param name="response"></param>
internal GeckoNavigatedEventArgs(Uri value, nsIRequest response, GeckoWindow domWind, bool _sameDocument, bool _errorPage)
{
Uri = value;
_response = response;
DomWindow = domWind;
DomWindowTopLevel = ((domWind == null) ? true : DomWindow.DomWindow.Equals(DomWindow.Top.DomWindow));
IsSameDocument = _sameDocument;
IsErrorPage = _errorPage;
}
void nsIWebProgressListener.OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, Int32 aCurSelfProgress, Int32 aMaxSelfProgress, Int32 aCurTotalProgress, Int32 aMaxTotalProgress)
{
Trace.TraceInformation("nsIWebProgressListener.OnProgressChange");
var e = new RequestProgressChangeEventArgs(aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress);
Events.Raise(EventKey.RequestProgressChange, e);
if (e.Cancel && (aRequest != null))
{
aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
}
}
void nsIWebProgressListener.OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, UInt32 aStatus, String aMessage)
{
Trace.TraceInformation("nsIWebProgressListener.OnStatusChange");
var e = new RequestStatusChangeEventArgs(aStatus, aMessage);
Events.Raise(EventKey.RequestStatusChange, e);
if (e.Cancel && (aRequest != null))
{
aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
}
}
public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
if (_printing && ((aStateFlags & STATE_STOP) != 0))
{
_printing = false;
if (PrintProgress != null)
{
PrintProgress.Invoke(this, new PdfPrintProgressEventArgs(false));
}
}
}
/// <summary>
/// PDF打印进度变化回调
/// </summary>
/// <param name="aWebProgress"></param>
/// <param name="aRequest"></param>
/// <param name="aCurSelfProgress"></param>
/// <param name="aMaxSelfProgress"></param>
/// <param name="aCurTotalProgress"></param>
/// <param name="aMaxTotalProgress"></param>
public void OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
{
if (aMaxTotalProgress <= 0)
{
return;
}
var statusText = "Making PDF File...";
this.RaiseStatusChanged(aCurTotalProgress, statusText);
}
void nsIWebProgressListener.OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation)
{
Trace.TraceInformation("nsIWebProgressListener.OnLocationChange");
var e = new LocationChangeEventArgs(aLocation.ToUri());
Events.Raise(EventKey.LocationChange, e);
if (e.Cancel && (aRequest != null))
{
aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
}
}
public void OnProgress(nsIWebProgress progress, nsIRequest request, Int32 currentTotalProgress, Int32 maxTotalProgress)
{
#if debug
OnGeneric("OnProgress");
#endif
ProgressChangedEventHandler eh = (ProgressChangedEventHandler)(owner.Events [Mono.Mozilla.WebBrowser.ProgressChangedEvent]);
if (eh != null)
{
Mono.WebBrowser.ProgressChangedEventArgs e = new Mono.WebBrowser.ProgressChangedEventArgs(currentTotalProgress, maxTotalProgress);
eh(this, e);
}
}
public void OnDataAvailable(nsIRequest aRequest, nsISupports aContext, nsIInputStream aInputStream, ulong aOffset, uint aCount)
{
// This gets called several times with small chunks of data.
// Do what you need with the stream. In my case, I read it
// in a small buffer, which then gets written to an output
// filestream (not shown).
// The aOffset parameter is the sum of all previously received data.
var lInput = InputStream.Create(aInputStream);
byte[] lBuffer = new byte[aCount];
lInput.Read(lBuffer, 0, (int)aCount);
}
private void OnProgressChange(
nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress,
int aMaxTotalProgress)
{
if (!_isListening)
{
return;
}
// var evnt = _onProgressChangeCallback;
// if ( evnt != null )
// evnt( aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress );
}
private void OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
{
if (!_isListening)
{
return;
}
var evnt = _onStatusChangeCallback;
if (evnt != null)
{
evnt(aMessage);
}
}
public void OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
{
if (aMaxTotalProgress == 0)
{
return;
}
RaiseStatusChanged(new PdfMakingStatus()
{
percentage = (int)(100.0 * (aCurTotalProgress) / aMaxTotalProgress),
statusLabel = Status
});
}
internal GeckoResponse(nsIRequest request)
{
// we use only one wrapper
_request = Request.WrapRequest( request );
if ( _request is Channel )
{
_channel = ( Channel ) _request;
if ( _channel is HttpChannel )
{
_httpChannel = ( HttpChannel ) _channel;
}
}
}
private void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
if (!_isListening)
{
return;
}
var evnt = _onStateChangeCallback;
if (evnt != null)
{
evnt(aWebProgress, aRequest, aStateFlags, aStatus);
}
}
public void OnStopRequest(nsIRequest aRequest, nsISupports aContext, int aStatusCode)
{
// This will also get called once, when the download is
// complete or interrupted. You can perform the post-download
// actions here.
if (aStatusCode != GeckoError.NS_OK)
{
// download interrupted
}
else
{
// download completed
}
}
public void OnProgressChange(nsIWebProgress webProgress, nsIRequest request, int currentSelfProgress,
int maxSelfProgress,
int currentTotalProgress, int maxTotalProgress)
{
if (maxTotalProgress == 0)
return;
// if we use the maxTotalProgress, the problem is that it starts off below 100, the jumps to 100 at the end
// so it looks a lot better to just always scale, to 100, the current progress by the max at that point
RaiseStatusChanged(new PdfMakingStatus()
{
percentage = (int) (100.0*(currentTotalProgress)/maxTotalProgress),
statusLabel = Status
});
}
public void OnProgressChange(nsIWebProgress webProgress, nsIRequest request, int currentSelfProgress,
int maxSelfProgress,
int currentTotalProgress, int maxTotalProgress)
{
if (maxTotalProgress == 0)
{
return;
}
// if we use the maxTotalProgress, the problem is that it starts off below 100, the jumps to 100 at the end
// so it looks a lot better to just always scale, to 100, the current progress by the max at that point
RaiseStatusChanged(new PdfMakingStatus()
{
percentage = (int)(100.0 * (currentTotalProgress) / maxTotalProgress),
statusLabel = Status
});
}
/// <summary>
/// PDF打印状态回调
/// </summary>
/// <param name="aWebProgress"></param>
/// <param name="aRequest"></param>
/// <param name="aStateFlags"></param>
/// <param name="aStatus"></param>
public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
var bFinished = ((aStateFlags & nsIWebProgressListenerConstants.STATE_STOP) != 0);
if (!bFinished)
{
return;
}
//回调过不再回调
if (this.brwPrintCheckTimer.Enabled)
{
return;
}
//启动定时器检查打印是否结束，下一步到定时器回调
this.brwPrintCheckTimer.Enabled = true;
}
public static Request CreateRequest(nsIRequest request)
{
if (request is nsIChannel)
{
return(Channel.CreateChannel((nsIChannel)request));
}
if (request is nsIAsyncStreamCopier)
{
return(new AsyncStreamCopier((nsIAsyncStreamCopier)request));
}
if (request is nsILoadGroup)
{
return(new LoadGroup((nsILoadGroup)request));
}
if (request is nsIIncrementalDownload)
{
return(new IncrementalDownload((nsIIncrementalDownload)request));
}
if (request is imgIRequest)
{
return(new ImgRequest((imgIRequest)request));
}
if (request is nsIInputStreamPump)
{
}
// This interface no longer exists in gecko 45
#if false
if (request is nsIURIChecker)
{
return(new UriChecker(( nsIURIChecker )request));
}
#endif
return(new Request(request));
}
void nsIWebProgressListener.OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
{
int nProgress = aCurTotalProgress;
int nProgressMax = Math.Max(aMaxTotalProgress, 0);
if (nProgressMax == 0)
nProgressMax = Int32.MaxValue;
if (nProgress > nProgressMax)
nProgress = nProgressMax;
OnProgressChanged(new GeckoProgressEventArgs(nProgress, nProgressMax));
}
void nsIWebProgressListener.OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation)
{
// make sure we're loading the top-level window
nsIDOMWindow domWindow = aWebProgress.GetDOMWindow();
if (domWindow != null)
{
if (domWindow != domWindow.GetTop())
return;
}
Uri uri = new Uri(nsString.Get(aLocation.GetSpec));
OnNavigated(new GeckoNavigatedEventArgs(uri, new GeckoResponse(aRequest)));
UpdateCommandStatus();
}
public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
_finished = (aStateFlags & nsIWebProgressListenerConstants.STATE_STOP) != 0;
}
public void OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState)
{
}
void nsIWebProgressListener2.OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint aFlags)
{
OnLocationChange(aWebProgress, aRequest, aLocation, aFlags);
}
void nsIWebProgressListener.OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
{
if (aWebProgress.GetIsLoadingDocument())
{
StatusText = aMessage;
UpdateCommandStatus();
}
}
public void OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
{
}
public void OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
{
}
public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
{
if (_printing && ((aStateFlags & STATE_STOP) != 0)) {
_printing = false;
if (PrintProgress != null) {
PrintProgress.Invoke (this, new PdfPrintProgressEventArgs(false));
}
}
}
internal GeckoResponse(nsIRequest request)
{
Channel = Xpcom.QueryInterface<nsIChannel>(request);
HttpChannel = Xpcom.QueryInterface<nsIHttpChannel>(request);
}
private void OnStateChange( nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus )
{
if ( !_isListening ) return;
var evnt = _onStateChangeCallback;
if ( evnt != null ) evnt( aWebProgress, aRequest, aStateFlags, aStatus );
}
private void OnStatusChange( nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage )
{
if (!_isListening) return;
var evnt = _onStatusChangeCallback;
if ( evnt != null ) evnt( aMessage );
}
void nsIWebProgressListener.OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aState)
{
SetSecurityState((GeckoSecurityState) aState);
}
void nsIWebProgressListener.OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStateFlags, int aStatus)
{
bool cancelled = false;
if ((aStateFlags & nsIWebProgressListenerConstants.STATE_START) != 0 && (aStateFlags & nsIWebProgressListenerConstants.STATE_IS_NETWORK) != 0)
{
IsBusy = true;
Uri uri;
Uri.TryCreate(nsString.Get(aRequest.GetName), UriKind.Absolute, out uri);
GeckoNavigatingEventArgs ea = new GeckoNavigatingEventArgs(uri);
OnNavigating(ea);
if (ea.Cancel)
{
aRequest.Cancel(0);
cancelled = true;
}
}
// maybe we'll add another event here to allow users to cancel certain content types
//if ((aStateFlags & nsIWebProgressListenerConstants.STATE_TRANSFERRING) != 0)
//{
// GeckoResponse rsp = new GeckoResponse(aRequest);
// if (rsp.ContentType == "application/x-executable")
// {
// // do something
// }
//}
if (cancelled || ((aStateFlags & nsIWebProgressListenerConstants.STATE_STOP) != 0 && (aStateFlags & nsIWebProgressListenerConstants.STATE_IS_NETWORK) != 0))
{
// clear busy state
IsBusy = false;
// kill any cached document and raise DocumentCompleted event
UnloadDocument();
OnDocumentCompleted(EventArgs.Empty);
// clear progress bar
OnProgressChanged(new GeckoProgressEventArgs(100, 100));
// clear status bar
StatusText = "";
}
}
protected Request(nsIRequest request)
{
_request = new ComPtr<nsIRequest>( request );
}
public void OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint aFlags)
{
}
void nsIWebProgressListener.OnProgressChange(
nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress,
int aMaxTotalProgress )
{
OnProgressChange(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress);
}
void nsIWebProgressListener.OnStateChange( nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus )
{
OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
}
void nsIWebProgressListener.OnSecurityChange( nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState )
{
OnSecurityChange( aWebProgress, aRequest, aState );
}
public static nsIRequest GetProxy(Mono.WebBrowser.IWebBrowser control, nsIRequest obj)
{
object o = Base.GetProxyForObject(control, typeof(nsIRequest).GUID, obj);
return(o as nsIRequest);
}
void nsIWebProgressListener.OnStatusChange( nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage )
{
OnStatusChange( aWebProgress, aRequest, aStatus, aMessage );
}
