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 0000000..19ebd1d Binary files /dev/null and b/BaiduCdp.rc differ 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 0000000..21566bc Binary files /dev/null and b/resource.h differ diff --git a/wke.h b/wke.h new file mode 100644 index 0000000..e436a9f --- /dev/null +++ b/wke.h @@ -0,0 +1,1238 @@ +/* +* +* wolar@qq.com +* http://miniblink.net +* https://github.com/weolar/miniblink49 +* https://weolar.github.io/miniblink/doc-main.html api文档地址 +* licence Apache-2.0 +* +*/ + +#ifndef WKE_DEFINE_H +#define WKE_DEFINE_H + +#include + +////////////////////////////////////////////////////////////////////////// +#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 +