amass/FluentUI
1
0
Fork 0
mirror of https://github.com/zhuzichu520/FluentUI.git synced 2024-11-26 21:37:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
zhuzichu 2023-09-06 14:05:29 +08:00
parent ddee70cdca
commit ed5956d824
8 changed files with 375 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
example/qml-Qt6/page/T_Http.qml
View File

@ -17,6 +17,12 @@ FluContentPage{
cacheDir:cacheDirPath
}
FluHttp{
id:http_breakpoint_download
cacheDir:cacheDirPath
breakPointDownload: true
}
FluHttp{
id:http_cache_ifnonecacherequest
cacheMode:FluHttpType.IfNoneCacheRequest
@ -125,6 +131,45 @@ FluContentPage{
folder_dialog.open()
}
}
FluProgressButton{
property string saveFilePath: FluTools.getApplicationDirPath()+ "/download/big_buck_bunny.mp4"
property string resourcePath: "http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4"
id:btn_breakpoint_download
implicitWidth: parent.width
implicitHeight: 36
text: progress === 1 ? "打开文件" : "断点下载文件"
Component.onCompleted: {
progress = http_breakpoint_download.breakPointDownloadProgress(resourcePath,saveFilePath)
}
onClicked: {
if(progress === 1){
FluTools.showFileInFolder(saveFilePath)
}else{
http_breakpoint_download.download(resourcePath,callable_breakpoint_download,saveFilePath)
}
}
FluMenu{
id:menu_breakpoint_download
width: 120
FluMenuItem{
text: "删除文件"
onClicked: {
if(FluTools.removeFile(btn_breakpoint_download.saveFilePath)){
btn_breakpoint_download.progress = 0
}
}
}
}
MouseArea {
anchors.fill: parent
acceptedButtons: Qt.RightButton
onClicked: {
if(btn_breakpoint_download.progress === 1){
menu_breakpoint_download.popup()
}
}
}
}
FluProgressButton{
id:btn_upload
implicitWidth: parent.width
@ -230,6 +275,30 @@ FluContentPage{
}
}
HttpCallable{
id:callable_breakpoint_download
onStart: {
btn_breakpoint_download.disabled = true
}
onFinish: {
btn_breakpoint_download.disabled = false
}
onError:
(status,errorString,result)=>{
btn_breakpoint_download.progress = 0
showError(errorString)
console.debug(status+";"+errorString+";"+result)
}
onSuccess:
(result)=>{
showSuccess(result)
}
onDownloadProgress:
(recv,total)=>{
btn_breakpoint_download.progress = recv/total
}
}
HttpCallable{
id:callable_download
onStart: {
@ -289,5 +358,4 @@ FluContentPage{
}
}
}
}

71
example/qml/page/T_Http.qml
View File

@ -8,7 +8,6 @@ import FluentUI 1.0
import "qrc:///example/qml/component"
import "../component"
FluContentPage{
title:"Http"
@ -19,6 +18,12 @@ FluContentPage{
cacheDir:cacheDirPath
}
FluHttp{
id:http_breakpoint_download
cacheDir:cacheDirPath
breakPointDownload: true
}
FluHttp{
id:http_cache_ifnonecacherequest
cacheMode:FluHttpType.IfNoneCacheRequest
@ -127,6 +132,45 @@ FluContentPage{
folder_dialog.open()
}
}
FluProgressButton{
property string saveFilePath: FluTools.getApplicationDirPath()+ "/download/big_buck_bunny.mp4"
property string resourcePath: "http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4"
id:btn_breakpoint_download
implicitWidth: parent.width
implicitHeight: 36
text: progress === 1 ? "打开文件" : "断点下载文件"
Component.onCompleted: {
progress = http_breakpoint_download.breakPointDownloadProgress(resourcePath,saveFilePath)
}
onClicked: {
if(progress === 1){
FluTools.showFileInFolder(saveFilePath)
}else{
http_breakpoint_download.download(resourcePath,callable_breakpoint_download,saveFilePath)
}
}
FluMenu{
id:menu_breakpoint_download
width: 120
FluMenuItem{
text: "删除文件"
onClicked: {
if(FluTools.removeFile(btn_breakpoint_download.saveFilePath)){
btn_breakpoint_download.progress = 0
}
}
}
}
MouseArea {
anchors.fill: parent
acceptedButtons: Qt.RightButton
onClicked: {
if(btn_breakpoint_download.progress === 1){
menu_breakpoint_download.popup()
}
}
}
}
FluProgressButton{
id:btn_upload
implicitWidth: parent.width
@ -232,6 +276,30 @@ FluContentPage{
}
}
HttpCallable{
id:callable_breakpoint_download
onStart: {
btn_breakpoint_download.disabled = true
}
onFinish: {
btn_breakpoint_download.disabled = false
}
onError:
(status,errorString,result)=>{
btn_breakpoint_download.progress = 0
showError(errorString)
console.debug(status+";"+errorString+";"+result)
}
onSuccess:
(result)=>{
showSuccess(result)
}
onDownloadProgress:
(recv,total)=>{
btn_breakpoint_download.progress = recv/total
}
}
HttpCallable{
id:callable_download
onStart: {
@ -291,5 +359,4 @@ FluContentPage{
}
}
}
}

2
example/src/main.cpp
View File

@ -37,7 +37,7 @@ int main(int argc, char *argv[])
FramelessConfig::instance()->set(Global::Option::EnableBlurBehindWindow);
#ifdef Q_OS_WIN // 此设置仅在Windows下生效
FramelessConfig::instance()->set(Global::Option::ForceHideWindowFrameBorder);
FramelessConfig::instance()->set(Global::Option::EnableBlurBehindWindow,true);
FramelessConfig::instance()->set(Global::Option::EnableBlurBehindWindow,false);
#endif
#ifdef Q_OS_MACOS
FramelessConfig::instance()->set(Global::Option::ForceNonNativeBackgroundBlur,false);

123
src/FluHttp.cpp
View File

@ -25,7 +25,7 @@ FluHttp::FluHttp(QObject *parent)
timeout(15000);
cacheMode(FluHttpType::CacheMode::NoCache);
cacheDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation)+"/httpcache");
breakPointDownload(true);
breakPointDownload(false);
}
FluHttp::~FluHttp(){
@ -40,21 +40,18 @@ void FluHttp::cancel(){
}
}
void FluHttp::handleReply(QNetworkReply* reply){
_cacheReply.append(reply);
}
void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
QThreadPool::globalInstance()->start([=](){
QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"post")).toMap();
auto requestMap = toRequest(url,params,headers,"post");
QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
Q_EMIT callable->start();
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
Q_EMIT callable->finish();
return;
}
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
for (int i = 0; i < retry(); ++i) {
QNetworkAccessManager manager;
@ -84,17 +81,16 @@ void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> pa
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QString errorString = reply->errorString();
bool isSuccess = reply->error() == QNetworkReply::NoError;
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
if (isSuccess) {
handleCache(data,result);
handleCache(requestMap,result);
Q_EMIT callable->success(result);
break;
}else{
if(i == retry()-1){
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
Q_EMIT callable->error(status,errorString,result);
}
@ -106,15 +102,16 @@ void FluHttp::post(QString url,HttpCallable* callable,QMap<QString, QVariant> pa
void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<QString, QVariant> headers){
QThreadPool::globalInstance()->start([=](){
QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"postString")).toMap();
auto requestMap = toRequest(url,params,headers,"postString");
QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
Q_EMIT callable->start();
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
Q_EMIT callable->finish();
return;
}
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
for (int i = 0; i < retry(); ++i) {
QNetworkAccessManager manager;
@ -135,17 +132,16 @@ void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QString errorString = reply->errorString();
bool isSuccess = reply->error() == QNetworkReply::NoError;
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
if (isSuccess) {
handleCache(data,result);
handleCache(requestMap,result);
Q_EMIT callable->success(result);
break;
}else{
if(i == retry()-1){
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
Q_EMIT callable->error(status,errorString,result);
}
@ -157,15 +153,16 @@ void FluHttp::postString(QString url,HttpCallable* callable,QString params,QMap<
void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
QThreadPool::globalInstance()->start([=](){
QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"postJson")).toMap();
auto requestMap = toRequest(url,params,headers,"postJson");
QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
Q_EMIT callable->start();
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
Q_EMIT callable->finish();
return;
}
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
for (int i = 0; i < retry(); ++i) {
QNetworkAccessManager manager;
@ -186,17 +183,16 @@ void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QString errorString = reply->errorString();
bool isSuccess = reply->error() == QNetworkReply::NoError;
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
if (isSuccess) {
handleCache(data,result);
handleCache(requestMap,result);
Q_EMIT callable->success(result);
break;
}else{
if(i == retry()-1){
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
Q_EMIT callable->error(status,errorString,result);
}
@ -208,13 +204,14 @@ void FluHttp::postJson(QString url,HttpCallable* callable,QMap<QString, QVariant
void FluHttp::get(QString url,HttpCallable* callable,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
QThreadPool::globalInstance()->start([=](){
QMap<QString, QVariant> data = invokeIntercept(toRequest(url,params,headers,"get")).toMap();
auto requestMap = toRequest(url,params,headers,"get");
QMap<QString, QVariant> data = invokeIntercept(requestMap).toMap();
Q_EMIT callable->start();
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::FirstCacheThenRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::IfNoneCacheRequest && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
Q_EMIT callable->finish();
return;
}
@ -236,17 +233,16 @@ void FluHttp::get(QString url,HttpCallable* callable,QMap<QString, QVariant> par
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QString errorString = reply->errorString();
bool isSuccess = reply->error() == QNetworkReply::NoError;
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
if (isSuccess) {
handleCache(data,result);
handleCache(requestMap,result);
Q_EMIT callable->success(result);
break;
}else{
if(i == retry()-1){
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(data)){
Q_EMIT callable->cache(readCache(data));
if(_cacheMode == FluHttpType::CacheMode::RequestFailedReadCache && cacheExists(requestMap)){
Q_EMIT callable->cache(readCache(requestMap));
}
Q_EMIT callable->error(status,errorString,result);
}
@ -268,17 +264,21 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
QNetworkRequest request(_url);
addHeaders(&request,data["headers"].toMap());
QSharedPointer<QFile> file(new QFile(savePath));
QDir dir = QFileInfo(savePath).path();
if (!dir.exists(dir.path())){
dir.mkpath(dir.path());
}
QEventLoop loop;
connect(&manager,&QNetworkAccessManager::finished,&manager,[&loop](QNetworkReply *reply){
loop.quit();
});
auto filePath = getCacheFilePath(data);
qint64 seek = 0;
auto filePath = getCacheFilePath(requestMap);
QSharedPointer<QFile> fileCache(new QFile(filePath));
if(fileCache->exists() && file->exists() && _breakPointDownload){
QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(data).toUtf8()).object();
auto fileSize = cacheInfo.value("fileSize").toInteger();
auto contentLength = cacheInfo.value("contentLength").toInteger();
QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(requestMap).toUtf8()).object();
qint64 fileSize = cacheInfo.value("fileSize").toDouble();
qint64 contentLength = cacheInfo.value("contentLength").toDouble();
if(fileSize == contentLength && file->size() == contentLength){
Q_EMIT callable->downloadProgress(fileSize,contentLength);
Q_EMIT callable->success(savePath);
@ -301,12 +301,12 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
{
qDebug()<<"FileCache Error";
}
connect(reply,&QNetworkReply::readyRead,reply,[reply,file,fileCache,data,callable,seek]{
connect(reply,&QNetworkReply::readyRead,reply,[reply,file,fileCache,requestMap,callable,seek]{
if (!reply || !file || reply->error() != QNetworkReply::NoError)
{
return;
}
QMap<QString, QVariant> downMap = data;
QMap<QString, QVariant> downMap = requestMap;
qint64 contentLength = reply->header(QNetworkRequest::ContentLengthHeader).toLongLong()+seek;
downMap.insert("contentLength",contentLength);
QString eTag = reply->header(QNetworkRequest::ETagHeader).toString();
@ -325,7 +325,6 @@ void FluHttp::download(QString url,HttpCallable* callable,QString savePath,QMap<
}else{
Q_EMIT callable->error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString(),"");
}
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
Q_EMIT callable->finish();
@ -371,7 +370,6 @@ void FluHttp::upload(QString url,HttpCallable* callable,QMap<QString, QVariant>
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QString errorString = reply->errorString();
bool isSuccess = reply->error() == QNetworkReply::NoError;
_cacheReply.removeOne(reply);
reply->deleteLater();
reply = nullptr;
if (isSuccess) {
@ -393,12 +391,12 @@ QMap<QString, QVariant> FluHttp::toRequest(const QString& url,const QVariant& pa
return request;
}
QVariant FluHttp::invokeIntercept(QMap<QString, QVariant> request){
QVariant FluHttp::invokeIntercept(QMap<QString, QVariant> request,Qt::ConnectionType type){
if(!FluApp::getInstance()->httpInterceptor()){
return request;
}
QVariant target;
QMetaObject::invokeMethod(FluApp::getInstance()->httpInterceptor(), "onIntercept",Qt::BlockingQueuedConnection,Q_RETURN_ARG(QVariant,target),Q_ARG(QVariant, request));
QMetaObject::invokeMethod(FluApp::getInstance()->httpInterceptor(), "onIntercept",type,Q_RETURN_ARG(QVariant,target),Q_ARG(QVariant, request));
return target;
}
@ -463,3 +461,26 @@ void FluHttp::handleCache(QMap<QString, QVariant> request,const QString& result)
}
file->write(FluTools::getInstance()->toBase64(result).toUtf8());
}
qreal FluHttp::breakPointDownloadProgress(QString url,QString savePath,QMap<QString, QVariant> params,QMap<QString, QVariant> headers){
auto requestMap = toRequest(url,params,headers,"download");
requestMap.insert("savePath",savePath);
QSharedPointer<QFile> file(new QFile(savePath));
auto filePath = getCacheFilePath(requestMap);
QSharedPointer<QFile> fileCache(new QFile(filePath));
if(fileCache->exists() && file->exists() && _breakPointDownload){
QJsonObject cacheInfo = QJsonDocument::fromJson(readCache(requestMap).toUtf8()).object();
double fileSize = cacheInfo.value("fileSize").toDouble();
double contentLength = cacheInfo.value("contentLength").toDouble();
if(fileSize == contentLength && file->size() == contentLength){
return 1;
}
if(fileSize==file->size()){
return fileSize/contentLength;
}else{
return 0;
}
}else{
return 0;
}
}

4
src/FluHttp.h
View File

@ -32,9 +32,8 @@ class FluHttp : public QObject
Q_PROPERTY_AUTO(bool,breakPointDownload);
QML_NAMED_ELEMENT(FluHttp)
private:
QVariant invokeIntercept(QMap<QString, QVariant> request);
QVariant invokeIntercept(QMap<QString, QVariant> request,Qt::ConnectionType type = Qt::BlockingQueuedConnection);
QMap<QString, QVariant> toRequest(const QString& url,const QVariant& params,const QVariant& headers,const QString& method);
void handleReply(QNetworkReply* reply);
void addQueryParam(QUrl* url,const QMap<QString, QVariant>& params);
void addHeaders(QNetworkRequest* request,const QMap<QString, QVariant>& params);
void handleCache(QMap<QString, QVariant> request, const QString& result);
@ -51,6 +50,7 @@ public:
Q_INVOKABLE void postJson(QString url,HttpCallable* callable,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
Q_INVOKABLE void download(QString url,HttpCallable* callable,QString savePath,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
Q_INVOKABLE void upload(QString url,HttpCallable* callable,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
Q_INVOKABLE qreal breakPointDownloadProgress(QString url,QString savePath,QMap<QString, QVariant> params = {},QMap<QString, QVariant> headers = {});
Q_INVOKABLE void cancel();
private:
QList<QPointer<QNetworkReply>> _cacheReply;

22
src/FluTools.cpp
View File

@ -6,6 +6,7 @@
#include <QScreen>
#include <QColor>
#include <QFileInfo>
#include <QProcess>
#include <QDir>
#include <QCryptographicHash>
#include <QTextDocument>
@ -151,6 +152,27 @@ bool FluTools::removeDir(QString dirPath){
return qDir.removeRecursively();
}
bool FluTools::removeFile(QString filePath){
QFile file(filePath);
return file.remove();
}
QString FluTools::sha256(QString text){
return QCryptographicHash::hash(text.toUtf8(), QCryptographicHash::Sha256).toHex();
}
void FluTools::showFileInFolder(QString path){
#if defined(Q_OS_WIN)
QProcess::startDetached("explorer.exe", {"/select,", QDir::toNativeSeparators(path)});
#endif
#if defined(Q_OS_LINUX)
QFileInfo fileInfo(path);
auto process = "xdg-open";
auto arguments = { fileInfo.absoluteDir().absolutePath() };
QProcess::startDetached(process, arguments);
#endif
#if defined(Q_OS_MACOS)
QProcess::execute("/usr/bin/osascript", {"-e", "tell application \"Finder\" to reveal POSIX file \"" + path + "\""});
QProcess::execute("/usr/bin/osascript", {"-e", "tell application \"Finder\" to activate"});
#endif
}

13
src/FluTools.h
View File

@ -180,6 +180,19 @@ public:
*/
Q_INVOKABLE bool removeDir(QString dirPath);
/**
* @brief removeFile
* @param filePath
* @return
*/
Q_INVOKABLE bool removeFile(QString filePath);
/**
* @brief showFileInFolder
* @param path
*/
Q_INVOKABLE void showFileInFolder(QString path);
};
#endif // FLUTOOLS_H

176
src/Qt5/imports/FluentUI/plugins.qmltypes
View File

@ -8,21 +8,6 @@ import QtQuick.tooling 1.2
Module {
dependencies: ["QtQuick 2.0"]
Component {
name: "FluHttpType"
exports: ["FluentUI/FluHttpType 1.0"]
isCreatable: false
exportMetaObjectRevisions: [0]
Enum {
name: "CacheMode"
values: {
"NoCache": 0,
"RequestFailedReadCache": 1,
"IfNoneCacheRequest": 2,
"FirstCacheThenRequest": 4
}
}
}
Component {
name: "FluCalendarViewType"
exports: ["FluentUI/FluCalendarViewType 1.0"]
@ -85,116 +70,140 @@ Module {
exportMetaObjectRevisions: [0]
Property { name: "retry"; type: "int" }
Property { name: "timeout"; type: "int" }
Property { name: "cacheMode"; type: "int" }
Property { name: "cacheDir"; type: "string" }
Property { name: "breakPointDownload"; type: "bool" }
Method {
name: "get"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "get"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "get"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
}
Method {
name: "post"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "post"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "post"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
}
Method {
name: "postString"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "string" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "postString"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "string" }
}
Method {
name: "postString"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
}
Method {
name: "postJson"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "postJson"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "postJson"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
}
Method {
name: "download"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "filePath"; type: "string" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "savePath"; type: "string" }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "download"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "filePath"; type: "string" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "savePath"; type: "string" }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "download"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "filePath"; type: "string" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "savePath"; type: "string" }
}
Method {
name: "upload"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "upload"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "upload"
Parameter { name: "url"; type: "string" }
Parameter { name: "callable"; type: "QJSValue" }
Parameter { name: "callable"; type: "HttpCallable"; isPointer: true }
}
Method {
name: "breakPointDownloadProgress"
type: "double"
Parameter { name: "url"; type: "string" }
Parameter { name: "savePath"; type: "string" }
Parameter { name: "params"; type: "QVariantMap" }
Parameter { name: "headers"; type: "QVariantMap" }
}
Method {
name: "breakPointDownloadProgress"
type: "double"
Parameter { name: "url"; type: "string" }
Parameter { name: "savePath"; type: "string" }
Parameter { name: "params"; type: "QVariantMap" }
}
Method {
name: "breakPointDownloadProgress"
type: "double"
Parameter { name: "url"; type: "string" }
Parameter { name: "savePath"; type: "string" }
}
Method { name: "cancel" }
}
@ -204,6 +213,21 @@ Module {
exports: ["FluentUI/FluHttpInterceptor 1.0"]
exportMetaObjectRevisions: [0]
}
Component {
name: "FluHttpType"
exports: ["FluentUI/FluHttpType 1.0"]
isCreatable: false
exportMetaObjectRevisions: [0]
Enum {
name: "CacheMode"
values: {
"NoCache": 0,
"RequestFailedReadCache": 1,
"IfNoneCacheRequest": 2,
"FirstCacheThenRequest": 4
}
}
}
Component {
name: "FluNavigationViewType"
exports: ["FluentUI/FluNavigationViewType 1.0"]
@ -253,20 +277,6 @@ Module {
"File": 1
}
}
}
Component {
name: "FluTimelineType"
exports: ["FluentUI/FluTimelineType 1.0"]
isCreatable: false
exportMetaObjectRevisions: [0]
Enum {
name: "Mode"
values: {
"Left": 0,
"Right": 1,
"Alternate": 2
}
}
}
Component {
name: "FluStatusViewType"
@ -332,6 +342,20 @@ Module {
}
}
}
Component {
name: "FluTimelineType"
exports: ["FluentUI/FluTimelineType 1.0"]
isCreatable: false
exportMetaObjectRevisions: [0]
Enum {
name: "Mode"
values: {
"Left": 0,
"Right": 1,
"Alternate": 2
}
}
}
Component {
name: "FluTreeViewType"
exports: ["FluentUI/FluTreeViewType 1.0"]
@ -1787,6 +1811,38 @@ Module {
}
}
}
Component {
name: "HttpCallable"
prototype: "QObject"
exports: ["FluentUI/HttpCallable 1.0"]
exportMetaObjectRevisions: [0]
Signal { name: "start" }
Signal { name: "finish" }
Signal {
name: "error"
Parameter { name: "status"; type: "int" }
Parameter { name: "errorString"; type: "string" }
Parameter { name: "result"; type: "string" }
}
Signal {
name: "success"
Parameter { name: "result"; type: "string" }
}
Signal {
name: "cache"
Parameter { name: "result"; type: "string" }
}
Signal {
name: "downloadProgress"
Parameter { name: "recv"; type: "qlonglong" }
Parameter { name: "total"; type: "qlonglong" }
}
Signal {
name: "uploadProgress"
Parameter { name: "recv"; type: "qlonglong" }
Parameter { name: "total"; type: "qlonglong" }
}
}
Component {
name: "QRCode"
defaultProperty: "data"
@ -1816,6 +1872,7 @@ Module {
exportMetaObjectRevisions: [0]
Property { name: "saveFolder"; type: "string" }
Property { name: "captureMode"; type: "int" }
Property { name: "hitDrawData"; type: "DrawData"; isPointer: true }
Signal {
name: "captrueToPixmapCompleted"
Parameter { name: "captrue"; type: "QPixmap" }
@ -1829,6 +1886,25 @@ Module {
Parameter { name: "start"; type: "QPoint" }
Parameter { name: "end"; type: "QPoint" }
}
Method {
name: "appendDrawData"
type: "DrawData*"
Parameter { name: "drawType"; type: "int" }
Parameter { name: "start"; type: "QPoint" }
Parameter { name: "end"; type: "QPoint" }
}
Method {
name: "updateDrawData"
Parameter { name: "data"; type: "DrawData"; isPointer: true }
Parameter { name: "start"; type: "QPoint" }
Parameter { name: "end"; type: "QPoint" }
}
Method { name: "clear" }
Method {
name: "hit"
type: "DrawData*"
Parameter { name: "point"; type: "QPoint" }
}
}
Component {
name: "WindowHelper"