Browse Source

added public message api

pull/2/head
Skycoder42 7 years ago
parent
commit
7dfa1d49aa
  1. 2
      examples/mvvmwidgets/SampleWidgets/widgetseventservice.cpp
  2. 76
      src/mvvmcore/coreapp.cpp
  3. 16
      src/mvvmcore/coreapp.h
  4. 9
      src/mvvmcore/coreapp_p.h
  5. 2
      src/mvvmcore/ipresenter.h
  6. 538
      src/mvvmcore/message.cpp
  7. 326
      src/mvvmcore/message.h
  8. 23
      src/mvvmcore/message_p.h
  9. 4
      src/mvvmcore/serviceregistry.cpp
  10. 16
      src/mvvmcore/viewmodel.cpp
  11. 5
      src/mvvmcore/viewmodel.h
  12. 24
      src/mvvmwidgets/widgetspresenter.cpp
  13. 1
      src/mvvmwidgets/widgetspresenter.h

2
examples/mvvmwidgets/SampleWidgets/widgetseventservice.cpp

@ -27,7 +27,7 @@ int WidgetsEventService::addEvent(const QString &name)
_events.insert(_cnt, timer); _events.insert(_cnt, timer);
connect(timer.data(), &QTimer::timeout, this, [this, name]() { connect(timer.data(), &QTimer::timeout, this, [this, name]() {
_echoService->ping(name);//TODO event triggered signal _echoService->ping(name);
}); });
timer->start(1000); timer->start(1000);

76
src/mvvmcore/coreapp.cpp

@ -53,6 +53,35 @@ IPresenter *CoreApp::presenter() const
return d->presenter.data(); return d->presenter.data();
} }
void CoreApp::show(const char *viewModelName, const QVariantHash &params)
{
auto metaId = QMetaType::type(viewModelName);
auto metaObject = QMetaType::metaObjectForType(metaId);
if(!metaObject) {
throw PresenterException(QByteArrayLiteral("Given name (") +
viewModelName +
QByteArrayLiteral(") does not name a type with meta data"));
}
show(metaObject, params);
}
void CoreApp::show(const QMetaObject *viewMetaObject, const QVariantHash &params)
{
if(!viewMetaObject->inherits(&ViewModel::staticMetaObject)) {
throw PresenterException(QByteArrayLiteral("Given type (") +
viewMetaObject->className() +
QByteArrayLiteral(") is not a class that extends QtMvvm::ViewModel"));
}
showImp(viewMetaObject, params);
}
MessageResult *CoreApp::showDialog(const MessageConfig &config)
{
auto result = new MessageResult();
CoreAppPrivate::dInstance()->showDialog(config, result);
return result;
}
void CoreApp::bootApp() void CoreApp::bootApp()
{ {
if(!d->presenter) if(!d->presenter)
@ -89,26 +118,13 @@ bool CoreApp::autoParse(QCommandLineParser &parser, const QStringList &arguments
} }
} }
void CoreApp::show(const char *viewModelName, const QVariantHash &params) const void CoreApp::showImp(const QMetaObject *metaObject, const QVariantHash &params)
{
auto metaId = QMetaType::type(viewModelName);
auto metaObject = QMetaType::metaObjectForType(metaId);
if(!metaObject) {
throw PresenterException(QByteArrayLiteral("Given name (") +
viewModelName +
QByteArrayLiteral(") does not name a type with meta data"));
}
show(metaObject, params);
}
void CoreApp::show(const QMetaObject *viewMetaObject, const QVariantHash &params) const
{ {
if(!viewMetaObject->inherits(&ViewModel::staticMetaObject)) { QMetaObject::invokeMethod(CoreAppPrivate::dInstance().data(), "showViewModel", Qt::QueuedConnection,
throw PresenterException(QByteArrayLiteral("Given type (") + Q_ARG(const QMetaObject*, metaObject),
viewMetaObject->className() + Q_ARG(const QVariantHash&, params),
QByteArrayLiteral(") is not a class that extends QtMvvm::ViewModel")); Q_ARG(QPointer<ViewModel>, nullptr),
} Q_ARG(quint32, 0));
ViewModel::showImp(viewMetaObject, params, nullptr);
} }
// ------------- Private Implementation ------------- // ------------- Private Implementation -------------
@ -125,21 +141,12 @@ QScopedPointer<CoreAppPrivate> &CoreAppPrivate::dInstance()
return instance->d; return instance->d;
} }
void CoreAppPrivate::showViewModel(const QMetaObject *metaObject, const QVariantHash &params, QPointer<ViewModel> parent, quint32 requestCode)
{
QMetaObject::invokeMethod(this, "showViewModelPrivate", Qt::QueuedConnection,
Q_ARG(const QMetaObject*, metaObject),
Q_ARG(const QVariantHash&, params),
Q_ARG(QPointer<ViewModel>, parent),
Q_ARG(quint32, requestCode));
}
IPresenter *CoreAppPrivate::currentPresenter() const IPresenter *CoreAppPrivate::currentPresenter() const
{ {
return presenter.data(); return presenter.data();
} }
void CoreAppPrivate::showViewModelPrivate(const QMetaObject *metaObject, const QVariantHash &params, QPointer<ViewModel> parent, quint32 requestCode) void CoreAppPrivate::showViewModel(const QMetaObject *metaObject, const QVariantHash &params, QPointer<ViewModel> parent, quint32 requestCode)
{ {
if(presenter) { if(presenter) {
QPointer<ViewModel> vm; QPointer<ViewModel> vm;
@ -172,3 +179,14 @@ void CoreAppPrivate::showViewModelPrivate(const QMetaObject *metaObject, const Q
<< "- no presenter was set"; << "- no presenter was set";
} }
} }
void CoreAppPrivate::showDialog(const MessageConfig &config, MessageResult *result)
{
if(presenter)
presenter->showDialog(config, result);
else {
logCritical() << "Failed to show dialog ff type"
<< config.type() << ":" << config.subType()
<< "- no presenter was set";
}
}

16
src/mvvmcore/coreapp.h

@ -9,6 +9,7 @@ class QCommandLineParser;
#include "QtMvvmCore/qtmvvmcore_global.h" #include "QtMvvmCore/qtmvvmcore_global.h"
#include "QtMvvmCore/viewmodel.h" #include "QtMvvmCore/viewmodel.h"
#include "QtMvvmCore/ipresenter.h" #include "QtMvvmCore/ipresenter.h"
#include "QtMvvmCore/message.h"
namespace QtMvvm { namespace QtMvvm {
@ -28,6 +29,13 @@ public:
void registerApp(); void registerApp();
IPresenter *presenter() const; IPresenter *presenter() const;
template <typename TViewModel>
static inline void show(const QVariantHash &params = {});
static void show(const char *viewModelName, const QVariantHash &params = {});
static void show(const QMetaObject *viewMetaObject, const QVariantHash &params = {});
static MessageResult *showDialog(const MessageConfig &config);
public Q_SLOTS: public Q_SLOTS:
void bootApp(); void bootApp();
@ -37,18 +45,16 @@ protected:
virtual void closeApp(); virtual void closeApp();
bool autoParse(QCommandLineParser &parser, const QStringList &arguments); bool autoParse(QCommandLineParser &parser, const QStringList &arguments);
template <typename TViewModel>
inline void show(const QVariantHash &params = {}) const;
void show(const char *viewModelName, const QVariantHash &params = {}) const;
void show(const QMetaObject *viewMetaObject, const QVariantHash &params = {}) const;
private: private:
friend class QtMvvm::CoreAppPrivate; friend class QtMvvm::CoreAppPrivate;
QScopedPointer<CoreAppPrivate> d; QScopedPointer<CoreAppPrivate> d;
static void showImp(const QMetaObject *metaObject, const QVariantHash &params);
}; };
template<typename TViewModel> template<typename TViewModel>
inline void CoreApp::show(const QVariantHash &params) const inline void CoreApp::show(const QVariantHash &params)
{ {
static_assert(std::is_base_of<ViewModel, TViewModel>::value, "TViewModel must extend QtMvvm::ViewModel"); static_assert(std::is_base_of<ViewModel, TViewModel>::value, "TViewModel must extend QtMvvm::ViewModel");
ViewModel::showImp(&TViewModel::staticMetaObject, params, nullptr); ViewModel::showImp(&TViewModel::staticMetaObject, params, nullptr);

9
src/mvvmcore/coreapp_p.h

@ -15,18 +15,15 @@ class Q_MVVMCORE_EXPORT CoreAppPrivate : public QObject
public: public:
static QScopedPointer<CoreAppPrivate> &dInstance(); static QScopedPointer<CoreAppPrivate> &dInstance();
void showViewModel(const QMetaObject *metaObject,
const QVariantHash &params,
QPointer<ViewModel> parent,
quint32 requestCode);
IPresenter *currentPresenter() const; IPresenter *currentPresenter() const;
private Q_SLOTS: public Q_SLOTS:
void showViewModelPrivate(const QMetaObject *metaObject, void showViewModel(const QMetaObject *metaObject,
const QVariantHash &params, const QVariantHash &params,
QPointer<ViewModel> parent, QPointer<ViewModel> parent,
quint32 requestCode); quint32 requestCode);
void showDialog(const MessageConfig &config, MessageResult *result);
private: private:
CoreAppPrivate(); CoreAppPrivate();

2
src/mvvmcore/ipresenter.h

@ -5,6 +5,7 @@
#include "QtMvvmCore/qtmvvmcore_global.h" #include "QtMvvmCore/qtmvvmcore_global.h"
#include "QtMvvmCore/viewmodel.h" #include "QtMvvmCore/viewmodel.h"
#include "QtMvvmCore/message.h"
namespace QtMvvm { namespace QtMvvm {
@ -30,6 +31,7 @@ public:
inline virtual ~IPresenter() = default; inline virtual ~IPresenter() = default;
virtual void present(ViewModel *viewModel, const QVariantHash &params, QPointer<ViewModel> parent = nullptr) = 0; virtual void present(ViewModel *viewModel, const QVariantHash &params, QPointer<ViewModel> parent = nullptr) = 0;
virtual void showDialog(const MessageConfig &config, MessageResult *result) = 0;
}; };
} }

538
src/mvvmcore/message.cpp

@ -1,13 +1,32 @@
#include "message.h" #include "message.h"
#include "message_p.h" #include "message_p.h"
#include "coreapp.h"
#include <QtGui/QGuiApplication>
using namespace QtMvvm; using namespace QtMvvm;
MessageConfig::MessageConfig(MessageType type) : const QByteArray MessageConfig::TypeMessageBox = "msgbox";
d(new MessageConfigPrivate(type)) const QByteArray MessageConfig::TypeInputDialog = "input";
const QByteArray MessageConfig::TypeFileDialog = "file";
const QByteArray MessageConfig::SubTypeInformation = "information";
const QByteArray MessageConfig::SubTypeWarning = "warning";
const QByteArray MessageConfig::SubTypeCritical = "critical";
const QByteArray MessageConfig::SubTypeQuestion = "question";
const QByteArray MessageConfig::SubTypeAbout = "about";
const QByteArray MessageConfig::SubTypeDir = "dir";
const QByteArray MessageConfig::SubTypeOpenFile = "open";
const QByteArray MessageConfig::SubTypeOpenFiles = "files";
const QByteArray MessageConfig::SubTypeSaveFile = "save";
MessageConfig::MessageConfig(const QByteArray &type, const QByteArray &subType) :
d(new MessageConfigPrivate(type, subType))
{ {
resetPositiveAction(); if(subType.isEmpty())
resetNegativeAction(); resetSubType();
resetNeutralAction(); resetButtons();
} }
MessageConfig::MessageConfig(const MessageConfig &other) : MessageConfig::MessageConfig(const MessageConfig &other) :
@ -22,11 +41,16 @@ MessageConfig &MessageConfig::operator=(const MessageConfig &other)
return (*this); return (*this);
} }
MessageConfig::MessageType MessageConfig::type() const QByteArray MessageConfig::type() const
{ {
return d->type; return d->type;
} }
QByteArray MessageConfig::subType() const
{
return d->subType;
}
QString MessageConfig::title() const QString MessageConfig::title() const
{ {
return d->title; return d->title;
@ -37,24 +61,14 @@ QString MessageConfig::text() const
return d->text; return d->text;
} }
QString MessageConfig::positiveAction() const MessageConfig::StandardButtons MessageConfig::buttons() const
{
return d->positiveAction;
}
QString MessageConfig::negativeAction() const
{ {
return d->negativeAction; return d->buttons;
} }
QString MessageConfig::neutralAction() const QHash<MessageConfig::StandardButton, QString> MessageConfig::buttonTexts() const
{ {
return d->neutralAction; return d->buttonTexts;
}
QByteArray MessageConfig::inputType() const
{
return d->inputType;
} }
QVariant MessageConfig::defaultValue() const QVariant MessageConfig::defaultValue() const
@ -62,113 +76,174 @@ QVariant MessageConfig::defaultValue() const
return d->defaultValue; return d->defaultValue;
} }
QVariantMap MessageConfig::editProperties() const QVariantMap MessageConfig::viewProperties() const
{ {
return d->editProperties; return d->editProperties;
} }
void MessageConfig::setType(MessageConfig::MessageType type) void MessageConfig::setType(const QByteArray &type)
{ {
d->type = type; d->type = type;
resetPositiveAction();
resetNegativeAction();
resetNeutralAction();
} }
void MessageConfig::setTitle(QString title) void MessageConfig::setSubType(const QByteArray &subType)
{ {
d->title = title; d->subType = subType;
} }
void MessageConfig::setText(QString text) void MessageConfig::setTitle(const QString &title)
{ {
d->text = text; d->title = title;
} }
void MessageConfig::setPositiveAction(QString positiveAction) void MessageConfig::setText(const QString &text)
{ {
d->positiveAction = positiveAction; d->text = text;
} }
void MessageConfig::setNegativeAction(QString negativeAction) void MessageConfig::setButtons(StandardButtons buttons)
{ {
d->negativeAction = negativeAction; d->buttons = buttons;
} }
void MessageConfig::setNeutralAction(QString neutralAction) void MessageConfig::setButtonTexts(const QHash<StandardButton, QString> &buttonTexts)
{ {
d->neutralAction = neutralAction; d->buttonTexts = buttonTexts;
} }
void MessageConfig::setInputType(QByteArray inputType) void MessageConfig::setButtonText(MessageConfig::StandardButton button, const QString &text)
{ {
d->inputType = inputType; d->buttonTexts.insert(button, text);
} }
void MessageConfig::setDefaultValue(QVariant defaultValue) void MessageConfig::setDefaultValue(const QVariant &defaultValue)
{ {
d->defaultValue = defaultValue; d->defaultValue = defaultValue;
} }
void MessageConfig::setEditProperties(QVariantMap editProperties) void MessageConfig::setViewProperties(const QVariantMap &editProperties)
{ {
d->editProperties = editProperties; d->editProperties = editProperties;
} }
void MessageConfig::resetPositiveAction() void MessageConfig::setViewProperty(const QString &key, const QVariant &value)
{ {
switch (d->type) { d->editProperties.insert(key, value);
case Information:
case Warning:
case Critical:
case Input:
d->positiveAction = tr("Ok");
break;
case Question:
d->positiveAction = tr("Yes");
break;
default:
Q_UNREACHABLE();
break;
} }
void MessageConfig::resetSubType()
{
if(d->type == TypeMessageBox)
d->subType = SubTypeInformation;
else if(d->type == TypeInputDialog)
d->subType = QMetaType::typeName(QMetaType::QString);
else
d->subType.clear();
} }
void MessageConfig::resetNegativeAction() void MessageConfig::resetButtons()
{ {
switch (d->type) { if(d->type == TypeMessageBox) {
case Input: if(d->subType == SubTypeQuestion)
d->negativeAction = tr("Cancel"); d->buttons = Yes | No;
else if(d->subType == SubTypeAbout)
d->buttons = Close;
else
d->buttons = Ok;
} else if(d->type == TypeInputDialog)
d->buttons = Ok | Cancel;
else
d->buttons = Ok;
d->buttonTexts.clear();
}
MessageResult::MessageResult() :
QObject(nullptr),
d(new MessageResultPrivate())
{}
MessageResult::~MessageResult() {}
bool MessageResult::hasResult() const
{
return d->result.isValid();
}
QVariant MessageResult::result() const
{
return d->result;
}
bool MessageResult::autoDelete() const
{
return d->autoDelete;
}
void MessageResult::setCloseTarget(QObject *closeObject, const QMetaMethod &closeMethod)
{
Q_ASSERT_X(closeObject, Q_FUNC_INFO, "closeObject must not be null");
d->closeObject = closeObject;
d->closeMethod = closeMethod;
if(d->closeRequested)
d->closeMethod.invoke(d->closeObject, Qt::QueuedConnection);
}
void MessageResult::complete(MessageResult::ResultType result)
{
switch (result) {
case PositiveResult:
emit positiveAction();
break; break;
case Question: case NegativeResult:
d->negativeAction = tr("No"); emit negativeAction();
break; break;
case Information: case NeutralResult:
case Warning: emit neutralAction();
case Critical:
d->negativeAction.clear();
break; break;
default: default:
Q_UNREACHABLE(); Q_UNREACHABLE();
break;
} }
emit anyAction(result);
if(d->autoDelete)
deleteLater();
} }
void MessageConfig::resetNeutralAction() void MessageResult::discardMessage()
{ {
d->neutralAction.clear(); if(d->closeObject && !d->closeRequested)
d->closeMethod.invoke(d->closeObject, Qt::QueuedConnection);
d->closeRequested = true;
}
void MessageResult::setResult(QVariant result)
{
d->result = result;
}
void MessageResult::setAutoDelete(bool autoDelete)
{
if (d->autoDelete == autoDelete)
return;
d->autoDelete = autoDelete;
emit autoDeleteChanged(autoDelete);
} }
// ------------- Private Implementation ------------- // ------------- Private Implementation -------------
QtMvvm::MessageConfigPrivate::MessageConfigPrivate(MessageConfig::MessageType type) : QtMvvm::MessageConfigPrivate::MessageConfigPrivate(const QByteArray &type, const QByteArray &subType) :
QSharedData(), QSharedData(),
type(type), type(type),
subType(subType),
title(), title(),
text(), text(),
positiveAction(), buttons(MessageConfig::Ok),
negativeAction(), buttonTexts(),
neutralAction(),
inputType(),
defaultValue(), defaultValue(),
editProperties() editProperties()
{} {}
@ -176,12 +251,325 @@ QtMvvm::MessageConfigPrivate::MessageConfigPrivate(MessageConfig::MessageType ty
QtMvvm::MessageConfigPrivate::MessageConfigPrivate(const QtMvvm::MessageConfigPrivate &other) : QtMvvm::MessageConfigPrivate::MessageConfigPrivate(const QtMvvm::MessageConfigPrivate &other) :
QSharedData(other), QSharedData(other),
type(other.type), type(other.type),
subType(other.subType),
title(other.title), title(other.title),
text(other.text), text(other.text),
positiveAction(other.positiveAction), buttons(other.buttons),
negativeAction(other.negativeAction), buttonTexts(other.buttonTexts),
neutralAction(other.neutralAction),
inputType(other.inputType),
defaultValue(other.defaultValue), defaultValue(other.defaultValue),
editProperties(other.editProperties) editProperties(other.editProperties)
{} {}
MessageResultPrivate::MessageResultPrivate() :
closeObject(nullptr),
closeMethod(),
closeRequested(false),
result(),
autoDelete(true)
{}
// ------------- Namespace methods implementation -------------
MessageResult *QtMvvm::information(const QString &title, const QString &text, const QString &okText)
{
MessageConfig config(MessageConfig::TypeMessageBox, MessageConfig::SubTypeInformation);
config.setTitle(title);
config.setText(text);
if(!okText.isNull())
config.setButtonText(MessageConfig::Ok, okText);
return CoreApp::showDialog(config);
}
void QtMvvm::information(const QString &title, const QString &text, QObject *scope, std::function<void ()> onResult, const QString &okText)
{
auto result = information(title, text, okText);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, onResult,
Qt::QueuedConnection);
}
}
void QtMvvm::information(const QString &title, const QString &text, std::function<void ()> onResult, const QString &okText)
{
information(title, text, CoreApp::instance(), onResult, okText);
}
MessageResult *QtMvvm::question(const QString &title, const QString &text, const QString &yesText, const QString &noText)
{
MessageConfig config(MessageConfig::TypeMessageBox, MessageConfig::SubTypeQuestion);
config.setTitle(title);
config.setText(text);
if(!yesText.isNull())
config.setButtonText(MessageConfig::Yes, yesText);
if(!noText.isNull())
config.setButtonText(MessageConfig::No, noText);
return CoreApp::showDialog(config);
}
void QtMvvm::question(const QString &title, const QString &text, QObject *scope, std::function<void (bool)> onResult, const QString &yesText, const QString &noText)
{
auto result = question(title, text, yesText, noText);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult);
}, Qt::QueuedConnection);
}
}
void QtMvvm::question(const QString &title, const QString &text, std::function<void (bool)> onResult, const QString &yesText, const QString &noText)
{
question(title, text, CoreApp::instance(), onResult, yesText, noText);
}
MessageResult *QtMvvm::warning(const QString &title, const QString &text, const QString &okText)
{
MessageConfig config(MessageConfig::TypeMessageBox, MessageConfig::SubTypeWarning);
config.setTitle(title);
config.setText(text);
if(!okText.isNull())
config.setButtonText(MessageConfig::Ok, okText);
return CoreApp::showDialog(config);
}
void QtMvvm::warning(const QString &title, const QString &text, QObject *scope, std::function<void ()> onResult, const QString &okText)
{
auto result = warning(title, text, okText);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, onResult,
Qt::QueuedConnection);
}
}
void QtMvvm::warning(const QString &title, const QString &text, std::function<void ()> onResult, const QString &okText)
{
warning(title, text, CoreApp::instance(), onResult, okText);
}
MessageResult *QtMvvm::critical(const QString &title, const QString &text, const QString &okText)
{
MessageConfig config(MessageConfig::TypeMessageBox, MessageConfig::SubTypeCritical);
config.setTitle(title);
config.setText(text);
if(!okText.isNull())
config.setButtonText(MessageConfig::Ok, okText);
return CoreApp::showDialog(config);
}
void QtMvvm::critical(const QString &title, const QString &text, QObject *scope, std::function<void ()> onResult, const QString &okText)
{
auto result = critical(title, text, okText);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, onResult,
Qt::QueuedConnection);
}
}
void QtMvvm::critical(const QString &title, const QString &text, std::function<void ()> onResult, const QString &okText)
{
critical(title, text, CoreApp::instance(), onResult, okText);
}
MessageResult *QtMvvm::about(const QString &description, const QUrl &websiteUrl, const QString &licenseName, const QUrl &licenseUrl, const QString &companyName, bool addQtVersion, const QStringList &extraTopInfos, const QString &extraBottomInfos)
{
static const QString pBegin = QStringLiteral("<p>");
static const QString pEnd = QStringLiteral("</p>");
static const QString br = QStringLiteral("<br/>");
MessageConfig config(MessageConfig::TypeMessageBox, MessageConfig::SubTypeAbout);
config.setViewProperty(QStringLiteral("addQtVersion"), addQtVersion);
config.setTitle(MessageConfig::tr("%1 — Version %2")
.arg(QGuiApplication::applicationDisplayName())
.arg(QCoreApplication::applicationVersion()));
//create the content string:
//basic text
QString text = pBegin + description + pEnd;
//qt version info + extra infos
if(addQtVersion || !extraTopInfos.isEmpty()) {
text += pBegin;
if(addQtVersion) {
auto runtimeVers = qVersion();
auto compileVers = QT_VERSION_STR;
QString qtVersion;
if(qstrcmp(runtimeVers, compileVers) == 0)
qtVersion = QString::fromUtf8(runtimeVers);
else {
qtVersion = MessageConfig::tr("%1 (Built with %2)")
.arg(QString::fromUtf8(runtimeVers))
.arg(QString::fromUtf8(runtimeVers));
}
text += MessageConfig::tr("Qt-Version: <a href=\"https://www.qt.io/\">%2</a>")
.arg(qtVersion);
}
if(!extraTopInfos.isEmpty()) {
auto withBr = addQtVersion;
foreach(auto info, extraTopInfos){
text += info + (withBr ? br : QString());
withBr = true;
}
}
text += pEnd;
}
//Developer info
text += pBegin + MessageConfig::tr("Developed by: %1")
.arg(companyName.isEmpty() ? QCoreApplication::organizationName() : companyName);
if(websiteUrl.isValid()) {
text += br + MessageConfig::tr("Project Website: <a href=\"%1\">%2</a>")
.arg(QString::fromUtf8(websiteUrl.toEncoded()))
.arg(websiteUrl.toString());
}
if(!licenseName.isEmpty()) {
if(licenseUrl.isValid()) {
text += br + MessageConfig::tr("License: <a href=\"%1\">%2</a>")
.arg(QString::fromUtf8(licenseUrl.toEncoded()))
.arg(licenseName);
} else {
text += br + MessageConfig::tr("License: %1")
.arg(licenseName);
}
}
text += pEnd;
//extra bottom infos
if(!extraBottomInfos.isEmpty())
text += pBegin + extraBottomInfos + pEnd;
//set in the config
config.setText(text);
return CoreApp::showDialog(config);
}
MessageResult *QtMvvm::getInput(const QString &title, const QString &text, const char *inputType, const QVariant &defaultValue, const QVariantMap &viewProperties, const QString &okText, const QString &cancelText)
{
MessageConfig config(MessageConfig::TypeInputDialog, inputType);
config.setTitle(title);
config.setText(text);
config.setDefaultValue(defaultValue);
config.setViewProperties(viewProperties);
if(!okText.isNull())
config.setButtonText(MessageConfig::Ok, okText);
if(!cancelText.isNull())
config.setButtonText(MessageConfig::Cancel, cancelText);
return CoreApp::showDialog(config);
}
void QtMvvm::getInput(const QString &title, const QString &text, const char *inputType, QObject *scope, std::function<void (QVariant)> onResult, const QVariant &defaultValue, const QVariantMap &viewProperties, const QString &okText, const QString &cancelText)
{
auto result = getInput(title, text, inputType, defaultValue, viewProperties, okText, cancelText);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult, result](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult ? result->result() : QVariant());
}, Qt::QueuedConnection);
}
}
void QtMvvm::getInput(const QString &title, const QString &text, const char *inputType, std::function<void (QVariant)> onResult, const QVariant &defaultValue, const QVariantMap &viewProperties, const QString &okText, const QString &cancelText)
{
getInput(title, text, inputType, CoreApp::instance(), onResult, defaultValue, viewProperties, okText, cancelText);
}
MessageResult *QtMvvm::getExistingDirectory(const QString &title, const QUrl &dir)
{
MessageConfig config(MessageConfig::TypeFileDialog, MessageConfig::SubTypeDir);
config.setTitle(title);
config.setDefaultValue(dir);
return CoreApp::showDialog(config);
}
void QtMvvm::getExistingDirectory(QObject *scope, std::function<void (QUrl)> onResult, const QString &title, const QUrl &dir)
{
auto result = getExistingDirectory(title, dir);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult, result](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult ? result->result().toUrl() : QUrl());
}, Qt::QueuedConnection);
}
}
void QtMvvm::getExistingDirectory(std::function<void (QUrl)> onResult, const QString &title, const QUrl &dir)
{
getExistingDirectory(CoreApp::instance(), onResult, title, dir);
}
MessageResult *QtMvvm::getOpenFile(const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
MessageConfig config(MessageConfig::TypeFileDialog, MessageConfig::SubTypeOpenFile);
config.setTitle(title);
config.setDefaultValue(dir);
config.setViewProperty(QStringLiteral("mimeTypes"), supportedMimeTypes);
return CoreApp::showDialog(config);
}
void QtMvvm::getOpenFile(QObject *scope, std::function<void (QUrl)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
auto result = getOpenFile(title, supportedMimeTypes, dir);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult, result](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult ? result->result().toUrl() : QUrl());
}, Qt::QueuedConnection);
}
}
void QtMvvm::getOpenFile(std::function<void (QUrl)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
getOpenFile(CoreApp::instance(), onResult, title, supportedMimeTypes, dir);
}
MessageResult *QtMvvm::getOpenFiles(const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
MessageConfig config(MessageConfig::TypeFileDialog, MessageConfig::SubTypeOpenFiles);
config.setTitle(title);
config.setDefaultValue(dir);
config.setViewProperty(QStringLiteral("mimeTypes"), supportedMimeTypes);
return CoreApp::showDialog(config);
}
void QtMvvm::getOpenFiles(QObject *scope, std::function<void (QList<QUrl>)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
auto result = getOpenFiles(title, supportedMimeTypes, dir);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult, result](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult ? result->result().value<QList<QUrl>>() : QList<QUrl>());
}, Qt::QueuedConnection);
}
}
void QtMvvm::getOpenFiles(std::function<void (QList<QUrl>)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
getOpenFiles(CoreApp::instance(), onResult, title, supportedMimeTypes, dir);
}
MessageResult *QtMvvm::getSaveFile(const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
MessageConfig config(MessageConfig::TypeFileDialog, MessageConfig::SubTypeOpenFile);
config.setTitle(title);
config.setDefaultValue(dir);
config.setViewProperty(QStringLiteral("mimeTypes"), supportedMimeTypes);
return CoreApp::showDialog(config);
}
void QtMvvm::getSaveFile(QObject *scope, std::function<void (QUrl)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
auto result = getSaveFile(title, supportedMimeTypes, dir);
if(result) {
QObject::connect(result, &MessageResult::anyAction,
scope, [onResult, result](MessageResult::ResultType type) {
onResult(type == MessageResult::PositiveResult ? result->result().toUrl() : QUrl());
}, Qt::QueuedConnection);
}
}
void QtMvvm::getSaveFile(std::function<void (QUrl)> onResult, const QString &title, const QStringList &supportedMimeTypes, const QUrl &dir)
{
getSaveFile(CoreApp::instance(), onResult, title, supportedMimeTypes, dir);
}

326
src/mvvmcore/message.h

@ -1,8 +1,13 @@
#ifndef QTMVVM_MESSAGE_H #ifndef QTMVVM_MESSAGE_H
#define QTMVVM_MESSAGE_H #define QTMVVM_MESSAGE_H
#include <functional>
#include <QtCore/qcoreapplication.h> #include <QtCore/qcoreapplication.h>
#include <QtCore/qshareddata.h> #include <QtCore/qshareddata.h>
#include <QtCore/qscopedpointer.h>
#include <QtCore/qurl.h>
#include <QtCore/qvariant.h>
#include "QtMvvmCore/qtmvvmcore_global.h" #include "QtMvvmCore/qtmvvmcore_global.h"
@ -14,65 +19,320 @@ class Q_MVVMCORE_EXPORT MessageConfig
Q_GADGET Q_GADGET
Q_DECLARE_TR_FUNCTIONS(MessageConfig) Q_DECLARE_TR_FUNCTIONS(MessageConfig)
Q_PROPERTY(MessageType type READ type WRITE setType) Q_PROPERTY(QByteArray type READ type WRITE setType)
Q_PROPERTY(QByteArray subType READ subType WRITE setSubType RESET resetSubType)
Q_PROPERTY(QString title READ title WRITE setTitle) Q_PROPERTY(QString title READ title WRITE setTitle)
Q_PROPERTY(QString text READ text WRITE setText) Q_PROPERTY(QString text READ text WRITE setText)
Q_PROPERTY(QString positiveAction READ positiveAction WRITE setPositiveAction RESET resetPositiveAction) Q_PROPERTY(StandardButtons buttons READ buttons WRITE setButtons RESET resetButtons)
Q_PROPERTY(QString negativeAction READ negativeAction WRITE setNegativeAction RESET resetNegativeAction) Q_PROPERTY(QHash<StandardButton, QString> buttonTexts READ buttonTexts WRITE setButtonTexts RESET resetButtons)
Q_PROPERTY(QString neutralAction READ neutralAction WRITE setNeutralAction RESET resetNeutralAction)
Q_PROPERTY(QByteArray inputType READ inputType WRITE setInputType)
Q_PROPERTY(QVariant defaultValue READ defaultValue WRITE setDefaultValue) Q_PROPERTY(QVariant defaultValue READ defaultValue WRITE setDefaultValue)
Q_PROPERTY(QVariantMap editProperties READ editProperties WRITE setEditProperties) Q_PROPERTY(QVariantMap viewProperties READ viewProperties WRITE setViewProperties)
public: public:
enum MessageType { enum StandardButton {
Information, // keep this in sync with QPlatformDialogHelper::StandardButton
Question, NoButton = 0x00000000,
Warning, Ok = 0x00000400,
Critical, Save = 0x00000800,
Input SaveAll = 0x00001000,
Open = 0x00002000,
Yes = 0x00004000,
YesToAll = 0x00008000,
No = 0x00010000,
NoToAll = 0x00020000,
Abort = 0x00040000,
Retry = 0x00080000,
Ignore = 0x00100000,
Close = 0x00200000,
Cancel = 0x00400000,
Discard = 0x00800000,
Help = 0x01000000,
Apply = 0x02000000,
Reset = 0x04000000,
RestoreDefaults = 0x08000000
}; };
Q_ENUM(MessageType) Q_DECLARE_FLAGS(StandardButtons, StandardButton)
Q_FLAG(StandardButtons)
static const QByteArray TypeMessageBox;
static const QByteArray TypeInputDialog;
static const QByteArray TypeFileDialog;
static const QByteArray SubTypeInformation;
static const QByteArray SubTypeWarning;
static const QByteArray SubTypeCritical;
static const QByteArray SubTypeQuestion;
static const QByteArray SubTypeAbout;
MessageConfig(MessageType type = Information); static const QByteArray SubTypeDir;
static const QByteArray SubTypeOpenFile;
static const QByteArray SubTypeOpenFiles;
static const QByteArray SubTypeSaveFile;
MessageConfig(const QByteArray &type = TypeMessageBox, const QByteArray &subType = {});
MessageConfig(const MessageConfig &other); MessageConfig(const MessageConfig &other);
~MessageConfig(); ~MessageConfig();
MessageConfig &operator=(const MessageConfig &other); MessageConfig &operator=(const MessageConfig &other);
MessageType type() const; QByteArray type() const;
QByteArray subType() const;
QString title() const; QString title() const;
QString text() const; QString text() const;
QString positiveAction() const; StandardButtons buttons() const;
QString negativeAction() const; QHash<StandardButton, QString> buttonTexts() const;
QString neutralAction() const;
QByteArray inputType() const; QByteArray inputType() const;
QVariant defaultValue() const; QVariant defaultValue() const;
QVariantMap editProperties() const; QVariantMap viewProperties() const;
void setType(MessageType type); void setType(const QByteArray &type);
void setTitle(QString title); void setSubType(const QByteArray &subType);
void setText(QString text); void setTitle(const QString &title);
void setPositiveAction(QString positiveAction); void setText(const QString &text);
void setNegativeAction(QString negativeAction); void setButtons(StandardButtons buttons);
void setNeutralAction(QString neutralAction); void setButtonTexts(const QHash<StandardButton, QString> &buttonTexts);
void setInputType(QByteArray inputType); void setButtonText(StandardButton button, const QString &text);
void setDefaultValue(QVariant defaultValue); void setDefaultValue(const QVariant &defaultValue);
void setEditProperties(QVariantMap editProperties); void setViewProperties(const QVariantMap &viewProperties);
void setViewProperty(const QString &key, const QVariant &value);
void resetPositiveAction();
void resetNegativeAction(); void resetSubType();
void resetNeutralAction(); void resetButtons();
private: private:
QSharedDataPointer<MessageConfigPrivate> d; QSharedDataPointer<MessageConfigPrivate> d;
}; };
class MessageResultPrivate;
class Q_MVVMCORE_EXPORT MessageResult : public QObject
{
Q_OBJECT
Q_PROPERTY(QVariant result READ result WRITE setResult)
Q_PROPERTY(bool autoDelete READ autoDelete WRITE setAutoDelete NOTIFY autoDeleteChanged)
public:
enum ResultType {
PositiveResult,
NegativeResult,
NeutralResult
};
Q_ENUM(ResultType)
explicit MessageResult();
~MessageResult();
bool hasResult() const;
QVariant result() const;
bool autoDelete() const;
//USE IN GUI ONLY
//TODO USE IN GUI ONLY in doc
Q_INVOKABLE void setCloseTarget(QObject *closeObject, const QMetaMethod &closeMethod);
Q_INVOKABLE void complete(MessageResult::ResultType result);
Q_INVOKABLE inline void complete(MessageResult::ResultType result, const QVariant &resultValue) {
setResult(resultValue);
complete(result);
}
public Q_SLOTS:
void discardMessage();
void setResult(QVariant result);
void setAutoDelete(bool autoDelete);
Q_SIGNALS:
void positiveAction();
void negativeAction();
void neutralAction();
void anyAction(ResultType result);
void autoDeleteChanged(bool autoDelete);
private:
QScopedPointer<MessageResultPrivate> d;
};
Q_MVVMCORE_EXPORT MessageResult *information(const QString &title,
const QString &text,
const QString &okText = {});
Q_MVVMCORE_EXPORT void information(const QString &title,
const QString &text,
QObject *scope,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT void information(const QString &title,
const QString &text,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT MessageResult *question(const QString &title,
const QString &text,
const QString &yesText = {},
const QString &noText = {});
Q_MVVMCORE_EXPORT void question(const QString &title,
const QString &text,
QObject *scope,
std::function<void(bool)> onResult,
const QString &yesText = {},
const QString &noText = {});
Q_MVVMCORE_EXPORT void question(const QString &title,
const QString &text,
std::function<void(bool)> onResult,
const QString &yesText = {},
const QString &noText = {});
Q_MVVMCORE_EXPORT MessageResult *warning(const QString &title,
const QString &text,
const QString &okText = {});
Q_MVVMCORE_EXPORT void warning(const QString &title,
const QString &text,
QObject *scope,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT void warning(const QString &title,
const QString &text,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT MessageResult *critical(const QString &title,
const QString &text,
const QString &okText = {});
Q_MVVMCORE_EXPORT void critical(const QString &title,
const QString &text,
QObject *scope,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT void critical(const QString &title,
const QString &text,
std::function<void()> onResult,
const QString &okText = {});
Q_MVVMCORE_EXPORT MessageResult *about(const QString &description,
const QUrl &websiteUrl = QUrl(),
const QString &licenseName = QString(),
const QUrl &licenseUrl = QUrl(),
const QString &companyName = QString(),
bool addQtVersion = true,
const QStringList &extraTopInfos = QStringList(),
const QString &extraBottomInfos = QString());
Q_MVVMCORE_EXPORT MessageResult *getInput(const QString &title,
const QString &text,
const char *inputType,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {});
Q_MVVMCORE_EXPORT void getInput(const QString &title,
const QString &text,
const char *inputType,
QObject *scope,
std::function<void(QVariant)> onResult,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {});
Q_MVVMCORE_EXPORT void getInput(const QString &title,
const QString &text,
const char *inputType,
std::function<void(QVariant)> onResult,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {});
template <typename TEdit>
inline MessageResult *getInput(const QString &title,
const QString &text,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {}) {
return getInput(title, text, QMetaType::typeName(qMetaTypeId<TEdit>()), defaultValue, viewProperties, okText, cancelText);
}
template <typename TEdit>
inline void getInput(const QString &title,
const QString &text,
QObject *scope,
std::function<void(TEdit)> onResult,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {}) {
getInput(title, text, QMetaType::typeName(qMetaTypeId<TEdit>()), scope, [onResult](QVariant v) {
onResult(v.template value<TEdit>());
}, defaultValue, viewProperties, okText, cancelText);
}
template <typename TEdit>
inline void getInput(const QString &title,
const QString &text,
std::function<void(TEdit)> onResult,
const QVariant &defaultValue = {},
const QVariantMap &viewProperties = {},
const QString &okText = {},
const QString &cancelText = {}) {
getInput(title, text, QMetaType::typeName(qMetaTypeId<TEdit>()), [onResult](QVariant v) {
onResult(v.template value<TEdit>());
}, defaultValue, viewProperties, okText, cancelText);
}
Q_MVVMCORE_EXPORT MessageResult *getExistingDirectory(const QString &title = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getExistingDirectory(QObject *scope,
std::function<void(QUrl)> onResult,
const QString &title = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getExistingDirectory(std::function<void(QUrl)> onResult,
const QString &title = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT MessageResult *getOpenFile(const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getOpenFile(QObject *scope,
std::function<void(QUrl)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getOpenFile(std::function<void(QUrl)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT MessageResult *getOpenFiles(const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getOpenFiles(QObject *scope,
std::function<void(QList<QUrl>)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getOpenFiles(std::function<void(QList<QUrl>)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT MessageResult *getSaveFile(const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getSaveFile(QObject *scope,
std::function<void(QUrl)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
Q_MVVMCORE_EXPORT void getSaveFile(std::function<void(QUrl)> onResult,
const QString &title = {},
const QStringList &supportedMimeTypes = {},
const QUrl &dir = {});
} }
Q_DECLARE_METATYPE(QtMvvm::MessageConfig) Q_DECLARE_METATYPE(QtMvvm::MessageConfig)
Q_DECLARE_TYPEINFO(QtMvvm::MessageConfig, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(QtMvvm::MessageConfig, Q_MOVABLE_TYPE);
Q_DECLARE_METATYPE(QtMvvm::MessageResult*)
Q_DECLARE_OPERATORS_FOR_FLAGS(QtMvvm::MessageConfig::StandardButtons)
#endif // QTMVVM_MESSAGE_H #endif // QTMVVM_MESSAGE_H

23
src/mvvmcore/message_p.h

@ -9,20 +9,31 @@ namespace QtMvvm {
class MessageConfigPrivate : public QSharedData class MessageConfigPrivate : public QSharedData
{ {
public: public:
MessageConfigPrivate(MessageConfig::MessageType type); MessageConfigPrivate(const QByteArray &type, const QByteArray &subType);
MessageConfigPrivate(const MessageConfigPrivate &other); MessageConfigPrivate(const MessageConfigPrivate &other);
MessageConfig::MessageType type; QByteArray type;
QByteArray subType;
QString title; QString title;
QString text; QString text;
QString positiveAction; MessageConfig::StandardButtons buttons;
QString negativeAction; QHash<MessageConfig::StandardButton, QString> buttonTexts;
QString neutralAction;
QByteArray inputType;
QVariant defaultValue; QVariant defaultValue;
QVariantMap editProperties; QVariantMap editProperties;
}; };
class MessageResultPrivate
{
public:
MessageResultPrivate();
QPointer<QObject> closeObject;
QMetaMethod closeMethod;
bool closeRequested;
QVariant result;
bool autoDelete;
};
} }
#endif // QTMVVM_MESSAGE_P_H #endif // QTMVVM_MESSAGE_P_H

4
src/mvvmcore/serviceregistry.cpp

@ -96,9 +96,9 @@ QObject *ServiceRegistryPrivate::constructInjectedLocked(const QMetaObject *meta
throw ServiceConstructionException("Failed to convert QObject to interface with iid \"" + throw ServiceConstructionException("Failed to convert QObject to interface with iid \"" +
iid + iid +
"\". Use QtMvvm::registerInterfaceConverter to make it convertable " "\". Use QtMvvm::registerInterfaceConverter to make it convertable "
"or change the properties type to \"QObject*\""); "or change the property's type to \"QObject*\"");
} }
tProp.write(instance, variant); //TODO check if casting works tProp.write(instance, variant);
} }
} }

16
src/mvvmcore/viewmodel.cpp

@ -61,18 +61,16 @@ void ViewModel::showForResult(quint32 requestCode, const QMetaObject *viewMetaOb
viewMetaObject->className() + viewMetaObject->className() +
QByteArrayLiteral(") is not a class that extends QtMvvm::ViewModel")); QByteArrayLiteral(") is not a class that extends QtMvvm::ViewModel"));
} }
showResultImp(requestCode, viewMetaObject, params); showImp(viewMetaObject, params, const_cast<ViewModel*>(this), requestCode);
} }
void ViewModel::showImp(const QMetaObject *mo, const QVariantHash &params, QPointer<ViewModel> parent) void ViewModel::showImp(const QMetaObject *metaObject, const QVariantHash &params, QPointer<ViewModel> parent, quint32 requestCode)
{ {
CoreAppPrivate::dInstance()->showViewModel(mo, params, parent, 0); QMetaObject::invokeMethod(CoreAppPrivate::dInstance().data(), "showViewModel", Qt::QueuedConnection,
} Q_ARG(const QMetaObject*, metaObject),
Q_ARG(const QVariantHash&, params),
void ViewModel::showResultImp(quint32 requestCode, const QMetaObject *mo, const QVariantHash &params) const Q_ARG(QPointer<ViewModel>, parent),
{ Q_ARG(quint32, requestCode));
Q_ASSERT_X(requestCode != 0, Q_FUNC_INFO, "requestCode must not be 0");
CoreAppPrivate::dInstance()->showViewModel(mo, params, const_cast<ViewModel*>(this), requestCode);
} }
// ------------- Private Implementation ------------- // ------------- Private Implementation -------------

5
src/mvvmcore/viewmodel.h

@ -45,8 +45,7 @@ private:
QScopedPointer<ViewModelPrivate> d; QScopedPointer<ViewModelPrivate> d;
static void showImp(const QMetaObject *mo, const QVariantHash &params, QPointer<ViewModel> parent); static void showImp(const QMetaObject *metaObject, const QVariantHash &params, QPointer<ViewModel> parent, quint32 requestCode = 0);
void showResultImp(quint32 requestCode, const QMetaObject *mo, const QVariantHash &params) const;
}; };
// ------------- Generic Implementation ------------- // ------------- Generic Implementation -------------
@ -62,7 +61,7 @@ template<typename TViewModel>
void ViewModel::showForResult(quint32 requestCode, const QVariantHash &params) const void ViewModel::showForResult(quint32 requestCode, const QVariantHash &params) const
{ {
static_assert(std::is_base_of<ViewModel, TViewModel>::value, "TViewModel must extend QtMvvm::ViewModel"); static_assert(std::is_base_of<ViewModel, TViewModel>::value, "TViewModel must extend QtMvvm::ViewModel");
showResultImp(requestCode, &TViewModel::staticMetaObject, params); showImp(&TViewModel::staticMetaObject, params, const_cast<ViewModel*>(this), requestCode);
} }
} }

24
src/mvvmwidgets/widgetspresenter.cpp

@ -77,6 +77,11 @@ void WidgetsPresenter::present(ViewModel *viewModel, const QVariantHash &params,
} }
} }
void WidgetsPresenter::showDialog(const MessageConfig &config, MessageResult *result)
{
Q_UNIMPLEMENTED();
}
const QMetaObject *WidgetsPresenter::findWidgetMetaObject(const QMetaObject *viewModelMetaObject) const QMetaObject *WidgetsPresenter::findWidgetMetaObject(const QMetaObject *viewModelMetaObject)
{ {
auto currentMeta = viewModelMetaObject; auto currentMeta = viewModelMetaObject;
@ -149,22 +154,9 @@ bool WidgetsPresenter::tryPresent(QWidget *view, QWidget *parentView)
bool WidgetsPresenter::setupLifeCycle(ViewModel *viewModel, QWidget *view) bool WidgetsPresenter::setupLifeCycle(ViewModel *viewModel, QWidget *view)
{ {
//TODO fix //TODO implement as soon as quick part is ready as well
return false; Q_UNUSED(viewModel)
Q_UNUSED(view)
auto viewMo = view->metaObject();
if(viewMo->indexOfSignal("qtmvvm_visibleChanged(bool)") != -1) {
connect(view, SIGNAL(qtmvvm_visibleChanged(bool)),
viewModel, SLOT(updateVisible(bool)));
return true;
}
if(viewMo->indexOfSignal("visibleChanged(bool)") != -1) {
connect(view, SIGNAL(visibleChanged(bool)),
viewModel, SLOT(updateVisible(bool)));
return true;
}
return false; return false;
} }

1
src/mvvmwidgets/widgetspresenter.h

@ -35,6 +35,7 @@ public:
static void registerViewExplicitly(const QMetaObject *viewModelType, const QMetaObject *viewType); static void registerViewExplicitly(const QMetaObject *viewModelType, const QMetaObject *viewType);
void present(ViewModel *viewModel, const QVariantHash &params, QPointer<ViewModel> parent) override; void present(ViewModel *viewModel, const QVariantHash &params, QPointer<ViewModel> parent) override;
void showDialog(const MessageConfig &config, MessageResult *result) override;
protected: protected:
virtual const QMetaObject *findWidgetMetaObject(const QMetaObject *viewModelMetaObject); virtual const QMetaObject *findWidgetMetaObject(const QMetaObject *viewModelMetaObject);

Loading…
Cancel
Save