8402134
/
old_flsystem
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
old_flsystem/类库/Api.Framework/MB/MB_WebView.cs

3455 lines
110 KiB
C#
Raw Normal View History

1
2022-09-20 03:10:29 +00:00
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
namespace MB
{
public class WebView : IDisposable
{
private IntPtr m_hWnd;
private IntPtr m_OldProc;
private wkePaintUpdatedCallback m_wkePaintUpdatedCallback;
private WndProcCallback m_WndProcCallback;
private bool m_bMouseEnabled;
private bool m_bTransparent;
#region 设置回调事件
private wkeTitleChangedCallback m_wkeTitleChangedCallback;
private wkeMouseOverUrlChangedCallback m_wkeMouseOverUrlChangedCallback;
private wkeURLChangedCallback2 m_wkeURLChangedCallback2;
private wkeAlertBoxCallback m_wkeAlertBoxCallback;
private wkeConfirmBoxCallback m_wkeConfirmBoxCallback;
private wkePromptBoxCallback m_wkePromptBoxCallback;
private wkeNavigationCallback m_wkeNavigationCallback;
private wkeCreateViewCallback m_wkeCreateViewCallback;
private wkeDocumentReady2Callback m_wkeDocumentReadyCallback;
private wkeLoadingFinishCallback m_wkeLoadingFinishCallback;
private wkeDownloadCallback m_wkeDownloadCallback;
private wkeDownload2Callback m_wkeDownloadCallback2;
private wkeConsoleCallback m_wkeConsoleCallback;
private wkeLoadUrlBeginCallback m_wkeLoadUrlBeginCallback;
private wkeLoadUrlEndCallback m_wkeLoadUrlEndCallback;
private wkeLoadUrlFailCallback m_wkeLoadUrlFailCallback;
private wkeDidCreateScriptContextCallback m_wkeDidCreateScriptContextCallback;
private wkeWillReleaseScriptContextCallback m_wkeWillReleaseScriptContextCallback;
private wkeNetResponseCallback m_wkeNetResponseCallback;
private wkeWillMediaLoadCallback m_wkeWillMediaLoadCallback;
private wkeOnOtherLoadCallback m_wkeOnOtherLoadCallback;
private event EventHandler<TitleChangeEventArgs> m_titleChangeHandler = null;
private event EventHandler<MouseOverUrlChangedEventArgs> m_mouseOverUrlChangedHandler = null;
private event EventHandler<UrlChangeEventArgs> m_urlChangeHandler = null;
private event EventHandler<AlertBoxEventArgs> m_alertBoxHandler = null;
private event EventHandler<ConfirmBoxEventArgs> m_confirmBoxHandler = null;
private event EventHandler<PromptBoxEventArgs> m_promptBoxHandler = null;
private event EventHandler<NavigateEventArgs> m_navigateHandler = null;
private event EventHandler<CreateViewEventArgs> m_createViewHandler = null;
private event EventHandler<DocumentReadyEventArgs> m_documentReadyHandler = null;
private event EventHandler<LoadingFinishEventArgs> m_loadingFinishHandler = null;
private event EventHandler<DownloadEventArgs> m_downloadHandler = null;
private event EventHandler<DownloadEventArgs2> m_downloadHandler2 = null;
private event EventHandler<ConsoleEventArgs> m_consoleHandler = null;
private event EventHandler<LoadUrlBeginEventArgs> m_loadUrlBeginHandler = null;
private event EventHandler<LoadUrlEndEventArgs> m_loadUrlEndHandler = null;
private event EventHandler<LoadUrlFailEventArgs> m_loadUrlFailHandler = null;
private event EventHandler<DidCreateScriptContextEventArgs> m_didCreateScriptContextHandler = null;
private event EventHandler<WillReleaseScriptContextEventArgs> m_willReleaseScriptContextHandler = null;
private event EventHandler<NetResponseEventArgs> m_netResponseHandler = null;
private event EventHandler<WillMediaLoadEventArgs> m_willMediaLoadHandler = null;
private event EventHandler<OtherLoadEventArgs> m_OtherLoadHandler = null;
private void SetCallback()
{
m_wkeTitleChangedCallback = new wkeTitleChangedCallback((IntPtr WebView, IntPtr param, IntPtr title) =>
{
m_titleChangeHandler?.Invoke(this, new TitleChangeEventArgs(WebView, title));
});
m_wkeMouseOverUrlChangedCallback = new wkeMouseOverUrlChangedCallback((IntPtr WebView, IntPtr param, IntPtr url) =>
{
m_titleChangeHandler?.Invoke(this, new TitleChangeEventArgs(WebView, url));
});
m_wkeURLChangedCallback2 = new wkeURLChangedCallback2((IntPtr WebView, IntPtr param, IntPtr frame, IntPtr url) =>
{
m_urlChangeHandler?.Invoke(this, new UrlChangeEventArgs(WebView, url, frame));
});
m_wkeAlertBoxCallback = new wkeAlertBoxCallback((IntPtr WebView, IntPtr param, IntPtr msg) =>
{
m_alertBoxHandler?.Invoke(this, new AlertBoxEventArgs(WebView, msg));
});
m_wkeConfirmBoxCallback = new wkeConfirmBoxCallback((IntPtr WebView, IntPtr param, IntPtr msg) =>
{
if (m_confirmBoxHandler != null)
{
ConfirmBoxEventArgs e = new ConfirmBoxEventArgs(WebView, msg);
m_confirmBoxHandler(this, e);
return Convert.ToByte(e.Result);
}
return 0;
});
m_wkePromptBoxCallback = new wkePromptBoxCallback((IntPtr webView, IntPtr param, IntPtr msg, IntPtr defaultResult, IntPtr result) =>
{
if (m_promptBoxHandler != null)
{
PromptBoxEventArgs e = new PromptBoxEventArgs(webView, msg, defaultResult, result);
m_promptBoxHandler(this, e);
return Convert.ToByte(e.Result);
}
return 0;
});
m_wkeNavigationCallback = new wkeNavigationCallback((IntPtr webView, IntPtr param, wkeNavigationType navigationType, IntPtr url) =>
{
if (m_navigateHandler != null)
{
NavigateEventArgs e = new NavigateEventArgs(webView, navigationType, url);
m_navigateHandler(this, e);
return (byte)(e.Cancel ? 0 : 1);
}
return 1;
});
m_wkeCreateViewCallback = new wkeCreateViewCallback((IntPtr webView, IntPtr param, wkeNavigationType navigationType, IntPtr url, IntPtr windowFeatures) =>
{
if (m_createViewHandler != null)
{
CreateViewEventArgs e = new CreateViewEventArgs(webView, navigationType, url, windowFeatures);
m_createViewHandler(this, e);
return e.NewWebViewHandle;
}
return webView;
});
m_wkeDocumentReadyCallback = new wkeDocumentReady2Callback((IntPtr webView, IntPtr param, IntPtr frame) =>
{
m_documentReadyHandler?.Invoke(this, new DocumentReadyEventArgs(webView, frame));
});
m_wkeLoadingFinishCallback = new wkeLoadingFinishCallback((IntPtr webView, IntPtr param, IntPtr url, wkeLoadingResult result, IntPtr failedReason) =>
{
m_loadingFinishHandler?.Invoke(this, new LoadingFinishEventArgs(webView, url, result, failedReason));
});
m_wkeDownloadCallback = new wkeDownloadCallback((IntPtr webView, IntPtr param, IntPtr url) =>
{
if (m_downloadHandler != null)
{
DownloadEventArgs e = new DownloadEventArgs(webView, url);
m_downloadHandler(this, e);
return (byte)(e.Cancel ? 1 : 0);
}
return 1;
});
m_wkeDownloadCallback2 = new wkeDownload2Callback((IntPtr webView, IntPtr param, uint expectedContentLength, IntPtr url, IntPtr mime, IntPtr disposition, IntPtr job, IntPtr dataBind) =>
{
if (m_downloadHandler2 != null)
{
DownloadEventArgs2 e = new DownloadEventArgs2(webView, param, expectedContentLength, url, mime, disposition, job, dataBind);
m_downloadHandler2(this, e);
return (byte)(e.Cancel ? 1 : 0);
}
return 1;
});
m_wkeConsoleCallback = new wkeConsoleCallback((IntPtr webView, IntPtr param, wkeConsoleLevel level, IntPtr message, IntPtr sourceName, uint sourceLine, IntPtr stackTrace) =>
{
m_consoleHandler?.Invoke(this, new ConsoleEventArgs(webView, level, message, sourceName, sourceLine, stackTrace));
});
m_wkeLoadUrlBeginCallback = new wkeLoadUrlBeginCallback((IntPtr webView, IntPtr param, IntPtr url, IntPtr job) =>
{
if (m_loadUrlBeginHandler != null)
{
LoadUrlBeginEventArgs e = new LoadUrlBeginEventArgs(webView, url, job);
m_loadUrlBeginHandler(this, e);
return (byte)(e.Cancel ? 1 : 0);
}
return 0;
});
m_wkeLoadUrlEndCallback = new wkeLoadUrlEndCallback((IntPtr webView, IntPtr param, IntPtr url, IntPtr job, IntPtr buf, int len) =>
{
m_loadUrlEndHandler?.Invoke(this, new LoadUrlEndEventArgs(webView, url, job, buf, len));
});
m_wkeDidCreateScriptContextCallback = new wkeDidCreateScriptContextCallback((IntPtr webView, IntPtr param, IntPtr frame, IntPtr context, int extensionGroup, int worldId) =>
{
m_didCreateScriptContextHandler?.Invoke(this, new DidCreateScriptContextEventArgs(webView, frame, context, extensionGroup, worldId));
});
m_wkeWillReleaseScriptContextCallback = new wkeWillReleaseScriptContextCallback((IntPtr webView, IntPtr param, IntPtr frame, IntPtr context, int worldId) =>
{
m_willReleaseScriptContextHandler?.Invoke(this, new WillReleaseScriptContextEventArgs(webView, frame, context, worldId));
});
m_wkeNetResponseCallback = new wkeNetResponseCallback((IntPtr WebView, IntPtr param, IntPtr url, IntPtr job) => {
if (m_netResponseHandler != null)
{
NetResponseEventArgs e = new NetResponseEventArgs(WebView, url, job);
m_netResponseHandler(this, e);
return (byte)(e.Cancel ? 1 : 0);
}
return 0;
});
m_wkeWillMediaLoadCallback = new wkeWillMediaLoadCallback((IntPtr webView, IntPtr param, IntPtr url, IntPtr info) =>
{
m_willMediaLoadHandler?.Invoke(this, new WillMediaLoadEventArgs(webView, url, info));
});
m_wkeOnOtherLoadCallback = new wkeOnOtherLoadCallback((IntPtr webView, IntPtr param, wkeOtherLoadType type, IntPtr info) =>
{
m_OtherLoadHandler?.Invoke(this, new OtherLoadEventArgs(webView, type, info));
});
}
/// <summary>
/// 窗口过程事件
/// </summary>
public event EventHandler<WindowProcEventArgs> OnWindowProc;
/// <summary>
/// 鼠标经过URL改变事件
/// </summary>
public event EventHandler<MouseOverUrlChangedEventArgs> OnMouseoverUrlChange
{
add
{
if (m_mouseOverUrlChangedHandler == null)
{
MBApi.wkeOnMouseOverUrlChanged(Handle, m_wkeMouseOverUrlChangedCallback, IntPtr.Zero);
}
m_mouseOverUrlChangedHandler += value;
}
remove
{
m_mouseOverUrlChangedHandler -= value;
if (m_mouseOverUrlChangedHandler == null)
{
MBApi.wkeOnMouseOverUrlChanged(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 标题被改变事件
/// </summary>
public event EventHandler<TitleChangeEventArgs> OnTitleChange
{
add
{
if (m_titleChangeHandler == null)
{
MBApi.wkeOnTitleChanged(Handle, m_wkeTitleChangedCallback, IntPtr.Zero);
}
m_titleChangeHandler += value;
}
remove
{
m_titleChangeHandler -= value;
if (m_titleChangeHandler == null)
{
MBApi.wkeOnTitleChanged(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// URL被改变事件
/// </summary>
public event EventHandler<UrlChangeEventArgs> OnURLChange
{
add
{
if (m_urlChangeHandler == null)
{
MBApi.wkeOnURLChanged2(Handle, m_wkeURLChangedCallback2, IntPtr.Zero);
}
m_urlChangeHandler += value;
}
remove
{
m_urlChangeHandler -= value;
if (m_urlChangeHandler == null)
{
MBApi.wkeOnURLChanged2(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// alert被调用事件
/// </summary>
public event EventHandler<AlertBoxEventArgs> OnAlertBox
{
add
{
if (m_alertBoxHandler == null)
{
MBApi.wkeOnAlertBox(Handle, m_wkeAlertBoxCallback, IntPtr.Zero);
}
m_alertBoxHandler += value;
}
remove
{
m_alertBoxHandler -= value;
if (m_alertBoxHandler == null)
{
MBApi.wkeOnAlertBox(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// confirm被调用事件
/// </summary>
public event EventHandler<ConfirmBoxEventArgs> OnConfirmBox
{
add
{
if (m_confirmBoxHandler == null)
{
MBApi.wkeOnConfirmBox(Handle, m_wkeConfirmBoxCallback, IntPtr.Zero);
}
m_confirmBoxHandler += value;
}
remove
{
m_confirmBoxHandler -= value;
if (m_confirmBoxHandler == null)
{
MBApi.wkeOnConfirmBox(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// prompt被调用事件
/// </summary>
public event EventHandler<PromptBoxEventArgs> OnPromptBox
{
add
{
if (m_promptBoxHandler == null)
{
MBApi.wkeOnPromptBox(Handle, m_wkePromptBoxCallback, IntPtr.Zero);
}
m_promptBoxHandler += value;
}
remove
{
m_promptBoxHandler -= value;
if (m_promptBoxHandler == null)
{
MBApi.wkeOnPromptBox(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 导航事件
/// </summary>
public event EventHandler<NavigateEventArgs> OnNavigate
{
add
{
if (m_navigateHandler == null)
{
MBApi.wkeOnNavigation(Handle, m_wkeNavigationCallback, IntPtr.Zero);
}
m_navigateHandler += value;
}
remove
{
m_navigateHandler -= value;
if (m_navigateHandler == null)
{
MBApi.wkeOnNavigation(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 将创建新窗口
/// </summary>
public event EventHandler<CreateViewEventArgs> OnCreateView
{
add
{
if (m_createViewHandler == null)
{
MBApi.wkeOnCreateView(Handle, m_wkeCreateViewCallback, IntPtr.Zero);
}
m_createViewHandler += value;
}
remove
{
m_createViewHandler -= value;
if (m_createViewHandler == null)
{
MBApi.wkeOnCreateView(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 文档就绪
/// </summary>
public event EventHandler<DocumentReadyEventArgs> OnDocumentReady
{
add
{
if (m_documentReadyHandler == null)
{
MBApi.wkeOnDocumentReady2(Handle, m_wkeDocumentReadyCallback, IntPtr.Zero);
}
m_documentReadyHandler += value;
}
remove
{
m_documentReadyHandler -= value;
if (m_documentReadyHandler == null)
{
MBApi.wkeOnDocumentReady2(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 载入完成
/// </summary>
public event EventHandler<LoadingFinishEventArgs> OnLoadingFinish
{
add
{
if (m_loadingFinishHandler == null)
{
MBApi.wkeOnLoadingFinish(Handle, m_wkeLoadingFinishCallback, IntPtr.Zero);
}
m_loadingFinishHandler += value;
}
remove
{
m_loadingFinishHandler -= value;
if (m_loadingFinishHandler == null)
{
MBApi.wkeOnLoadingFinish(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 下载
/// </summary>
public event EventHandler<DownloadEventArgs> OnDownload
{
add
{
if (m_downloadHandler == null)
{
MBApi.wkeOnDownload(Handle, m_wkeDownloadCallback, IntPtr.Zero);
}
m_downloadHandler += value;
}
remove
{
m_downloadHandler -= value;
if (m_downloadHandler == null)
{
MBApi.wkeOnDownload(Handle, null, IntPtr.Zero);
}
}
}
public event EventHandler<DownloadEventArgs2> OnDownload2
{
add
{
if (m_downloadHandler2 == null)
{
MBApi.wkeOnDownload2(Handle, m_wkeDownloadCallback2, IntPtr.Zero);
}
m_downloadHandler2 += value;
}
remove
{
m_downloadHandler2 -= value;
if (m_downloadHandler2 == null)
{
MBApi.wkeOnDownload2(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 控制台
/// </summary>
public event EventHandler<ConsoleEventArgs> OnConsole
{
add
{
if (m_consoleHandler == null)
{
MBApi.wkeOnConsole(Handle, m_wkeConsoleCallback, IntPtr.Zero);
}
m_consoleHandler += value;
}
remove
{
m_consoleHandler -= value;
if (m_consoleHandler == null)
{
MBApi.wkeOnConsole(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 开始载入URL
/// </summary>
public event EventHandler<LoadUrlBeginEventArgs> OnLoadUrlBegin
{
add
{
if (m_loadUrlBeginHandler == null)
{
MBApi.wkeOnLoadUrlBegin(Handle, m_wkeLoadUrlBeginCallback, IntPtr.Zero);
}
m_loadUrlBeginHandler += value;
}
remove
{
m_loadUrlBeginHandler -= value;
if (m_loadUrlBeginHandler == null)
{
MBApi.wkeOnLoadUrlBegin(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 结束载入URL
/// </summary>
public event EventHandler<LoadUrlEndEventArgs> OnLoadUrlEnd
{
add
{
if (m_loadUrlEndHandler == null)
{
MBApi.wkeOnLoadUrlEnd(Handle, m_wkeLoadUrlEndCallback, IntPtr.Zero);
}
m_loadUrlEndHandler += value;
}
remove
{
m_loadUrlEndHandler -= value;
if (m_loadUrlEndHandler == null)
{
MBApi.wkeOnLoadUrlEnd(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 载入URL失败
/// </summary>
public event EventHandler<LoadUrlFailEventArgs> OnLoadUrlFail
{
add
{
if (m_loadUrlFailHandler == null)
{
MBApi.wkeOnLoadUrlFail(Handle, m_wkeLoadUrlFailCallback, IntPtr.Zero);
}
m_loadUrlFailHandler += value;
}
remove
{
m_loadUrlFailHandler -= value;
if (m_loadUrlFailHandler == null)
{
MBApi.wkeOnLoadUrlFail(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 脚本上下文已创建
/// </summary>
public event EventHandler<DidCreateScriptContextEventArgs> OnDidCreateScriptContext
{
add
{
if (m_didCreateScriptContextHandler == null)
{
MBApi.wkeOnDidCreateScriptContext(Handle, m_wkeDidCreateScriptContextCallback, IntPtr.Zero);
}
m_didCreateScriptContextHandler += value;
}
remove
{
m_didCreateScriptContextHandler -= value;
if (m_didCreateScriptContextHandler == null)
{
MBApi.wkeOnDidCreateScriptContext(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 脚本上下文将释放
/// </summary>
public event EventHandler<WillReleaseScriptContextEventArgs> OnWillReleaseScriptContext
{
add
{
if (m_willReleaseScriptContextHandler == null)
{
MBApi.wkeOnWillReleaseScriptContext(Handle, m_wkeWillReleaseScriptContextCallback, IntPtr.Zero);
}
m_willReleaseScriptContextHandler += value;
}
remove
{
m_willReleaseScriptContextHandler -= value;
if (m_willReleaseScriptContextHandler == null)
{
MBApi.wkeOnWillReleaseScriptContext(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 网络响应事件
/// </summary>
public event EventHandler<NetResponseEventArgs> OnNetResponse
{
add
{
if (m_netResponseHandler == null)
{
MBApi.wkeNetOnResponse(Handle, m_wkeNetResponseCallback, IntPtr.Zero);
}
m_netResponseHandler += value;
}
remove
{
m_netResponseHandler -= value;
if (m_netResponseHandler == null)
{
MBApi.wkeNetOnResponse(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 媒体将被载入事件
/// </summary>
public event EventHandler<WillMediaLoadEventArgs> OnWillMediaLoad
{
add
{
if (m_willMediaLoadHandler == null)
{
MBApi.wkeOnWillMediaLoad(Handle, m_wkeWillMediaLoadCallback, IntPtr.Zero);
}
m_willMediaLoadHandler += value;
}
remove
{
m_willMediaLoadHandler -= value;
if (m_willMediaLoadHandler == null)
{
MBApi.wkeOnWillMediaLoad(Handle, null, IntPtr.Zero);
}
}
}
/// <summary>
/// 其他载入事件
/// </summary>
public event EventHandler<OtherLoadEventArgs> OnOtherLoad
{
add
{
if (m_OtherLoadHandler == null)
{
MBApi.wkeOnOtherLoad(Handle, m_wkeOnOtherLoadCallback, IntPtr.Zero);
}
m_OtherLoadHandler += value;
}
remove
{
m_OtherLoadHandler -= value;
if (m_OtherLoadHandler == null)
{
MBApi.wkeOnOtherLoad(Handle, null, IntPtr.Zero);
}
}
}
#endregion
/// <summary>
/// 构造函数
/// </summary>
public WebView()
{
/*if (!File.Exists($"{Environment.CurrentDirectory}\\node.dll"))
{
MessageBox.Show("请在程序同目录下放置node.dll文件", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
Process.GetCurrentProcess().Kill();
}*/
if (MBApi.wkeIsInitialize() == 0)
{
MBApi.wkeInitialize();
}
m_wkePaintUpdatedCallback = new wkePaintUpdatedCallback(wkeOnPaintUpdated);
m_WndProcCallback = new WndProcCallback(OnWndProc);
SetCallback();
Handle = MBApi.wkeCreateWebView();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="window">窗口</param>
/// <param name="isTransparent">true 表示为分层窗口，窗口必须是顶层</param>
public WebView(IWin32Window window, bool isTransparent = false)
{
/*if (!File.Exists($"{Environment.CurrentDirectory}\\node.dll"))
{
MessageBox.Show("请在程序同目录下放置node.dll文件", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
Process.GetCurrentProcess().Kill();
}*/
if (MBApi.wkeIsInitialize() == 0)
{
MBApi.wkeInitialize();
}
m_wkePaintUpdatedCallback = new wkePaintUpdatedCallback(wkeOnPaintUpdated);
m_WndProcCallback = new WndProcCallback(OnWndProc);
SetCallback();
Bind(window, isTransparent);
}
/// <summary>
/// 销毁 WebView
/// </summary>
public void Dispose()
{
if (Handle != IntPtr.Zero)
{
if (m_OldProc != IntPtr.Zero)
{
MB_Common.SetWindowLong(m_hWnd, (int)WinConst.GWL_WNDPROC, m_OldProc.To32());
m_OldProc = IntPtr.Zero;
}
MBApi.wkeSetHandle(Handle, IntPtr.Zero);
MBApi.wkeDestroyWebView(Handle);
Handle = IntPtr.Zero;
m_hWnd = IntPtr.Zero;
}
}
protected void wkeOnPaintUpdated(IntPtr webView, IntPtr param, IntPtr hdc, int x, int y, int cx, int cy)
{
IntPtr hWnd = param;
if ((int)WinConst.WS_EX_LAYERED == ((int)WinConst.WS_EX_LAYERED & MB_Common.GetWindowLong(m_hWnd, (int)WinConst.GWL_EXSTYLE)))
{
RECT rectDest = new RECT();
MB_Common.GetWindowRect(m_hWnd, ref rectDest);
MB_Common.OffsetRect(ref rectDest, -rectDest.Left, -rectDest.Top);
SIZE sizeDest = new SIZE(rectDest.Right - rectDest.Left, rectDest.Bottom - rectDest.Top);
POINT pointSource = new POINT();
BITMAP bmp = new BITMAP();
IntPtr hBmp = MB_Common.GetCurrentObject(hdc, (int)WinConst.OBJ_BITMAP);
MB_Common.GetObject(hBmp, Marshal.SizeOf(typeof(BITMAP)), ref bmp);
sizeDest.cx = bmp.bmWidth;
sizeDest.cy = bmp.bmHeight;
IntPtr hdcScreen = MB_Common.GetDC(hWnd);
BLENDFUNCTION blend = new BLENDFUNCTION();
blend.BlendOp = (byte)WinConst.AC_SRC_OVER;
blend.SourceConstantAlpha = 255;
blend.AlphaFormat = (byte)WinConst.AC_SRC_ALPHA;
if (MB_Common.UpdateLayeredWindow(m_hWnd, hdcScreen, IntPtr.Zero, ref sizeDest, hdc, ref pointSource, 0, ref blend, (int)WinConst.ULW_ALPHA) == 0)
{
IntPtr hdcMemory = MB_Common.CreateCompatibleDC(hdcScreen);
IntPtr hbmpMemory = MB_Common.CreateCompatibleBitmap(hdcScreen, sizeDest.cx, sizeDest.cy);
IntPtr hbmpOld = MB_Common.SelectObject(hdcMemory, hbmpMemory);
MB_Common.BitBlt(hdcMemory, 0, 0, sizeDest.cx, sizeDest.cy, hdc, 0, 0, (int)WinConst.SRCCOPY | (int)WinConst.CAPTUREBLT);
MB_Common.BitBlt(hdc, 0, 0, sizeDest.cx, sizeDest.cy, hdcMemory, 0, 0, (int)WinConst.SRCCOPY | (int)WinConst.CAPTUREBLT);
MB_Common.UpdateLayeredWindow(m_hWnd, hdcScreen, IntPtr.Zero, ref sizeDest, hdcMemory, ref pointSource, 0, ref blend, (int)WinConst.ULW_ALPHA);
MB_Common.SelectObject(hdcMemory, hbmpOld);
MB_Common.DeleteObject(hbmpMemory);
MB_Common.DeleteDC(hdcMemory);
}
MB_Common.ReleaseDC(m_hWnd, hdcScreen);
}
else
{
RECT rc = new RECT(x, y, x + cx, y + cy);
MB_Common.InvalidateRect(m_hWnd, ref rc, true);
}
}
protected IntPtr OnWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
if (OnWindowProc != null)
{
WindowProcEventArgs e = new WindowProcEventArgs(hWnd, (int)msg, wParam, lParam);
OnWindowProc(this, e);
if (e.bHand)
{
return e.Result;
}
}
switch (msg)
{
case (uint)WinConst.WM_PAINT: // 当窗口显示区域的一部分显示内容或者全部变为“无效”，以致于必须“更新画面”时
{
if ((int)WinConst.WS_EX_LAYERED != ((int)WinConst.WS_EX_LAYERED & MB_Common.GetWindowLong(hWnd, (int)WinConst.GWL_EXSTYLE)))
{
PAINTSTRUCT ps = new PAINTSTRUCT();
IntPtr hdc = MB_Common.BeginPaint(hWnd, ref ps);
RECT rcClip = ps.rcPaint;
RECT rcClient = new RECT();
MB_Common.GetClientRect(hWnd, ref rcClient);
RECT rcInvalid = rcClient;
if (rcClip.Right != rcClip.Left && rcClip.Bottom != rcClip.Top)
{
MB_Common.IntersectRect(ref rcInvalid, ref rcClip, ref rcClient);
}
int srcX = rcInvalid.Left - rcClient.Left;
int srcY = rcInvalid.Top - rcClient.Top;
int destX = rcInvalid.Left;
int destY = rcInvalid.Top;
int width = rcInvalid.Right - rcInvalid.Left;
int height = rcInvalid.Bottom - rcInvalid.Top;
if (width != 0 && height != 0)
{
MB_Common.BitBlt(hdc, destX, destY, width, height, MBApi.wkeGetViewDC(Handle), srcX, srcY, (int)WinConst.SRCCOPY);
}
MB_Common.EndPaint(hWnd, ref ps);
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_ERASEBKGND: // 窗口背景被擦除时
{
return new IntPtr(1);
}
case (uint)WinConst.WM_SIZE: // 窗口尺寸改变时
{
MBApi.wkeResize(Handle, lParam.To32().LOWORD(), lParam.To32().HIWORD());
break;
}
case (uint)WinConst.WM_KEYDOWN: // 非系统键被按下时
{
uint flags = 0;
if ((lParam.To32().HIWORD() & (int)WinConst.KF_REPEAT) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_REPEAT;
}
if ((lParam.To32().HIWORD() & (int)WinConst.KF_EXTENDED) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_EXTENDED;
}
if (MBApi.wkeFireKeyDownEvent(Handle, wParam.To32(), flags, false) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_KEYUP: // 非系统键被抬起时
{
uint flags = 0;
if ((lParam.To32().HIWORD() & (int)WinConst.KF_REPEAT) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_REPEAT;
}
if ((lParam.To32().HIWORD() & (int)WinConst.KF_EXTENDED) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_EXTENDED;
}
if (MBApi.wkeFireKeyUpEvent(Handle, wParam.To32(), flags, false) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_CHAR: // ASCII码为0-127之间的按键被按下时
{
uint flags = 0;
if ((lParam.To32().HIWORD() & (int)WinConst.KF_REPEAT) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_REPEAT;
}
if ((lParam.To32().HIWORD() & (int)WinConst.KF_EXTENDED) != 0)
{
flags |= (uint)wkeKeyFlags.WKE_EXTENDED;
}
if (MBApi.wkeFireKeyPressEvent(Handle, wParam.To32(), flags, false) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_LBUTTONDOWN:
case (uint)WinConst.WM_MBUTTONDOWN:
case (uint)WinConst.WM_RBUTTONDOWN:
case (uint)WinConst.WM_LBUTTONDBLCLK:
case (uint)WinConst.WM_MBUTTONDBLCLK:
case (uint)WinConst.WM_RBUTTONDBLCLK:
case (uint)WinConst.WM_LBUTTONUP:
case (uint)WinConst.WM_MBUTTONUP:
case (uint)WinConst.WM_RBUTTONUP:
case (uint)WinConst.WM_MOUSEMOVE:
{
if (msg == (uint)WinConst.WM_LBUTTONDOWN || msg == (uint)WinConst.WM_MBUTTONDOWN || msg == (uint)WinConst.WM_RBUTTONDOWN)
{
if (MB_Common.GetFocus() != hWnd)
{
MB_Common.SetFocus(hWnd);
}
MB_Common.SetCapture(hWnd);
}
else if (msg == (uint)WinConst.WM_LBUTTONUP || msg == (uint)WinConst.WM_MBUTTONUP || msg == (uint)WinConst.WM_RBUTTONUP)
{
MB_Common.ReleaseCapture();
}
uint flags = 0;
if ((wParam.To32() & (int)WinConst.MK_CONTROL) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_CONTROL;
}
if ((wParam.To32() & (int)WinConst.MK_SHIFT) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_SHIFT;
}
if ((wParam.To32() & (int)WinConst.MK_LBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_LBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_MBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_MBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_RBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_RBUTTON;
}
if (MBApi.wkeFireMouseEvent(Handle, msg, lParam.To32().LOWORD(), lParam.To32().HIWORD(), flags) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_CONTEXTMENU:
{
POINT pt;
pt.x = lParam.To32().LOWORD();
pt.y = lParam.To32().HIWORD();
if (pt.x != -1 && pt.y != -1)
{
MB_Common.ScreenToClient(hWnd, ref pt);
}
uint flags = 0;
if ((wParam.To32() & (int)WinConst.MK_CONTROL) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_CONTROL;
}
if ((wParam.To32() & (int)WinConst.MK_SHIFT) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_SHIFT;
}
if ((wParam.To32() & (int)WinConst.MK_LBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_LBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_MBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_MBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_RBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_RBUTTON;
}
if (MBApi.wkeFireContextMenuEvent(Handle, pt.x, pt.y, flags) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_MOUSEWHEEL:
{
POINT pt;
pt.x = lParam.To32().LOWORD();
pt.y = lParam.To32().HIWORD();
MB_Common.ScreenToClient(hWnd, ref pt);
uint flags = 0;
if ((wParam.To32() & (int)WinConst.MK_CONTROL) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_CONTROL;
}
if ((wParam.To32() & (int)WinConst.MK_SHIFT) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_SHIFT;
}
if ((wParam.To32() & (int)WinConst.MK_LBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_LBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_MBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_MBUTTON;
}
if ((wParam.To32() & (int)WinConst.MK_RBUTTON) != 0)
{
flags |= (uint)wkeMouseFlags.WKE_RBUTTON;
}
if (MBApi.wkeFireMouseWheelEvent(Handle, pt.x, pt.y, wParam.To32().HIWORD(), flags) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_SETFOCUS:
{
MBApi.wkeSetFocus(Handle);
return IntPtr.Zero;
}
case (uint)WinConst.WM_KILLFOCUS:
{
MBApi.wkeKillFocus(Handle);
return IntPtr.Zero;
}
case (uint)WinConst.WM_SETCURSOR:
{
if (MBApi.wkeFireWindowsMessage(Handle, hWnd, (uint)WinConst.WM_SETCURSOR, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) != 0)
{
return IntPtr.Zero;
}
break;
}
case (uint)WinConst.WM_IME_STARTCOMPOSITION:
{
wkeRect caret = MBApi.wkeGetCaretRect(Handle);
COMPOSITIONFORM COMPOSITIONFORM = new COMPOSITIONFORM();
COMPOSITIONFORM.dwStyle = (int)WinConst.CFS_POINT | (int)WinConst.CFS_FORCE_POSITION;
COMPOSITIONFORM.ptCurrentPos.x = caret.x;
COMPOSITIONFORM.ptCurrentPos.y = caret.y;
IntPtr hIMC = MB_Common.ImmGetContext(hWnd);
MB_Common.ImmSetCompositionWindow(hIMC, ref COMPOSITIONFORM);
MB_Common.ImmReleaseContext(hWnd, hIMC);
return IntPtr.Zero;
}
case (uint)WinConst.WM_INPUTLANGCHANGE:
{
return MB_Common.DefWindowProc(hWnd, msg, wParam, lParam);
}
}
return MB_Common.CallWindowProc(m_OldProc, hWnd, msg, wParam, lParam);
}
#region 基本方法
/// <summary>
/// 初始化miniblink，如果没有调用，则在 new WebView 时会自己初始化
/// </summary>
public void wkeInitialize()
{
if (MBApi.wkeIsInitialize() == 0)
{
MBApi.wkeInitialize();
}
}
/// <summary>
/// 初始化miniblink，并可以设置一些参数，如果没有调用，则在 new WebView 时会自己初始化
/// </summary>
/// <param name="settings"></param>
public void wkeInitialize(wkeSettings settings)
{
if (MBApi.wkeIsInitialize() == 0)
{
MBApi.wkeInitializeEx(settings);
}
}
/// <summary>
/// 获取版本
/// </summary>
public uint Version
{
get { return MBApi.wkeGetVersion(); }
}
/// <summary>
/// 获取版本信息
/// </summary>
public string VersionString
{
get
{
IntPtr utf8 = MBApi.wkeGetVersionString();
if (utf8 != IntPtr.Zero)
{
return Marshal.PtrToStringAnsi(utf8);
}
return null;
}
}
/// <summary>
/// 设置代理
/// </summary>
/// <param name="proxy"></param>
public void SetProxy(wkeProxy proxy)
{
MBApi.wkeSetProxy(ref proxy);
}
/// <summary>
/// 判断是否主框架
/// </summary>
/// <param name="WebFrame">框架句柄</param>
/// <returns></returns>
public bool FrameIsMainFrame(IntPtr WebFrame)
{
return MBApi.wkeIsMainFrame(WebFrame) != 0;
}
/// <summary>
/// 判断是否远程框架
/// </summary>
/// <param name="WebFrame"></param>
/// <returns></returns>
public bool FrameIsRemoteFrame(IntPtr WebFrame)
{
return MBApi.wkeIsWebRemoteFrame(WebFrame) != 0;
}
/// <summary>
/// 获取v8Context
/// </summary>
/// <param name="WebFrame">框架句柄</param>
/// <returns></returns>
public IntPtr FrameGetMainWorldScriptContext(IntPtr WebFrame)
{
IntPtr v8ContextPtr = IntPtr.Zero;
MBApi.wkeWebFrameGetMainWorldScriptContext(WebFrame, ref v8ContextPtr);
return v8ContextPtr;
}
/// <summary>
/// 获取v8Isolate
/// </summary>
/// <returns></returns>
public IntPtr GetBlinkMainThreadIsolate()
{
return MBApi.wkeGetBlinkMainThreadIsolate();
}
/// <summary>
/// 设置mimeType。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="type">MIMEType</param>
public void NetSetMIMEType(IntPtr job, string MIMEType)
{
MBApi.wkeNetSetMIMEType(job, MIMEType);
}
/// <summary>
/// 获取mimeType。此方法应该在 OnNetResponse 事件中使用
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public string NetGetMIMEType(IntPtr job)
{
//IntPtr ptr = MBApi.wkeNetGetMIMEType(job, IntPtr.Zero);
//return ptr.UTF8PtrToStr();
IntPtr mime = MBApi.wkeCreateStringW(null, 0);
if (mime == IntPtr.Zero)
{
return string.Empty;
}
MBApi.wkeNetGetMIMEType(job, mime);
string mimeType = MBApi.wkeGetStringW(mime).UTF8PtrToStr();
MBApi.wkeDeleteString(mime);
return mimeType;
}
/// <summary>
/// 继续执行中断的网络任务，参看wkeNetHoldJobToAsynCommit接口。
/// </summary>
/// <param name="job"></param>
public void NetContinueJob(IntPtr job)
{
MBApi.wkeNetContinueJob(job);
}
/// <summary>
/// 通过jobPtr获取当前请求的url。
/// </summary>
/// <param name="job"></param>
public string NetGetUrlByJob(IntPtr job)
{
IntPtr ptr = MBApi.wkeNetGetUrlByJob(job);
return ptr.UTF8PtrToStr();
}
/// <summary>
/// 获取Raw格式的HTTP请求数据，wkeSlist是个保存了网络数据的链表结构，请参看wke.h文件。
/// </summary>
/// <param name="job"></param>
public wkeSlist NetGetRawHttpHead(IntPtr job)
{
IntPtr ptr = MBApi.wkeNetGetRawHttpHead(job);
return (wkeSlist)ptr.UTF8PtrToStruct(typeof(wkeSlist));
}
/// <summary>
/// 获取Raw格式的HTTP响应数据，wkeSlist是个保存了网络数据的链表结构，请参看wke.h文件。
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public wkeSlist NetGetRawResponseHead(IntPtr job)
{
IntPtr ptr = MBApi.wkeNetGetRawResponseHead(job);
return (wkeSlist)ptr.UTF8PtrToStruct(typeof(wkeSlist));
}
/// <summary>
/// 取消本次网络请求，需要在wkeOnLoadUrlBegin里调用。
/// </summary>
/// <param name="job"></param>
public void NetCancelRequest(IntPtr job)
{
MBApi.wkeNetCancelRequest(job);
}
/// <summary>
/// 网络访问经常存在异步操作，当wkeOnLoadUrlBegin里拦截到一个请求后如不能马上判断出结果，此时可以调用本接口，处理完成后需调用wkeNetContinueJob来让此请求继续。
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public bool NetHoldJobToAsynCommit(IntPtr job)
{
return MBApi.wkeNetHoldJobToAsynCommit(job) == 1 ? true : false;
}
/// <summary>
/// 修改当前请求的url。
/// </summary>
/// <param name="job"></param>
/// <param name="url"></param>
/// <returns></returns>
public bool NetChangeRequestUrl(IntPtr job, string url)
{
return MBApi.wkeNetChangeRequestUrl(job, url) == 1 ? true : false;
}
/// <summary>
/// 创建一个网络请求
/// </summary>
/// <param name="url"></param>
/// <param name="method"></param>
/// <param name="mime"></param>
/// <returns></returns>
public IntPtr NetCreateWebUrlRequest(IntPtr url, IntPtr method, IntPtr mime)
{
return MBApi.wkeNetCreateWebUrlRequest(url, method, mime);
}
/// <summary>
/// 创建一个网络请求
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public IntPtr NetCreateWebUrlRequest2(IntPtr request)
{
return MBApi.wkeNetCreateWebUrlRequest2(request);
}
/// <summary>
/// 复制一个网络请求
/// </summary>
/// <param name="job"></param>
/// <param name="needExtraData"></param>
/// <returns></returns>
public IntPtr NetCopyWebUrlRequest(IntPtr job, bool needExtraData)
{
return MBApi.wkeNetCopyWebUrlRequest(job, needExtraData);
}
/// <summary>
/// 取消网络请求。
/// </summary>
/// <param name="request"></param>
public void NetDeleteBlinkWebURLRequestPtr(IntPtr request)
{
MBApi.wkeNetDeleteBlinkWebURLRequestPtr(request);
}
/// <summary>
/// 在指定网络请求中插入一个请求头。
/// </summary>
/// <param name="request"></param>
/// <param name="name"></param>
/// <param name="value"></param>
public void NetAddHTTPHeaderFieldToUrlRequest(IntPtr request, IntPtr name, IntPtr value)
{
MBApi.wkeNetAddHTTPHeaderFieldToUrlRequest(request, name, value);
}
/// <summary>
/// 开始网络请求。
/// </summary>
/// <param name="webView"></param>
/// <param name="request"></param>
/// <param name="param"></param>
/// <param name="callback"></param>
/// <returns></returns>
public int NetStartUrlRequest(IntPtr webView, IntPtr request, IntPtr param, wkeUrlRequestCallbacks callback)
{
return MBApi.wkeNetStartUrlRequest(webView, request, param, callback);
}
/// <summary>
/// 获取HTTP响应状态码。
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public int NetGetHttpStatusCode(IntPtr response)
{
return MBApi.wkeNetGetHttpStatusCode(response);
}
/// <summary>
/// 获取响应数据大小。
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public long NetGetExpectedContentLength(IntPtr response)
{
return MBApi.wkeNetGetExpectedContentLength(response);
}
/// <summary>
/// 获取响应url。
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public string NetGetResponseUrl(IntPtr response)
{
IntPtr ptr = MBApi.wkeNetGetResponseUrl(response);
return ptr.UTF8PtrToStr();
}
/// <summary>
/// 取消网络请求。
/// </summary>
/// <param name="requestId"></param>
public void NetCancelWebUrlRequest(int requestId)
{
MBApi.wkeNetCancelWebUrlRequest(requestId);
}
/// <summary>
/// 获取此请求中的post数据，注意：只有当请求是post时才可获取到，get请求直接从url上取就好了。
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public wkePostBodyElements NetGetPostBody(IntPtr job)
{
IntPtr ptr = MBApi.wkeNetGetPostBody(job);
return (wkePostBodyElements)ptr.UTF8PtrToStruct(typeof(wkePostBodyElements));
}
/// <summary>
/// 创建一组post数据内容
/// </summary>
/// <param name="job"></param>
/// <param name="length"></param>
/// <returns></returns>
public wkePostBodyElements NetCreatePostBodyElements(long length)
{
IntPtr ptr = MBApi.wkeNetCreatePostBodyElements(Handle, length);
return (wkePostBodyElements)ptr.UTF8PtrToStruct(typeof(wkePostBodyElements));
}
/// <summary>
/// 干掉指定的post数据内容组，释放内存。
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
public void NetFreePostBodyElements(IntPtr elements)
{
MBApi.wkeNetFreePostBodyElements(elements);
}
/// <summary>
/// 创建一个post数据内容。
/// </summary>
/// <param name="webView"></param>
/// <returns></returns>
public wkePostBodyElement NetCreatePostBodyElement()
{
IntPtr ptr = MBApi.wkeNetCreatePostBodyElement(Handle);
return (wkePostBodyElement)ptr.UTF8PtrToStruct(typeof(wkePostBodyElement));
}
/// <summary>
/// 干掉指定的post数据内容，释放内存。
/// </summary>
/// <param name="elements"></param>
public void NetFreePostBodyElement(IntPtr element)
{
MBApi.wkeNetFreePostBodyElement(element);
}
/// <summary>
/// 设置HTTP头字段。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="response"></param>
public void NetSetHTTPHeaderField(IntPtr job, string key, string value, bool response)
{
MBApi.wkeNetSetHTTPHeaderField(job, key, value, response);
}
/// <summary>
/// 获取HTTP请求头
/// </summary>
/// <param name="job"></param>
/// <param name="key"></param>
public string NetGetHTTPHeaderField(IntPtr job, string key)
{
return MBApi.wkeNetGetHTTPHeaderField(job, key).UTF8PtrToStr();
}
/// <summary>
/// 获取HTTP响应头
/// </summary>
/// <param name="job"></param>
/// <param name="key"></param>
public string NetGetHTTPHeaderFieldFromResponse(IntPtr job, string key)
{
return MBApi.wkeNetGetHTTPHeaderFieldFromResponse(job, key).UTF8PtrToStr();
}
/// <summary>
/// 设置网络数据。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="data"></param>
public void NetSetData(IntPtr job, byte[] data)
{
MBApi.wkeNetSetData(job, data, data.Length);
}
/// <summary>
/// 设置网络数据。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="str">string数据</param>
public void NetSetData(IntPtr job, string str)
{
byte[] data = Encoding.UTF8.GetBytes(str);
MBApi.wkeNetSetData(job, data, data.Length);
}
/// <summary>
/// 设置网络数据。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="png">PNG图片数据</param>
public void NetSetData(IntPtr job, Image png)
{
byte[] data = null;
using (MemoryStream ms = new MemoryStream())
{
png.Save(ms, ImageFormat.Png);
data = ms.GetBuffer();
}
MBApi.wkeNetSetData(job, data, data.Length);
}
/// <summary>
/// 设置网络数据。此方法应该在 OnLoadUrlBegin 事件中使用
/// </summary>
/// <param name="job"></param>
/// <param name="img">图片数据</param>
/// <param name="fmt">图片格式</param>
public void NetSetData(IntPtr job, Image img, ImageFormat fmt)
{
byte[] data = null;
using (MemoryStream ms = new MemoryStream())
{
img.Save(ms, fmt);
data = ms.GetBuffer();
}
MBApi.wkeNetSetData(job, data, data.Length);
}
/// <summary>
/// 此方法应该在 OnLoadUrlBegin 事件中使用，调用此函数后,网络层收到数据会存储在一buf内,接收数据完成后响应OnLoadUrlEnd事件.#此调用严重影响性能,慎用，
/// 此函数和WebView.NetSetData的区别是，WebView.NetHookRequest会在接受到真正网络数据后再调用回调，并允许回调修改网络数据。
/// 而WebView.NetSetData是在网络数据还没发送的时候修改
/// </summary>
/// <param name="job"></param>
public void NetHookRequest(IntPtr job)
{
MBApi.wkeNetHookRequest(job);
}
/// <summary>
/// 获取请求方法
/// </summary>
/// <param name="job"></param>
/// <returns></returns>
public wkeRequestType GetRequestMethod(IntPtr job)
{
return MBApi.wkeNetGetRequestMethod(job);
}
/// <summary>
/// 获取图标，结果再Callback中取
/// </summary>
/// <param name="WebView"></param>
/// <param name="Callback"></param>
/// <param name="param"></param>
/// <returns></returns>
public int NetGetFavicon(IntPtr WebView, wkeNetResponseCallback Callback, IntPtr param)
{
return MBApi.wkeNetGetFavicon(WebView, Callback, param);
}
/// <summary>
/// 指定一个回调函数，访问所有Cookie
/// </summary>
/// <param name="visitor">wkeCookieVisitor 委托</param>
/// <param name="userData">用户数据</param>
public void VisitAllCookie(wkeCookieVisitor visitor, IntPtr userData)
{
MBApi.wkeVisitAllCookie(Handle, userData, visitor);
}
/// <summary>
/// 执行cookie命令，清空等操作
/// </summary>
/// <param name="command"></param>
public void PerformCookieCommand(wkeCookieCommand command)
{
MBApi.wkePerformCookieCommand(command);
}
/// <summary>
/// 绑定指定窗口
/// </summary>
/// <param name="window">窗口</param>
/// <param name="isTransparent">是否透明模式，必须是顶层窗口才有效</param>
/// <returns></returns>
public bool Bind(IWin32Window window, bool isTransparent = false)
{
if (m_hWnd == window.Handle)
{
return true;
}
if (Handle == IntPtr.Zero)
{
Handle = MBApi.wkeCreateWebView();
if (Handle == IntPtr.Zero)
{
return false;
}
}
m_hWnd = window.Handle;
MBApi.wkeSetHandle(Handle, m_hWnd);
MBApi.wkeOnPaintUpdated(Handle, m_wkePaintUpdatedCallback, m_hWnd);
if (isTransparent)
{
MBApi.wkeSetTransparent(Handle, true);
int exStyle = MB_Common.GetWindowLong(m_hWnd, (int)WinConst.GWL_EXSTYLE);
MB_Common.SetWindowLong(m_hWnd, (int)WinConst.GWL_EXSTYLE, exStyle | (int)WinConst.WS_EX_LAYERED);
}
else
{
MBApi.wkeSetTransparent(Handle, false);
}
m_OldProc = (IntPtr)MB_Common.GetWindowLong(m_hWnd, (int)WinConst.GWL_WNDPROC);
IntPtr ptrProcCallback = Marshal.GetFunctionPointerForDelegate(m_WndProcCallback);
if (m_OldProc != ptrProcCallback)
{
m_OldProc = (IntPtr)MB_Common.SetWindowLong(m_hWnd, (int)WinConst.GWL_WNDPROC, (int)ptrProcCallback);
}
RECT rc = new RECT();
MB_Common.GetClientRect(m_hWnd, ref rc);
MBApi.wkeResize(Handle, rc.Right - rc.Left, rc.Bottom - rc.Top);
return true;
}
/// <summary>
/// 载入URL
/// </summary>
/// <param name="URL"></param>
public void Load(string URL)
{
MBApi.wkeLoadW(Handle, URL);
}
/// <summary>
/// 载入URL
/// </summary>
/// <param name="URL"></param>
public void LoadURL(string URL)
{
MBApi.wkeLoadURLW(Handle, URL);
}
/// <summary>
/// 载入本地文件
/// </summary>
/// <param name="FileName">文件名</param>
public void LoadFile(string FileName)
{
MBApi.wkeLoadFileW(Handle, FileName);
}
/// <summary>
/// 载入内存HTML文本
/// </summary>
/// <param name="html">HTML文本</param>
public void LoadHTML(string Html)
{
MBApi.wkeLoadHTMLW(Handle, Html);
}
/// <summary>
/// POST方式载入URL
/// </summary>
/// <param name="URL"></param>
/// <param name="PostData">提交的POST数据</param>
public void PostURL(string URL, byte[] PostData)
{
MBApi.wkePostURLW(Handle, URL, PostData, PostData.Length);
}
/// <summary>
/// 载入内存HTML文本，并指定 BaseURL
/// </summary>
/// <param name="Html">HTML文本</param>
/// <param name="BaseURL"></param>
public void LoadHtmlWithBaseUrl(string Html, string BaseURL)
{
MBApi.wkeLoadHtmlWithBaseUrl(Handle, Encoding.UTF8.GetBytes(Html), Encoding.UTF8.GetBytes(BaseURL));
}
/// <summary>
/// 停止载入
/// </summary>
public void StopLoading()
{
MBApi.wkeStopLoading(Handle);
}
/// <summary>
/// 重新载入
/// </summary>
public void Reload()
{
MBApi.wkeReload(Handle);
}
/// <summary>
/// 跳转到指定偏移的浏览历史
/// </summary>
/// <param name="offset"></param>
public void GoToOffset(int offset)
{
MBApi.wkeGoToOffset(Handle, offset);
}
/// <summary>
/// 跳转到指定索引的浏览历史
/// </summary>
/// <param name="index"></param>
public void GoToIndex(int index)
{
MBApi.wkeGoToIndex(Handle, index);
}
/// <summary>
/// 获取Webview的ID
/// </summary>
/// <returns></returns>
public int GetId()
{
return MBApi.wkeGetWebviewId(Handle);
}
/// <summary>
/// 根据Webview的ID判断是否活动Webview
/// </summary>
/// <param name="webViewId"></param>
/// <returns></returns>
public bool IsWebviewAlive(int webViewId)
{
return MBApi.wkeIsWebviewAlive(Handle, webViewId) != 0;
}
/// <summary>
/// 获取文档完成URL
/// </summary>
/// <param name="frameId">框架ID</param>
/// <param name="partialURL"></param>
/// <returns></returns>
public string GetDocumentCompleteURL(IntPtr frameId, string partialURL)
{
byte[] utf8 = Encoding.UTF8.GetBytes(partialURL);
return MBApi.wkeGetDocumentCompleteURL(Handle, frameId, utf8).UTF8PtrToStr();
}
/// <summary>
/// 获取当前URL
/// </summary>
public string GetURL()
{
IntPtr pUrl = MBApi.wkeGetURL(Handle);
if (pUrl != IntPtr.Zero)
return pUrl.UTF8PtrToStr();
return string.Empty;
}
/// <summary>
/// 获取指定框架的URL
/// </summary>
/// <param name="FrameId">框架ID</param>
/// <returns></returns>
public string GetFrameURL(IntPtr FrameId)
{
IntPtr pUrl = MBApi.wkeGetFrameUrl(Handle, FrameId);
if (pUrl != IntPtr.Zero)
return pUrl.UTF8PtrToStr();
return string.Empty;
}
/// <summary>
/// 垃圾回收
/// </summary>
/// <param name="delayMs">延迟的毫秒数</param>
public void GC(int delayMs)
{
MBApi.wkeGC(Handle, delayMs);
}
/// <summary>
/// 设置当前WebView的代理
/// </summary>
/// <param name="proxy"></param>
public void SetViewProxy(wkeProxy proxy)
{
MBApi.wkeSetViewProxy(Handle, ref proxy);
}
/// <summary>
/// 休眠
/// </summary>
public void Sleep()
{
MBApi.wkeSleep(Handle);
}
/// <summary>
/// 唤醒
/// </summary>
public void Wake()
{
MBApi.wkeWake(Handle);
}
/// <summary>
/// 设置UserAgent
/// </summary>
/// <param name="UserAgent"></param>
public void SetUserAgent(string UserAgent)
{
MBApi.wkeSetUserAgentW(Handle, UserAgent);
}
/// <summary>
/// 获取UserAgent
/// </summary>
/// <returns></returns>
public string GetUserAgent()
{
IntPtr pstr = MBApi.wkeGetUserAgent(Handle);
if (pstr != IntPtr.Zero)
{
return pstr.UTF8PtrToStr();
}
return string.Empty;
}
/// <summary>
/// 后退
/// </summary>
public bool GoBack()
{
return MBApi.wkeGoBack(Handle) != 0;
}
/// <summary>
/// 前进
/// </summary>
public bool GoForward()
{
return MBApi.wkeGoForward(Handle) != 0;
}
/// <summary>
/// 全选
/// </summary>
public void EditorSelectAll()
{
MBApi.wkeEditorSelectAll(Handle);
}
/// <summary>
/// 取消选择
/// </summary>
public void EditorUnSelect()
{
MBApi.wkeEditorUnSelect(Handle);
}
/// <summary>
/// 复制
/// </summary>
public void EditorCopy()
{
MBApi.wkeEditorCopy(Handle);
}
/// <summary>
/// 剪切
/// </summary>
public void EditorCut()
{
MBApi.wkeEditorCut(Handle);
}
/// <summary>
/// 粘贴
/// </summary>
public void EditorPaste()
{
MBApi.wkeEditorPaste(Handle);
}
/// <summary>
/// 删除
/// </summary>
public void EditorDelete()
{
MBApi.wkeEditorDelete(Handle);
}
/// <summary>
/// 撤销
/// </summary>
public void EditorUndo()
{
MBApi.wkeEditorUndo(Handle);
}
/// <summary>
/// 重做
/// </summary>
public void EditorRedo()
{
MBApi.wkeEditorRedo(Handle);
}
/// <summary>
/// 获取Cookie
/// </summary>
/// <returns></returns>
public string GetCookie()
{
IntPtr pStr = MBApi.wkeGetCookieW(Handle);
if (pStr != IntPtr.Zero)
{
return Marshal.PtrToStringUni(pStr);
}
return string.Empty;
}
/// <summary>
/// 设置Cookie
/// </summary>
/// <param name="Url"></param>
/// <param name="Cookie">cookie格式必须是:Set-cookie: PRODUCTINFO=webxpress; domain=.fidelity.com; path=/; secure</param>
public void SetCookie(string Url, string Cookie)
{
byte[] url = Encoding.UTF8.GetBytes(Url);
byte[] cookie = Encoding.UTF8.GetBytes(Cookie);
MBApi.wkeSetCookie(Handle, url, cookie);
}
/// <summary>
/// 设置Cookie目录
/// </summary>
/// <param name="Path"></param>
public void SetCookieJarPath(string Path)
{
MBApi.wkeSetCookieJarPath(Handle, Path);
}
/// <summary>
/// 设置Cookie全路径，包含文件名
/// </summary>
/// <param name="FileName"></param>
public void SetCookieJarFullPath(string FileName)
{
MBApi.wkeSetCookieJarFullPath(Handle, FileName);
}
/// <summary>
/// 设置 LocalStorage 目录
/// </summary>
/// <param name="Path"></param>
public void SetLocalStorageFullPath(string Path)
{
MBApi.wkeSetLocalStorageFullPath(Handle, Path);
}
/// <summary>
/// 添加插件目录
/// </summary>
/// <param name="Path"></param>
public void AddPluginDirectory(string Path)
{
MBApi.wkeAddPluginDirectory(Handle, Path);
}
/// <summary>
/// 获得焦点
/// </summary>
public void SetFocus()
{
MBApi.wkeSetFocus(Handle);
}
/// <summary>
/// 失去焦点
/// </summary>
public void KillFocus()
{
MBApi.wkeKillFocus(Handle);
}
/// <summary>
/// 运行JS
/// </summary>
/// <param name="JavaScript">脚本,如果需要返回值，则需要 return</param>
/// <returns></returns>
public object RunJS(string JavaScript)
{
long jsValue = MBApi.wkeRunJSW(Handle, JavaScript);
return ToNetValue(jsValue);
}
/// <summary>
/// 执行页面中的js函数
/// </summary>
/// <param name="strFuncName"></param>
/// <param name="param"></param>
/// <returns></returns>
public object CallJsFunc(string strFuncName, params object[] param)
{
IntPtr es = MBApi.wkeGlobalExec(Handle);
var args = param.Select(arg => ToJsValue(arg)).ToArray();
long jsValue = MBApi.jsCall(es, MBApi.jsGetGlobal(es, strFuncName), MBApi.jsUndefined(), args, args.Length);
return ToNetValue(jsValue);
}
/// <summary>
/// 将js中的函数绑定到c#的函数，用于实现js调用c#
/// </summary>
/// <param name="name"></param>
/// <param name="fn"></param>
/// <param name="argCount"></param>
public void BindFunction(string name, wkeJsNativeFunction fn, uint argCount = 0)
{
MBApi.wkeJsBindFunction(name, fn, IntPtr.Zero, argCount);
}
/// <summary>
/// 在指定框架运行JS
/// </summary>
/// <param name="FrameId">框架ID</param>
/// <param name="JavaScript">脚本</param>
/// <param name="IsInClosure">是否闭包</param>
/// <returns></returns>
public object RunJsByFrame(IntPtr FrameId, string JavaScript, bool IsInClosure = false)
{
byte[] utf8 = Encoding.UTF8.GetBytes(JavaScript);
return MBApi.wkeRunJsByFrame(Handle, FrameId, utf8, IsInClosure);
}
/// <summary>
/// 全局执行
/// </summary>
/// <returns>返回全局 jsExecState</returns>
public IntPtr GlobalExec()
{
return MBApi.wkeGlobalExec(Handle);
}
/// <summary>
/// 获取指定框架jsExecState
/// </summary>
/// <param name="FrameId">框架ID</param>
/// <returns>返回 jsExecState</returns>
public IntPtr GetGlobalExecByFrame(IntPtr FrameId)
{
return MBApi.wkeGetGlobalExecByFrame(Handle, FrameId);
}
/// <summary>
/// 在c#中封装一个js函数，用于下面的类型转换
/// </summary>
public class JsFunc
{
private string m_strName = null;
private WebView m_webView;
public JsFunc(WebView webView, long jsValue)
{
m_webView = webView;
IntPtr es = MBApi.wkeGlobalExec(m_webView.Handle);
m_strName = "func" + Guid.NewGuid().ToString().Replace("-", "");
MBApi.jsSetGlobal(es, m_strName, jsValue);
}
public object Invoke(params object[] param)
{
IntPtr es = MBApi.wkeGlobalExec(m_webView.Handle);
long value = MBApi.jsGetGlobal(es, m_strName);
long[] jsps = param.Select(i => m_webView.ToJsValue(i)).ToArray();
object result = m_webView.ToNetValue(MBApi.jsCall(es, value, MBApi.jsUndefined(), jsps, jsps.Length));
MBApi.jsSetGlobal(es, m_strName, MBApi.jsUndefined());
return result;
}
}
/// <summary>
/// 将js值转成c#值，参考凹大神的 https://gitee.com/aochulai/NetMiniblink
/// </summary>
/// <param name="value"></param>
/// <param name="bFunExecute">指定如果是函数是否执行该函数，如果执行，则返回函数执行的结果而不是函数本身</param>
/// <returns></returns>
public object ToNetValue(long value, bool bFunExecute = false)
{
jsType type = MBApi.jsTypeOf(value);
IntPtr es = MBApi.wkeGlobalExec(Handle);
switch (type)
{
case jsType.NULL:
case jsType.UNDEFINED:
{
return null;
}
case jsType.NUMBER:
{
return MBApi.jsToDouble(es, value);
}
case jsType.BOOLEAN:
{
return MBApi.jsToBoolean(es, value);
}
case jsType.STRING:
{
return MBApi.jsToTempStringW(es, value).UnicodePtrToStr();
}
case jsType.FUNCTION:
{
JsFunc function = new JsFunc(this, value);
if (bFunExecute)
{
return function.Invoke(); // 如果有参数一般是从另一个jsType传过来，具体情况具体分析
}
return function;
}
case jsType.ARRAY:
{
int len = MBApi.jsGetLength(es, value);
object[] array = new object[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = ToNetValue(MBApi.jsGetAt(es, value, i));
}
return array;
}
case jsType.OBJECT:
{
IntPtr ptr = MBApi.jsGetKeys(es, value);
jsKeys keys = (jsKeys)Marshal.PtrToStructure(ptr, typeof(jsKeys));
string[] strKeyArr = keys.keys.PtrToStringArray(keys.length);
ExpandoObject exp = new ExpandoObject();
IDictionary<string, object> map = (IDictionary<string, object>)exp;
foreach (string key in strKeyArr)
{
map.Add(key, ToNetValue(MBApi.jsGet(es, value, key)));
}
return map;
}
default:
{
throw new NotSupportedException();
}
}
}
// 定义一个通用的函数形式
public delegate object CommonFuncType(object[] param);
/// <summary>
/// 将c#值转成js值
/// </summary>
/// <param name="obj"></param>
/// <param name="bFunExecute">指定如果是函数是否执行该函数，如果执行则返回函数执行的结果，如果不执行则返回的是函数的参数，
/// 注意不是函数本身，这个和ToNetValue不一样，这是由于jsData结构定义导致的</param>
/// <returns></returns>
public long ToJsValue(object obj, bool bFunExecute = false)
{
IntPtr es = MBApi.wkeGlobalExec(Handle);
if (obj == null)
{
return MBApi.jsUndefined();
}
else if (obj is int)
{
return MBApi.jsInt((int)obj);
}
else if (obj is bool)
{
return MBApi.jsBoolean((bool)obj);
}
else if (obj is double)
{
return MBApi.jsDouble((double)obj);
}
else if (obj is long)
{
return ToJsValue(obj.ToString());
}
else if (obj is float)
{
return MBApi.jsFloat((float)obj);
}
else if (obj is DateTime)
{
return MBApi.jsDouble(((DateTime)obj).ToLong());
}
else if (obj is string)
{
return MBApi.jsStringW(es, obj.ToString());
}
else if (obj is decimal)
{
var dec = (decimal)obj;
if (dec.ToString().Contains("."))
{
return ToJsValue(Convert.ToDouble(dec.ToString()));
}
else
{
return ToJsValue(Convert.ToInt32(dec.ToString()));
}
}
else if (obj is IEnumerable)
{
List<object> list = new List<object>();
foreach (object item in (IEnumerable)obj)
{
list.Add(item);
}
long array = MBApi.jsEmptyArray(es);
MBApi.jsSetLength(es, array, list.Count);
for (int i = 0; i < list.Count; i++)
{
MBApi.jsSetAt(es, array, i, ToJsValue(list[i]));
}
return array;
}
else if (obj is Delegate)
{
Delegate func = (Delegate)obj;
IntPtr funcptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(jsData)));
jsData funcdata = new jsData
{
typeName = "function",
finalize = (ptr) =>
{
Marshal.FreeHGlobal(ptr);
},
callAsFunction = (fes, fobj, fargs, fcount) =>
{
if (func is CommonFuncType)
{
var fps = new List<object>();
for (var i = 0; i < fcount; i++)
{
fps.Add(ToNetValue(MBApi.jsArg(fes, i)));
}
if (bFunExecute)
{
return ToJsValue(((CommonFuncType)func)(fps.ToArray()));
}
return ToJsValue(fps.ToArray());
}
else // 如果传过来的不是动态参数，而是具体的参数
{
object[] fps = new object[func.Method.GetParameters().Length];
for (int i = 0; i < fcount && i < fps.Length; i++)
{
fps[i] = ToNetValue(MBApi.jsArg(fes, i));
}
if (bFunExecute)
{
return ToJsValue(func.Method.Invoke(func.Target, fps));
}
return ToJsValue(fps);
}
},
};
Marshal.StructureToPtr(funcdata, funcptr, false);
return MBApi.jsFunction(es, funcptr);
}
else
{
long jsobj = MBApi.jsEmptyObject(es);
PropertyInfo[] PropertyArr = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var ps in PropertyArr)
{
object oValue = ps.GetValue(obj, null);
if (oValue != null)
{
MBApi.jsSet(es, jsobj, ps.Name, ToJsValue(oValue));
}
}
return jsobj;
}
}
/// <summary>
/// 启用或禁用编辑模式
/// </summary>
/// <param name="editable"></param>
public void SetEditable(bool editable)
{
MBApi.wkeSetEditable(Handle, editable);
}
/// <summary>
/// 启用或禁用跨域检查
/// </summary>
/// <param name="enable"></param>
public void SetCspCheckEnable(bool enable)
{
MBApi.wkeSetCspCheckEnable(Handle, enable);
}
/// <summary>
/// 设置网络接口
/// </summary>
/// <param name="NetInterface"></param>
public void SetNetInterface(string NetInterface)
{
MBApi.wkeSetViewNetInterface(Handle, NetInterface);
}
/// <summary>
/// 截图
/// </summary>
/// <returns></returns>
public Bitmap PrintToBitmap()
{
if (Handle == IntPtr.Zero)
{
return null;
}
MBApi.wkeRunJSW(Handle, @"document.body.style.overflow='hidden'");
int w = MBApi.wkeGetContentWidth(Handle);
int h = MBApi.wkeGetContentHeight(Handle);
int oldwidth = MBApi.wkeGetWidth(Handle);
int oldheight = MBApi.wkeGetHeight(Handle);
MBApi.wkeResize(Handle, w, h);
Bitmap bmp = new Bitmap(w, h);
Rectangle rc = new Rectangle(0, 0, w, h);
System.Drawing.Imaging.BitmapData data = bmp.LockBits(rc, System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
MBApi.wkePaint(Handle, data.Scan0, 0);
bmp.UnlockBits(data);
MBApi.wkeResize(Handle, oldwidth, oldheight);
MBApi.wkeRunJSW(Handle, @"document.body.style.overflow='visible'");
return bmp;
}
/// <summary>
/// 设置调试配置
/// </summary>
/// <param name="debugString">"showDevTools" 是开启devtools功能，参数为：front_end/inspector.html(utf8编码)</param>
/// <param name="param"></param>
public void SetDebugConfig(string debugString, string param)
{
MBApi.wkeSetDebugConfig(Handle, debugString, Encoding.UTF8.GetBytes(param));
}
/// <summary>
/// 获取调试配置
/// </summary>
/// <param name="debugString"></param>
/// <returns></returns>
public string GetDebugConfig(string debugString)
{
return MBApi.wkeGetDebugConfig(Handle, debugString).UTF8PtrToStr();
}
/// <summary>
/// 设置上下文菜单项目是否显示
/// </summary>
/// <param name="item"></param>
/// <param name="isShow"></param>
public void SetContextMenuItemShow(wkeMenuItemId item, bool isShow)
{
MBApi.wkeSetContextMenuItemShow(Handle, item, isShow);
}
/// <summary>
/// 设置语言
/// </summary>
/// <param name="language"></param>
public void SetLanguage(string language)
{
MBApi.wkeSetLanguage(Handle, language);
}
/// <summary>
/// 设置设备参数
/// </summary>
/// <param name="device">如：“navigator.platform”</param>
/// <param name="paramStr"></param>
/// <param name="paramInt"></param>
/// <param name="paramFloat"></param>
public void SetDeviceParameter(string device, string paramStr, int paramInt = 0, float paramFloat = 0)
{
MBApi.wkeSetDeviceParameter(Handle, device, paramStr, paramInt, paramFloat);
}
/// <summary>
/// 显示DevTools窗口
/// </summary>
/// <param name="Path">路径</param>
/// <param name="Callback"></param>
public void ShowDevtools(string Path, wkeOnShowDevtoolsCallback Callback, IntPtr Param)
{
MBApi.wkeShowDevtools(Handle, Path, Callback, Param);
}
/// <summary>
/// 删除将发送请求的信息
/// </summary>
/// <param name="WillSendRequestInfoPtr"></param>
public void DeleteWillSendRequestInfo(IntPtr WillSendRequestInfoPtr)
{
MBApi.wkeDeleteWillSendRequestInfo(Handle, WillSendRequestInfoPtr);
}
/// <summary>
/// 在指定框架插入CSS
/// </summary>
/// <param name="FrameId">框架ID</param>
/// <param name="cssText"></param>
public void InsertCSSByFrame(IntPtr FrameId, string cssText)
{
byte[] utf8 = Encoding.UTF8.GetBytes(cssText);
MBApi.wkeInsertCSSByFrame(Handle, FrameId, utf8);
}
/// <summary>
/// 序列化到MHTML
/// </summary>
/// <returns></returns>
public string SerializeToMHTML()
{
return MBApi.wkeUtilSerializeToMHTML(Handle).UTF8PtrToStr();
}
/// <summary>
/// 获取网页HTML
/// </summary>
/// <returns></returns>
public string GetSource()
{
return MBApi.wkeGetSource(Handle).UTF8PtrToStr();
}
/// <summary>
/// 设置视图配置，可设置尺寸和背景色
/// </summary>
/// <param name="settings"></param>
public void SetViewSettings(wkeViewSettings settings)
{
MBApi.wkeSetViewSettings(Handle, settings);
}
#endregion
#region 属性
/// <summary>
/// 获取 WebView 句柄
/// </summary>
public IntPtr Handle { get; private set; }
/// <summary>
/// 获取宿主窗口句柄
/// </summary>
public IntPtr HostHandle
{
get { return MBApi.wkeGetHostHWND(Handle); }
}
/// <summary>
/// 获取是否处于唤醒状态
/// </summary>
public bool IsWake
{
get { return MBApi.wkeIsAwake(Handle) != 0; }
}
/// <summary>
/// 获取是否正在载入
/// </summary>
public bool IsLoading
{
get { return MBApi.wkeIsLoading(Handle) != 0; }
}
/// <summary>
/// 获取是否载入失败
/// </summary>
public bool IsLoadingFailed
{
get { return MBApi.wkeIsLoadingFailed(Handle) != 0; }
}
/// <summary>
/// 获取是否载入完成
/// </summary>
public bool IsLoadingCompleted
{
get { return MBApi.wkeIsLoadingCompleted(Handle) != 0; }
}
/// <summary>
/// 获取文档是否就绪
/// </summary>
public bool IsDocumentReady
{
get { return MBApi.wkeIsDocumentReady(Handle) != 0; }
}
/// <summary>
/// 获取标题
/// </summary>
public string Title
{
get
{
IntPtr pTitle = MBApi.wkeGetTitleW(Handle);
if (pTitle != IntPtr.Zero)
{
return Marshal.PtrToStringUni(pTitle);
}
return string.Empty;
}
}
/// <summary>
/// 获取宽度
/// </summary>
public int Width
{
get { return MBApi.wkeGetWidth(Handle); }
}
/// <summary>
/// 获取高度
/// </summary>
public int Height
{
get { return MBApi.wkeGetHeight(Handle); }
}
/// <summary>
/// 获取内容宽度
/// </summary>
public int ContentWidth
{
get { return MBApi.wkeGetContentWidth(Handle); }
}
/// <summary>
/// 获取内容高度
/// </summary>
public int ContentHeight
{
get { return MBApi.wkeGetContentHeight(Handle); }
}
/// <summary>
/// 是否透明
/// </summary>
public bool Transparent
{
get { return m_bTransparent; }
set
{
m_bTransparent = value;
MBApi.wkeSetTransparent(Handle, value);
}
}
/// <summary>
/// 获取是否能后退操作
/// </summary>
public bool CanGoBack
{
get { return MBApi.wkeCanGoBack(Handle) != 0; }
}
/// <summary>
/// 获取是否能前进操作
/// </summary>
public bool CanGoForward
{
get { return MBApi.wkeCanGoForward(Handle) != 0; }
}
/// <summary>
/// 获取或设置Cookie引擎是否启用
/// </summary>
public bool CookieEnabled
{
get { return MBApi.wkeIsCookieEnabled(Handle) != 0; }
set { MBApi.wkeSetCookieEnabled(Handle, value); }
}
/// <summary>
/// 获取或设置媒体音量
/// </summary>
public float MediaVolume
{
get { return MBApi.wkeGetMediaVolume(Handle); }
set { MBApi.wkeSetMediaVolume(Handle, value); }
}
/// <summary>
/// 获取或设置缩放因子
/// </summary>
public float ZoomFactor
{
get { return MBApi.wkeGetZoomFactor(Handle); }
set { MBApi.wkeSetZoomFactor(Handle, value); }
}
/// <summary>
/// 获取主框架句柄
/// </summary>
public IntPtr MainFrame
{
get { return MBApi.wkeWebFrameGetMainFrame(Handle); }
}
/// <summary>
/// 获取或设置光标类型
/// </summary>
public wkeCursorStyle CursorInfoType
{
get { return MBApi.wkeGetCursorInfoType(Handle); }
set { MBApi.wkeSetCursorInfoType(Handle, value); }
}
/// <summary>
/// 设置是否启用内存缓存
/// </summary>
/// <param name="Enable"></param>
public bool MemoryCacheEnable
{
set { MBApi.wkeSetMemoryCacheEnable(Handle, value); }
}
/// <summary>
/// 设置是否导航到新窗口
/// </summary>
/// <param name="enable">如果为false 则不会弹出新窗口</param>
public bool NavigationToNewWindowEnable
{
set { MBApi.wkeSetNavigationToNewWindowEnable(Handle, value); }
}
/// <summary>
/// 设置是否启用触摸
/// </summary>
public bool TouchEnable
{
set { MBApi.wkeSetTouchEnabled(Handle, value); }
}
/// <summary>
/// 设置是否启用 NPAPI 插件
/// </summary>
public bool NpapiPluginsEnabled
{
set { MBApi.wkeSetNpapiPluginsEnabled(Handle, value); }
}
/// <summary>
/// 设置是否启用无头模式，可以关闭渲染
/// </summary>
public bool HeadlessEnabled
{
set { MBApi.wkeSetHeadlessEnabled(Handle, value); }
}
/// <summary>
/// 设置是否启用拖拽，可关闭拖拽文件加载网页
/// </summary>
public bool DragEnable
{
set { MBApi.wkeSetDragEnable(Handle, value); }
}
/// <summary>
/// 设置或获取是否禁用鼠标
/// </summary>
public bool MouseEnabled
{
get { return m_bMouseEnabled; }
set { MBApi.wkeSetMouseEnabled(Handle, value); }
}
/// <summary>
/// 可关闭拖拽到其他进程
/// </summary>
public bool DragDropEnable
{
set { MBApi.wkeSetDragDropEnable(Handle, value); }
}
/// <summary>
/// 设置资源回收间隔
/// </summary>
public int ResourceGc
{
set { MBApi.wkeSetResourceGc(Handle, value); }
}
/// <summary>
/// 获取是否真正处理手势
/// </summary>
public bool IsProcessingUserGesture
{
get { return MBApi.wkeIsProcessingUserGesture(Handle) != 0; }
}
#endregion
}
#region 事件参数
public class MiniblinkEventArgs : EventArgs
{
public IntPtr Handle { get; }
public MiniblinkEventArgs(IntPtr webView)
{
Handle = webView;
}
}
/// <summary>
/// OnMouseOverUrlChanged 事件参数
/// </summary>
public class MouseOverUrlChangedEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public MouseOverUrlChangedEventArgs(IntPtr webView, IntPtr url) : base(webView)
{
m_url = url;
}
public string URL
{
get { return MBApi.wkeGetStringW(m_url).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnTitleChange 事件参数
/// </summary>
public class TitleChangeEventArgs : MiniblinkEventArgs
{
private IntPtr m_title;
public TitleChangeEventArgs(IntPtr webView, IntPtr title) : base(webView)
{
m_title = title;
}
public string Title
{
get { return MBApi.wkeGetStringW(m_title).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnUrlChange 事件参数
/// </summary>
public class UrlChangeEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public UrlChangeEventArgs(IntPtr webView, IntPtr url, IntPtr webFrame) : base(webView)
{
m_url = url;
WebFrame = webFrame;
}
public string URL
{
get { return MBApi.wkeGetStringW(m_url).UnicodePtrToStr(); }
}
public IntPtr WebFrame { get; }
}
/// <summary>
/// OnAlertBox事件参数
/// </summary>
public class AlertBoxEventArgs : MiniblinkEventArgs
{
private IntPtr m_msg;
public AlertBoxEventArgs(IntPtr webView, IntPtr msg) : base(webView)
{
m_msg = msg;
}
public string Msg
{
get { return MBApi.wkeGetStringW(m_msg).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnConfirmBox事件参数
/// </summary>
public class ConfirmBoxEventArgs : MiniblinkEventArgs
{
private IntPtr m_msg;
public bool Result { get; set; }
public ConfirmBoxEventArgs(IntPtr webView, IntPtr msg) : base(webView)
{
m_msg = msg;
}
public string Msg
{
get { return MBApi.wkeGetStringW(m_msg).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnPromptBox事件参数
/// </summary>
public class PromptBoxEventArgs : MiniblinkEventArgs
{
private IntPtr m_msg;
private IntPtr m_defaultStr;
private IntPtr m_resultStr;
public PromptBoxEventArgs(IntPtr webView, IntPtr msg, IntPtr defaultResult, IntPtr result) : base(webView)
{
m_msg = msg;
m_defaultStr = defaultResult;
m_resultStr = result;
}
public bool Result { get; set; }
public string Msg
{
get { return MBApi.wkeGetStringW(m_msg).UnicodePtrToStr(); }
}
public string DefaultResultString
{
get { return MBApi.wkeGetStringW(m_defaultStr).UnicodePtrToStr(); }
}
public string ResultString
{
set { MBApi.wkeSetStringW(m_resultStr, value, value.Length); }
}
}
/// <summary>
/// OnNavigate事件参数
/// </summary>
public class NavigateEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public NavigateEventArgs(IntPtr webView, wkeNavigationType navigationType, IntPtr url) : base(webView)
{
NavigationType = navigationType;
m_url = url;
}
public wkeNavigationType NavigationType { get; }
public bool Cancel { get; set; }
public string URL
{
get { return MBApi.wkeGetStringW(m_url).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnCreateView事件参数
/// </summary>
public class CreateViewEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
private IntPtr m_windowFeatures;
public CreateViewEventArgs(IntPtr webView, wkeNavigationType navigationType, IntPtr url, IntPtr windowFeatures) : base(webView)
{
NavigationType = navigationType;
m_url = url;
m_windowFeatures = windowFeatures;
NewWebViewHandle = webView;
}
public wkeNavigationType NavigationType { get; }
public IntPtr NewWebViewHandle { get; set; }
public string URL
{
get { return MBApi.wkeGetStringW(m_url).UnicodePtrToStr(); }
}
public wkeWindowFeatures WindowFeatures
{
get { return (wkeWindowFeatures)m_windowFeatures.UTF8PtrToStruct(typeof(wkeWindowFeatures)); }
}
}
/// <summary>
/// OnDocumentReady
/// </summary>
public class DocumentReadyEventArgs : MiniblinkEventArgs
{
public DocumentReadyEventArgs(IntPtr webView, IntPtr frame) : base(webView)
{
Frame = frame;
}
public IntPtr Frame { get; }
}
/// <summary>
/// OnLoadingFinish事件参数
/// </summary>
public class LoadingFinishEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
private IntPtr m_failedReason;
public LoadingFinishEventArgs(IntPtr webView, IntPtr url, wkeLoadingResult result, IntPtr failedReason) : base(webView)
{
m_url = url;
LoadingResult = result;
m_failedReason = failedReason;
}
public wkeLoadingResult LoadingResult { get; }
public string URL
{
get { return MBApi.wkeGetStringW(m_url).UnicodePtrToStr(); }
}
public string FailedReason
{
get { return MBApi.wkeGetStringW(m_failedReason).UnicodePtrToStr(); }
}
}
/// <summary>
/// OnDownload事件参数
/// </summary>
public class DownloadEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public DownloadEventArgs(IntPtr webView, IntPtr url) : base(webView)
{
m_url = url;
}
public string SaveFilePath { get; set; }
public bool Cancel { get; set; }
public long ContentLength { get; set; }
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public event EventHandler<DownloadProgressEventArgs> Progress;
public void OnProgress(DownloadProgressEventArgs e)
{
Progress?.Invoke(this, e);
}
public event EventHandler<DownloadFinishEventArgs> Finish;
public void OnFinish(DownloadFinishEventArgs e)
{
Finish?.Invoke(this, e);
}
}
/// <summary>
/// OnDownload2事件参数，貌似有问题，经常报“c#尝试读取或写入受保护的内存。这通常指示其他内存已损坏”
/// </summary>
public class DownloadEventArgs2 : MiniblinkEventArgs
{
private IntPtr m_url;
private IntPtr m_mime;
private IntPtr m_disposition;
private IntPtr m_dataBind;
public DownloadEventArgs2(IntPtr webView, IntPtr param, uint expectedContentLength, IntPtr url, IntPtr mime, IntPtr disposition, IntPtr job, IntPtr dataBind) : base(webView)
{
m_url = url;
m_mime = mime;
m_disposition = disposition;
m_dataBind = dataBind;
ContentLength = expectedContentLength;
Job = job;
}
public string SaveFilePath { get; set; }
public bool Cancel { get; set; }
public long ContentLength { get; set; }
public IntPtr Job { get; }
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public string Mime
{
get { return m_mime.UTF8PtrToStr(); }
}
public string Disposition
{
get { return m_disposition.UTF8PtrToStr(); }
}
public string DataBind
{
get { return m_dataBind.UTF8PtrToStr(); }
}
public event EventHandler<DownloadProgressEventArgs> Progress;
public void OnProgress(DownloadProgressEventArgs e)
{
Progress?.Invoke(this, e);
}
public event EventHandler<DownloadFinishEventArgs> Finish;
public void OnFinish(DownloadFinishEventArgs e)
{
Finish?.Invoke(this, e);
}
}
/// <summary>
/// 下载过程事件参数
/// </summary>
public class DownloadProgressEventArgs : EventArgs
{
public long Total { get; set; }
public long Received { get; set; }
public byte[] Data { get; set; }
public bool Cancel { get; set; }
}
/// <summary>
/// 下载完成事件参数
/// </summary>
public class DownloadFinishEventArgs : EventArgs
{
public Exception Error { get; set; }
public bool IsCompleted { get; set; }
}
/// <summary>
/// OnConsole事件参数
/// </summary>
public class ConsoleEventArgs : MiniblinkEventArgs
{
private IntPtr m_message;
private IntPtr m_sourceName;
private IntPtr m_stackTrace;
public ConsoleEventArgs(IntPtr webView, wkeConsoleLevel level, IntPtr message, IntPtr sourceName, uint sourceLine, IntPtr stackTrace) : base(webView)
{
Level = level;
m_message = message;
m_sourceName = sourceName;
SourceLine = sourceLine;
m_stackTrace = stackTrace;
}
public wkeConsoleLevel Level { get; }
public uint SourceLine { get; }
public string Message
{
get { return MBApi.wkeGetStringW(m_message).UTF8PtrToStr(); }
}
public string SourceName
{
get { return MBApi.wkeGetStringW(m_sourceName).UTF8PtrToStr(); }
}
public string StackTrace
{
get { return MBApi.wkeGetStringW(m_stackTrace).UTF8PtrToStr(); }
}
}
/// <summary>
/// OnLoadUrlBegin事件参数
/// </summary>
public class LoadUrlBeginEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public LoadUrlBeginEventArgs(IntPtr webView, IntPtr url, IntPtr job) : base(webView)
{
m_url = url;
Job = job;
}
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public IntPtr Job { get; }
public bool Cancel { get; set; }
}
/// <summary>
/// OnLoadUrlEnd事件参数
/// </summary>
public class LoadUrlEndEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
private IntPtr m_buf;
public LoadUrlEndEventArgs(IntPtr webView, IntPtr url, IntPtr job, IntPtr buf, int len) : base(webView)
{
m_url = url;
Job = job;
m_buf = buf;
Len = len;
}
public IntPtr Job { get; }
public int Len { get; }
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public byte[] Data
{
get { return m_buf.StructToBytes(); }
set { m_buf = Data.ByteToUtf8Ptr(); }
}
}
/// <summary>
/// OnLoadUrlFail事件参数
/// </summary>
public class LoadUrlFailEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public LoadUrlFailEventArgs(IntPtr webView, IntPtr url, IntPtr job) : base(webView)
{
m_url = url;
Job = job;
}
public IntPtr Job { get; }
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
}
/// <summary>
/// OnDidCreateScriptContext
/// </summary>
public class DidCreateScriptContextEventArgs : MiniblinkEventArgs
{
public DidCreateScriptContextEventArgs(IntPtr webView, IntPtr frame, IntPtr context, int extensionGroup, int worldId) : base(webView)
{
Frame = frame;
Context = context;
ExtensionGroup = extensionGroup;
WorldId = worldId;
}
public IntPtr Frame { get; }
public IntPtr Context { get; }
public int ExtensionGroup { get; }
public int WorldId { get; }
}
/// <summary>
/// OnWillReleaseScriptContext 事件参数
/// </summary>
public class WillReleaseScriptContextEventArgs : MiniblinkEventArgs
{
public WillReleaseScriptContextEventArgs(IntPtr webView, IntPtr frame, IntPtr context, int worldId) : base(webView)
{
Frame = frame;
Context = context;
WorldId = worldId;
}
public IntPtr Frame { get; }
public IntPtr Context { get; }
public int WorldId { get; }
}
/// <summary>
/// OnNetResponse 事件参数
/// </summary>
public class NetResponseEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
public NetResponseEventArgs(IntPtr webView, IntPtr url, IntPtr job) : base(webView)
{
m_url = url;
Job = job;
}
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public IntPtr Job { get; }
public bool Cancel { get; set; }
}
/// <summary>
/// OnWillMediaLoad 事件参数
/// </summary>
public class WillMediaLoadEventArgs : MiniblinkEventArgs
{
private IntPtr m_url;
private wkeMediaLoadInfo m_info;
public WillMediaLoadEventArgs(IntPtr webView, IntPtr url, IntPtr info) : base(webView)
{
m_url = url;
m_info = (wkeMediaLoadInfo)Marshal.PtrToStructure(info, typeof(wkeMediaLoadInfo));
}
public string URL
{
get { return m_url.UTF8PtrToStr(); }
}
public wkeMediaLoadInfo Info
{
get { return m_info; }
}
}
/// <summary>
/// OnOtherLoad 事件参数
/// </summary>
public class OtherLoadEventArgs : MiniblinkEventArgs
{
private wkeTempCallbackInfo m_info;
public OtherLoadEventArgs(IntPtr webView, wkeOtherLoadType type, IntPtr info) : base(webView)
{
LoadType = type;
m_info = (wkeTempCallbackInfo)Marshal.PtrToStructure(info, typeof(wkeTempCallbackInfo));
}
public wkeOtherLoadType LoadType { get; }
public int Size
{
get { return m_info.size; }
}
public IntPtr Frame
{
get { return m_info.frame; }
}
public wkeWillSendRequestInfo WillSendRequestInfo
{
get
{
wkeWillSendRequestInfo srInfo = new wkeWillSendRequestInfo();
if (m_info.willSendRequestInfo != IntPtr.Zero)
{
srInfo.isHolded = Marshal.ReadInt32(m_info.willSendRequestInfo) != 0;
IntPtr ptr = Marshal.ReadIntPtr(m_info.willSendRequestInfo, 4);
srInfo.url = MBApi.wkeGetStringW(ptr).UTF8PtrToStr();
ptr = Marshal.ReadIntPtr(m_info.willSendRequestInfo, 8);
srInfo.newUrl = MBApi.wkeGetStringW(ptr).UTF8PtrToStr();
srInfo.resourceType = (wkeResourceType)Marshal.ReadInt32(m_info.willSendRequestInfo, 12);
srInfo.httpResponseCode = Marshal.ReadInt32(m_info.willSendRequestInfo, 16);
ptr = Marshal.ReadIntPtr(m_info.willSendRequestInfo, 20);
srInfo.method = MBApi.wkeGetStringW(ptr).UTF8PtrToStr();
ptr = Marshal.ReadIntPtr(m_info.willSendRequestInfo, 24);
srInfo.referrer = MBApi.wkeGetStringW(ptr).UTF8PtrToStr();
srInfo.headers = Marshal.ReadIntPtr(m_info.willSendRequestInfo, 28);
}
return srInfo;
}
}
public IntPtr WillSendRequestInfoPtr
{
get { return m_info.willSendRequestInfo; }
}
}
/// <summary>
/// 窗口过程事件参数
/// </summary>
public class WindowProcEventArgs : EventArgs
{
public WindowProcEventArgs(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam)
{
Handle = hWnd;
Msg = msg;
this.wParam = wParam;
this.lParam = lParam;
}
public IntPtr Handle { get; }
public int Msg { get; }
public IntPtr wParam { get; }
public IntPtr lParam { get; }
public IntPtr Result { get; set; }
/// <summary>
/// 如果为 true 则会返回 Result ，false 则返回默认值
/// </summary>
public bool bHand { get; set; }
}
#endregion
}