From f8f8a22c53cdfa0e402903ccad4960a819138136 Mon Sep 17 00:00:00 2001 From: Cool <252858527@qq.com> Date: Fri, 11 Jan 2019 16:19:00 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=9E=E7=8E=B0=E7=99=BE=E5=BA=A6=E7=BD=91?= =?UTF-8?q?=E7=9B=98=E4=B8=8D=E5=B8=A6=E5=AF=86=E7=A0=81=E5=88=86=E4=BA=AB?= =?UTF-8?q?=E4=B8=8B=E8=BD=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 25 + BaiduCdp.rc | Bin 0 -> 4660 bytes BaiduCdp.sln | 22 + BaiduCdp.vcxproj | 105 ++++ BaiduCdp.vcxproj.filters | 62 ++ GlobalHeader.h | 18 + Http_Request.cpp | 336 ++++++++++ Http_Request.h | 119 ++++ PanParse.cpp | 882 +++++++++++++++++++++++++++ PanParse.h | 196 ++++++ WebsocketEx.cpp | 11 + WebsocketEx.h | 19 + WkeWindow.cpp | 1245 ++++++++++++++++++++++++++++++++++++++ WkeWindow.h | 258 ++++++++ base64.h | 130 ++++ main.cpp | 31 + resource.h | Bin 0 -> 1236 bytes wke.h | 1238 +++++++++++++++++++++++++++++++++++++ 18 files changed, 4697 insertions(+) create mode 100644 .gitignore create mode 100644 BaiduCdp.rc create mode 100644 BaiduCdp.sln create mode 100644 BaiduCdp.vcxproj create mode 100644 BaiduCdp.vcxproj.filters create mode 100644 GlobalHeader.h create mode 100644 Http_Request.cpp create mode 100644 Http_Request.h create mode 100644 PanParse.cpp create mode 100644 PanParse.h create mode 100644 WebsocketEx.cpp create mode 100644 WebsocketEx.h create mode 100644 WkeWindow.cpp create mode 100644 WkeWindow.h create mode 100644 base64.h create mode 100644 main.cpp create mode 100644 resource.h create mode 100644 wke.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..32ad2c6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +#忽略这些依赖的库文件可以到 +#发布页面下载https://github.com/cool2528/baiduCDP/releases +/.vs +/include +/lib +/LocalStorage + +#防止编译器生成的文件也上传 +/Debug +/Release +#这些都是vs项目生成的文件 +*.aps +*.suo +*.db +*.dll +*.lib +*.sdf +*.db +*.iobj +*.ipdb +*.ipch +*.1.tlog +*.log +*.pch +*.pdb \ No newline at end of file diff --git a/BaiduCdp.rc b/BaiduCdp.rc new file mode 100644 index 0000000000000000000000000000000000000000..19ebd1d1995af7d29ce6e934e235fd7234e90052 GIT binary patch literal 4660 zcmd^D%}x_h6h3Z^zJRNtY#_Ek`PUu&p-wE*$`pi1(ioxGh{Zrr5?#13ae;|3?syv? zz@^XPO7Z*7<=9SViin#@%w*=yoO|y1Ki|FW+0RLt6i-&9El=b?_T>urpRg~MfJlT~U>EJ#9y^C=hv;&M>cZ9bmc=zx{X>EA{o(Z`r*P&%n$5Bu_nB4>S zw(@3T>nG%?WR#mLN0qOo>nM9k>Jmyr)}$o9)TAk^QUfY%#%`tZ64KN*iQ=+n3dGxFygywdo(b+Ye$##L(-)Bw~qj1{d# zqc}cRY8l*R$wGDrz5=wlHG>@NVIMtQ2Zs-PeXJ@C_%=N2)U*!I?*CquuAKH;WBIjl zSZCWjN8WkFa2N(~z5w4ViVpnp&aY&&-IA$u#4RIoy*Lv~uA(Ce9f%ZJ;7?#a+x=62`=<&2rSA=XAZ(LRw^_hpe}CuiwWWZ&dTc z$7~7RzK)tAR@Csty@osR5<0Y|{k{Rpl=ilJPGc{c(eFH}bw;If=ibB$w>pGO;z0u) z&fU8K3B;Wes7-V~^-%sYv@YSBt9tW9g$>Ziy@|Vjj(A3SwAaxes?0iM)`2|r2(<|5 zb#U`M5vZL}iii6Ae)9R_&Vvu9Urw$a=OicdGV<)}r*9|kUf$ikRde;*^I}o`&cJ5c z73!Y7rzfcrp1Y7o44g&0`Xe?a$A}c8p4`2RJiS`QSjGCmE2DCmt)fPjI8CqkMKrBI zYX;VI_4LLwAMFTnHKEZ5?}|nuD|cX97Wt!fd70Cv%b@9G+_}Q=!RR)c6~;$|cXg9R z?B*eH4)UofuhJLr>EbVN1g*b1MMoC<;a`Z+`8bz6h|}e z=!|0-HOE=%7_KY1a=AW^AnbvD4559N<77EDO9WX)PFb%!iO?=eTZq(&aj#;&f_jPb zPow(g6W6e+>X($yUmEO$8u$k-%A<#(8hSO>d;9(TU$^sxVScyQ5gs5l~|&nvTtp7Gtr lfBiMh^XA3BrY)9cLHb5oI2>O(_+Nql_r!lY$Ma4}zW~?D9_Ro7 literal 0 HcmV?d00001 diff --git a/BaiduCdp.sln b/BaiduCdp.sln new file mode 100644 index 0000000..9676ed1 --- /dev/null +++ b/BaiduCdp.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BaiduCdp", "BaiduCdp.vcxproj", "{34066ECC-24F2-4940-BB0B-1A119ACF43FE}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {34066ECC-24F2-4940-BB0B-1A119ACF43FE}.Debug|Win32.ActiveCfg = Debug|Win32 + {34066ECC-24F2-4940-BB0B-1A119ACF43FE}.Debug|Win32.Build.0 = Debug|Win32 + {34066ECC-24F2-4940-BB0B-1A119ACF43FE}.Release|Win32.ActiveCfg = Release|Win32 + {34066ECC-24F2-4940-BB0B-1A119ACF43FE}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/BaiduCdp.vcxproj b/BaiduCdp.vcxproj new file mode 100644 index 0000000..3983d4c --- /dev/null +++ b/BaiduCdp.vcxproj @@ -0,0 +1,105 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {34066ECC-24F2-4940-BB0B-1A119ACF43FE} + Win32Proj + BaiduCdp + + + + Application + true + v140_xp + Unicode + + + Application + false + v120 + true + Unicode + + + + + + + + + + + + + true + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;CURL_STATICLIB;D_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + false + e:\boost_1_67_0;.\include;%(AdditionalIncludeDirectories) + MultiThreadedDebug + + + Windows + true + E:\boost_1_67_0\lib32-msvc-14.0;.\lib + ws2_32.lib;wldap32.lib;Crypt32.lib;%(AdditionalDependencies) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/BaiduCdp.vcxproj.filters b/BaiduCdp.vcxproj.filters new file mode 100644 index 0000000..83c54eb --- /dev/null +++ b/BaiduCdp.vcxproj.filters @@ -0,0 +1,62 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {e8fec2f2-1e54-4228-a65b-4d83b388d88d} + + + + + 源文件 + + + 源文件 + + + BaiduParse + + + BaiduParse + + + + + 头文件 + + + 头文件 + + + 头文件 + + + BaiduParse + + + BaiduParse + + + BaiduParse + + + 头文件 + + + + + 资源文件 + + + \ No newline at end of file diff --git a/GlobalHeader.h b/GlobalHeader.h new file mode 100644 index 0000000..42cd546 --- /dev/null +++ b/GlobalHeader.h @@ -0,0 +1,18 @@ +#ifndef __GLOBALHEADER__ +#define __GLOBALHEADER__ +#include "wke.h" +#include +#include +#include +typedef struct { + wkeWebView window; + std::wstring url; +} Application; +#define MBDLL_NAME L"node.dll" +#define APP_NAME L"BaiduCdp" +#define CLOSE_MSG "close" +#define MAX_MSG "max" +#define MIN_MSG "min" +#define HOST_NAME "http://baiducdp.com" +extern Application app; +#endif diff --git a/Http_Request.cpp b/Http_Request.cpp new file mode 100644 index 0000000..ac1614c --- /dev/null +++ b/Http_Request.cpp @@ -0,0 +1,336 @@ +#include "Http_Request.h" +#include +#include +#ifdef _DEBUG +#pragma comment(lib,"libcurld.lib") +#else +#pragma comment(lib,"libcurl.lib") +#endif +HttpRequest::HttpRequest() +:m_CurlHandle(NULL), +headerList(nullptr), +m_Cookies("") +{ + try{ + CURLcode rcode = curl_global_init(CURL_GLOBAL_ALL); + if (rcode) + throw rcode; + m_CurlHandle = curl_easy_init(); + if (m_CurlHandle) + { + curl_easy_setopt(m_CurlHandle, CURLOPT_SSL_VERIFYPEER, false); // ֤ԷSSL֤ + curl_easy_setopt(m_CurlHandle, CURLOPT_SSL_VERIFYHOST, false); //֤֤ + } + } + catch (CURLcode& errCode) + { + //־ + throw std::runtime_error("LibCurl initialization environment failed"); + } +} + +HttpRequest::~HttpRequest() +{ + if (headerList) + { + curl_slist_free_all(headerList); + headerList = nullptr; + } + if (m_CurlHandle) + { + curl_easy_cleanup(m_CurlHandle); + m_CurlHandle = nullptr; + } + curl_global_cleanup(); //رcurl +} + +void HttpRequest::SetRequestHeader(const std::string strKey, const std::string strValue) +{ + std::string strRequestHeader(strKey + ":" + strValue); + headerList = curl_slist_append(headerList, strRequestHeader.c_str()); +} + +void HttpRequest::SetRequestHeader(RequestHeaderValue& HeaderValue) +{ + for (auto &v : HeaderValue) + { + std::string strRequestHeader(v.first + ":" + v.second); + headerList = curl_slist_append(headerList, strRequestHeader.c_str()); + } +} + +void HttpRequest::Send(RequestType Enumtype, const std::string strUrl,const std::string strPost) +{ + CURLcode dwCurlCode; + if (!m_CurlHandle)return; + m_Request.clear(); + m_ResponseHeader.clear(); + m_Cookies.clear(); + switch (Enumtype) + { + case GET: + { + AutoAddHeader(); + if (!CheckHeaderExist("Referer:")) + { + headerList = curl_slist_append(headerList, ("Referer:" + strUrl).c_str()); + } + //URL + curl_easy_setopt(m_CurlHandle, CURLOPT_URL, strUrl.c_str()); + curl_easy_setopt(m_CurlHandle, CURLOPT_HTTPHEADER, headerList); //ԶЭͷͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERFUNCTION, header_callback); //ûصЭͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERDATA, &m_ResponseHeader); + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEFUNCTION, read_callback); //дĻص + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEDATA, &m_Request); //շص + curl_easy_setopt(m_CurlHandle, CURLOPT_NOBODY, 0); //շص + dwCurlCode = curl_easy_perform(m_CurlHandle); + if (CURLE_OK != dwCurlCode) + { + //־ + } + m_Cookies = GetCookies(GetallResponseHeaders()); + + } + break; + case POST: + { + AutoAddHeader(); + if (!CheckHeaderExist("Referer:")) + { + headerList = curl_slist_append(headerList, ("Referer:" + strUrl).c_str()); + } + if (!CheckHeaderExist("Content-Type:")) + { + headerList = curl_slist_append(headerList, ("Content-Type: application/x-www-form-urlencoded")); + } + //URL + curl_easy_setopt(m_CurlHandle, CURLOPT_URL, strUrl.c_str()); + curl_easy_setopt(m_CurlHandle, CURLOPT_HTTPHEADER, headerList); //ԶЭͷͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_POSTFIELDSIZE, (long)strPost.length()); //Ҫ͵ݴС + curl_easy_setopt(m_CurlHandle, CURLOPT_POSTFIELDS, strPost.c_str()); //Ҫ͵ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERFUNCTION, header_callback); //ûصЭͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERDATA, &m_ResponseHeader); + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEFUNCTION, read_callback); //дĻص + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEDATA, &m_Request); //շص + curl_easy_setopt(m_CurlHandle, CURLOPT_NOBODY, 0); //շص + dwCurlCode = curl_easy_perform(m_CurlHandle); + if (CURLE_OK != dwCurlCode) + { + //־ + } + m_Cookies = GetCookies(GetallResponseHeaders()); + } + break; + case HEAD: + { + AutoAddHeader(); + if (!CheckHeaderExist("Referer:")) + { + headerList = curl_slist_append(headerList, ("Referer:" + strUrl).c_str()); + } + //URL + curl_easy_setopt(m_CurlHandle, CURLOPT_URL, strUrl.c_str()); + curl_easy_setopt(m_CurlHandle, CURLOPT_HTTPHEADER, headerList); //ԶЭͷͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERFUNCTION, header_callback); //ûصЭͷ + curl_easy_setopt(m_CurlHandle, CURLOPT_HEADERDATA, &m_ResponseHeader); + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEFUNCTION, read_callback); //дĻص + curl_easy_setopt(m_CurlHandle, CURLOPT_WRITEDATA, &m_Request); //շص + curl_easy_setopt(m_CurlHandle, CURLOPT_NOBODY, 1); //շص + dwCurlCode = curl_easy_perform(m_CurlHandle); + if (CURLE_OK != dwCurlCode) + { + //־ + } + m_Cookies = GetCookies(GetallResponseHeaders()); + } + default: + break; + } + if (headerList) + { + curl_slist_free_all(headerList); + headerList = nullptr; + } +} + +std::string HttpRequest::GetResponseText() +{ + std::string strResultText; + for (auto v: m_Request) + strResultText.append(1, v); + return strResultText; +} + +responseData HttpRequest::GetResponseBody() const +{ + return m_Request; +} + +std::string HttpRequest::GetallResponseHeaders() +{ + std::string strResultText; + for (auto v : m_ResponseHeader) + strResultText.append(1, v); + return strResultText; +} + +void HttpRequest::SetRequestCookies(const std::string strCookie) +{ + if (!m_CurlHandle)return; + curl_easy_setopt(m_CurlHandle, CURLOPT_COOKIE, strCookie.c_str()); + +} + +void HttpRequest::SetHttpRedirect(bool val) +{ + if (!m_CurlHandle)return; + curl_easy_setopt(m_CurlHandle, CURLOPT_FOLLOWLOCATION, (long)val); +} + +std::string HttpRequest::GetResponCookie() const +{ + return m_Cookies; +} + +void HttpRequest::AutoAddHeader() +{ + if (!headerList || !CheckHeaderExist("Accept:")) + { + headerList = curl_slist_append(headerList, "Accept:*/*"); + } + if (!CheckHeaderExist("Accept-Language:")) + { + headerList = curl_slist_append(headerList, "Accept-Language:zh-cn"); + } + if (!CheckHeaderExist("User-Agent:")) + { + headerList = curl_slist_append(headerList, "User-Agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36"); + } +} + +std::string HttpRequest::GetCookies(const std::string strHeader) +{ + std::string strResult, strTwoResult; + std::vector headerList; + std::set resultList; + if (!strHeader.empty()) + { + std::string split = strHeader + "\r\n"; + std::string strsub; + size_t pos = 0; + size_t npos = 0; + npos = split.find("\r\n", pos); + while (npos != std::string::npos) + { + strsub = split.substr(pos, npos - pos); + pos = npos + strlen("\r\n"); + npos = split.find("\r\n", pos); + headerList.push_back(strsub); + } + } + for (auto & v : headerList) + { + std::string strTmp; + int nPos = v.find("Set-Cookie:"); + if (nPos != std::string::npos) + { + std::string strTmp = v.substr(nPos + lstrlenA("Set-Cookie:"), v.length() - (nPos + lstrlenA("Set-Cookie:")));; + if (strTmp.at(strTmp.length() - 1) != ';') + { + strTmp += ";"; + } + strResult += strTmp; + } + } + headerList.clear(); + if (!strResult.empty()) + { + if (strResult.at(strResult.length() - 1) != ';') + strResult += ";"; + std::string split = strResult; + std::string strsub; + size_t pos = 0; + size_t npos = 0; + npos = split.find(";", pos); + while (npos != std::string::npos) + { + strsub = split.substr(pos, npos - pos); + pos = npos + strlen(";"); + npos = split.find(";", pos); + resultList.insert(strsub); + } + } + else + { + return strResult; + } + + for (auto& s : resultList) + strTwoResult += s + ";"; + return strTwoResult; +} + +std::vector HttpRequest::StrSplit(const std::string &str, const std::string &pattern) +{ + std::vector resultVec; + std::string split = str; + std::string strsub; + size_t pos = 0; + size_t npos = 0; + npos = split.find(pattern, pos); + while (npos != std::string::npos) + { + strsub = split.substr(pos, npos - pos); + pos = npos + pattern.length(); + npos = split.find(pattern, pos); + resultVec.push_back(strsub); + } + return resultVec; +} + +std::string HttpRequest::MergeCookie(const std::string wornCookie, const std::string newCookie) +{ + std::string strResult = wornCookie; + std::vector strCookieArr = StrSplit(newCookie, ";"); + for (auto v : strCookieArr) + { + int npos = std::string::npos; + if (strResult.find(v) == npos) + strResult += v + ";"; + } + return strResult; +} + +bool HttpRequest::CheckHeaderExist(const std::string strHeaderKey) +{ + bool isBresult = false; + struct curl_slist* TmpheaderList = headerList; + while (TmpheaderList) + { + std::string tmpHeaderstr = TmpheaderList->data; + if (tmpHeaderstr.find(strHeaderKey)!=std::string::npos) + { + isBresult = true; + break; + } + TmpheaderList = TmpheaderList->next; + } + return isBresult; +} + +size_t HttpRequest::header_callback(char *ptr, size_t size, size_t nmemb, void* userdata) +{ + size_t lsize = size * nmemb; + for (size_t i = 0; i < lsize; i++) + ((responseData*)userdata)->push_back(ptr[i]); + return lsize; +} + +size_t HttpRequest::read_callback(char *ptr, size_t size, size_t nmemb, void* userdata) +{ + size_t lsize = size * nmemb; + for (size_t i = 0; i < lsize; i++) + ((responseData*)userdata)->push_back(ptr[i]); + return lsize; +} + diff --git a/Http_Request.h b/Http_Request.h new file mode 100644 index 0000000..2a2abed --- /dev/null +++ b/Http_Request.h @@ -0,0 +1,119 @@ +#ifndef __HTTP_REQUEST__ +#define __HTTP_REQUEST__ +#include +#include +#include +#include +#include +/* + HTTPЭ + ʹlibcurl +*/ +typedef void* RequestResultPtr; +typedef std::vector responseData; +/* +http +*/ +typedef enum EnumRequestType +{ + GET, + POST, + HEAD +}RequestType; +/* +Эͷmap +*/ +typedef std::map RequestHeaderValue; +class HttpRequest +{ +public: + HttpRequest(); + ~HttpRequest(); + /* + Эͷ KEY value ʽ + key = "user-agent" + value = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36" + */ + void SetRequestHeader(const std::string strKey, const std::string strValue); + /* + Эͷ mapͷʽ + */ + void SetRequestHeader(RequestHeaderValue& HeaderValue); + /* + HTTP + Enumtype http + strPost Enumtype =POST ʱ + */ + void Send(RequestType Enumtype,const std::string strUrl,const std::string strPost=""); + /* + ȡȡhttpӦҳ + */ + std::string GetResponseText(); + /* + ȡȡhttpӦҳĶ image File + */ + responseData GetResponseBody() const; + /* + ȡhttpӦͷ + */ + std::string GetallResponseHeaders(); + /* + õcookie + */ + void SetRequestCookies(const std::string strCookie); + /* + ֹ߽ض + */ + void SetHttpRedirect(bool val); + /* + ȡķصcookies + */ + std::string GetResponCookie() const; + /* + ϲcookies + */ + std::string MergeCookie(const std::string wornCookie, const std::string newCookie); +private: + /*Ϊڲʹú*/ + /* + ԶЭͷ + */ + void AutoAddHeader(); + /* + ȡЭͷcookies + */ + std::string GetCookies(const std::string strHeader); + /* + ַָ + */ + std::vector StrSplit(const std::string &str, const std::string &pattern); + /* + 鿴ԶЭͷǷ + */ + bool CheckHeaderExist(const std::string strHeaderKey); + static size_t header_callback(char *ptr, size_t size, size_t nmemb, void* userdata); + static size_t read_callback(char *ptr, size_t size, size_t nmemb, void* userdata); +private: + /* + CURL + */ + CURL* m_CurlHandle; + /* + Ľ + */ + responseData m_Request; + /* + շصЭͷ + */ + responseData m_ResponseHeader; + /* + Эͷָ + */ + struct curl_slist* headerList; + /* + ڲcookie ûϲcookiesʹ + */ + std::string m_Cookies; +}; +#endif + diff --git a/PanParse.cpp b/PanParse.cpp new file mode 100644 index 0000000..4324884 --- /dev/null +++ b/PanParse.cpp @@ -0,0 +1,882 @@ +#include "PanParse.h" +#include +#include +#include +#include +#include +#include "base64.h" +#include "rapidjson/document.h" +#include "rapidjson/writer.h" +#include "rapidjson/stringbuffer.h" +#include "resource.h" +#pragma comment(lib,"dbghelp.lib") +#pragma comment(lib,"shlwapi.lib") +std::string CBaiduParse::m_vcCodeUrl; +std::string CBaiduParse::m_VerCode; +DWORD CBaiduParse::WriteFileBuffer(std::string szFileNmae, PVOID pFileBuffer, DWORD dwFileSize) +{ + DWORD dwStates = -1; + std::string szFilePath, strName; + size_t npos = -1; + if (szFileNmae.empty()) + return dwStates; + npos = szFileNmae.rfind("\\"); + if (npos != std::string::npos) + { + szFilePath = szFileNmae.substr(0, npos + 1); + if (!szFilePath.empty()) + { + if (MakeSureDirectoryPathExists(szFilePath.c_str())) + { + HANDLE hFile = INVALID_HANDLE_VALUE; + DWORD dwError = NULL; + hFile = CreateFileA(szFileNmae.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + dwError = ::GetLastError(); + if (hFile != INVALID_HANDLE_VALUE) + { + ::WriteFile(hFile, pFileBuffer, dwFileSize, &dwStates, NULL); + /* CloseHandle(hFile); + ofstream file(szFileNmae, std::ios::out|std::ios::binary); + //file.open(szFileNmae,std::ios::out); + if (!file.is_open()) + return dwStates; + file.write((char*)pFileBuffer, dwFileSize); + file.close(); + dwStates = NULL;*/ + ::CloseHandle(hFile); + } + } + } + } + + return dwStates; +} +REQUESTINFO CBaiduParse::ParseBaiduAddr(const std::string strUrl, std::string& strCookies) +{ + HttpRequest BaiduHttp; + BAIDUREQUESTINFO BaiduInfo; + REQUESTINFO strRealUrl; + std::string strDownloadUrl; + std::string strResponseText; + BaiduHttp.SetRequestCookies(strCookies); + BaiduHttp.SetHttpRedirect(true); + BaiduHttp.Send(GET, strUrl); + strResponseText = BaiduHttp.GetResponseText(); + strResponseText = Utf8_To_Gbk(strResponseText.c_str()); + if (strResponseText.empty()) + return strRealUrl; + std::string strJson = GetTextMid(strResponseText, "yunData.setData(", ");"); + BaiduInfo = GetBaiduInfo(strJson); + strDownloadUrl = "https://pan.baidu.com/api/sharedownload?sign=" + BaiduInfo.sign + \ + "×tamp=" + BaiduInfo.timestamp + "&channel=chunlei&web=1&app_id=" + BaiduInfo.app_id + \ + "&bdstoken=" + BaiduInfo.bdstoken + "&logid=" + GetLogid() + "&clienttype=0"; + strCookies = BaiduHttp.MergeCookie(strCookies, BaiduHttp.GetResponCookie()); + strJson = "encrypt=0&product=share&uk=%1%&primaryid=%2%&fid_list=%%5B%3%%%5D&path_list="; + strJson = str(boost::format(strJson) % BaiduInfo.uk % BaiduInfo.shareid % BaiduInfo.fs_id); + /*׼ύݻȡʵURLַ*/ + BaiduHttp.SetRequestHeader("Content-Type", " application/x-www-form-urlencoded; charset=UTF-8"); + BaiduHttp.SetRequestHeader("Accept", " application/json, text/javascript, */*; q=0.01"); + BaiduHttp.SetRequestCookies(strCookies); + BaiduHttp.Send(POST, strDownloadUrl, strJson); + strJson = BaiduHttp.GetResponseText(); + rapidjson::Document dc; + dc.Parse(strJson.c_str()); + if (!dc.IsObject()) + return strRealUrl; + int nError = -1; + if (dc.HasMember("errno") && dc["errno"].IsInt()) + nError = dc["errno"].GetInt(); + if (!nError) + { + if (dc.HasMember("list") && dc["list"].IsArray()) + { + for (auto &v : dc["list"].GetArray()) + { + if (v.HasMember("dlink") && v["dlink"].IsString()) + strRealUrl.strDownloadUrl = v["dlink"].GetString(); + } + } + } + else + { + //Ҫ֤ + int index = 0; + do + { + if (index>5) + break; + strRealUrl.strDownloadUrl = GetBaiduAddr(BaiduInfo, strCookies); + index++; + } while (strRealUrl.strDownloadUrl.empty()); + } + BaiduHttp.Send(HEAD, strRealUrl.strDownloadUrl); + strRealUrl.strDownloadUrl = GetTextMid(BaiduHttp.GetallResponseHeaders(), "Location: ", "\r\n"); + strRealUrl.strFileName = BaiduInfo.server_filename; + strRealUrl.strCookies = strCookies; + return strRealUrl; +} +std::string CBaiduParse::GetBaiduAddr(BAIDUREQUESTINFO baiduinfo, const std::string strCookies) +{ + + std::string strRealUrl; + std::string strVcCode; + VERCODEINFO verCinfo = GetVerCodeinfo(baiduinfo, strCookies); + m_vcCodeUrl = verCinfo.image; + //ʾ֤봰 + ShowInputVerCodeDlg(); + HttpRequest BaiduHttp; + strVcCode = m_VerCode; + std::string strDownloadUrl = "https://pan.baidu.com/api/sharedownload?sign=" + baiduinfo.sign + \ + "×tamp=" + baiduinfo.timestamp + "&channel=chunlei&web=1&app_id=" + baiduinfo.app_id + \ + "&bdstoken=" + baiduinfo.bdstoken + "&logid=" + GetLogid() + "&clienttype=0"; + std::string strJson = "encrypt=0&product=share&vcode_input=%1%&vcode_str=%2%&uk=%3%&primaryid=%4%&fid_list=%%5B%5%%%5D"; + strJson = str(boost::format(strJson) % strVcCode % verCinfo.verCode % baiduinfo.uk % baiduinfo.shareid % baiduinfo.fs_id); + /*׼ύݻȡʵURLַ*/ + BaiduHttp.SetRequestHeader("Content-Type", " application/x-www-form-urlencoded; charset=UTF-8"); + BaiduHttp.SetRequestHeader("Accept", " application/json, text/javascript, */*; q=0.01"); + BaiduHttp.SetRequestCookies(strCookies); + BaiduHttp.Send(POST, strDownloadUrl, strJson); + strJson = BaiduHttp.GetResponseText(); + rapidjson::Document dc; + dc.Parse(strJson.c_str()); + if (!dc.IsObject()) + return strRealUrl; + int nError = -1; + if (dc.HasMember("errno") && dc["errno"].IsInt()) + nError = dc["errno"].GetInt(); + if (!nError) + { + if (dc.HasMember("list") && dc["list"].IsArray()) + { + for (auto &v : dc["list"].GetArray()) + { + if (v.HasMember("dlink") && v["dlink"].IsString()) + strRealUrl = v["dlink"].GetString(); + } + } + } + return strRealUrl; +} +VERCODEINFO CBaiduParse::GetVerCodeinfo(BAIDUREQUESTINFO baiduinfo, const std::string strCookies) +{ + VERCODEINFO result; + HttpRequest BaiduHttp; + std::string strJson; + std::string strVerCodeUrl = "https://pan.baidu.com/api/getvcode?prod=pan&t=0.48382518029895166&channel=chunlei&web=1&app_id=" + baiduinfo.app_id + "&bdstoken=" + baiduinfo.bdstoken + "&logid=" + GetLogid() + "&clienttype=0"; + BaiduHttp.SetRequestHeader("Accept", " application/json, text/javascript, */*; q=0.01"); + BaiduHttp.SetRequestHeader("Accept-Language", "zh-Hans-CN,zh-Hans;q=0.8,en-US;q=0.5,en;q=0.3"); + BaiduHttp.SetRequestCookies(strCookies); + BaiduHttp.Send(GET, strVerCodeUrl); + strJson = BaiduHttp.GetResponseText(); + rapidjson::Document dc; + dc.Parse(strJson.c_str()); + if (!dc.IsObject()) + return result; + if (dc.HasMember("img") && dc["img"].IsString()) + result.image = dc["img"].GetString(); + if (dc.HasMember("vcode") && dc["vcode"].IsString()) + result.verCode = dc["vcode"].GetString(); + return result; +} + +long long CBaiduParse::getTimeStamp() +{ + timeb t; + ftime(&t); + return t.time * 1000 + t.millitm; +} + +BAIDUREQUESTINFO CBaiduParse::GetBaiduInfo(const std::string strJson) +{ + BAIDUREQUESTINFO baiduInfo; + rapidjson::Document dc; + dc.Parse(strJson.c_str()); + if (!dc.IsObject()) + return baiduInfo; + if (dc.HasMember("bdstoken") && dc["bdstoken"].IsString()) + baiduInfo.bdstoken = dc["bdstoken"].GetString(); + if (dc.HasMember("shareid") && dc["shareid"].IsInt64()) + baiduInfo.shareid = std::to_string(dc["shareid"].GetInt64()); + if (dc.HasMember("uk") && dc["uk"].IsUint64()) + baiduInfo.uk = std::to_string(dc["uk"].GetUint64()); + if (dc.HasMember("sign") && dc["sign"].IsString()) + baiduInfo.sign = dc["sign"].GetString(); + if (dc.HasMember("timestamp") && dc["timestamp"].IsInt()) + baiduInfo.timestamp = std::to_string(dc["timestamp"].GetInt()); + if (dc.HasMember("file_list") && dc["file_list"].IsObject()) + { + rapidjson::Value file_list = dc["file_list"].GetObject(); + if (file_list.HasMember("list") && file_list["list"].IsArray()) + { + for (auto& v : file_list["list"].GetArray()) + { + if (v.HasMember("app_id") && v["app_id"].IsString()) + { + baiduInfo.app_id = v["app_id"].GetString(); + } + if (v.HasMember("server_filename") && v["server_filename"].IsString()) + { + baiduInfo.server_filename = v["server_filename"].GetString(); + } + if (v.HasMember("fs_id") && v["fs_id"].IsUint64()) + { + baiduInfo.fs_id = std::to_string(v["fs_id"].GetUint64()); + } + } + } + } + return baiduInfo; +} + +std::string CBaiduParse::Unicode_To_Ansi(const wchar_t* szbuff) +{ + std::string result; + CHAR* MultPtr = nullptr; + int MultLen = -1; + MultLen = ::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, szbuff, -1, NULL, NULL, NULL, NULL); + MultPtr = new CHAR[MultLen + 1]; + if (MultPtr) + { + ZeroMemory(MultPtr, MultLen + 1); + ::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, szbuff, -1, MultPtr, MultLen, NULL, NULL); + result = MultPtr; + delete[] MultPtr; + MultPtr = nullptr; + } + return result; +} + +std::wstring CBaiduParse::Ansi_To_Unicode(const char* szbuff) +{ + std::wstring result; + WCHAR* widePtr = nullptr; + int wideLen = -1; + wideLen = ::MultiByteToWideChar(CP_ACP, NULL, szbuff, -1, NULL, NULL); + widePtr = new WCHAR[wideLen + 1]; + if (widePtr) + { + ZeroMemory(widePtr, (wideLen + 1) * sizeof(WCHAR)); + ::MultiByteToWideChar(CP_ACP, NULL, szbuff, -1, widePtr, wideLen); + result = widePtr; + delete[] widePtr; + widePtr = nullptr; + } + return result; +} + +std::string CBaiduParse::Gbk_To_Utf8(const char* szBuff) +{ + std::string resault; + int widLen = 0; + int MultiLen = 0; + WCHAR* widPtr = nullptr; + CHAR* MulitPtr = nullptr; + widLen = ::MultiByteToWideChar(CP_ACP, NULL, szBuff, -1, NULL, NULL);//ȡתҪĿռ + widPtr = new WCHAR[widLen + 1]; + if (!widPtr) + return resault; + ZeroMemory(widPtr, (widLen + 1) * sizeof(WCHAR)); + if (!::MultiByteToWideChar(CP_ACP, NULL, szBuff, -1, widPtr, widLen)) + { + delete[] widPtr; + widPtr = nullptr; + return resault; + } + MultiLen = ::WideCharToMultiByte(CP_UTF8, NULL, widPtr, -1, NULL, NULL, NULL, NULL); + if (MultiLen) + { + MulitPtr = new CHAR[MultiLen + 1]; + if (!MulitPtr) + { + delete[] widPtr; + widPtr = nullptr; + return resault; + } + ZeroMemory(MulitPtr, (MultiLen + 1) * sizeof(CHAR)); + ::WideCharToMultiByte(CP_UTF8, NULL, widPtr, -1, MulitPtr, MultiLen, NULL, NULL); + resault = MulitPtr; + delete[] MulitPtr; + MulitPtr = nullptr; + } + delete[] widPtr; + widPtr = nullptr; + return resault; +} + +std::string CBaiduParse::Utf8_To_Gbk(const char* szBuff) +{ + std::string resault; + int widLen = 0; + int MultiLen = 0; + WCHAR* widPtr = nullptr; + CHAR* MulitPtr = nullptr; + widLen = ::MultiByteToWideChar(CP_UTF8, NULL, szBuff, -1, NULL, NULL);//ȡתҪĿռ + widPtr = new WCHAR[widLen + 1]; + if (!widPtr) + return resault; + ZeroMemory(widPtr, (widLen + 1) * sizeof(WCHAR)); + if (!::MultiByteToWideChar(CP_UTF8, NULL, szBuff, -1, widPtr, widLen)) + { + delete[] widPtr; + widPtr = nullptr; + return resault; + } + MultiLen = ::WideCharToMultiByte(CP_ACP, NULL, widPtr, -1, NULL, NULL, NULL, NULL); + if (MultiLen) + { + MulitPtr = new CHAR[MultiLen + 1]; + if (!MulitPtr) + { + delete[] widPtr; + widPtr = nullptr; + return resault; + } + ZeroMemory(MulitPtr, (MultiLen + 1) * sizeof(CHAR)); + ::WideCharToMultiByte(CP_ACP, NULL, widPtr, -1, MulitPtr, MultiLen, NULL, NULL); + resault = MulitPtr; + delete[] MulitPtr; + MulitPtr = nullptr; + } + delete[] widPtr; + widPtr = nullptr; + return resault; +} + + +std::string CBaiduParse::GetTextMid(const std::string strSource, const std::string strLeft, const std::string strRight) +{ + std::string strResult; + int nBeigin = 0, nEnd = 0, nLeft = 0; + if (strSource.empty())return strResult; + nBeigin = strSource.find(strLeft); + if (nBeigin == std::string::npos)return strResult; + nLeft = nBeigin + strLeft.length(); + nEnd = strSource.find(strRight, nLeft); + if (nEnd == std::string::npos) + { + strResult = strSource.substr(nLeft, strSource.length()); + return strResult; + } + strResult = strSource.substr(nLeft, nEnd - nLeft); + return strResult; +} + +std::string CBaiduParse::GetLogid(bool isFlag /*= true*/) +{ + std::string strResult; + srand(ULLONG_MAX); + CHAR szLogid[0x20]; + CHAR szTime[0x20]; + CHAR szResult[0x50]; + ZeroMemory(szLogid, 0x20); + ZeroMemory(szTime, 0X20); + ZeroMemory(szResult, 0X50); + sprintf_s(szLogid, "%I64u", labs(rand())); + sprintf_s(szTime, "%I64d", getTimeStamp()); + strcat_s(szResult, szTime); + strcat_s(szResult, "0."); + if (isFlag) + { + if (lstrlenA(szLogid) >= 16) + szLogid[16] = 0; + } + else + { + if (lstrlenA(szLogid) >= 16) + szLogid[17] = 0; + } + strcat_s(szResult, szLogid); + strResult = szResult; + strResult = aip::base64_encode(strResult.c_str(), strResult.length()); + return strResult; +} + +bool CBaiduParse::GetloginBassInfo(BaiduUserInfo& baseInfo, const std::string strCookie) +{ + HttpRequest BaiduHttp; + BaiduHttp.SetRequestCookies(strCookie); + BaiduHttp.Send(GET, HOME_URL); + std::string strResult(BaiduHttp.GetResponseText()); +// WriteFileBuffer(".\\1.txt", (char*)strResult.c_str(), strResult.length()); +// strResult = GetTextMid(strResult, "context=", ";\n var yunData"); + REGEXVALUE rv = GetRegexValue(strResult, "context=(.*?);\\s"); + if (rv.size() < 1) + return false; + strResult = rv.at(0); + //WriteFileBuffer(".\\2.txt", (char*)strResult.c_str(), strResult.length()); + rapidjson::Document dc; + dc.Parse(strResult.c_str()); + if (!dc.IsObject()) + return false; + if (dc.HasMember("bdstoken") && dc["bdstoken"].IsString()) + baseInfo.bdstoken = dc["bdstoken"].GetString(); + if (dc.HasMember("username") && dc["username"].IsString()) + baseInfo.strUserName = dc["username"].GetString(); + if (dc.HasMember("photo") && dc["photo"].IsString()) + baseInfo.strHeadImageUrl = dc["photo"].GetString(); + if (dc.HasMember("is_vip") && dc["is_vip"].IsInt()) + baseInfo.is_vip = dc["is_vip"].GetInt(); + return true; +} + +REGEXVALUE CBaiduParse::GetRegexValue(const std::string strvalue, const std::string strRegx) +{ + REGEXVALUE rvResult; + if (strvalue.empty() || strRegx.empty()) + return rvResult; + boost::regex expr(strRegx); + boost::smatch what; + if (boost::regex_search(strvalue, what, expr)) + { + size_t length = what.size(); + for (size_t i = 1; i < length;++i) + { + if (what[i].matched) + { + /* std::vectorval; + val.resize(what[i].str().length()); + memcpy(val.data(), &what[i].str()[1], what[i].str().length() - 2);*/ + rvResult.push_back(what[i].str()); + } + } + } + return rvResult; +} + +void CBaiduParse::ShowInputVerCodeDlg() +{ + ::DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_VERCODE), GetDesktopWindow(), ImageProc); +} + +std::string CBaiduParse::GetBaiduFileListInfo(const std::string& path, const std::string strCookie) +{ + std::string strResultJson; + FileTypeArray fileInfoResult; + std::string strFileUrl,strResult; + ZeroMemory(&fileInfoResult, sizeof(fileInfoResult)); + if (strCookie.empty() || path.empty()) + return strResultJson; + BaiduUserInfo userinfo; + if (!GetloginBassInfo(userinfo, strCookie)) + return strResultJson; + strFileUrl = str(boost::format(FILE_LIST_URL) % URL_Coding(path.c_str()).c_str() % userinfo.bdstoken % GetLogid() % std::to_string(getTimeStamp())); + HttpRequest BaiduHttp; + BaiduHttp.SetRequestCookies(strCookie); + BaiduHttp.Send(GET, strFileUrl); + strResult = BaiduHttp.GetResponseText(); + rapidjson::Document dc; + dc.Parse(strResult.c_str()); + if (!dc.IsObject()) + return strResultJson; + if (dc.HasMember("list") && dc["list"].IsArray()) + { + for (auto&v:dc["list"].GetArray()) + { + if (v.IsObject()) + { + BaiduFileInfo item; + if (v.HasMember("category") && v["category"].IsInt()) + item.nCategory = v["category"].GetInt(); + if (v.HasMember("isdir") && v["isdir"].IsInt()) + item.nisdir = v["isdir"].GetInt(); + if (v.HasMember("path") && v["path"].IsString()) + item.strPath = v["path"].GetString(); + if (v.HasMember("server_filename") && v["server_filename"].IsString()) + item.server_filename = v["server_filename"].GetString(); + if (v.HasMember("size") && v["size"].IsUint()) + item.size = v["size"].GetUint(); + if (v.HasMember("server_ctime") && v["server_ctime"].IsUint()) + item.server_ctime = v["server_ctime"].GetUint(); + if (v.HasMember("fs_id") && v["fs_id"].IsUint64()) + item.fs_id = std::to_string(v["fs_id"].GetUint64()); + if (!item.nisdir) + item.strFileType = ::PathFindExtensionA(Utf8_To_Gbk(item.server_filename.c_str()).c_str()); + fileInfoResult.push_back(item); + } + } + } + rapidjson::Document docjson; + docjson.SetObject(); + rapidjson::Value UsrName(rapidjson::kStringType); + UsrName.SetString(userinfo.strUserName.c_str(), userinfo.strUserName.length(), docjson.GetAllocator()); + docjson.AddMember(rapidjson::StringRef("UserName"), UsrName, docjson.GetAllocator()); + rapidjson::Value UsrHeaderImage(rapidjson::kStringType); + UsrHeaderImage.SetString(userinfo.strHeadImageUrl.c_str(), userinfo.strHeadImageUrl.length(), docjson.GetAllocator()); + docjson.AddMember(rapidjson::StringRef("UserHeader"), UsrHeaderImage, docjson.GetAllocator()); + rapidjson::Value array_list(rapidjson::kArrayType); + for (size_t i = 0; i < fileInfoResult.size();i++) + { + rapidjson::Value itemObject(rapidjson::kObjectType); + rapidjson::Value isdir(rapidjson::kNumberType); + isdir.SetInt(fileInfoResult[i].nisdir); + itemObject.AddMember(rapidjson::StringRef("isdir"), isdir, docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("name"), rapidjson::StringRef(fileInfoResult[i].server_filename.c_str()), docjson.GetAllocator()); + std::string strFilesize = GetFileSizeType(fileInfoResult[i].size); + rapidjson::Value FileSize(rapidjson::kStringType); + FileSize.SetString(strFilesize.c_str(), strFilesize.length(), docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("Size"), FileSize, docjson.GetAllocator()); + rapidjson::Value nCategory(rapidjson::kNumberType); + nCategory.SetInt(fileInfoResult[i].nCategory); + itemObject.AddMember(rapidjson::StringRef("nCategory"), nCategory, docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("path"), rapidjson::StringRef(fileInfoResult[i].strPath.c_str()), docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("FileType"), rapidjson::StringRef(fileInfoResult[i].strFileType.c_str()), docjson.GetAllocator()); + std::string strTime = timestampToDate(fileInfoResult[i].server_ctime); + rapidjson::Value FileTime(rapidjson::kStringType); + FileTime.SetString(strTime.c_str(), strTime.length(), docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("ChangeTime"), FileTime, docjson.GetAllocator()); + rapidjson::Value fs_id(rapidjson::kStringType); + fs_id.SetString(fileInfoResult[i].fs_id.c_str(), fileInfoResult[i].fs_id.length(), docjson.GetAllocator()); + itemObject.AddMember(rapidjson::StringRef("fs_id"), fs_id, docjson.GetAllocator()); + array_list.PushBack(itemObject, docjson.GetAllocator()); + + } + docjson.AddMember(rapidjson::StringRef("data"), array_list, docjson.GetAllocator()); + rapidjson::StringBuffer buffer; + rapidjson::Writer writer(buffer); + docjson.Accept(writer); + strResultJson = buffer.GetString(); + //WriteFileBuffer(".\\1.txt",(PVOID)strResultJson.c_str(), strResultJson.length()); + return strResultJson; +} + +std::string CBaiduParse::URL_Coding(const char* szSource, bool isletter /*= true*/, bool isUtf8 /*= true*/) +{ + CHAR szTemp[20]; + CHAR* buffer = nullptr; + std::string strBuffer; + std::string result; + std::string strTemp; + if (isUtf8) + strBuffer = Gbk_To_Utf8(szSource); + else + strBuffer = szSource; + int lens = strBuffer.length(); + buffer = new CHAR[lens + 1]; + if (!buffer)return result; + ZeroMemory(buffer, lens + 1); + memcpy(buffer, strBuffer.c_str(), lens); + for (int i = 0; i 44 && cbyte < 58 && 47 != cbyte) //0-9 + { + sprintf_s(szTemp, "%c", cbyte); + strTemp = szTemp; + result += strTemp; + } + else if (cbyte > 'A' && cbyte <= 'Z') //A-Z + { + sprintf_s(szTemp, "%c", cbyte); + strTemp = szTemp; + result += strTemp; + } + else if (cbyte > 'a' && cbyte <= 'z') //a-z + { + sprintf_s(szTemp, "%c", cbyte); + strTemp = szTemp; + result += strTemp; + } + else + { + sprintf_s(szTemp, "%02X", *(PBYTE)(buffer + i)); + strTemp = "%"; + strTemp += szTemp; + result += strTemp; + } + } + else + { + sprintf_s(szTemp, "%02X", *(PBYTE)(buffer + i)); + strTemp = "%"; + strTemp += szTemp; + result += strTemp; + } + } + delete[] buffer; + return result; +} + +std::string CBaiduParse::UnEscape(const char* strSource) +{ + std::string strResult; + int nDestStep = 0; + int nLength = strlen(strSource); + if (!nLength || nLength < 6) return strResult; + char* pResult = new char[nLength + 1]; + wchar_t* pWbuufer = nullptr; + if (!pResult) + { + pResult = NULL; + return strResult; + } + ZeroMemory(pResult, nLength + 1); + for (int nPos = 0; nPos < nLength; nPos++) + { + if (strSource[nPos] == '\\' && strSource[nPos + 1] == 'u') + { + char szTemp[5]; + char szSource[5]; + ZeroMemory(szTemp, 5); + ZeroMemory(szSource, 5); + CopyMemory(szSource, (char*)strSource + nPos + 2, 4); + sscanf_s(szSource, "%04X", szTemp); + CopyMemory(pResult + nDestStep, szTemp, 4); + nDestStep += 2; + } + } + nDestStep += 2; + pWbuufer = new wchar_t[nDestStep]; + if (!pWbuufer) + { + delete[] pWbuufer; + pWbuufer = nullptr; + return strResult; + } + ZeroMemory(pWbuufer, nDestStep); + CopyMemory(pWbuufer, pResult, nDestStep); + delete[] pResult; + pResult = nullptr; + CHAR* MultPtr = nullptr; + int MultLen = -1; + MultLen = ::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pWbuufer, -1, NULL, NULL, NULL, NULL); + MultPtr = new CHAR[MultLen + 1]; + if (MultPtr) + { + ZeroMemory(MultPtr, MultLen + 1); + ::WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pWbuufer, -1, MultPtr, MultLen, NULL, NULL); + strResult = MultPtr; + delete[] MultPtr; + MultPtr = nullptr; + } + delete[] pWbuufer; + pWbuufer = nullptr; + return strResult; +} + +float CBaiduParse::roundEx(float Floatnum) +{ + return (int)(Floatnum * 100 + 0.5) / 100.0; +} + +std::string CBaiduParse::GetFileSizeType(double dSize) +{ + std::string szFileSize; + if (dSize <1024) + { + szFileSize = str(boost::format("%.2f B") %roundEx(dSize)); + } + else if (dSize >1024 && dSize < 1024 * 1024 * 1024 && dSize <1024 * 1024) + { + szFileSize = str(boost::format("%.2f KB") %roundEx(dSize / 1024)); + } + else if (dSize >1024 * 1024 && dSize <1024 * 1024 * 1024) + { + szFileSize = str(boost::format("%.2f MB") %roundEx(dSize / 1024 / 1024)); + } + else if (dSize >1024 * 1024 * 1024) + { + szFileSize = str(boost::format("%.2f GB") %roundEx(dSize / 1024 / 1024 / 1024)); + } + return szFileSize; +} + +std::string CBaiduParse::timestampToDate(ULONGLONG ctime) +{ + struct tm time; + time_t tick = (time_t)ctime; + ::localtime_s(&time, &tick); + char sztime[100]; + ZeroMemory(sztime, 100); + ::strftime(sztime, 100, "%Y-%m-%d", &time); + return std::string(sztime); +} + +std::string CBaiduParse::GetBaiduLocalFileAddr(const std::string path, const std::string strCookie) +{ + std::string strResult; + if (path.empty() || strCookie.empty()) + return strResult; + HttpRequest BaiduHttp; + BaiduHttp.SetRequestCookies(strCookie); + BaiduHttp.SetRequestHeader("User-Agent", "netdisk;6.0.0.12;PC;PC-Windows;10.0.16299;WindowsBaiduYunGuanJia"); + BaiduHttp.SetRequestHeader("Accept", " image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*"); + BaiduHttp.SetRequestHeader("Host", " d.pcs.baidu.com"); + std::string strRequestUrl = str(boost::format(DOWN_LOCAL_FILE) % path.c_str()); + BaiduHttp.Send(GET, strRequestUrl); + strResult = BaiduHttp.GetResponseText(); + rapidjson::Document dc; + dc.Parse(strResult.c_str()); + if (!dc.IsObject()) + return std::string(""); + + return strResult; +} + +std::string CBaiduParse::ShareBaiduFile(SHAREFILEINFO shareFileinfo, const std::string strCookie) +{ + std::string strResult; + std::string sharDat; + if (strCookie.empty()) + return strResult; + HttpRequest BaiduHttp; + BaiduHttp.SetRequestCookies(strCookie); + BaiduUserInfo userinfo; + if (!GetloginBassInfo(userinfo, strCookie)) + return strResult; + std::string strShareUrl; + if (shareFileinfo.nschannel) + { + strShareUrl = str(boost::format(SHARE_FILE_URL_1) % userinfo.bdstoken % GetLogid()); + sharDat = str(boost::format("schannel=4&channel_list=%%5B%%5D&period=%1%&pwd=%2%&fid_list=%%5B%3%%%5D") % shareFileinfo.strperiod % shareFileinfo.strPwd % shareFileinfo.strpath_list); + } + else + { + strShareUrl = str(boost::format(SHARE_FILE_URL_2) % userinfo.bdstoken % GetLogid()); + sharDat = str(boost::format("schannel=0&channel_list=%%5B%%5D&period=%1%&path_list=%%5B%%22%2%%%22%%5D") % shareFileinfo.strperiod % URL_Coding(Utf8_To_Gbk(shareFileinfo.strpath_list.c_str()).c_str())); + } + BaiduHttp.Send(POST, strShareUrl, sharDat); + strResult = BaiduHttp.GetResponseText(); + return strResult; +} + +std::string CBaiduParse::DeleteBaiduFile(const std::string strJsonData, const std::string strCookie) +{ + std::string bResult; + if (strJsonData.empty() || strCookie.empty()) + return bResult; + rapidjson::Document dc; + dc.Parse(strJsonData.c_str()); + if (!dc.IsObject()) + return bResult; + if (!dc.HasMember("data") && !dc["data"].IsArray()) + { + return bResult; + } + rapidjson::Value datajson = dc["data"].GetArray(); + std::string strSupDir; + std::string strSendData="["; + for (size_t i = 0; i < datajson.Size(); i++) + { + if (i < (datajson.Size()-1)) + { + if (datajson[i].HasMember("path") && datajson[i]["path"].IsString()) + { + std::string strTempFile(Utf8_To_Gbk(datajson[i]["path"].GetString())); + strSendData += "\"" + strTempFile + "\","; + } + } + else{ + std::string strTempFile(Utf8_To_Gbk(datajson[i]["path"].GetString())); + int npos = strTempFile.rfind("/"); + if (npos != std::string::npos) + { + strSupDir = strTempFile.substr(0, npos); + if (strSupDir.empty()) + strSupDir = "/"; + } + strSendData += "\"" + strTempFile + "\"]"; + } + } + strSendData = URL_Coding(strSendData.c_str()); + std::string strDeleteUrl("https://pan.baidu.com/api/filemanager?opera=delete&async=1&channel=chunlei&web=1&app_id=250528&clienttype=0&bdstoken="); + HttpRequest BaiduHttp; + BaiduHttp.SetRequestCookies(strCookie); + BaiduHttp.SetRequestHeader("Accept", "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*"); + BaiduHttp.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded"); + BaiduUserInfo userinfo; + if (!GetloginBassInfo(userinfo, strCookie)) + return bResult; + strDeleteUrl += userinfo.bdstoken; + BaiduHttp.Send(POST, strDeleteUrl, "filelist="+strSendData); + strDeleteUrl = BaiduHttp.GetResponseText(); + dc.Parse(strDeleteUrl.c_str()); + if (!dc.IsObject()) + return bResult; + if (!dc.HasMember("errno") && !dc["errno"].IsInt()) + return bResult; + int errorn = dc["errno"].GetInt(); + if (errorn == 0) + bResult = GetBaiduFileListInfo(strSupDir, strCookie); + return bResult; +} + +CBaiduParse::CBaiduParse() +{ + +} + +INT_PTR CALLBACK CBaiduParse::ImageProc(_In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + HWND imageHwnd = ::GetDlgItem(hwndDlg, IDC_STATIC_IMG); + HttpRequest baiduHttp; + baiduHttp.Send(GET, m_vcCodeUrl); + responseData imageData = baiduHttp.GetResponseBody(); + CImage img; + HBITMAP bithandel = NULL, hMole = NULL; + if (LodcomImage(imageData.data(), imageData.size(), img)) + { + hMole = img.Detach(); + bithandel = (HBITMAP)::SendMessage(imageHwnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hMole); + DeleteObject(bithandel); + } + + } + break; + case WM_COMMAND: + { + switch (LOWORD(wParam)) + { + case IDC_BTN_OK: + { + char szCode[MAX_PATH]; + ZeroMemory(szCode, MAX_PATH); + ::GetDlgItemTextA(hwndDlg, IDC_EDIT_CODE, szCode, MAX_PATH); + m_VerCode = szCode; + ::EndDialog(hwndDlg, 0); + } + break; + default: + break; + } + } + default: + break; + } + return 0; +} + +BOOL CBaiduParse::LodcomImage(LPVOID PmemIm, ULONG dwLen, CImage& ImgObj) +{ + LPVOID m_ImageBuf = NULL; + BOOL bRet = FALSE; + HGLOBAL Hglobal = ::GlobalAlloc(GMEM_MOVEABLE, dwLen); + if (!Hglobal) + { + return bRet; + } + m_ImageBuf = ::GlobalLock(Hglobal); //ȫַڴȻ + memset(m_ImageBuf, 0, dwLen); + memcpy(m_ImageBuf, PmemIm, dwLen); + ::GlobalUnlock(Hglobal); // + IStream *Pstream = NULL; + HRESULT hr = ::CreateStreamOnHGlobal(Hglobal, TRUE, &Pstream); + if (FAILED(hr))return bRet; + hr = ImgObj.Load(Pstream); + if (FAILED(hr))return bRet; + Pstream->Release(); + bRet = TRUE; + ::GlobalFree(Hglobal); //ͷȫڴ + return bRet; +} + +CBaiduParse::~CBaiduParse() +{ + +} diff --git a/PanParse.h b/PanParse.h new file mode 100644 index 0000000..4185793 --- /dev/null +++ b/PanParse.h @@ -0,0 +1,196 @@ +#ifndef __PANPARSE__ +#define __PANPARSE__ +#ifndef min +#define min +#endif +#ifndef max +#define max +#endif +#include +#undef min +#undef max +#include "Http_Request.h" +#define HOME_URL "https://pan.baidu.com/disk/home?#/all?path=%2F&vmode=list" +#define FILE_LIST_URL "https://pan.baidu.com/api/list?order=name&desc=1&showempty=0&web=1&page=1&num=100&dir=%1%&t=0.1312003882264028&channel=chunlei&web=1&app_id=250528&bdstoken=%2%&logid=%3%&clienttype=0&startLogTime=%4%" +#define DOWN_LOCAL_FILE "http://d.pcs.baidu.com/rest/2.0/pcs/file?app_id=250528&channel=00000000000000000000000000000000&check_blue=1&clienttype=8&devuid=0&dtype=1&ehps=0&err_ver=1.0&es=1&esl=1&method=locatedownload&path=%1%&ver=4.0&version=6.0.0.12&vip=3" +#define SHARE_FILE_URL_1 "https://pan.baidu.com/share/set?channel=chunlei&clienttype=0&web=1&channel=chunlei&web=1&app_id=250528&bdstoken=%1%&logid=%2%&clienttype=0" +#define SHARE_FILE_URL_2 "https://pan.baidu.com/share/pset?channel=chunlei&clienttype=0&web=1&channel=chunlei&web=1&app_id=250528&bdstoken=%1%&logid=%2%&clienttype=0" +#define USER_AGENT "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36" +extern HINSTANCE g_hInstance; +typedef struct baiduRequestInfo +{ + std::string sign; + std::string bdstoken; + std::string timestamp; + std::string app_id; + std::string fs_id; + std::string uk; + std::string shareid; + std::string BDCLND; + std::string server_filename; +}BAIDUREQUESTINFO, *PBAIDUREQUESTINFO; +/* +ȡݷ +*/ +typedef std::vector REGEXVALUE; +/* +֤Ϣ +*/ +typedef struct verCodeinfo +{ + std::string image; + std::string verCode; +}VERCODEINFO; +/* +ؽʵַԼļ +*/ +typedef struct RequestInfo +{ + std::string strDownloadUrl; + std::string strFileName; + std::string strCookies; + std::string strSavePath; +}REQUESTINFO; +/* +ȡû½ĻϢ +*/ +typedef struct userInfo +{ + std::string strUserName; + std::string strHeadImageUrl; + std::string bdstoken; + int is_vip; +}BaiduUserInfo; +/* +ٶûļб +*/ +typedef struct fileInfo +{ + int nCategory; //ļ 6ļлzip͵ļҪisdirжǷļ 3ͼƬ 2 1Ƶ 5exeļ + std::string strPath; //ļڵ· + std::string server_filename; //ļ + int nisdir; //Ƿļ 1 0 + ULONG size; //ļĴС + std::string strFileType; //ݺ׺ļ + ULONG server_ctime; //ļʱ + std::string fs_id; //ʹ +}BaiduFileInfo; +/* +ļϢб +*/ +typedef std::vector FileTypeArray; +/* +ļϢ +*/ +typedef struct shareInfo +{ + std::string strPwd; + std::string strpath_list; + int nschannel; + std::string strperiod; +}SHAREFILEINFO; +class CBaiduParse +{ +public: + explicit CBaiduParse(); + ~CBaiduParse(); +private: + CBaiduParse(const CBaiduParse&); + //ַ֤ + static std::string m_vcCodeUrl; + //֤ + static std::string m_VerCode; + //֤봰ڻص + static INT_PTR CALLBACK ImageProc( + _In_ HWND hwndDlg, + _In_ UINT uMsg, + _In_ WPARAM wParam, + _In_ LPARAM lParam + ); + //ͼƬ + static BOOL LodcomImage(LPVOID PmemIm, ULONG dwLen, CImage& ImgObj); +public: +//ʾ֤Ĵ + void ShowInputVerCodeDlg(); +/* +ȡٶļбϢ +*/ +std::string GetBaiduFileListInfo(const std::string& path, const std::string strCookie); +/* +дļ +*/ +DWORD WriteFileBuffer(std::string szFileNmae, PVOID pFileBuffer, DWORD dwFileSize); +/* +ȡû¼ĻϢ +*/ +bool GetloginBassInfo(BaiduUserInfo& baseInfo,const std::string strCookie); +/* +ȡָ +*/ +REGEXVALUE GetRegexValue(const std::string strvalue, const std::string strRegx); +/* + ٶʵصַ + strUrl ַ + strCookies ¼cookies + ؽʵַԼļ +*/ +REQUESTINFO ParseBaiduAddr(const std::string strUrl, std::string& strCookies); +/* +֤ +*/ +std::string GetBaiduAddr(BAIDUREQUESTINFO baiduinfo, const std::string strCookies); +/* +ȡ֤Ϣ +*/ +VERCODEINFO GetVerCodeinfo(BAIDUREQUESTINFO baiduinfo, const std::string strCookies); +/* +ȡ BAIDUREQUESTINFO Ϣ +*/ +BAIDUREQUESTINFO GetBaiduInfo(const std::string strJson); +/* +ļ·ȡҪصʵصַ +*/ +std::string GetBaiduLocalFileAddr(const std::string path, const std::string strCookie); +/* +ٶûļļ +*/ +std::string ShareBaiduFile(SHAREFILEINFO shareFileinfo, const std::string strCookie); +/*ɾٶļ*/ +std::string DeleteBaiduFile(const std::string strJsonData, const std::string strCookie); +/* + ȡʱ +*/ +long long getTimeStamp(); +/* +ȡıм +*/ +std::string GetTextMid(const std::string strSource, const std::string strLeft, const std::string strRight); +/* +ȡҪLogid +*/ +std::string GetLogid(bool isFlag = true); +inline float roundEx(float Floatnum); +/* +ȡļС +*/ +std::string GetFileSizeType(double dSize); +/* +ʱת +*/ +std::string timestampToDate(ULONGLONG ctime); +/* +ת +*/ +std::string Unicode_To_Ansi(const wchar_t* szbuff); +std::wstring Ansi_To_Unicode(const char* szbuff); +std::string Gbk_To_Utf8(const char* szBuff); +std::string Utf8_To_Gbk(const char* szBuff); +// szSource ҪURLַ +// isletter Ƿ񲻱ĸ ĬΪtrue false +// isUtf8 ǷΪUTF-8ʽ ĬΪtrue UTF-8 false 򲻱Ϊutf-8 +/***************************************************/ +std::string URL_Coding(const char* szSource, bool isletter = true, bool isUtf8 = true); +//\uxxxx\uxxxxַ +std::string UnEscape(const char* strSource); +}; +#endif diff --git a/WebsocketEx.cpp b/WebsocketEx.cpp new file mode 100644 index 0000000..9817361 --- /dev/null +++ b/WebsocketEx.cpp @@ -0,0 +1,11 @@ +#include "WebsocketEx.h" + + +CWebsocketEx::CWebsocketEx() +{ +} + + +CWebsocketEx::~CWebsocketEx() +{ +} diff --git a/WebsocketEx.h b/WebsocketEx.h new file mode 100644 index 0000000..2406b8d --- /dev/null +++ b/WebsocketEx.h @@ -0,0 +1,19 @@ +#ifndef __CWEBSOCKETEX__ +#define __CWEBSOCKETEX__ +#include +#include +typedef websocketpp::client client; +using websocketpp::lib::placeholders::_1; +using websocketpp::lib::placeholders::_2; +using websocketpp::lib::bind; +//˳͵Ϣ,ͨǵ +typedef websocketpp::config::asio_client::message_type::ptr message_ptr; +class CWebsocketEx +{ +public: + CWebsocketEx(); + ~CWebsocketEx(); +public: + static void on_MessageCall_Back(client* c, websocketpp::connection_hdl hdl, message_ptr msg); +}; +#endif //__CWEBSOCKETEX__ diff --git a/WkeWindow.cpp b/WkeWindow.cpp new file mode 100644 index 0000000..b71e550 --- /dev/null +++ b/WkeWindow.cpp @@ -0,0 +1,1245 @@ +#include "WkeWindow.h" +#include +#include +#include +#include +#include "rapidjson/document.h" +#include "rapidjson/writer.h" +#include "rapidjson/stringbuffer.h" +#pragma comment(lib,"Wininet.lib") +#pragma comment(lib,"shlwapi.lib") +#pragma warning(disable:4996) +std::mutex g_mutx; +WNDPROC CWkeWindow::m_oldProc = NULL; + +void* CWkeWindow::AlloclocalHeap(const std::string& strBuffer) +{ + char* pResutPtr = nullptr; + if (strBuffer.empty()) + return pResutPtr; + int nLen = strBuffer.length() + 1; + pResutPtr = new char[nLen]; + if (!pResutPtr) + return pResutPtr; + ZeroMemory(pResutPtr, nLen); + CopyMemory(pResutPtr, strBuffer.c_str(),strBuffer.length()); + return pResutPtr; +} + +std::shared_ptr CWkeWindow::Instance = nullptr; +void CWkeWindow::ParseAria2JsonInfo(const std::string& strJSon) +{ + rapidjson::Document dc; + dc.Parse(strJSon.c_str()); + if (!dc.IsObject()) + return; + std::string strDownStatus; + std::string strGidItem; + if (dc.HasMember("method") && dc["method"].IsString()) + { + strDownStatus = dc["method"].GetString(); + if (dc.HasMember("params") && dc["params"].IsArray()) + { + for (auto &v : dc["params"].GetArray()) + { + if (!v.IsObject()) + continue; + if (v.HasMember("gid") && v["gid"].IsString()) + strGidItem = v["gid"].GetString(); + } + } + if (strDownStatus == ARIA2_DOWNLOAD_COMPLATE) + { + PVOID sendPtr = AlloclocalHeap(strGidItem); + ::PostMessage(m_hwnd, ARIA2_DOWNLOAD_COMPLATE_MSG, NULL, (LPARAM)sendPtr); + } + else if (strDownStatus == ARIA2_DOWNLOAD_START) + { + PVOID sendPtr = AlloclocalHeap(strGidItem); + ::PostMessage(m_hwnd, ARIA2_DOWNLOAD_START_MSG, NULL, (LPARAM)sendPtr); + } + else if (strDownStatus == ARIA2_DOWNLOAD_STOP) + { + PVOID sendPtr = AlloclocalHeap(strGidItem); + ::PostMessage(m_hwnd, ARIA2_DOWNLOAD_STOP_MSG, NULL, (LPARAM)sendPtr); + } + else if (strDownStatus == ARIA2_DOWNLOAD_PAUSE) + { + PVOID sendPtr = AlloclocalHeap(strGidItem); + ::PostMessage(m_hwnd, ARIA2_DOWNLOAD_PAUSE_MSG, NULL, (LPARAM)sendPtr); + } + else if (strDownStatus == ARIA2_DOWNLOAD_ERROR) + { + PVOID sendPtr = AlloclocalHeap(strGidItem); + ::PostMessage(m_hwnd, ARIA2_DOWNLOAD_ERROR_MSG, NULL, (LPARAM)sendPtr); + } + } + if (dc.HasMember("result") && dc["result"].IsArray()) + { + //ʼװjson͸UI̴߳Ⱦ + rapidjson::Document sendJson; + sendJson.SetObject(); + rapidjson::Value arrlist(rapidjson::kArrayType); + int nErrcount = 0; + for (auto& v : dc["result"].GetArray()) + { + rapidjson::Value sendItemObj(rapidjson::kObjectType); + DOWNFILELISTINFO ItemValue; + ZeroMemory(&ItemValue, sizeof(DOWNFILELISTINFO)); + ULONGLONG totalLength, completedLength, downloadSpeed; + if (v.HasMember("totalLength") && v["totalLength"].IsString()) + sscanf_s(v["totalLength"].GetString(), "%I64d", &totalLength); + if (v.HasMember("completedLength") && v["completedLength"].IsString()) + sscanf_s(v["completedLength"].GetString(), "%I64d", &completedLength); + if (v.HasMember("downloadSpeed") && v["downloadSpeed"].IsString()) + sscanf_s(v["downloadSpeed"].GetString(), "%I64d", &downloadSpeed); + if (v.HasMember("connections") && v["connections"].IsString()) + ItemValue.connections = v["connections"].GetString(); + if (v.HasMember("gid") && v["gid"].IsString()) + ItemValue.strFileGid = v["gid"].GetString(); + if (v.HasMember("errorMessage") && v["errorMessage"].IsString() && v.HasMember("errorCode") && v["errorCode"].IsString()) + { + nErrcount++; + ItemValue.nErrCode = atoi(v["errorCode"].GetString()); + ItemValue.strErrMessage = v["errorMessage"].GetString(); + } + if (v.HasMember("files") && v["files"].IsArray()) + { + for (auto& keyval : v["files"].GetArray()) + { + if (keyval.HasMember("path") && keyval["path"].IsString()) + { + char szName[MAX_PATH]; + ZeroMemory(szName, MAX_PATH); + std::string szFileName = m_BaiduPare.Utf8_To_Gbk(keyval["path"].GetString()); + CopyMemory(szName, szFileName.c_str(), szFileName.length()); + PathStripPathA(szName); + ItemValue.strFileName = szName; + } + + + } + } + ItemValue.Downloadpercentage = (size_t)Getpercentage(completedLength, totalLength); + ItemValue.DownloadSpeed = GetFileSizeType(downloadSpeed); + rapidjson::Value connections(rapidjson::kStringType);//ǰ + connections.SetString(ItemValue.connections.c_str(), ItemValue.connections.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("connections"), connections, sendJson.GetAllocator()); + rapidjson::Value downloadSpeedItem(rapidjson::kStringType);//ٶÿ + downloadSpeedItem.SetString(ItemValue.DownloadSpeed.c_str(), ItemValue.DownloadSpeed.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("downloadSpeed"), downloadSpeedItem, sendJson.GetAllocator()); + rapidjson::Value FileName(rapidjson::kStringType);//ǰļ + FileName.SetString(ItemValue.strFileName.c_str(), ItemValue.strFileName.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("name"), FileName, sendJson.GetAllocator()); + rapidjson::Value Gid(rapidjson::kStringType);//ǰGIDΨһʶ + Gid.SetString(ItemValue.strFileGid.c_str(), ItemValue.strFileGid.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("gid"), Gid, sendJson.GetAllocator()); + rapidjson::Value Downloadpercentage(rapidjson::kNumberType);//ǰصİٷְ + Downloadpercentage.SetUint(ItemValue.Downloadpercentage); + sendItemObj.AddMember(rapidjson::StringRef("progress"), Downloadpercentage, sendJson.GetAllocator()); + rapidjson::Value nErrCode(rapidjson::kNumberType);//ش + nErrCode.SetUint(ItemValue.nErrCode); + sendItemObj.AddMember(rapidjson::StringRef("errorCode"), nErrCode, sendJson.GetAllocator()); + rapidjson::Value ErrMessage(rapidjson::kStringType);//شԭ + ErrMessage.SetString(ItemValue.strErrMessage.c_str(), ItemValue.strErrMessage.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("errorMessage"), ErrMessage, sendJson.GetAllocator()); + arrlist.PushBack(sendItemObj, sendJson.GetAllocator()); + } + //͸UI߳ + sendJson.AddMember(rapidjson::StringRef("data"), arrlist, sendJson.GetAllocator()); + rapidjson::StringBuffer buffer; + rapidjson::Writer writer(buffer); + sendJson.Accept(writer); + std::string strResultJson = buffer.GetString(); + strResultJson = m_BaiduPare.Gbk_To_Utf8(strResultJson.c_str()); + PVOID pSendDataPtr = AlloclocalHeap(strResultJson); + if (!nErrcount) + { + ::PostMessage(m_hwnd, ARIA2_UPDATE_TELLACTIVE_LIST_MSG, NULL, (LPARAM)pSendDataPtr); + } + + } + if (numStopped) + { + if (!m_ErrorArray.empty()) + { + if (dc.HasMember("result") && dc["result"].IsArray()) + { + //ʼװjson͸UI̴߳Ⱦ + rapidjson::Document sendJson; + sendJson.SetObject(); + rapidjson::Value arrlist(rapidjson::kArrayType); + int nErrcount = 0; + for (auto& v : dc["result"].GetArray()) + { + rapidjson::Value sendItemObj(rapidjson::kObjectType); + DOWNFILELISTINFO ItemValue; + ZeroMemory(&ItemValue, sizeof(DOWNFILELISTINFO)); + ULONGLONG totalLength, completedLength, downloadSpeed; + if (v.HasMember("totalLength") && v["totalLength"].IsString()) + sscanf_s(v["totalLength"].GetString(), "%I64d", &totalLength); + if (v.HasMember("completedLength") && v["completedLength"].IsString()) + sscanf_s(v["completedLength"].GetString(), "%I64d", &completedLength); + if (v.HasMember("downloadSpeed") && v["downloadSpeed"].IsString()) + sscanf_s(v["downloadSpeed"].GetString(), "%I64d", &downloadSpeed); + if (v.HasMember("connections") && v["connections"].IsString()) + ItemValue.connections = v["connections"].GetString(); + if (v.HasMember("gid") && v["gid"].IsString()) + ItemValue.strFileGid = v["gid"].GetString(); + if (v.HasMember("errorMessage") && v["errorMessage"].IsString() && v.HasMember("errorCode") && v["errorCode"].IsString()) + { + nErrcount++; + ItemValue.nErrCode = atoi(v["errorCode"].GetString()); + ItemValue.strErrMessage = v["errorMessage"].GetString(); + } + if (v.HasMember("files") && v["files"].IsArray()) + { + for (auto& keyval : v["files"].GetArray()) + { + if (keyval.HasMember("path") && keyval["path"].IsString()) + { + char szName[MAX_PATH]; + ZeroMemory(szName, MAX_PATH); + std::string szFileName = m_BaiduPare.Utf8_To_Gbk(keyval["path"].GetString()); + CopyMemory(szName, szFileName.c_str(), szFileName.length()); + PathStripPathA(szName); + ItemValue.strFileName = szName; + } + + } + } + ItemValue.Downloadpercentage = (size_t)Getpercentage(completedLength, totalLength); + ItemValue.DownloadSpeed = GetFileSizeType(downloadSpeed); + rapidjson::Value connections(rapidjson::kStringType);//ǰ + connections.SetString(ItemValue.connections.c_str(), ItemValue.connections.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("connections"), connections, sendJson.GetAllocator()); + rapidjson::Value downloadSpeedItem(rapidjson::kStringType);//ٶÿ + downloadSpeedItem.SetString(ItemValue.DownloadSpeed.c_str(), ItemValue.DownloadSpeed.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("downloadSpeed"), downloadSpeedItem, sendJson.GetAllocator()); + rapidjson::Value FileName(rapidjson::kStringType);//ǰļ + FileName.SetString(ItemValue.strFileName.c_str(), ItemValue.strFileName.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("name"), FileName, sendJson.GetAllocator()); + rapidjson::Value Gid(rapidjson::kStringType);//ǰGIDΨһʶ + Gid.SetString(ItemValue.strFileGid.c_str(), ItemValue.strFileGid.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("gid"), Gid, sendJson.GetAllocator()); + rapidjson::Value Downloadpercentage(rapidjson::kNumberType);//ǰصİٷְ + Downloadpercentage.SetUint(ItemValue.Downloadpercentage); + sendItemObj.AddMember(rapidjson::StringRef("progress"), Downloadpercentage, sendJson.GetAllocator()); + rapidjson::Value nErrCode(rapidjson::kNumberType);//ش + nErrCode.SetUint(ItemValue.nErrCode); + sendItemObj.AddMember(rapidjson::StringRef("errorCode"), nErrCode, sendJson.GetAllocator()); + rapidjson::Value ErrMessage(rapidjson::kStringType);//شԭ + ErrMessage.SetString(ItemValue.strErrMessage.c_str(), ItemValue.strErrMessage.length(), sendJson.GetAllocator()); + sendItemObj.AddMember(rapidjson::StringRef("errorMessage"), ErrMessage, sendJson.GetAllocator()); + arrlist.PushBack(sendItemObj, sendJson.GetAllocator()); + } + //͸UI߳ + sendJson.AddMember(rapidjson::StringRef("data"), arrlist, sendJson.GetAllocator()); + rapidjson::StringBuffer buffer; + rapidjson::Writer writer(buffer); + sendJson.Accept(writer); + std::string strResultJson = buffer.GetString(); + strResultJson = m_BaiduPare.Gbk_To_Utf8(strResultJson.c_str()); + PVOID pSendDataPtr = AlloclocalHeap(strResultJson); + if (nErrcount) + ::PostMessage(m_hwnd, ARIA2_UPDATE_TELLERROR_LIST_MSG, NULL, (LPARAM)pSendDataPtr); + } + } + } + if (dc.HasMember("result") && dc["result"].IsObject()) + { + rapidjson::Value itemObj = dc["result"].GetObjectW(); + if (itemObj.HasMember("numActive") && itemObj["numActive"].IsString()) + numActive = atol(itemObj["numActive"].GetString()); + if (itemObj.HasMember("numStopped") && itemObj["numStopped"].IsString()) + numStopped = atol(itemObj["numStopped"].GetString()); + } +} + +std::string CWkeWindow::GetFileSizeType(double dSize) +{ + std::string szFileSize; + if (dSize <1024) + { + szFileSize = str(boost::format("%.2f B") % m_BaiduPare.roundEx(dSize)); + } + else if (dSize >1024 && dSize < 1024 * 1024 * 1024 && dSize <1024 * 1024) + { + szFileSize = str(boost::format("%.2f KB") % m_BaiduPare.roundEx(dSize / 1024)); + } + else if (dSize >1024 * 1024 && dSize <1024 * 1024 * 1024) + { + szFileSize = str(boost::format("%.2f MB") % m_BaiduPare.roundEx(dSize / 1024 / 1024)); + } + else if (dSize >1024 * 1024 * 1024) + { + szFileSize = str(boost::format("%.2f GB") % m_BaiduPare.roundEx(dSize / 1024 / 1024 / 1024)); + } + return szFileSize; +} + +double CWkeWindow::Getpercentage(double completedLength, double totalLength) +{ + return completedLength / totalLength * 100; +} + + +LRESULT CALLBACK CWkeWindow::MainProc(_In_ HWND hwnd, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam) +{ + static int index = 0; + switch (uMsg) + { + case ARIA2_UPDATE_TELLACTIVE_LIST_MSG: //µǰصб + { + if (lParam) + { + const char* pbuffer = (const char*)lParam; + std::string strJsonData(pbuffer); + delete pbuffer; + GetInstance()->UpdateDownloadList(strJsonData); + } + } + break; + case ARIA2_UPDATE_TELLERROR_LIST_MSG://ʧܵļб + { + if (lParam) + { + const char* pbuffer = (const char*)lParam; + std::string strJsonData(pbuffer); + delete pbuffer; + static auto updateErrorList = [](const std::string strJosn) { + jsExecState es = wkeGlobalExec(app.window); + jsValue thisObject = jsGetGlobal(es, "app"); + jsValue func = jsGet(es, thisObject, "updatedownloadErrorList"); + jsValue jsArg[1] = { jsString(es, strJosn.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); + }; + updateErrorList(strJsonData); + GetInstance()->m_ErrorArray.clear(); + //ʧܵļڴ滺 + GetInstance()->SendText(GetInstance()->m_BaiduPare.Gbk_To_Utf8(ARIA2_PURGEDOWNLOAD_RESULT)); + } + + } + break; + case ARIA2_DOWNLOAD_COMPLATE_MSG: //ij + { + if (lParam) + { + const char* pbuffer = (const char*)lParam; + std::string strGID(pbuffer); + delete pbuffer; + auto it = GetInstance()->m_DownloadArray.begin(); + for (size_t i=0; i < GetInstance()->m_DownloadArray.size();i++) + { + if (GetInstance()->m_DownloadArray[i].strFileGid == strGID) + GetInstance()->m_DownloadArray.erase(it+i); + } + strGID = GetInstance()->GetFileCompletedInfo(strGID); + //ݵб + static auto addSussedList = [](const std::string Gid) { + std::string buffer = str(boost::format("{\"name\":\"%1%\",\"ChangeTime\":\"%2%\"}") % Gid % GetInstance()->m_BaiduPare.timestampToDate((ULONGLONG)time(NULL))); + jsExecState es = wkeGlobalExec(app.window); + jsValue thisObject = jsGetGlobal(es, "app"); + jsValue func = jsGet(es, thisObject, "updatedownloadSussedList"); + jsValue jsArg[1] = { jsString(es, buffer.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); + }; + addSussedList(strGID); + //صļڴ滺 + GetInstance()->SendText(GetInstance()->m_BaiduPare.Gbk_To_Utf8(ARIA2_PURGEDOWNLOAD_RESULT)); + } + } + break; + case ARIA2_DOWNLOAD_START_MSG: //ijʼ + { + if (lParam) + { + const char* pbuffer = (const char*)lParam; + std::string strGID(pbuffer); + delete pbuffer; + DOWNLOADSTATUS vector_item; + ZeroMemory(&vector_item, sizeof(DOWNLOADSTATUS)); + vector_item.strFileGid = strGID; + vector_item.strFileStatus = ARIA2_STATUS_ACTIVE; + GetInstance()->m_DownloadArray.push_back(vector_item); + } + } + break; + case ARIA2_DOWNLOAD_STOP_MSG: //ijֹͣ + { + + } + break; + case ARIA2_DOWNLOAD_PAUSE_MSG: //ij ͣ + { + index++; + } + break; + case ARIA2_DOWNLOAD_ERROR_MSG: //ijس + { + if (lParam) + { + const char* pbuffer = (const char*)lParam; + std::string strGID(pbuffer); + delete pbuffer; + if (GetInstance()->m_ErrorArray.empty()) + { + GetInstance()->m_ErrorArray.push_back(strGID); + } + else + { + for (size_t i = 0; i < GetInstance()->m_ErrorArray.size(); i++) + { + if (GetInstance()->m_ErrorArray.at(i) != strGID) + { + GetInstance()->m_ErrorArray.push_back(strGID); + } + } + } + } + } + break; + default: + break; + } + return CallWindowProc(m_oldProc, hwnd, uMsg, wParam, lParam); +} + +std::string CWkeWindow::GetFileCompletedInfo(const std::string& strGid) +{ + std::string StrJson="{\"data\":"; + std::string strResult; + jsExecState es = wkeGlobalExec(app.window); + jsValue thisObject = jsGetGlobal(es, "app"); + jsValue func = jsGet(es, thisObject, "GetBackupListString"); + jsValue rString = jsCall(es, func, thisObject, nullptr, 0); + jsType Type = jsTypeOf(rString); + StrJson += jsToTempString(es, rString); + StrJson += "}"; + rapidjson::Document dc; + dc.Parse(StrJson.c_str()); + if (!dc.IsObject()) + return strResult; + if (dc.HasMember("data") && dc["data"].IsArray()) + { + for (auto& v:dc["data"].GetArray()) + { + if (v.HasMember("gid") && v["gid"].IsString()) + { + if (strGid == v["gid"].GetString()) + { + if (v.HasMember("name") && v["name"].IsString()) + strResult = v["name"].GetString(); + } + } + } + } + return strResult; +} + +void CWkeWindow::on_socket_init(websocketpp::connection_hdl hdl) +{ + +} + +void CWkeWindow::on_message(websocketpp::connection_hdl hdl, message_ptr msg) +{ + DWORD dwThread = ::GetThreadId(::GetCurrentThread()); + websocketpp::frame::opcode::value opcodes = msg->get_opcode(); + if (opcodes == websocketpp::frame::opcode::text) + { + + std::string strMsgText = msg->get_payload(); + ParseAria2JsonInfo(strMsgText); + } +} + +void CWkeWindow::on_open(websocketpp::connection_hdl hdl) +{ + m_hdl = hdl; +} + +void CWkeWindow::on_close(websocketpp::connection_hdl hdl) +{ + hdl.reset(); +} + +void CWkeWindow::on_fail(websocketpp::connection_hdl hdl) +{ + hdl.reset(); +} + +void CWkeWindow::start(std::string uri) +{ + websocketpp::lib::error_code ec; + client::connection_ptr con = m_WssClient.get_connection(uri, ec); + if (ec) { + //ʧ + return; + } + m_WssClient.connect(con); + m_WssClient.run(); +} + +BOOL CWkeWindow::RunAria2() +{ + STARTUPINFOA si; + PROCESS_INFORMATION pi; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&pi, sizeof(pi)); + si.dwFlags = STARTF_USESHOWWINDOW; // ָwShowWindowԱЧ + si.wShowWindow = true; // ˳ԱΪTRUEĻʾ½̵ڣ + std::string strCommandlineArg = str(boost::format("aria2c.exe --check-certificate=false --disable-ipv6=true --enable-rpc=true --quiet=false --rpc-allow-origin-all=true --rpc-listen-all=true --rpc-listen-port=6800 --rpc-secret=CDP --stop-with-process=%1%")\ + % std::to_string(GetCurrentProcessId())); + BOOL bRet = ::CreateProcessA(NULL, // ڴִָļļ + const_cast(strCommandlineArg.c_str()), // в + NULL, // ĬϽ̰ȫ + NULL, // Ḭ̆߳ȫ + FALSE, // ָǰڵľԱӽ̼̳ + CREATE_NEW_CONSOLE, // Ϊ½̴һµĿ̨ + NULL, // ʹñ̵Ļ + NULL, // ʹñ̵Ŀ¼ + &si, + &pi); + ::CloseHandle(pi.hProcess); + return bRet; +} + +void CWkeWindow::Connect() +{ + try{ + start("ws://127.0.0.1:6800/jsonrpc"); + } + catch (websocketpp::exception const & e) { + std::cout << e.what() << std::endl; + } + catch (std::exception const & e) { + std::cout << e.what() << std::endl; + } + catch (...) { + std::cout << "other exception" << std::endl; + } +} + +void CWkeWindow::SendText(std::string& strText) +{ + if (m_hdl.lock().get()) + { + m_WssClient.send(m_hdl, strText, websocketpp::frame::opcode::text); + } +} + +void CALLBACK CWkeWindow::TimeProc(HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime) +{ + GetInstance()->SendText(GetInstance()->m_BaiduPare.Gbk_To_Utf8(ARIA2_GETGLOBAL_STATUS)); + if (GetInstance()->numActive > 0) + { + GetInstance()->SendText(GetInstance()->m_BaiduPare.Gbk_To_Utf8(ARIA2_TELLACTICE_SENDDATA)); + wkeRunJS(app.window, "app.backupdownloadListinfo = app.downloadListinfo;"); + } + else if (GetInstance()->numStopped > 0 && !GetInstance()->m_ErrorArray.empty()) + { + GetInstance()->SendText(GetInstance()->m_BaiduPare.Gbk_To_Utf8(ARIA2_TELLSTOPPED)); + } + else + { + GetInstance()->numStopped = 0; + } +} + +void CWkeWindow::runApp(Application* app) +{ + DWORD dwThread = ::GetThreadId(::GetCurrentThread()); + memset(app, 0, sizeof(Application)); + app->url = L"http://baiducdp.com/ui/element.html"; // ʹhookķʽԴ + + if (!createWebWindow(app)) { + PostQuitMessage(0); + return; + } + runMessageLoop(app); +} +std::string CWkeWindow::CarkUrl(const char* url) +{ + std::string result = "http://"; + URL_COMPONENTSA uc; + char Scheme[1000]; + char HostName[1000]; + char UserName[1000]; + char Password[1000]; + char UrlPath[1000]; + char ExtraInfo[1000]; + + uc.dwStructSize = sizeof(uc); + uc.lpszScheme = Scheme; + uc.lpszHostName = HostName; + uc.lpszUserName = UserName; + uc.lpszPassword = Password; + uc.lpszUrlPath = UrlPath; + uc.lpszExtraInfo = ExtraInfo; + + uc.dwSchemeLength = 1000; + uc.dwHostNameLength = 1000; + uc.dwUserNameLength = 1000; + uc.dwPasswordLength = 1000; + uc.dwUrlPathLength = 1000; + uc.dwExtraInfoLength = 1000; + InternetCrackUrlA(url, 0, 0, &uc); + return (result += HostName); + +} +bool CWkeWindow::InintMiniBlink() +{ + bool bResult = false; + std::vector mbPath; + mbPath.resize(MAX_PATH); + ::GetModuleFileName(nullptr, mbPath.data(), MAX_PATH); + if (!::PathRemoveFileSpec(mbPath.data())) return bResult; + if (!PathAppendW(mbPath.data(), MBDLL_NAME))return bResult; + if (!::PathFileExists(mbPath.data())) + { + ::MessageBox(NULL, L"ȱminiblink node.dllļ!", L"", NULL); + return bResult; + } + wkeSetWkeDllPath(mbPath.data()); + wkeInitialize(); + bResult = true; + return bResult; +} +void CWkeWindow::quitApplication(Application* app) +{ + if (app->window) { + wkeDestroyWebWindow(app->window); + app->window = NULL; + } +} +void CWkeWindow::runMessageLoop(Application* app) +{ + MSG msg = { 0 }; + while (GetMessageW(&msg, NULL, 0, 0)) { + TranslateMessage(&msg); + DispatchMessageW(&msg); + } +} +bool CWkeWindow::createWebWindow(Application* app) +{ + app->window = wkeCreateWebWindow(WKE_WINDOW_TYPE_TRANSPARENT, NULL, 0, 0, 1024, 640); + if (!app->window) + return false; + //ڵĴھ + m_hwnd = wkeGetWindowHandle(app->window); + m_oldProc =(WNDPROC)::SetWindowLongPtr(m_hwnd, GWL_WNDPROC, (DWORD)MainProc); + ::SetTimer(m_hwnd, UPDTAE_UI_TIMEID, 1000, TimeProc); + //ôڵı + wkeSetWindowTitleW(app->window, APP_NAME); + //Ajax ֧ + wkeSetCspCheckEnable(app->window, false); + //ڱرʱĻصûѡǷر + wkeOnWindowClosing(app->window, OnCloseCallBack,this); + //ôٵĻص + wkeOnWindowDestroy(app->window, OnWindowDestroy, this); + //µwebwindowڴô˻ص + wkeOnCreateView(app->window, onCreateView, this); + //documentĵسɹص + wkeOnDocumentReady(app->window, OnDocumentReady, this); + //ҳǰصҪΪ˼رԴ + wkeOnLoadUrlBegin(app->window, onLoadUrlBegin, this); + //ôھʾ + wkeMoveToCenter(app->window); + //ַ + wkeLoadURLW(app->window, app->url.c_str()); + //ȫjs󶨺 + wkeJsBindFunction("sysMenuCallBack", SysMenuJsNativeFunction, this, 1); + //ΪwebWindow һжϰٶǷ¼ɹĺ + wkeJsBindFunction("isLoginBaidu", IsLoginBaidu, this, 0); + // һлٶȵ¼лĿ¼ĺ + wkeJsBindFunction("SwitchDirPath", SwitchDirPath, this, 1); + //һлٶȵ¼ļĵĺ + wkeJsBindFunction("DownloadUserFile", DownloadUserFile, this, 1); + //һٶȵ¼ļĺ + wkeJsBindFunction("ShareBaiduFile", ShareBaiduFile, this, 4); + //һɾٶȵ¼ļĺ + wkeJsBindFunction("DeleteBaiduFile", DeleteBaiduFile, this, 1); + //һطļĺ + wkeJsBindFunction("DownShareFile", DownShareFile, this, 1); + return true; +} + +bool CWkeWindow::OnCloseCallBack(wkeWebView webWindow, void* param) +{ + if (param) + { + Application* app = (Application*)param; + return IDYES == MessageBoxW(NULL, L"ȷҪ˳", L"wkexe", MB_YESNO | MB_ICONQUESTION); + } + return true; +} + +void CWkeWindow::OnWindowDestroy(wkeWebView webWindow, void* param) +{ + Application* app = (Application*)param; + app->window = NULL; + PostQuitMessage(0); +} + +void CWkeWindow::OnDocumentReady(wkeWebView webWindow, void* param) +{ + wkeShowWindow(webWindow, true); +} + +bool CWkeWindow::onLoadUrlBegin(wkeWebView webView, void* param, const char* url, void *job) +{ + if (!param)return false; + std::string localUrl = ((CWkeWindow*)param)->CarkUrl(url); + bool pos = localUrl == HOST_NAME ? true : false; + if (pos) { + const utf8* decodeURL = wkeUtilDecodeURLEscape(url); + if (!decodeURL) + return false; + std::string urlString(decodeURL); + std::string localPath = urlString.substr(sizeof(HOST_NAME)-1); + + std::wstring path = ((CWkeWindow*)param)->getResourcesPath(((CWkeWindow*)param)->utf8ToUtf16(localPath)); + std::vector buffer; + + ((CWkeWindow*)param)->readJsFile(path.c_str(), &buffer); + + wkeNetSetData(job, buffer.data(), buffer.size()); + + return true; + } + return false; +} + +std::wstring CWkeWindow::getResourcesPath(const std::wstring name) +{ + std::wstring bResult; + std::wstring temp; + std::vector mbPath; + mbPath.resize(MAX_PATH+1); + ::GetModuleFileName(nullptr, mbPath.data(), MAX_PATH); + if (!::PathRemoveFileSpec(mbPath.data())) return bResult; + temp += mbPath.data(); + temp += L"\\"; + bResult = temp + name; + return bResult; +} + +std::wstring CWkeWindow::utf8ToUtf16(const std::string& utf8String) +{ + std::wstring sResult; + int nUTF8Len = MultiByteToWideChar(CP_UTF8, 0, utf8String.c_str(), -1, NULL, NULL); + wchar_t* pUTF8 = new wchar_t[nUTF8Len + 1]; + + ZeroMemory(pUTF8, nUTF8Len + 1); + MultiByteToWideChar(CP_UTF8, 0, utf8String.c_str(), -1, pUTF8, nUTF8Len); + sResult = pUTF8; + delete[] pUTF8; + + return sResult; +} + +void CWkeWindow::readJsFile(const wchar_t* path, std::vector* buffer) +{ + HANDLE hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (INVALID_HANDLE_VALUE == hFile) { + //DebugBreak(); + return; + } + + DWORD fileSizeHigh; + const DWORD bufferSize = ::GetFileSize(hFile, &fileSizeHigh); + + DWORD numberOfBytesRead = 0; + buffer->resize(bufferSize); + BOOL b = ::ReadFile(hFile, &buffer->at(0), bufferSize, &numberOfBytesRead, nullptr); + ::CloseHandle(hFile); +} +// ص:ȡ¼ٶ̵cookie +void CWkeWindow::GetLoginCookieCallBack(wkeWebView webWindow, void* param) +{ + if (!param)return; + wkeShowWindow(webWindow, true); + std::string Url = wkeGetURL(webWindow); + int npos = Url.find("disk/home?"); + if (npos != std::string::npos) + { + ((CWkeWindow*)param)->isLogin = true; + ((CWkeWindow*)param)->strCookies = wkeGetCookie(webWindow); + OutputDebugStringA(wkeGetCookie(webWindow)); + /* + Ѿ¼ٶõ¼ٶȵİť + */ + wkeRunJS(app.window, "app.tablelistisShwo = true;"); + jsExecState es = wkeGlobalExec(app.window); + jsValue thisObject = jsGetGlobal(es, "app"); + bool b = jsIsObject(thisObject); + jsValue func = jsGet(es, thisObject, "updateBaiduList"); + std::string argJson = ((CWkeWindow*)param)->m_BaiduPare.GetBaiduFileListInfo("/", ((CWkeWindow*)param)->strCookies); + //argJson = Utf8_To_Gbk(argJson.c_str()); + jsValue jsArg[1] = { jsString(es, argJson.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); + wkeDestroyWebWindow(webWindow); + } +} +wkeWebView CWkeWindow::onCreateView(wkeWebView webWindow, void* param, wkeNavigationType navType, const wkeString url, const wkeWindowFeatures* features) +{ + if (!param)return webWindow; + std::string StrUrl(wkeGetString(url)); + ::OutputDebugStringA(wkeGetString(url)); + wkeWebView newWindow = wkeCreateWebWindow(WKE_WINDOW_TYPE_POPUP, NULL, features->x, features->y, features->width, features->height); + wkeSetCspCheckEnable(newWindow, false); + if (StrUrl.find("pan.baidu.com") != std::string::npos) + { + wkeOnDocumentReady(newWindow, GetLoginCookieCallBack, param); + //wkeSetDebugConfig(app.window, "showDevTools", GetInstance()->m_BaiduPare.Gbk_To_Utf8("E:\\vs2013\\Win32\\BaiduCdp\\Debug\\front_end\\inspector.html").c_str()); + } + wkeShowWindow(newWindow, true); + return newWindow; +} + +void CWkeWindow::UpdateDownloadList(const std::string& strJson) +{ + jsExecState es = wkeGlobalExec(app.window); + jsValue thisObject = jsGetGlobal(es, "app"); + jsValue func = jsGet(es, thisObject, "UpateDownloadlist"); + jsValue jsArg[1] = { jsString(es, strJson.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); +} + +jsValue CWkeWindow::SysMenuJsNativeFunction(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + //ȡ + int argCount = jsArgCount(es); + if (argCount < 1) + return jsUndefined(); + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return jsUndefined(); + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + if (arg0str == CLOSE_MSG) + ((CWkeWindow*)param)->blinkClose(); + else if (arg0str == MAX_MSG) + ((CWkeWindow*)param)->blinkMaximize(); + else if (arg0str == MIN_MSG) + ((CWkeWindow*)param)->blinkMinimize(); + return jsUndefined(); +} +void CWkeWindow::blinkMaximize() +{ + HWND hwnd = getHWND(); + static bool isMax = true; + if (isMax) + ::PostMessageW(hwnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0); + else + ::PostMessageW(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0); + isMax = !isMax; +} + +void CWkeWindow::blinkMinimize() +{ + HWND hwnd = getHWND(); + ::PostMessageW(hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0); +} + +void CWkeWindow::blinkClose() +{ + HWND hwnd = getHWND(); + ::PostMessageW(hwnd, WM_CLOSE, 0, 0); +} +HWND CWkeWindow::getHWND() +{ + + if (app.window) + return wkeGetWindowHandle(app.window); + return NULL; +} + +jsValue CWkeWindow::IsLoginBaidu(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + int argCount = jsArgCount(es); + if (argCount != 0) + return jsUndefined(); + jsValue result = jsInt(0); + if (!((CWkeWindow*)param)->strCookies.empty() && ((CWkeWindow*)param)->isLogin) + result = jsInt(1); + return result; +} + +jsValue CWkeWindow::SwitchDirPath(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + jsValue result = jsInt(0); + //ȡ + int argCount = jsArgCount(es); + if (argCount < 1) + return jsUndefined(); + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return jsUndefined(); + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + //jsExecState es = wkeGlobalExec(app.window); + arg0str = ((CWkeWindow*)param)->m_BaiduPare.Utf8_To_Gbk(arg0str.c_str()); + jsValue thisObject = jsGetGlobal(es, "app"); + bool b = jsIsObject(thisObject); + jsValue func = jsGet(es, thisObject, "updateBaiduList"); + std::string argJson = ((CWkeWindow*)param)->m_BaiduPare.GetBaiduFileListInfo(arg0str, ((CWkeWindow*)param)->strCookies); + jsValue jsArg[1] = { jsString(es, argJson.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); + result = jsInt(1); + return result; +} + +jsValue CWkeWindow::DownloadUserFile(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + //ȡ + int argCount = jsArgCount(es); + if (argCount < 1) + return jsUndefined(); + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return jsUndefined(); + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + arg0str = ((CWkeWindow*)param)->m_BaiduPare.Utf8_To_Gbk(arg0str.c_str()); + arg0str = ((CWkeWindow*)param)->m_BaiduPare.URL_Coding(arg0str.c_str()); + arg0str = ((CWkeWindow*)param)->m_BaiduPare.GetBaiduLocalFileAddr(arg0str, ((CWkeWindow*)param)->strCookies); + return jsUndefined(); +} + +jsValue CWkeWindow::ShareBaiduFile(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + int argCount = jsArgCount(es); + if (argCount < 3) + return jsUndefined(); + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return jsUndefined(); + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + std::string strRetResult; + SHAREFILEINFO shareinfo; + if (arg0str == "1") //˽ܷ + { + type = jsArgType(es, 1); + if (JSTYPE_NUMBER !=type) + return jsString(es, strRetResult.c_str()); + jsValue arg1 = jsArg(es, 1); + int period = jsToInt(es, arg1); + type = jsArgType(es, 2); + if (JSTYPE_STRING != type) + return jsString(es, strRetResult.c_str()); + jsValue arg2 = jsArg(es, 2); + std::string fid_list = jsToTempString(es, arg2); + type = jsArgType(es, 3); + if (JSTYPE_STRING != type) + return jsString(es, strRetResult.c_str()); + jsValue arg3 = jsArg(es, 3); + std::string pwd = jsToTempString(es, arg3); + switch (period) + { + case 0: //÷ + { + shareinfo.nschannel = 1; + shareinfo.strpath_list = fid_list; + shareinfo.strPwd = pwd; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + case 7: //7 + { + shareinfo.nschannel = 1; + shareinfo.strpath_list = fid_list; + shareinfo.strPwd = pwd; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + case 1: //1 + { + shareinfo.nschannel = 1; + shareinfo.strpath_list = fid_list; + shareinfo.strPwd = pwd; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + default: + break; + } + }else if (arg0str == "2") // + { + type = jsArgType(es, 1); + if (JSTYPE_NUMBER != type) + return jsString(es, strRetResult.c_str()); + jsValue arg1 = jsArg(es, 1); + int period = jsToInt(es, arg1); + type = jsArgType(es, 2); + if (JSTYPE_STRING != type) + return jsString(es, strRetResult.c_str()); + jsValue arg2 = jsArg(es, 2); + std::string fid_list = jsToTempString(es, arg2); + switch (period) + { + case 0: //÷ + { + shareinfo.nschannel = 0; + shareinfo.strpath_list = fid_list; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + case 7: //7 + { + shareinfo.nschannel = 0; + shareinfo.strpath_list = fid_list; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + case 1: //1 + { + shareinfo.nschannel = 0; + shareinfo.strpath_list = fid_list; + shareinfo.strperiod = std::to_string(period); + strRetResult = ((CWkeWindow*)param)->m_BaiduPare.ShareBaiduFile(shareinfo, ((CWkeWindow*)param)->strCookies); + } + break; + default: + break; + } + } + return jsString(es, strRetResult.c_str()); +} + +jsValue CWkeWindow::DeleteBaiduFile(jsExecState es, void* param) +{ + if (!param)return jsUndefined(); + int argCount = jsArgCount(es); + if (argCount < 1) + return jsUndefined(); + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return jsUndefined(); + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + std::string argJson = ((CWkeWindow*)param)->m_BaiduPare.DeleteBaiduFile(arg0str, ((CWkeWindow*)param)->strCookies); + jsValue thisObject = jsGetGlobal(es, "app"); + jsValue func = jsGet(es, thisObject, "updateBaiduList"); + jsValue jsArg[1] = { jsString(es, argJson.c_str()) }; + jsCall(es, func, thisObject, jsArg, 1); + return jsUndefined(); +} + +jsValue CWkeWindow::DownShareFile(jsExecState es, void* param) +{ + jsValue bResult = jsInt(0); + if (!param)return jsUndefined(); + int argCount = jsArgCount(es); + if (argCount < 1) + return bResult; + jsType type = jsArgType(es, 0); + if (JSTYPE_STRING != type) + return bResult; + jsValue arg0 = jsArg(es, 0); + std::string arg0str = jsToTempString(es, arg0); + int nType = ((CWkeWindow*)param)->JudgeDownUrlType(arg0str); + switch (nType) + { + case 1: /*ٶ*/ + { + REQUESTINFO rResult; + std::string strJson; + ZeroMemory(&rResult, sizeof(REQUESTINFO)); + std::string strTempCookie(((CWkeWindow*)param)->strCookies); + if (strTempCookie.empty()) + return bResult; + rResult = ((CWkeWindow*)param)->m_BaiduPare.ParseBaiduAddr(arg0str.c_str(), strTempCookie); + rResult.strSavePath = "d:/pdf"; + rResult.strFileName = GetInstance()->m_BaiduPare.Utf8_To_Gbk(rResult.strFileName.c_str()); + strJson = ((CWkeWindow*)param)->CreateDowndAria2Json(rResult); + ((CWkeWindow*)param)->SendText(strJson); + bResult = jsInt(1); + } + break; + case 2: /**/ + { + + } + break; + case 3:/*ͨ*/ + { + + } + break; + default: + { + REQUESTINFO rResult; + std::string strJson; + ZeroMemory(&rResult, sizeof(REQUESTINFO)); + rResult.strDownloadUrl = arg0str; + rResult.strSavePath = "d:/pdf"; + strJson = ((CWkeWindow*)param)->CreateDowndAria2Json(rResult); + ((CWkeWindow*)param)->SendText(strJson); + bResult = jsInt(1); + } + break; + } + return bResult; +} + +int CWkeWindow::JudgeDownUrlType(const std::string& strUrl) +{ + int nResult = 0; + if (strUrl.empty()) + return nResult; + std::string StrHost; + StrHost = CarkUrl(strUrl.c_str()); + if (!_strcmpi(StrHost.c_str(), "http://pan.baidu.com")) + nResult = 1; + else if (!_strcmpi(StrHost.c_str(), "http://www.lanzous.com")) + nResult = 2; + else if (StrHost.find("ctfile.com")!=std::string::npos) + { + nResult = 3; + } + return nResult; +} + +std::string CWkeWindow::CreateDowndAria2Json(REQUESTINFO& Downdinfo) +{ + std::string strResultJson; + if (Downdinfo.strDownloadUrl.empty()) + return strResultJson; + rapidjson::Document dc; + dc.SetObject(); + rapidjson::Value Method(rapidjson::kStringType); + const char method[] = "aria2.addUri"; + Method.SetString(method, strlen(method), dc.GetAllocator()); + dc.AddMember(rapidjson::StringRef("method"), Method, dc.GetAllocator()); + rapidjson::Value Params(rapidjson::kArrayType); + rapidjson::Value token(rapidjson::kStringType); + token.SetString("token:CDP", strlen("token:CDP"), dc.GetAllocator()); + Params.PushBack(token, dc.GetAllocator()); + rapidjson::Value downloadUrlList(rapidjson::kArrayType); + for (size_t i = 0; i < 18;i++) + { + rapidjson::Value downloadUrl(rapidjson::kStringType); + downloadUrl.SetString(Downdinfo.strDownloadUrl.c_str(), Downdinfo.strDownloadUrl.length(), dc.GetAllocator()); + downloadUrlList.PushBack(downloadUrl,dc.GetAllocator()); + } + Params.PushBack(downloadUrlList,dc.GetAllocator()); + rapidjson::Value itemObj(rapidjson::kObjectType); + rapidjson::Value out(rapidjson::kStringType); + out.SetString(Downdinfo.strFileName.c_str(), Downdinfo.strFileName.length(), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("out"), out, dc.GetAllocator()); + rapidjson::Value dir(rapidjson::kStringType); + dir.SetString(Downdinfo.strSavePath.c_str(), Downdinfo.strSavePath.length(), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("dir"), dir, dc.GetAllocator()); + rapidjson::Value user_agent(rapidjson::kStringType); + user_agent.SetString(USER_AGENT, strlen(USER_AGENT), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("user-agent"), user_agent, dc.GetAllocator()); + rapidjson::Value max_tries(rapidjson::kStringType); + max_tries.SetString("10", strlen("10"), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("max-tries"), max_tries, dc.GetAllocator()); + rapidjson::Value timeout(rapidjson::kStringType); + timeout.SetString("5", strlen("5"), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("timeout"), timeout, dc.GetAllocator()); + rapidjson::Value connect_timeout(rapidjson::kStringType); + connect_timeout.SetString("5", strlen("5"), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("connect-timeout"), connect_timeout, dc.GetAllocator()); + rapidjson::Value split(rapidjson::kStringType); + split.SetString("128", strlen("128"), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("split"), split, dc.GetAllocator()); + rapidjson::Value retry_wait(rapidjson::kStringType); + retry_wait.SetString("10", strlen("10"), dc.GetAllocator()); + itemObj.AddMember(rapidjson::StringRef("retry-wait"), retry_wait, dc.GetAllocator()); + Params.PushBack(itemObj, dc.GetAllocator()); + dc.AddMember(rapidjson::StringRef("params"), Params, dc.GetAllocator()); + rapidjson::Value id(rapidjson::kNumberType); + id.SetInt(1); + dc.AddMember(rapidjson::StringRef("id"), id, dc.GetAllocator()); + rapidjson::Value jsonrpc(rapidjson::kStringType); + jsonrpc.SetString("2.0", strlen("2.0"), dc.GetAllocator()); + dc.AddMember(rapidjson::StringRef("jsonrpc"), jsonrpc, dc.GetAllocator()); + rapidjson::StringBuffer buffer; + rapidjson::Writer writer(buffer); + dc.Accept(writer); + strResultJson = buffer.GetString(); + strResultJson = m_BaiduPare.Gbk_To_Utf8(strResultJson.c_str()); + return strResultJson; +} + +CWkeWindow::CWkeWindow() +:isLogin(false), +strCookies(""), +m_hwnd(NULL), +numActive(NULL), +numStopped(NULL) +{ + try + { + if (!InintMiniBlink()) + { + throw std::logic_error("Environment initialization failed"); + } + } + catch (...) + { + //Դ־ֱӽ + exit(0); + } + /* + ʼASIO + */ + m_WssClient.init_asio(); + // Register our handlers + m_WssClient.set_socket_init_handler(bind(&CWkeWindow::on_socket_init, this, ::_1)); + m_WssClient.set_message_handler(bind(&CWkeWindow::on_message, this, ::_1, ::_2)); + m_WssClient.set_open_handler(bind(&CWkeWindow::on_open, this, ::_1)); + m_WssClient.set_close_handler(bind(&CWkeWindow::on_close, this, ::_1)); + m_WssClient.set_fail_handler(bind(&CWkeWindow::on_fail, this, ::_1)); + if (RunAria2()) + { + m_RunThreadPtr.reset(new std::thread(&CWkeWindow::Connect, this)); + } +} + +CWkeWindow::~CWkeWindow() +{ + if (m_RunThreadPtr) + { + if (m_RunThreadPtr->joinable()) + { + if(m_hdl.lock().get()) + { + m_WssClient.close(m_hdl, websocketpp::close::status::going_away, "close"); + } + m_RunThreadPtr->join(); + } + m_RunThreadPtr.reset(); + } +} +CWkeWindow* CWkeWindow::GetInstance() +{ + if (Instance == NULL) + { + g_mutx.lock(); + if (!Instance.get()) + { + //std::shared_ptr temp = std::shared_ptr(new CWkeWindow); + Instance.reset(new CWkeWindow); + } + g_mutx.unlock(); + } + return Instance.get(); +} diff --git a/WkeWindow.h b/WkeWindow.h new file mode 100644 index 0000000..f7ac4fa --- /dev/null +++ b/WkeWindow.h @@ -0,0 +1,258 @@ +#ifndef __WKEWINDOW__ +#define __WKEWINDOW__ +#include +#include +#include "GlobalHeader.h" +#include "PanParse.h" +typedef websocketpp::client client; +using websocketpp::lib::placeholders::_1; +using websocketpp::lib::placeholders::_2; +using websocketpp::lib::bind; +// pull out the type of messages sent by our config +typedef websocketpp::config::asio_tls_client::message_type::ptr message_ptr; +typedef websocketpp::lib::shared_ptr context_ptr; +typedef client::connection_ptr connection_ptr; +typedef struct downFileListInfo +{ + std::string connections; //ǰӷ + std::string DownloadSpeed; // ٶ + size_t Downloadpercentage;//ؽȰٷֱ + std::string strFileName; + std::string strFileGid; + UINT nErrCode; + std::string strErrMessage; +}DOWNFILELISTINFO; +typedef std::vector ActiceDownloadList; +/* +ǰ״̬ +activeĿǰ +waitingڶе; δ +pausedͣء +errorֹͣء +completeֹͣء +removedûɾ +*/ +#define ARIA2_STATUS_ACTIVE "active" +#define ARIA2_STATUS_WAITING "waiting" +#define ARIA2_STATUS_PAUSED "paused" +#define ARIA2_STATUS_ERROR "error" +#define ARIA2_STATUS_COMPLETE "complete" +#define ARIA2_STATUS_REMOVED "removed" +typedef struct downloadStatus +{ + std::string strFileGid; //Ψһıʶ + std::string strFileStatus; +}DOWNLOADSTATUS; +/* +ԶϢ +*/ +#define ARIA2_ADDURL_MSG WM_USER + 0x101 +#define ARIA2_DOWNLOAD_START_MSG WM_USER + 0x102 +#define ARIA2_DOWNLOAD_COMPLATE_MSG WM_USER + 0x103 +#define ARIA2_DOWNLOAD_PAUSE_MSG WM_USER + 0x104 +#define ARIA2_DOWNLOAD_STOP_MSG WM_USER + 0x105 +#define ARIA2_DOWNLOAD_ERROR_MSG WM_USER + 0x106 +#define ARIA2_UPDATE_TELLACTIVE_LIST_MSG WM_USER +0x107 +#define ARIA2_UPDATE_TELLERROR_LIST_MSG WM_USER +0x108 +/* +ԶϢ +*/ +/*Aria2״̬*/ +#define ARIA2_DOWNLOAD_START "aria2.onDownloadStart" +#define ARIA2_DOWNLOAD_COMPLATE "aria2.onDownloadComplete" +#define ARIA2_DOWNLOAD_PAUSE "aria2.onDownloadPause" +#define ARIA2_DOWNLOAD_STOP "aria2.onDownloadStop" +#define ARIA2_DOWNLOAD_ERROR "aria2.onDownloadError" +/*Aria2״̬end*/ +/*ͲѯĹ̶*/ +#define ARIA2_TELLACTICE_SENDDATA "{\"method\":\"aria2.tellActive\",\"params\":[\"token:CDP\",[\"gid\",\"status\",\"files\",\"totalLength\",\"completedLength\",\"downloadSpeed\",\"connections\",\"errorCode\",\"errorMessage\"]],\"id\":1,\"jsonrpc\":\"2.0\"}" +#define ARIA2_GETGLOBAL_STATUS "{\"method\":\"aria2.getGlobalStat\",\"params\":[\"token:CDP\"],\"id\":1,\"jsonrpc\":\"2.0\"}" +#define ARIA2_TELLSTOPPED "{\"method\":\"aria2.tellStopped\",\"params\":[\"token:CDP\",0,3,[\"gid\",\"status\",\"totalLength\",\"completedLength\",\"downloadSpeed\",\"connections\",\"errorCode\",\"errorMessage\",\"files\"]],\"id\":1,\"jsonrpc\":\"2.0\"}" +#define ARIA2_PURGEDOWNLOAD_RESULT "{\"method\":\"aria2.purgeDownloadResult\",\"params\":[\"token:CDP\"],\"id\":1,\"jsonrpc\":\"2.0\"}" +//öʱ·Ͳѯ +#define UPDTAE_UI_TIMEID 508 +class CWkeWindow +{ +public: + ~CWkeWindow(); + static CWkeWindow* GetInstance(); +private: + explicit CWkeWindow(); + CWkeWindow(const CWkeWindow&); + CWkeWindow& operator =(const CWkeWindow&); + static std::shared_ptr Instance; +private: + + /* + жǷ񴥷 ٶȵ¼ɹص + */ + bool isLogin; + /* + ٶȵ¼ЧCookie + */ + std::string strCookies; + /*ٶ̽*/ + CBaiduParse m_BaiduPare; + /* + Wss + */ + client m_WssClient; + /*ڵĴھ*/ + HWND m_hwnd; + //ڵ»ص + static LRESULT CALLBACK MainProc( + _In_ HWND hwnd, + _In_ UINT uMsg, + _In_ WPARAM wParam, + _In_ LPARAM lParam + ); + static WNDPROC m_oldProc; + //ڴͶڴҪͷ + void* AlloclocalHeap(const std::string& strBuffer); + //aria2˷ + void ParseAria2JsonInfo(const std::string& strJSon); + //aria2ǰ + size_t numActive; + //aria2 ǰʧܵ + size_t numStopped; + //ȡļС + inline std::string GetFileSizeType(double dSize); + //ȡٷֱ + inline double Getpercentage(double completedLength, double totalLength); + //洢ǰصGID + std::vector m_DownloadArray; + //ΨһʶUIȡļϢ + std::string GetFileCompletedInfo(const std::string& strGid); + //ִֹͣʱ + std::vector m_ErrorArray; + private: + /*wssػصʼ*/ + //socket init + void on_socket_init(websocketpp::connection_hdl); + //շ˷Ϣ + void on_message(websocketpp::connection_hdl hdl, message_ptr); + //ͻ˽ʱĻص + void on_open(websocketpp::connection_hdl hdl); + //յرʱĻص + void on_close(websocketpp::connection_hdl); + //յʧϢʱĻص + void on_fail(websocketpp::connection_hdl hdl); + //ӳɹ󷵻Ӿ + websocketpp::connection_hdl m_hdl; + //˵ + void start(std::string uri); + //aria2 + BOOL RunAria2(); + //ӵaria2WSS + void Connect(); + //ıݸ + void SendText(std::string& strText); + /*wssػص*/ + //wssҪһ߳ + std::shared_ptr m_RunThreadPtr; + //ݸAria2Ķʱص + static void CALLBACK TimeProc(HWND hwnd, UINT message, UINT iTimerID, DWORD dwTime); +public: + /* + @ + */ + void runApp(Application* app); + /* + @ Ҫijûøֻص + */ + bool createWebWindow(Application* app); + /* + Ϣѭ + */ + void runMessageLoop(Application* app); + /* + ˳ + */ + void quitApplication(Application* app); + /* + ȡwebWindowھ + */ + HWND getHWND(); + void blinkMaximize(); + void blinkMinimize(); + void blinkClose(); + /* + ϵͳ˵JSص + */ + static jsValue SysMenuJsNativeFunction(jsExecState es, void* param); + /* + ֤ǷѾЧĵ¼˰ٶ + */ + static jsValue IsLoginBaidu(jsExecState es, void* param); + + /* + ļص + */ + static jsValue ShareBaiduFile(jsExecState es, void* param); + + /* + ɾļļ + */ + static jsValue DeleteBaiduFile(jsExecState es, void* param); + /* + ˹رյĻص true ٴڣ false ʲô + */ + static bool OnCloseCallBack(wkeWebView webWindow, void* param); + /* + ص + */ + static void OnWindowDestroy(wkeWebView webWindow, void* param); + /* + صĵسɹ + */ + static void OnDocumentReady(wkeWebView webWindow, void* param); + /* + ص ҳʱĻص hook + */ + static bool onLoadUrlBegin(wkeWebView webView, void* param, const char* url, void *job); + // ص:ȡ¼ٶ̵cookie + static void GetLoginCookieCallBack(wkeWebView webWindow, void* param); + /* + лĿ¼ + */ + static jsValue SwitchDirPath(jsExecState es, void* param); + /* + û̵ļ + */ + static jsValue DownloadUserFile(jsExecState es, void* param); + /*ط*/ + static jsValue DownShareFile(jsExecState es, void* param); + /*жطʲô + 1ٶ 2 3ͨ 0 ֪صַ + */ + int JudgeDownUrlType(const std::string& strUrl); + /* + װAria2صjsonϢ + */ + std::string CreateDowndAria2Json(REQUESTINFO& Downdinfo); + /* صµҳ棬˵ window.open ߵ */ + static wkeWebView onCreateView(wkeWebView webWindow, void* param, wkeNavigationType navType, const wkeString url, const wkeWindowFeatures* features); + /*صбݵUI*/ + void UpdateDownloadList(const std::string& strJson); + /* + ֽURLӵַȡ + */ + std::string CarkUrl(const char* url); + /* + ȡԴĿ¼ + */ + std::wstring getResourcesPath(const std::wstring name); + /* + ת + */ + std::wstring utf8ToUtf16(const std::string& utf8String); + /* + ȡļԴ + */ + void readJsFile(const wchar_t* path, std::vector* buffer); + /* + @ ʼminiblink + */ + bool InintMiniBlink(); +}; +#endif diff --git a/base64.h b/base64.h new file mode 100644 index 0000000..e0ab6ff --- /dev/null +++ b/base64.h @@ -0,0 +1,130 @@ +/** + * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * @author baidu aip + */ +#ifndef __AIP_BASE64_H__ +#define __AIP_BASE64_H__ + +#include +#include + +namespace aip { + + static const std::string base64_chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + + + static inline bool is_base64(const char c) + { + return (isalnum(c) || (c == '+') || (c == '/')); + } + + std::string base64_encode(const char * bytes_to_encode, unsigned int in_len) + { + std::string ret; + int i = 0; + int j = 0; + unsigned char char_array_3[3]; + unsigned char char_array_4[4]; + + while (in_len--) + { + char_array_3[i++] = *(bytes_to_encode++); + if(i == 3) + { + char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; + char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); + char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); + char_array_4[3] = char_array_3[2] & 0x3f; + + for(i = 0; (i <4) ; i++) + { + ret += base64_chars[char_array_4[i]]; + } + i = 0; + } + } + + if(i) + { + for(j = i; j < 3; j++) + { + char_array_3[j] = '\0'; + } + + char_array_4[0] = (char_array_3[0] & 0xfc) >> 2; + char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4); + char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6); + char_array_4[3] = char_array_3[2] & 0x3f; + + for(j = 0; (j < i + 1); j++) + { + ret += base64_chars[char_array_4[j]]; + } + + while((i++ < 3)) + { + ret += '='; + } + + } + + return ret; + } + + std::string base64_decode(std::string const & encoded_string) + { + int in_len = (int) encoded_string.size(); + int i = 0; + int j = 0; + int in_ = 0; + unsigned char char_array_4[4], char_array_3[3]; + std::string ret; + + while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) { + char_array_4[i++] = encoded_string[in_]; in_++; + if (i ==4) { + for (i = 0; i <4; i++) + char_array_4[i] = base64_chars.find(char_array_4[i]); + + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (i = 0; (i < 3); i++) + ret += char_array_3[i]; + i = 0; + } + } + + if (i) { + for (j = i; j <4; j++) + char_array_4[j] = 0; + + for (j = 0; j <4; j++) + char_array_4[j] = base64_chars.find(char_array_4[j]); + + char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (j = 0; (j < i - 1); j++) ret += char_array_3[j]; + } + + return ret; + } + +} +#endif diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..f1232ba --- /dev/null +++ b/main.cpp @@ -0,0 +1,31 @@ +#include "WkeWindow.h" +Application app; +HINSTANCE g_hInstance; +int APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nShowCmd) +{ + UNREFERENCED_PARAMETER(hPrevInstance); + UNREFERENCED_PARAMETER(lpCmdLine); + g_hInstance = hInstance; + CWkeWindow* wkeWindow = CWkeWindow::GetInstance(); + wkeWindow->runApp(&app); + wkeFinalize(); + return 0; +} +#if 0 +//2013ͻ +/*ǹVS2012⣬ôȻVS2013д +c++11 thread join()̷߳ +ϸμ https://stackoverflow.com/questions/10915233/stdthreadjoin-hangs-if-called-after-main-exits-when-using-vs2012-rc +*/ +#pragma warning(disable:4073) +#pragma init_seg(lib) +#if _MSC_VER < 1900 +struct VS2013_threading_fix +{ + VS2013_threading_fix() + { + _Cnd_do_broadcast_at_thread_exit(); + } +} threading_fix; +#endif +#endif \ No newline at end of file diff --git a/resource.h b/resource.h new file mode 100644 index 0000000000000000000000000000000000000000..21566bce51c9dde4fe91936e7899d46b029508f4 GIT binary patch literal 1236 zcmb7^-Acni5QPtdH-g|BxZsUYu&wq5+B8V8NlKFxy;}N{LZr0Pm@0^PBlr-$rg~Ndhi8f4hc{%#YfdPvv53d}@IHGM80yZLyu)rKK zuL&OcuFrQd5)3fq%0Puf;50cIzAq2GivJOQIR~{hHqmqohd-Ntn(wj%Fh zo6OcCTke^8%DybjyM=&cpA~U)?SLwn z>h)4*_uRy536N7Nhoc{;CIS zk6D3Fj~Z*zT2-`zJ5oH}ZEDx$+RLq&T*a33F>$MVtvDWi0 + +////////////////////////////////////////////////////////////////////////// +#define WKE_CALL_TYPE __cdecl + +typedef struct { + int x; + int y; + int w; + int h; +} wkeRect; + +typedef struct { + int x; + int y; +} wkePoint; + +typedef enum { + WKE_LBUTTON = 0x01, + WKE_RBUTTON = 0x02, + WKE_SHIFT = 0x04, + WKE_CONTROL = 0x08, + WKE_MBUTTON = 0x10, +} wkeMouseFlags; + +typedef enum { + WKE_EXTENDED = 0x0100, + WKE_REPEAT = 0x4000, +} wkeKeyFlags; + +typedef enum { + WKE_MSG_MOUSEMOVE = 0x0200, + WKE_MSG_LBUTTONDOWN = 0x0201, + WKE_MSG_LBUTTONUP = 0x0202, + WKE_MSG_LBUTTONDBLCLK = 0x0203, + WKE_MSG_RBUTTONDOWN = 0x0204, + WKE_MSG_RBUTTONUP = 0x0205, + WKE_MSG_RBUTTONDBLCLK = 0x0206, + WKE_MSG_MBUTTONDOWN = 0x0207, + WKE_MSG_MBUTTONUP = 0x0208, + WKE_MSG_MBUTTONDBLCLK = 0x0209, + WKE_MSG_MOUSEWHEEL = 0x020A, +} wkeMouseMsg; + +#if !defined(__cplusplus) +#ifndef HAVE_WCHAR_T +typedef unsigned short wchar_t; +#endif + +#define bool _Bool +#define false 0 +#define true 1 + +#endif + +#if defined(__cplusplus) +#define WKE_EXTERN_C extern "C" +#else +#define WKE_EXTERN_C +#endif + +typedef char utf8; +#if !defined(__cplusplus) +typedef void* jsExecState; +#else +struct JsExecStateInfo; +typedef JsExecStateInfo* jsExecState; +#endif +typedef __int64 jsValue; + +#if defined(__cplusplus) +namespace wke { class CWebView; }; +typedef wke::CWebView* wkeWebView; + +namespace wke { class CString; }; +typedef wke::CString* wkeString; + +#else +struct _tagWkeWebView; +typedef struct _tagWkeWebView* wkeWebView; + +struct _tagWkeString; +typedef struct _tagWkeString* wkeString; +#endif + +#if defined(__cplusplus) +namespace wke { class WkeMediaPlayer; }; +typedef wke::WkeMediaPlayer* wkeMediaPlayer; + +namespace wke { class WkeMediaPlayerClient; }; +typedef wke::WkeMediaPlayerClient* wkeMediaPlayerClient; +#else +typedef struct _tagWkeMediaPlayer* wkeMediaPlayer; +typedef struct _tagWkeMediaPlayerClient* wkeMediaPlayerClient; +#endif + +typedef enum { + WKE_PROXY_NONE, + WKE_PROXY_HTTP, + WKE_PROXY_SOCKS4, + WKE_PROXY_SOCKS4A, + WKE_PROXY_SOCKS5, + WKE_PROXY_SOCKS5HOSTNAME +} wkeProxyType; + +typedef struct { + wkeProxyType type; + char hostname[100]; + unsigned short port; + char username[50]; + char password[50]; +} wkeProxy; + +enum wkeSettingMask { + WKE_SETTING_PROXY = 1, + WKE_SETTING_PAINTCALLBACK_IN_OTHER_THREAD = 1 << 2, +}; + +typedef struct _wkeSettings { + wkeProxy proxy; + unsigned int mask; +} wkeSettings; + +typedef struct { + int size; + unsigned int bgColor; +} wkeViewSettings; + +typedef void* wkeWebFrameHandle; + +typedef void* (WKE_CALL_TYPE *FILE_OPEN_) (const char* path); +typedef void(WKE_CALL_TYPE *FILE_CLOSE_) (void* handle); +typedef size_t(WKE_CALL_TYPE *FILE_SIZE) (void* handle); +typedef int(WKE_CALL_TYPE *FILE_READ) (void* handle, void* buffer, size_t size); +typedef int(WKE_CALL_TYPE *FILE_SEEK) (void* handle, int offset, int origin); + +typedef FILE_OPEN_ WKE_FILE_OPEN; +typedef FILE_CLOSE_ WKE_FILE_CLOSE; +typedef FILE_SIZE WKE_FILE_SIZE; +typedef FILE_READ WKE_FILE_READ; +typedef FILE_SEEK WKE_FILE_SEEK; +typedef bool(WKE_CALL_TYPE *WKE_EXISTS_FILE)(const char * path); + +struct _wkeClientHandler; // declare warning fix +typedef void(WKE_CALL_TYPE *ON_TITLE_CHANGED) (const struct _wkeClientHandler* clientHandler, const wkeString title); +typedef void(WKE_CALL_TYPE *ON_URL_CHANGED) (const struct _wkeClientHandler* clientHandler, const wkeString url); + +typedef struct _wkeClientHandler { + ON_TITLE_CHANGED onTitleChanged; + ON_URL_CHANGED onURLChanged; +} wkeClientHandler; + +typedef bool(WKE_CALL_TYPE * wkeCookieVisitor)( + void* params, + const char* name, + const char* value, + const char* domain, + const char* path, // If |path| is non-empty only URLs at or below the path will get the cookie value. + int secure, // If |secure| is true the cookie will only be sent for HTTPS requests. + int httpOnly, // If |httponly| is true the cookie will only be sent for HTTP requests. + int* expires // The cookie expiration date is only valid if |has_expires| is true. + ); + +typedef enum { + wkeCookieCommandClearAllCookies, + wkeCookieCommandClearSessionCookies, + wkeCookieCommandFlushCookiesToFile, + wkeCookieCommandReloadCookiesFromFile, +} wkeCookieCommand; + +typedef enum { + WKE_NAVIGATION_TYPE_LINKCLICK, + WKE_NAVIGATION_TYPE_FORMSUBMITTE, + WKE_NAVIGATION_TYPE_BACKFORWARD, + WKE_NAVIGATION_TYPE_RELOAD, + WKE_NAVIGATION_TYPE_FORMRESUBMITT, + WKE_NAVIGATION_TYPE_OTHER +} wkeNavigationType; + +typedef enum { + WkeCursorInfoPointer, + WkeCursorInfoCross, + WkeCursorInfoHand, + WkeCursorInfoIBeam, + WkeCursorInfoWait, + WkeCursorInfoHelp, + WkeCursorInfoEastResize, + WkeCursorInfoNorthResize, + WkeCursorInfoNorthEastResize, + WkeCursorInfoNorthWestResize, + WkeCursorInfoSouthResize, + WkeCursorInfoSouthEastResize, + WkeCursorInfoSouthWestResize, + WkeCursorInfoWestResize, + WkeCursorInfoNorthSouthResize, + WkeCursorInfoEastWestResize, + WkeCursorInfoNorthEastSouthWestResize, + WkeCursorInfoNorthWestSouthEastResize, + WkeCursorInfoColumnResize, + WkeCursorInfoRowResize, + WkeCursorInfoMiddlePanning, + WkeCursorInfoEastPanning, + WkeCursorInfoNorthPanning, + WkeCursorInfoNorthEastPanning, + WkeCursorInfoNorthWestPanning, + WkeCursorInfoSouthPanning, + WkeCursorInfoSouthEastPanning, + WkeCursorInfoSouthWestPanning, + WkeCursorInfoWestPanning, + WkeCursorInfoMove, + WkeCursorInfoVerticalText, + WkeCursorInfoCell, + WkeCursorInfoContextMenu, + WkeCursorInfoAlias, + WkeCursorInfoProgress, + WkeCursorInfoNoDrop, + WkeCursorInfoCopy, + WkeCursorInfoNone, + WkeCursorInfoNotAllowed, + WkeCursorInfoZoomIn, + WkeCursorInfoZoomOut, + WkeCursorInfoGrab, + WkeCursorInfoGrabbing, + WkeCursorInfoCustom +} WkeCursorInfoType; + +typedef struct { + int x; + int y; + int width; + int height; + + bool menuBarVisible; + bool statusBarVisible; + bool toolBarVisible; + bool locationBarVisible; + bool scrollbarsVisible; + bool resizable; + bool fullscreen; +} wkeWindowFeatures; + +typedef struct { + int size; + void* data; + size_t length; +} wkeMemBuf; + +typedef struct { + struct Item { + enum wkeStorageType { + // String data with an associated MIME type. Depending on the MIME type, there may be + // optional metadata attributes as well. + StorageTypeString, + // Stores the name of one file being dragged into the renderer. + StorageTypeFilename, + // An image being dragged out of the renderer. Contains a buffer holding the image data + // as well as the suggested name for saving the image to. + StorageTypeBinaryData, + // Stores the filesystem URL of one file being dragged into the renderer. + StorageTypeFileSystemFile, + } storageType; + + // Only valid when storageType == StorageTypeString. + wkeMemBuf* stringType; + wkeMemBuf* stringData; + + // Only valid when storageType == StorageTypeFilename. + wkeMemBuf* filenameData; + wkeMemBuf* displayNameData; + + // Only valid when storageType == StorageTypeBinaryData. + wkeMemBuf* binaryData; + + // Title associated with a link when stringType == "text/uri-list". + // Filename when storageType == StorageTypeBinaryData. + wkeMemBuf* title; + + // Only valid when storageType == StorageTypeFileSystemFile. + wkeMemBuf* fileSystemURL; + __int64 fileSystemFileSize; + + // Only valid when stringType == "text/html". + wkeMemBuf* baseURL; + }; + + struct Item* m_itemList; + int m_itemListLength; + + int m_modifierKeyState; // State of Shift/Ctrl/Alt/Meta keys. + wkeMemBuf* m_filesystemId; +} wkeWebDragData; + +typedef enum { + wkeWebDragOperationNone = 0, + wkeWebDragOperationCopy = 1, + wkeWebDragOperationLink = 2, + wkeWebDragOperationGeneric = 4, + wkeWebDragOperationPrivate = 8, + wkeWebDragOperationMove = 16, + wkeWebDragOperationDelete = 32, + wkeWebDragOperationEvery = 0xffffffff +} wkeWebDragOperation; + +typedef wkeWebDragOperation wkeWebDragOperationsMask; + +typedef enum { + WKE_RESOURCE_TYPE_MAIN_FRAME = 0, // top level page + WKE_RESOURCE_TYPE_SUB_FRAME = 1, // frame or iframe + WKE_RESOURCE_TYPE_STYLESHEET = 2, // a CSS stylesheet + WKE_RESOURCE_TYPE_SCRIPT = 3, // an external script + WKE_RESOURCE_TYPE_IMAGE = 4, // an image (jpg/gif/png/etc) + WKE_RESOURCE_TYPE_FONT_RESOURCE = 5, // a font + WKE_RESOURCE_TYPE_SUB_RESOURCE = 6, // an "other" subresource. + WKE_RESOURCE_TYPE_OBJECT = 7, // an object (or embed) tag for a plugin, + // or a resource that a plugin requested. + WKE_RESOURCE_TYPE_MEDIA = 8, // a media resource. + WKE_RESOURCE_TYPE_WORKER = 9, // the main resource of a dedicated + // worker. + WKE_RESOURCE_TYPE_SHARED_WORKER = 10, // the main resource of a shared worker. + WKE_RESOURCE_TYPE_PREFETCH = 11, // an explicitly requested prefetch + WKE_RESOURCE_TYPE_FAVICON = 12, // a favicon + WKE_RESOURCE_TYPE_XHR = 13, // a XMLHttpRequest + WKE_RESOURCE_TYPE_PING = 14, // a ping request for + WKE_RESOURCE_TYPE_SERVICE_WORKER = 15, // the main resource of a service worker. + WKE_RESOURCE_TYPE_LAST_TYPE +} wkeResourceType; + +typedef struct { + wkeString url; + wkeString newUrl; + wkeResourceType resourceType; + int httpResponseCode; + wkeString method; + wkeString referrer; + void* headers; +} wkeWillSendRequestInfo; + +typedef enum { + wkeHttBodyElementTypeData, + wkeHttBodyElementTypeFile, +} wkeHttBodyElementType; + +typedef struct { + int size; + wkeHttBodyElementType type; + wkeMemBuf* data; + wkeString filePath; + __int64 fileStart; + __int64 fileLength; // -1 means to the end of the file. +} wkePostBodyElement; + +typedef struct { + int size; + wkePostBodyElement** element; + size_t elementSize; + bool isDirty; +} wkePostBodyElements; + +typedef struct { + int size; + wkeWebFrameHandle frame; + wkeWillSendRequestInfo* willSendRequestInfo; + const char* url; + wkePostBodyElements* postBody; +} wkeTempCallbackInfo; + +typedef enum _wkeRequestType { + kWkeRequestTypeInvalidation, + kWkeRequestTypeGet, + kWkeRequestTypePost, + kWkeRequestTypePut, +} wkeRequestType; + +typedef void(WKE_CALL_TYPE*wkeTitleChangedCallback)(wkeWebView webView, void* param, const wkeString title); +typedef void(WKE_CALL_TYPE*wkeURLChangedCallback)(wkeWebView webView, void* param, const wkeString url); +typedef void(WKE_CALL_TYPE*wkeURLChangedCallback2)(wkeWebView webView, void* param, wkeWebFrameHandle frameId, const wkeString url); +typedef void(WKE_CALL_TYPE*wkePaintUpdatedCallback)(wkeWebView webView, void* param, const HDC hdc, int x, int y, int cx, int cy); +typedef void(WKE_CALL_TYPE*wkePaintBitUpdatedCallback)(wkeWebView webView, void* param, const void* buffer, const wkeRect* r, int width, int height); +typedef void(WKE_CALL_TYPE*wkeAlertBoxCallback)(wkeWebView webView, void* param, const wkeString msg); +typedef bool(WKE_CALL_TYPE*wkeConfirmBoxCallback)(wkeWebView webView, void* param, const wkeString msg); +typedef bool(WKE_CALL_TYPE*wkePromptBoxCallback)(wkeWebView webView, void* param, const wkeString msg, const wkeString defaultResult, wkeString result); +typedef bool(WKE_CALL_TYPE*wkeNavigationCallback)(wkeWebView webView, void* param, wkeNavigationType navigationType, const wkeString url); +typedef wkeWebView(WKE_CALL_TYPE*wkeCreateViewCallback)(wkeWebView webView, void* param, wkeNavigationType navigationType, const wkeString url, const wkeWindowFeatures* windowFeatures); +typedef void(WKE_CALL_TYPE*wkeDocumentReadyCallback)(wkeWebView webView, void* param); +typedef void(WKE_CALL_TYPE*wkeDocumentReady2Callback)(wkeWebView webView, void* param, wkeWebFrameHandle frameId); + +typedef void(WKE_CALL_TYPE*wkeOnShowDevtoolsCallback)(wkeWebView webView, void* param); + +typedef void(WKE_CALL_TYPE*wkeNodeOnCreateProcessCallback)(wkeWebView webView, void* param, const WCHAR* applicationPath, const WCHAR* arguments, STARTUPINFOW* startup); +typedef void(WKE_CALL_TYPE*wkeOnPluginFindCallback)(wkeWebView webView, void* param, const utf8* mime, void* initializeFunc, void* getEntryPointsFunc, void* shutdownFunc); + +typedef struct { + int size; + int width; + int height; + double duration; +} wkeMediaLoadInfo; +typedef void(WKE_CALL_TYPE*wkeWillMediaLoadCallback)(wkeWebView webView, void* param, const char* url, wkeMediaLoadInfo* info); + +typedef void(WKE_CALL_TYPE*wkeStartDraggingCallback)( + wkeWebView webView, + void* param, + wkeWebFrameHandle frame, + const wkeWebDragData* data, + wkeWebDragOperationsMask mask, + const void* image, + const wkePoint* dragImageOffset + ); + +typedef void(WKE_CALL_TYPE*wkeUiThreadRunCallback)(HWND hWnd, void* param); +typedef int(WKE_CALL_TYPE*wkeUiThreadPostTaskCallback)(HWND hWnd, wkeUiThreadRunCallback callback, void* param); + +typedef enum { + WKE_DID_START_LOADING, + WKE_DID_STOP_LOADING, + WKE_DID_NAVIGATE, + WKE_DID_NAVIGATE_IN_PAGE, + WKE_DID_GET_RESPONSE_DETAILS, + WKE_DID_GET_REDIRECT_REQUEST, + WKE_DID_POST_REQUEST, +} wkeOtherLoadType; +typedef void(WKE_CALL_TYPE*wkeOnOtherLoadCallback)(wkeWebView webView, void* param, wkeOtherLoadType type, wkeTempCallbackInfo* info); + +typedef enum { + WKE_LOADING_SUCCEEDED, + WKE_LOADING_FAILED, + WKE_LOADING_CANCELED +} wkeLoadingResult; + +typedef void(WKE_CALL_TYPE*wkeLoadingFinishCallback)(wkeWebView webView, void* param, const wkeString url, wkeLoadingResult result, const wkeString failedReason); +typedef bool(WKE_CALL_TYPE*wkeDownloadCallback)(wkeWebView webView, void* param, const char* url); + +typedef enum { + wkeLevelDebug = 4, + wkeLevelLog = 1, + wkeLevelInfo = 5, + wkeLevelWarning = 2, + wkeLevelError = 3, + wkeLevelRevokedError = 6, + wkeLevelLast = wkeLevelInfo +} wkeConsoleLevel; +typedef void(WKE_CALL_TYPE*wkeConsoleCallback)(wkeWebView webView, void* param, wkeConsoleLevel level, const wkeString message, const wkeString sourceName, unsigned sourceLine, const wkeString stackTrace); + +typedef void(WKE_CALL_TYPE*wkeOnCallUiThread)(wkeWebView webView, void* paramOnInThread); +typedef void(WKE_CALL_TYPE*wkeCallUiThread)(wkeWebView webView, wkeOnCallUiThread func, void* param); + +typedef wkeMediaPlayer(WKE_CALL_TYPE* wkeMediaPlayerFactory)(wkeWebView webView, wkeMediaPlayerClient client, void* npBrowserFuncs, void* npPluginFuncs); +typedef bool(WKE_CALL_TYPE* wkeOnIsMediaPlayerSupportsMIMEType)(const utf8* mime); + +//wkeNet-------------------------------------------------------------------------------------- +typedef void* wkeNetJob; + +typedef struct wkeWebUrlRequest* wkeWebUrlRequestPtr; +typedef struct wkeWebUrlResponse* wkeWebUrlResponsePtr; + +typedef void(WKE_CALL_TYPE* wkeOnUrlRequestWillRedirectCallback)(wkeWebView webView, void* param, wkeWebUrlRequestPtr oldRequest, wkeWebUrlRequestPtr request, wkeWebUrlResponsePtr redirectResponse); +typedef void(WKE_CALL_TYPE* wkeOnUrlRequestDidReceiveResponseCallback)(wkeWebView webView, void* param, wkeWebUrlRequestPtr request, wkeWebUrlResponsePtr response); +typedef void(WKE_CALL_TYPE* wkeOnUrlRequestDidReceiveDataCallback)(wkeWebView webView, void* param, wkeWebUrlRequestPtr request, const char* data, int dataLength); +typedef void(WKE_CALL_TYPE* wkeOnUrlRequestDidFailCallback)(wkeWebView webView, void* param, wkeWebUrlRequestPtr request, const utf8* error); +typedef void(WKE_CALL_TYPE* wkeOnUrlRequestDidFinishLoadingCallback)(wkeWebView webView, void* param, wkeWebUrlRequestPtr request, double finishTime); + +typedef struct _wkeUrlRequestCallbacks { + wkeOnUrlRequestWillRedirectCallback willRedirectCallback; + wkeOnUrlRequestDidReceiveResponseCallback didReceiveResponseCallback; + wkeOnUrlRequestDidReceiveDataCallback didReceiveDataCallback; + wkeOnUrlRequestDidFailCallback didFailCallback; + wkeOnUrlRequestDidFinishLoadingCallback didFinishLoadingCallback; +} wkeUrlRequestCallbacks; + +typedef bool(WKE_CALL_TYPE*wkeLoadUrlBeginCallback)(wkeWebView webView, void* param, const char* url, wkeNetJob job); +typedef void(WKE_CALL_TYPE*wkeLoadUrlEndCallback)(wkeWebView webView, void* param, const char* url, wkeNetJob job, void* buf, int len); +typedef void(WKE_CALL_TYPE*wkeDidCreateScriptContextCallback)(wkeWebView webView, void* param, wkeWebFrameHandle frameId, void* context, int extensionGroup, int worldId); +typedef void(WKE_CALL_TYPE*wkeWillReleaseScriptContextCallback)(wkeWebView webView, void* param, wkeWebFrameHandle frameId, void* context, int worldId); +typedef bool(WKE_CALL_TYPE*wkeNetResponseCallback)(wkeWebView webView, void* param, const char* url, wkeNetJob job); +typedef void(WKE_CALL_TYPE*wkeOnNetGetFaviconCallback)(wkeWebView webView, void* param, const utf8* url, wkeMemBuf* buf); + +typedef void* v8ContextPtr; +typedef void* v8Isolate; + +//wke window----------------------------------------------------------------------------------- +typedef enum { + WKE_WINDOW_TYPE_POPUP, + WKE_WINDOW_TYPE_TRANSPARENT, + WKE_WINDOW_TYPE_CONTROL + +} wkeWindowType; + +typedef bool(WKE_CALL_TYPE*wkeWindowClosingCallback)(wkeWebView webWindow, void* param); +typedef void(WKE_CALL_TYPE*wkeWindowDestroyCallback)(wkeWebView webWindow, void* param); + +typedef struct { + RECT bounds; + bool draggable; +} wkeDraggableRegion; +typedef void(WKE_CALL_TYPE*wkeDraggableRegionsChangedCallback)(wkeWebView webView, void* param, const wkeDraggableRegion* rects, int rectCount); + +//JavaScript Bind----------------------------------------------------------------------------------- +#define JS_CALL __fastcall +typedef jsValue(JS_CALL* jsNativeFunction) (jsExecState es); + +typedef jsValue(WKE_CALL_TYPE* wkeJsNativeFunction) (jsExecState es, void* param); + +typedef enum { + JSTYPE_NUMBER, + JSTYPE_STRING, + JSTYPE_BOOLEAN, + JSTYPE_OBJECT, + JSTYPE_FUNCTION, + JSTYPE_UNDEFINED, + JSTYPE_ARRAY, + JSTYPE_NULL, +} jsType; + +// cexer JS对象、函数绑定支持 +typedef jsValue(WKE_CALL_TYPE*jsGetPropertyCallback)(jsExecState es, jsValue object, const char* propertyName); +typedef bool(WKE_CALL_TYPE*jsSetPropertyCallback)(jsExecState es, jsValue object, const char* propertyName, jsValue value); +typedef jsValue(WKE_CALL_TYPE*jsCallAsFunctionCallback)(jsExecState es, jsValue object, jsValue* args, int argCount); +struct tagjsData; // declare warning fix +typedef void(WKE_CALL_TYPE*jsFinalizeCallback)(struct tagjsData* data); + +typedef struct tagjsData { + char typeName[100]; + jsGetPropertyCallback propertyGet; + jsSetPropertyCallback propertySet; + jsFinalizeCallback finalize; + jsCallAsFunctionCallback callAsFunction; +} jsData; + +typedef struct _jsExceptionInfo { + const utf8* message; // Returns the exception message. + const utf8* sourceLine; // Returns the line of source code that the exception occurred within. + const utf8* scriptResourceName; // Returns the resource name for the script from where the function causing the error originates. + int lineNumber; // Returns the 1-based number of the line where the error occurred or 0 if the line number is unknown. + int startPosition; // Returns the index within the script of the first character where the error occurred. + int endPosition; // Returns the index within the script of the last character where the error occurred. + int startColumn; // Returns the index within the line of the first character where the error occurred. + int endColumn; // Returns the index within the line of the last character where the error occurred. + const utf8* callstackString; +} jsExceptionInfo; + +typedef struct _jsKeys { + unsigned int length; + const char** keys; + +#if defined(__cplusplus) + ~_jsKeys(); +#endif +} jsKeys; + + +#if defined(__cplusplus) +namespace wke { + +class IWebView { +public: + virtual void destroy() = 0; + + virtual const char* name() const = 0; + virtual void setName(const char* name) = 0; + + virtual bool isTransparent() const = 0; + virtual void setTransparent(bool transparent) = 0; + + virtual void loadURL(const utf8* url) = 0; + virtual void loadURL(const wchar_t* url) = 0; + + virtual void loadHTML(const utf8* html) = 0; + virtual void loadHTML(const wchar_t* html) = 0; + + virtual void loadFile(const utf8* filename) = 0; + virtual void loadFile(const wchar_t* filename) = 0; + + virtual const utf8* url() const = 0; + + virtual bool isLoading() const = 0; /*document load sucessed*/ + virtual bool isLoadingFailed() const = 0; /*document load failed*/ + virtual bool isLoadingSucceeded() const = 0; /*document load complete*/ + virtual bool isDocumentReady() const = 0; /*document ready*/ + virtual void stopLoading() = 0; + virtual void reload() = 0; + + virtual const utf8* title() = 0; + virtual const wchar_t* titleW() = 0; + + virtual void resize(int w, int h) = 0; + virtual int width() const = 0; /*viewport width*/ + virtual int height() const = 0; /*viewport height*/ + + virtual int contentsWidth() const = 0; /*contents width*/ + virtual int contentsHeight() const = 0; /*contents height*/ + + virtual void setDirty(bool dirty) = 0; + virtual bool isDirty() const = 0; + virtual void addDirtyArea(int x, int y, int w, int h) = 0; + + virtual void layoutIfNeeded() = 0; + virtual void paint(void* bits, int pitch) = 0; + + virtual bool canGoBack() const = 0; + virtual bool goBack() = 0; + virtual bool canGoForward() const = 0; + virtual bool goForward() = 0; + + virtual void editorSelectAll() = 0; + virtual void editorUnSelect() = 0; + virtual void editorCopy() = 0; + virtual void editorCut() = 0; + virtual void editorPaste() = 0; + virtual void editorDelete() = 0; + virtual void editorUndo() = 0; + virtual void editorRedo() = 0; + + virtual void setCookieEnabled(bool enable) = 0; + virtual bool isCookieEnabled() const = 0; + + virtual void setMediaVolume(float volume) = 0; + virtual float mediaVolume() const = 0; + + virtual bool fireMouseEvent(unsigned int message, int x, int y, unsigned int flags) = 0; + virtual bool fireContextMenuEvent(int x, int y, unsigned int flags) = 0; + virtual bool fireMouseWheelEvent(int x, int y, int delta, unsigned int flags) = 0; + virtual bool fireKeyUpEvent(unsigned int virtualKeyCode, unsigned int flags, bool systemKey) = 0; + virtual bool fireKeyDownEvent(unsigned int virtualKeyCode, unsigned int flags, bool systemKey) = 0; + virtual bool fireKeyPressEvent(unsigned int virtualKeyCode, unsigned int flags, bool systemKey) = 0; + + virtual void setFocus() = 0; + virtual void killFocus() = 0; + + virtual wkeRect getCaret() = 0; + + virtual jsValue runJS(const utf8* script) = 0; + virtual jsValue runJS(const wchar_t* script) = 0; + virtual jsExecState globalExec() = 0; + + virtual void sleep() = 0; //moveOffscreen + virtual void wake() = 0; //moveOnscreen + virtual bool isAwake() const = 0; + + virtual void setZoomFactor(float factor) = 0; + virtual float zoomFactor() const = 0; + + virtual void setEditable(bool editable) = 0; + + virtual void setClientHandler(const wkeClientHandler* handler) = 0; + virtual const wkeClientHandler* getClientHandler() const = 0; +}; + +} +#endif + +////////////////////////////////////////////////////////////////////////// + +#define WKE_DEFINE_ITERATOR0(returnVal, name, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR1(returnVal, name, p1, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR2(returnVal, name, p1, p2, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR3(returnVal, name, p1, p2, p3, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2, p3); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR4(returnVal, name, p1, p2, p3, p4, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2, p3, p4); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR5(returnVal, name, p1, p2, p3, p4, p5, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2, p3, p4, p5); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR6(returnVal, name, p1, p2, p3, p4, p5, p6, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2, p3, p4, p5, p6); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +#define WKE_DEFINE_ITERATOR11(returnVal, name, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, description) \ + typedef returnVal(WKE_CALL_TYPE* FN_##name)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + __declspec(selectany) FN_##name name = ((FN_##name)0); + +// --- + +#define WKE_DECLARE_ITERATOR0(returnVal, name, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(); + +#define WKE_DECLARE_ITERATOR1(returnVal, name, p1, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1); + +#define WKE_DECLARE_ITERATOR2(returnVal, name, p1, p2, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2); + +#define WKE_DECLARE_ITERATOR3(returnVal, name, p1, p2, p3, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2, p3); + +#define WKE_DECLARE_ITERATOR4(returnVal, name, p1, p2, p3, p4, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2, p3, p4); + +#define WKE_DECLARE_ITERATOR5(returnVal, name, p1, p2, p3, p4, p5, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2, p3, p4, p5); + +#define WKE_DECLARE_ITERATOR6(returnVal, name, p1, p2, p3, p4, p5, p6, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2, p3, p4, p5, p6); + +#define WKE_DECLARE_ITERATOR11(returnVal, name, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, description) \ + WKE_EXTERN_C __declspec(dllexport) returnVal WKE_CALL_TYPE name(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); + +// --- + +#define WKE_GET_PTR_ITERATOR(name) \ + name = (FN_##name)GetProcAddress(hMod, #name); \ + if (!name) \ + MessageBoxA(((HWND)0), "wke api not found", #name, 0); + +#define WKE_GET_PTR_ITERATOR0(returnVal, name, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR1(returnVal, name, p1, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR2(returnVal, name, p1, p2, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR3(returnVal, name, p1, p2, p3, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR4(returnVal, name, p1, p2, p3, p4, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR5(returnVal, name, p1, p2, p3, p4, p5, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR6(returnVal, name, p1, p2, p3, p4, p5, p6, description) \ + WKE_GET_PTR_ITERATOR(name); + +#define WKE_GET_PTR_ITERATOR11(returnVal, name, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, description) \ + WKE_GET_PTR_ITERATOR(name); + +// 以下是wke的导出函数。格式按照【返回类型】【函数名】【参数】来排列 + +#define WKE_FOR_EACH_DEFINE_FUNCTION(ITERATOR0, ITERATOR1, ITERATOR2, ITERATOR3, ITERATOR4, ITERATOR5, ITERATOR6, ITERATOR11) \ + ITERATOR0(void, wkeShutdown, "") \ + \ + ITERATOR0(unsigned int, wkeVersion, "") \ + ITERATOR0(const utf8*, wkeVersionString, "") \ + ITERATOR2(void, wkeGC, wkeWebView webView, long intervalSec, "") \ + ITERATOR2(void, wkeSetResourceGc, wkeWebView webView, long intervalSec, "") \ + \ + ITERATOR5(void, wkeSetFileSystem, WKE_FILE_OPEN pfnOpen, WKE_FILE_CLOSE pfnClose, WKE_FILE_SIZE pfnSize, WKE_FILE_READ pfnRead, WKE_FILE_SEEK pfnSeek, "") \ + \ + ITERATOR1(const char*, wkeWebViewName, wkeWebView webView, "") \ + ITERATOR2(void, wkeSetWebViewName, wkeWebView webView, const char* name, "") \ + \ + ITERATOR1(bool, wkeIsLoaded, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsLoadFailed, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsLoadComplete, wkeWebView webView, "") \ + \ + ITERATOR1(const utf8*, wkeGetSource, wkeWebView webView, "") \ + ITERATOR1(const utf8*, wkeTitle, wkeWebView webView, "") \ + ITERATOR1(const wchar_t*, wkeTitleW, wkeWebView webView, "") \ + ITERATOR1(int, wkeWidth, wkeWebView webView, "") \ + ITERATOR1(int, wkeHeight, wkeWebView webView, "") \ + ITERATOR1(int, wkeContentsWidth, wkeWebView webView, "") \ + ITERATOR1(int, wkeContentsHeight, wkeWebView webView, "") \ + \ + ITERATOR1(void, wkeSelectAll, wkeWebView webView, "") \ + ITERATOR1(void, wkeCopy, wkeWebView webView, "") \ + ITERATOR1(void, wkeCut, wkeWebView webView, "") \ + ITERATOR1(void, wkePaste, wkeWebView webView, "") \ + ITERATOR1(void, wkeDelete, wkeWebView webView, "") \ + \ + ITERATOR1(bool, wkeCookieEnabled, wkeWebView webView, "") \ + ITERATOR1(float, wkeMediaVolume, wkeWebView webView, "") \ + \ + ITERATOR5(bool, wkeMouseEvent, wkeWebView webView, unsigned int message, int x, int y, unsigned int flags, "") \ + ITERATOR4(bool, wkeContextMenuEvent, wkeWebView webView, int x, int y, unsigned int flags, "") \ + ITERATOR5(bool, wkeMouseWheel, wkeWebView webView, int x, int y, int delta, unsigned int flags, "") \ + ITERATOR4(bool, wkeKeyUp, wkeWebView webView, unsigned int virtualKeyCode, unsigned int flags, bool systemKey, "") \ + ITERATOR4(bool, wkeKeyDown, wkeWebView webView, unsigned int virtualKeyCode, unsigned int flags, bool systemKey, "") \ + ITERATOR4(bool, wkeKeyPress, wkeWebView webView, unsigned int virtualKeyCode, unsigned int flags, bool systemKey, "") \ + \ + ITERATOR1(void, wkeFocus, wkeWebView webView, "") \ + ITERATOR1(void, wkeUnfocus, wkeWebView webView, "") \ + \ + ITERATOR1(wkeRect, wkeGetCaret, wkeWebView webView, "") \ + \ + ITERATOR1(void, wkeAwaken, wkeWebView webView, "") \ + \ + ITERATOR1(float, wkeZoomFactor, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetClientHandler, wkeWebView webView, const wkeClientHandler* handler, "") \ + ITERATOR1(const wkeClientHandler*, wkeGetClientHandler, wkeWebView webView, "") \ + \ + ITERATOR1(const utf8*, wkeToString, const wkeString string, "") \ + ITERATOR1(const wchar_t*, wkeToStringW, const wkeString string, "") \ + \ + ITERATOR2(const utf8*, jsToString, jsExecState es, jsValue v, "") \ + ITERATOR2(const wchar_t*, jsToStringW, jsExecState es, jsValue v, "") \ + \ + ITERATOR1(void, wkeConfigure, const wkeSettings* settings, "") \ + ITERATOR0(bool, wkeIsInitialize, "") \ + \ + ITERATOR2(void, wkeSetViewSettings, wkeWebView webView, const wkeViewSettings* settings, "") \ + ITERATOR3(void, wkeSetDebugConfig, wkeWebView webView, const char* debugString, const char* param, "") \ + \ + ITERATOR0(void, wkeFinalize, "") \ + ITERATOR0(void, wkeUpdate, "") \ + ITERATOR0(unsigned int, wkeGetVersion, "") \ + ITERATOR0(const utf8*, wkeGetVersionString, "") \ + \ + ITERATOR0(wkeWebView, wkeCreateWebView, "") \ + ITERATOR1(void, wkeDestroyWebView, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetMemoryCacheEnable, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetMouseEnabled, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetTouchEnabled, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetNavigationToNewWindowEnable, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetCspCheckEnable, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetNpapiPluginsEnabled, wkeWebView webView, bool b, "") \ + ITERATOR2(void, wkeSetHeadlessEnabled, wkeWebView webView, bool b, "可以关闭渲染") \ + ITERATOR2(void, wkeSetDragEnable, wkeWebView webView, bool b, "可关闭拖拽文件加载网页") \ + ITERATOR2(void, wkeSetDragDropEnable, wkeWebView webView, bool b, "可关闭拖拽到其他进程") \ + ITERATOR2(void, wkeSetLanguage, wkeWebView webView, const char* language, "可关闭拖拽到其他进程") \ + \ + ITERATOR2(void, wkeSetViewNetInterface, wkeWebView webView, const char* netInterface, "") \ + \ + ITERATOR1(void, wkeSetProxy, const wkeProxy* proxy, "") \ + ITERATOR2(void, wkeSetViewProxy, wkeWebView webView, wkeProxy *proxy, "") \ + \ + ITERATOR1(const char*, wkeGetName, wkeWebView webView, "") \ + ITERATOR2(void, wkeSetName, wkeWebView webView, const char* name, "") \ + \ + ITERATOR2(void, wkeSetHandle, wkeWebView webView, HWND wnd, "") \ + ITERATOR3(void, wkeSetHandleOffset, wkeWebView webView, int x, int y, "") \ + \ + ITERATOR1(bool, wkeIsTransparent, wkeWebView webView, "") \ + ITERATOR2(void, wkeSetTransparent, wkeWebView webView, bool transparent, "") \ + \ + ITERATOR2(void, wkeSetUserAgent, wkeWebView webView, const utf8* userAgent, "") \ + ITERATOR1(const char*, wkeGetUserAgent, wkeWebView webView, "") \ + ITERATOR2(void, wkeSetUserAgentW, wkeWebView webView, const wchar_t* userAgent, "") \ + \ + ITERATOR4(void, wkeShowDevtools, wkeWebView webView, const wchar_t* path, wkeOnShowDevtoolsCallback callback, void* param, "") \ + \ + ITERATOR2(void, wkeLoadW, wkeWebView webView, const wchar_t* url, "") \ + ITERATOR2(void, wkeLoadURL, wkeWebView webView, const utf8* url, "") \ + ITERATOR2(void, wkeLoadURLW, wkeWebView webView, const wchar_t* url, "") \ + ITERATOR4(void, wkePostURL, wkeWebView wkeView, const utf8* url, const char* postData, int postLen, "") \ + ITERATOR4(void, wkePostURLW, wkeWebView wkeView, const wchar_t* url, const char* postData, int postLen, "") \ + \ + ITERATOR2(void, wkeLoadHTML, wkeWebView webView, const utf8* html, "") \ + ITERATOR3(void, wkeLoadHtmlWithBaseUrl, wkeWebView webView, const utf8* html, const utf8* baseUrl, "") \ + ITERATOR2(void, wkeLoadHTMLW, wkeWebView webView, const wchar_t* html, "") \ + \ + ITERATOR2(void, wkeLoadFile, wkeWebView webView, const utf8* filename, "") \ + ITERATOR2(void, wkeLoadFileW, wkeWebView webView, const wchar_t* filename, "") \ + \ + ITERATOR1(const utf8*, wkeGetURL, wkeWebView webView, "") \ + ITERATOR2(const utf8*, wkeGetFrameUrl, wkeWebView webView, wkeWebFrameHandle frameId, "") \ + \ + ITERATOR1(bool, wkeIsLoading, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsLoadingSucceeded, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsLoadingFailed, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsLoadingCompleted, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsDocumentReady, wkeWebView webView, "") \ + ITERATOR1(void, wkeStopLoading, wkeWebView webView, "") \ + ITERATOR1(void, wkeReload, wkeWebView webView, "") \ + ITERATOR2(void, wkeGoToOffset, wkeWebView webView, int offset, "") \ + ITERATOR2(void, wkeGoToIndex, wkeWebView webView, int index, "") \ + \ + ITERATOR1(int, wkeGetWebviewId, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsWebviewAlive, int id, "") \ + \ + ITERATOR3(const utf8*, wkeGetDocumentCompleteURL, wkeWebView webView, wkeWebFrameHandle frameId, const utf8* partialURL, "") \ + \ + ITERATOR3(wkeMemBuf*, wkeCreateMemBuf, wkeWebView webView, void* buf, size_t length, "") \ + ITERATOR1(void, wkeFreeMemBuf, wkeMemBuf* buf, "") \ + \ + ITERATOR1(const utf8*, wkeGetTitle, wkeWebView webView, "") \ + ITERATOR1(const wchar_t*, wkeGetTitleW, wkeWebView webView, "") \ + \ + ITERATOR3(void, wkeResize, wkeWebView webView, int w, int h, "") \ + ITERATOR1(int, wkeGetWidth, wkeWebView webView, "") \ + ITERATOR1(int, wkeGetHeight, wkeWebView webView, "") \ + ITERATOR1(int, wkeGetContentWidth, wkeWebView webView, "") \ + ITERATOR1(int, wkeGetContentHeight, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetDirty, wkeWebView webView, bool dirty, "") \ + ITERATOR1(bool, wkeIsDirty, wkeWebView webView, "") \ + ITERATOR5(void, wkeAddDirtyArea, wkeWebView webView, int x, int y, int w, int h, "") \ + ITERATOR1(void, wkeLayoutIfNeeded, wkeWebView webView, "") \ + ITERATOR11(void, wkePaint2, wkeWebView webView, void* bits, int bufWid, int bufHei, int xDst, int yDst, int w, int h, int xSrc, int ySrc, bool bCopyAlpha, "") \ + ITERATOR3(void, wkePaint, wkeWebView webView, void* bits, int pitch, "") \ + ITERATOR1(void, wkeRepaintIfNeeded, wkeWebView webView, "") \ + ITERATOR1(HDC, wkeGetViewDC, wkeWebView webView, "") \ + ITERATOR1(HWND, wkeGetHostHWND, wkeWebView webView, "") \ + \ + ITERATOR1(bool, wkeCanGoBack, wkeWebView webView, "") \ + ITERATOR1(bool, wkeGoBack, wkeWebView webView, "") \ + ITERATOR1(bool, wkeCanGoForward, wkeWebView webView, "") \ + ITERATOR1(bool, wkeGoForward, wkeWebView webView, "") \ + \ + ITERATOR1(void, wkeEditorSelectAll, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorUnSelect, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorCopy, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorCut, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorPaste, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorDelete, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorUndo, wkeWebView webView, "") \ + ITERATOR1(void, wkeEditorRedo, wkeWebView webView, "") \ + \ + ITERATOR1(const wchar_t*, wkeGetCookieW, wkeWebView webView, "") \ + ITERATOR1(const utf8*, wkeGetCookie, wkeWebView webView, "") \ + ITERATOR3(void, wkeSetCookie, wkeWebView webView, const utf8* url, const utf8* cookie, "cookie格式必须是:Set-cookie: PRODUCTINFO=webxpress; domain=.fidelity.com; path=/; secure") \ + ITERATOR3(void, wkeVisitAllCookie, wkeWebView webView, void* params, wkeCookieVisitor visitor, "") \ + ITERATOR2(void, wkePerformCookieCommand, wkeWebView webView, wkeCookieCommand command, "") \ + ITERATOR2(void, wkeSetCookieEnabled, wkeWebView webView, bool enable, "") \ + ITERATOR1(bool, wkeIsCookieEnabled, wkeWebView webView, "") \ + ITERATOR2(void, wkeSetCookieJarPath, wkeWebView webView, const WCHAR* path, "") \ + ITERATOR2(void, wkeSetCookieJarFullPath, wkeWebView webView, const WCHAR* path, "") \ + ITERATOR2(void, wkeSetLocalStorageFullPath, wkeWebView webView, const WCHAR* path, "") \ + ITERATOR2(void, wkeAddPluginDirectory, wkeWebView webView, const WCHAR* path, "") \ + \ + ITERATOR2(void, wkeSetMediaVolume, wkeWebView webView, float volume, "") \ + ITERATOR1(float, wkeGetMediaVolume, wkeWebView webView, "") \ + \ + ITERATOR5(bool, wkeFireMouseEvent, wkeWebView webView, unsigned int message, int x, int y, unsigned int flags, "") \ + ITERATOR4(bool, wkeFireContextMenuEvent, wkeWebView webView, int x, int y, unsigned int flags, "") \ + ITERATOR5(bool, wkeFireMouseWheelEvent, wkeWebView webView, int x, int y, int delta, unsigned int flags, "") \ + ITERATOR4(bool, wkeFireKeyUpEvent, wkeWebView webView, unsigned int virtualKeyCode, unsigned int flags, bool systemKey, "") \ + ITERATOR4(bool, wkeFireKeyDownEvent, wkeWebView webView, unsigned int virtualKeyCode, unsigned int flags, bool systemKey, "") \ + ITERATOR4(bool, wkeFireKeyPressEvent, wkeWebView webView, unsigned int charCode, unsigned int flags, bool systemKey, "") \ + ITERATOR6(bool, wkeFireWindowsMessage, wkeWebView webView, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, LRESULT* result, "") \ + \ + ITERATOR1(void, wkeSetFocus, wkeWebView webView, "") \ + ITERATOR1(void, wkeKillFocus, wkeWebView webView, "") \ + \ + ITERATOR1(wkeRect, wkeGetCaretRect, wkeWebView webView, "") \ + \ + ITERATOR2(jsValue, wkeRunJS, wkeWebView webView, const utf8* script, "") \ + ITERATOR2(jsValue, wkeRunJSW, wkeWebView webView, const wchar_t* script, "") \ + \ + ITERATOR1(jsExecState, wkeGlobalExec, wkeWebView webView, "") \ + ITERATOR2(jsExecState, wkeGetGlobalExecByFrame, wkeWebView webView, wkeWebFrameHandle frameId, "") \ + \ + ITERATOR1(void, wkeSleep, wkeWebView webView, "") \ + ITERATOR1(void, wkeWake, wkeWebView webView, "") \ + ITERATOR1(bool, wkeIsAwake, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetZoomFactor, wkeWebView webView, float factor, "") \ + ITERATOR1(float, wkeGetZoomFactor, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetEditable, wkeWebView webView, bool editable, "") \ + \ + ITERATOR1(const utf8*, wkeGetString, const wkeString string, "") \ + ITERATOR1(const wchar_t*, wkeGetStringW, const wkeString string, "") \ + \ + ITERATOR3(void, wkeSetString, wkeString string, const utf8* str, size_t len, "") \ + ITERATOR3(void, wkeSetStringW, wkeString string, const wchar_t* str, size_t len, "") \ + \ + ITERATOR2(wkeString, wkeCreateString, const utf8* str, size_t len, "") \ + ITERATOR2(wkeString, wkeCreateStringW, const wchar_t* str, size_t len, "") \ + ITERATOR1(void, wkeDeleteString, wkeString str, "") \ + \ + ITERATOR0(wkeWebView, wkeGetWebViewForCurrentContext, "") \ + ITERATOR3(void, wkeSetUserKeyValue, wkeWebView webView, const char* key, void* value, "") \ + ITERATOR2(void*, wkeGetUserKeyValue, wkeWebView webView, const char* key, "") \ + \ + ITERATOR1(int, wkeGetCursorInfoType, wkeWebView webView, "") \ + ITERATOR5(void, wkeSetDragFiles, wkeWebView webView, const POINT* clintPos, const POINT* screenPos, wkeString files[], int filesCount, "") \ + \ + ITERATOR5(void, wkeSetDeviceParameter, wkeWebView webView, const char* device, const char* paramStr, int paramInt, float paramFloat, "") \ + ITERATOR1(wkeTempCallbackInfo*, wkeGetTempCallbackInfo, wkeWebView webView, "") \ + \ + ITERATOR3(void, wkeOnMouseOverUrlChanged, wkeWebView webView, wkeTitleChangedCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnTitleChanged, wkeWebView webView, wkeTitleChangedCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnURLChanged, wkeWebView webView, wkeURLChangedCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnURLChanged2, wkeWebView webView, wkeURLChangedCallback2 callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnPaintUpdated, wkeWebView webView, wkePaintUpdatedCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnPaintBitUpdated, wkeWebView webView, wkePaintBitUpdatedCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnAlertBox, wkeWebView webView, wkeAlertBoxCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnConfirmBox, wkeWebView webView, wkeConfirmBoxCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnPromptBox, wkeWebView webView, wkePromptBoxCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnNavigation, wkeWebView webView, wkeNavigationCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnCreateView, wkeWebView webView, wkeCreateViewCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnDocumentReady, wkeWebView webView, wkeDocumentReadyCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnDocumentReady2, wkeWebView webView, wkeDocumentReady2Callback callback, void* param, "") \ + ITERATOR3(void, wkeOnLoadingFinish, wkeWebView webView, wkeLoadingFinishCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnDownload, wkeWebView webView, wkeDownloadCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnConsole, wkeWebView webView, wkeConsoleCallback callback, void* param, "") \ + ITERATOR3(void, wkeSetUIThreadCallback, wkeWebView webView, wkeCallUiThread callback, void* param, "") \ + ITERATOR3(void, wkeOnLoadUrlBegin, wkeWebView webView, wkeLoadUrlBeginCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnLoadUrlEnd, wkeWebView webView, wkeLoadUrlEndCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnDidCreateScriptContext, wkeWebView webView, wkeDidCreateScriptContextCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnWillReleaseScriptContext, wkeWebView webView, wkeWillReleaseScriptContextCallback callback, void* callbackParam, "") \ + ITERATOR3(void, wkeOnWindowClosing, wkeWebView webWindow, wkeWindowClosingCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnWindowDestroy, wkeWebView webWindow, wkeWindowDestroyCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnDraggableRegionsChanged, wkeWebView webView, wkeDraggableRegionsChangedCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnWillMediaLoad, wkeWebView webView, wkeWillMediaLoadCallback callback, void* param, "") \ + ITERATOR3(void, wkeOnStartDragging, wkeWebView webView, wkeStartDraggingCallback callback, void* param, "") \ + \ + ITERATOR3(void, wkeOnOtherLoad, wkeWebView webView, wkeOnOtherLoadCallback callback, void* param, "") \ + \ + ITERATOR1(bool, wkeIsProcessingUserGesture, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeNetSetMIMEType, wkeNetJob jobPtr, const char* type, "") \ + ITERATOR2(const char*, wkeNetGetMIMEType, wkeNetJob jobPtr, wkeString mime, "") \ + ITERATOR4(void, wkeNetSetHTTPHeaderField, wkeNetJob jobPtr, wchar_t* key, wchar_t* value, bool response, "") \ + ITERATOR2(const char*, wkeNetGetHTTPHeaderField, wkeNetJob jobPtr, const char* key, "") \ + ITERATOR3(void, wkeNetSetData, wkeNetJob jobPtr, void *buf, int len, "调用此函数后,网络层收到数据会存储在一buf内,接收数据完成后响应OnLoadUrlEnd事件.#此调用严重影响性能,慎用" \ + "此函数和wkeNetSetData的区别是，wkeNetHookRequest会在接受到真正网络数据后再调用回调，并允许回调修改网络数据。"\ + "而wkeNetSetData是在网络数据还没发送的时候修改") \ + ITERATOR1(void, wkeNetHookRequest, wkeNetJob jobPtr, "") \ + ITERATOR3(void, wkeNetOnResponse, wkeWebView webView, wkeNetResponseCallback callback, void* param, "") \ + ITERATOR1(wkeRequestType, wkeNetGetRequestMethod, wkeNetJob jobPtr, "") \ + ITERATOR3(int, wkeNetGetFavicon, wkeWebView webView, wkeOnNetGetFaviconCallback callback, void* param, "") \ + \ + ITERATOR1(void, wkeNetContinueJob, wkeNetJob jobPtr, "")\ + ITERATOR1(const char*, wkeNetGetUrlByJob, wkeNetJob jobPtr, "")\ + ITERATOR1(void, wkeNetCancelRequest, wkeNetJob jobPtr, "")\ + ITERATOR2(void, wkeNetChangeRequestUrl, wkeNetJob jobPtr, const char* url, "")\ + ITERATOR1(BOOL, wkeNetHoldJobToAsynCommit, wkeNetJob jobPtr, "")\ + \ + ITERATOR3(wkeWebUrlRequestPtr, wkeNetCreateWebUrlRequest, const utf8* url, const utf8* method, const utf8* mime, "")\ + ITERATOR3(void, wkeNetAddHTTPHeaderFieldToUrlRequest, wkeWebUrlRequestPtr request, const utf8* name, const utf8* value, "")\ + ITERATOR4(int, wkeNetStartUrlRequest, wkeWebView webView, wkeWebUrlRequestPtr request, void* param, const wkeUrlRequestCallbacks* callbacks, "")\ + ITERATOR1(int, wkeNetGetHttpStatusCode, wkeWebUrlResponsePtr response, "")\ + ITERATOR1(__int64, wkeNetGetExpectedContentLength, wkeWebUrlResponsePtr response, "")\ + ITERATOR1(const utf8*, wkeNetGetResponseUrl, wkeWebUrlResponsePtr response, "")\ + ITERATOR1(void, wkeNetCancelWebUrlRequest, int requestId, "")\ + \ + ITERATOR1(wkePostBodyElements*, wkeNetGetPostBody, wkeNetJob jobPtr, "") \ + ITERATOR2(wkePostBodyElements*, wkeNetCreatePostBodyElements, wkeWebView webView, size_t length, "") \ + ITERATOR1(void, wkeNetFreePostBodyElements, wkePostBodyElements* elements, "") \ + ITERATOR1(wkePostBodyElement*, wkeNetCreatePostBodyElement, wkeWebView webView, "") \ + ITERATOR1(void, wkeNetFreePostBodyElement, wkePostBodyElement* element, "") \ + \ + ITERATOR2(bool, wkeIsMainFrame, wkeWebView webView, wkeWebFrameHandle frameId, "") \ + ITERATOR2(bool, wkeIsWebRemoteFrame, wkeWebView webView, wkeWebFrameHandle frameId, "") \ + ITERATOR1(wkeWebFrameHandle, wkeWebFrameGetMainFrame, wkeWebView webView, "") \ + ITERATOR4(jsValue, wkeRunJsByFrame, wkeWebView webView, wkeWebFrameHandle frameId, const utf8* script, bool isInClosure, "") \ + ITERATOR3(void, wkeInsertCSSByFrame, wkeWebView webView, wkeWebFrameHandle frameId, const utf8* cssText, "") \ + \ + ITERATOR3(void, wkeWebFrameGetMainWorldScriptContext, wkeWebView webView, wkeWebFrameHandle webFrameId, v8ContextPtr contextOut, "") \ + \ + ITERATOR0(v8Isolate, wkeGetBlinkMainThreadIsolate, "") \ + \ + ITERATOR6(wkeWebView, wkeCreateWebWindow, wkeWindowType type, HWND parent, int x, int y, int width, int height, "") \ + ITERATOR1(void, wkeDestroyWebWindow, wkeWebView webWindow, "") \ + ITERATOR1(HWND, wkeGetWindowHandle, wkeWebView webWindow, "") \ + \ + ITERATOR2(void, wkeShowWindow, wkeWebView webWindow, bool show, "") \ + ITERATOR2(void, wkeEnableWindow, wkeWebView webWindow, bool enable, "") \ + \ + ITERATOR5(void, wkeMoveWindow, wkeWebView webWindow, int x, int y, int width, int height, "") \ + ITERATOR1(void, wkeMoveToCenter, wkeWebView webWindow, "") \ + ITERATOR3(void, wkeResizeWindow, wkeWebView webWindow, int width, int height, "") \ + \ + ITERATOR6(wkeWebDragOperation, wkeDragTargetDragEnter, wkeWebView webView, const wkeWebDragData* webDragData, const POINT* clientPoint, const POINT* screenPoint, wkeWebDragOperationsMask operationsAllowed, int modifiers, "") \ + ITERATOR5(wkeWebDragOperation, wkeDragTargetDragOver, wkeWebView webView, const POINT* clientPoint, const POINT* screenPoint, wkeWebDragOperationsMask operationsAllowed, int modifiers, "") \ + ITERATOR1(void, wkeDragTargetDragLeave, wkeWebView webView, "") \ + ITERATOR4(void, wkeDragTargetDrop, wkeWebView webView, const POINT* clientPoint, const POINT* screenPoint, int modifiers, "") \ + ITERATOR4(void, wkeDragTargetEnd, wkeWebView webView, const POINT* clientPoint, const POINT* screenPoint, wkeWebDragOperation operation, "") \ + \ + ITERATOR1(void, wkeUtilSetUiCallback, wkeUiThreadPostTaskCallback callback, "") \ + ITERATOR1(const utf8*, wkeUtilSerializeToMHTML, wkeWebView webView, "") \ + \ + ITERATOR2(void, wkeSetWindowTitle, wkeWebView webWindow, const utf8* title, "") \ + ITERATOR2(void, wkeSetWindowTitleW, wkeWebView webWindow, const wchar_t* title, "") \ + \ + ITERATOR3(void, wkeNodeOnCreateProcess, wkeWebView webView, wkeNodeOnCreateProcessCallback callback, void* param, "") \ + \ + ITERATOR4(void, wkeOnPluginFind, wkeWebView webView, const char* mime, wkeOnPluginFindCallback callback, void* param, "") \ + ITERATOR4(void, wkeAddNpapiPlugin, wkeWebView webView, void* initializeFunc, void* getEntryPointsFunc, void* shutdownFunc, "") \ + \ + ITERATOR1(wkeWebView, wkeGetWebViewByNData, void* ndata, "") \ + \ + ITERATOR5(bool, wkeRegisterEmbedderCustomElement, wkeWebView webView, wkeWebFrameHandle frameId, const char* name, void* options, void* outResult, "") \ + \ + ITERATOR3(void, wkeSetMediaPlayerFactory, wkeWebView webView, wkeMediaPlayerFactory factory, wkeOnIsMediaPlayerSupportsMIMEType callback,"") \ + \ + ITERATOR1(const utf8*, wkeUtilDecodeURLEscape, const utf8* url, "") \ + \ + ITERATOR3(void, jsBindFunction, const char* name, jsNativeFunction fn, unsigned int argCount, "") \ + ITERATOR2(void, jsBindGetter, const char* name, jsNativeFunction fn, "") \ + ITERATOR2(void, jsBindSetter, const char* name, jsNativeFunction fn, "") \ + \ + ITERATOR4(void, wkeJsBindFunction, const char* name, wkeJsNativeFunction fn, void* param, unsigned int argCount, "") \ + ITERATOR3(void, wkeJsBindGetter, const char* name, wkeJsNativeFunction fn, void* param, "") \ + ITERATOR3(void, wkeJsBindSetter, const char* name, wkeJsNativeFunction fn, void* param, "") \ + \ + ITERATOR1(int, jsArgCount, jsExecState es, "") \ + ITERATOR2(jsType, jsArgType, jsExecState es, int argIdx, "") \ + ITERATOR2(jsValue, jsArg, jsExecState es, int argIdx, "") \ + \ + ITERATOR1(jsType, jsTypeOf, jsValue v, "") \ + ITERATOR1(bool, jsIsNumber, jsValue v, "") \ + ITERATOR1(bool, jsIsString, jsValue v, "") \ + ITERATOR1(bool, jsIsBoolean, jsValue v, "") \ + ITERATOR1(bool, jsIsObject, jsValue v, "") \ + ITERATOR1(bool, jsIsFunction, jsValue v, "") \ + ITERATOR1(bool, jsIsUndefined, jsValue v, "") \ + ITERATOR1(bool, jsIsNull, jsValue v, "") \ + ITERATOR1(bool, jsIsArray, jsValue v, "") \ + ITERATOR1(bool, jsIsTrue, jsValue v, "") \ + ITERATOR1(bool, jsIsFalse, jsValue v, "") \ + \ + ITERATOR2(int, jsToInt, jsExecState es, jsValue v, "") \ + ITERATOR2(float, jsToFloat, jsExecState es, jsValue v, "") \ + ITERATOR2(double, jsToDouble, jsExecState es, jsValue v, "") \ + ITERATOR2(bool, jsToBoolean, jsExecState es, jsValue v, "") \ + ITERATOR3(jsValue, jsArrayBuffer, jsExecState es, char* buffer, size_t size, "") \ + ITERATOR2(wkeMemBuf*, jsGetArrayBuffer, jsExecState es, jsValue value, "") \ + ITERATOR2(const utf8*, jsToTempString, jsExecState es, jsValue v, "") \ + ITERATOR2(const wchar_t*, jsToTempStringW, jsExecState es, jsValue v, "") \ + ITERATOR2(void*, jsToV8Value, jsExecState es, jsValue v, "return v8::Persistent*") \ + \ + ITERATOR1(jsValue, jsInt, int n, "") \ + ITERATOR1(jsValue, jsFloat, float f, "") \ + ITERATOR1(jsValue, jsDouble, double d, "") \ + ITERATOR1(jsValue, jsBoolean, bool b, "") \ + \ + ITERATOR0(jsValue, jsUndefined, "") \ + ITERATOR0(jsValue, jsNull, "") \ + ITERATOR0(jsValue, jsTrue, "") \ + ITERATOR0(jsValue, jsFalse, "") \ + \ + ITERATOR2(jsValue, jsString, jsExecState es, const utf8* str, "") \ + ITERATOR2(jsValue, jsStringW, jsExecState es, const wchar_t* str, "") \ + ITERATOR1(jsValue, jsEmptyObject, jsExecState es, "") \ + ITERATOR1(jsValue, jsEmptyArray, jsExecState es, "") \ + \ + ITERATOR2(jsValue, jsObject, jsExecState es, jsData* obj, "") \ + ITERATOR2(jsValue, jsFunction, jsExecState es, jsData* obj, "") \ + ITERATOR2(jsData*, jsGetData, jsExecState es, jsValue object, "") \ + \ + ITERATOR3(jsValue, jsGet, jsExecState es, jsValue object, const char* prop, "") \ + ITERATOR4(void, jsSet, jsExecState es, jsValue object, const char* prop, jsValue v, "") \ + \ + ITERATOR3(jsValue, jsGetAt, jsExecState es, jsValue object, int index, "") \ + ITERATOR4(void, jsSetAt, jsExecState es, jsValue object, int index, jsValue v, "") \ + ITERATOR2(jsKeys*, jsGetKeys, jsExecState es, jsValue object, "") \ + ITERATOR2(bool, jsIsJsValueValid, jsExecState es, jsValue object, "") \ + ITERATOR1(bool, jsIsValidExecState, jsExecState es, "") \ + ITERATOR3(void, jsDeleteObjectProp, jsExecState es, jsValue object, const char* prop, "") \ + \ + ITERATOR2(int, jsGetLength, jsExecState es, jsValue object, "") \ + ITERATOR3(void, jsSetLength, jsExecState es, jsValue object, int length, "") \ + \ + ITERATOR1(jsValue, jsGlobalObject, jsExecState es, "") \ + ITERATOR1(wkeWebView, jsGetWebView, jsExecState es, "") \ + \ + ITERATOR2(jsValue, jsEval, jsExecState es, const utf8* str, "") \ + ITERATOR2(jsValue, jsEvalW, jsExecState es, const wchar_t* str, "") \ + ITERATOR3(jsValue, jsEvalExW, jsExecState es, const wchar_t* str, bool isInClosure, "") \ + \ + ITERATOR5(jsValue, jsCall, jsExecState es, jsValue func, jsValue thisObject, jsValue* args, int argCount, "") \ + ITERATOR4(jsValue, jsCallGlobal, jsExecState es, jsValue func, jsValue* args, int argCount, "") \ + \ + ITERATOR2(jsValue, jsGetGlobal, jsExecState es, const char* prop, "") \ + ITERATOR3(void, jsSetGlobal, jsExecState es, const char* prop, jsValue v, "") \ + \ + ITERATOR0(void, jsGC, "") \ + ITERATOR2(bool, jsAddRef, jsExecState es, jsValue val, "") \ + ITERATOR2(bool, jsReleaseRef, jsExecState es, jsValue val, "") \ + ITERATOR1(jsExceptionInfo*, jsGetLastErrorIfException, jsExecState es, "") \ + ITERATOR2(jsValue, jsThrowException, jsExecState es, const utf8* exception, "") \ + ITERATOR1(const utf8*, jsGetCallstack, jsExecState es, "") + +#if ENABLE_WKE == 1 + +WKE_EXTERN_C __declspec(dllexport) void wkeInit(); +WKE_EXTERN_C __declspec(dllexport) void wkeInitialize(); +WKE_EXTERN_C __declspec(dllexport) void wkeInitializeEx(const wkeSettings* settings); + +WKE_FOR_EACH_DEFINE_FUNCTION(WKE_DECLARE_ITERATOR0, WKE_DECLARE_ITERATOR1, WKE_DECLARE_ITERATOR2, \ + WKE_DECLARE_ITERATOR3, WKE_DECLARE_ITERATOR4, WKE_DECLARE_ITERATOR5, WKE_DECLARE_ITERATOR6, WKE_DECLARE_ITERATOR11) + +#else + +WKE_FOR_EACH_DEFINE_FUNCTION(WKE_DEFINE_ITERATOR0, WKE_DEFINE_ITERATOR1, WKE_DEFINE_ITERATOR2, \ + WKE_DEFINE_ITERATOR3, WKE_DEFINE_ITERATOR4, WKE_DEFINE_ITERATOR5, WKE_DEFINE_ITERATOR6, WKE_DEFINE_ITERATOR11) + +typedef void (WKE_CALL_TYPE *FN_wkeInitializeEx)(const wkeSettings* settings); + +__declspec(selectany) const wchar_t* kWkeDllPath = L"node.dll"; + +inline void wkeSetWkeDllPath(const wchar_t* dllPath) +{ + kWkeDllPath = dllPath; +} + +inline int wkeInitializeEx(const wkeSettings* settings) +{ + HMODULE hMod = LoadLibraryW(kWkeDllPath); + if (hMod) { + FN_wkeInitializeEx wkeInitializeExFunc = (FN_wkeInitializeEx)GetProcAddress(hMod, "wkeInitializeEx"); + wkeInitializeExFunc(settings); + + WKE_FOR_EACH_DEFINE_FUNCTION(WKE_GET_PTR_ITERATOR0, WKE_GET_PTR_ITERATOR1, WKE_GET_PTR_ITERATOR2, WKE_GET_PTR_ITERATOR3, \ + WKE_GET_PTR_ITERATOR4, WKE_GET_PTR_ITERATOR5, WKE_GET_PTR_ITERATOR6, WKE_GET_PTR_ITERATOR11); + return 1; + } + return 0; +} + +inline int wkeInit() +{ + return wkeInitializeEx(((const wkeSettings*)0)); +} + +inline int wkeInitialize() +{ + return wkeInitializeEx(((const wkeSettings*)0)); +} + +#endif + + + +#endif // WKE_DEFINE_H +