hatam
/
QtMvvm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

added public message api

pull/2/head
Skycoder42 8 years ago
parent
5664c9e982
commit
7dfa1d49aa
13 changed files with 860 additions and 188 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      examples/mvvmwidgets/SampleWidgets/widgetseventservice.cpp
  2. 76
      src/mvvmcore/coreapp.cpp
  3. 16
      src/mvvmcore/coreapp.h
  4. 13
      src/mvvmcore/coreapp_p.h
  5. 2
      src/mvvmcore/ipresenter.h
  6. 540
      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
View File

@ -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
View File

@ -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
View File

@ -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);

13
src/mvvmcore/coreapp_p.h
View File

@ -15,18 +15,15 @@ class Q_MVVMCORE_EXPORT CoreAppPrivate : public QObject
public: public:
static QScopedPointer<CoreAppPrivate> &dInstance(); static QScopedPointer<CoreAppPrivate> &dInstance();
IPresenter *currentPresenter() const;
public Q_SLOTS:
void showViewModel(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);
IPresenter *currentPresenter() const;
private Q_SLOTS:
void showViewModelPrivate(const QMetaObject *metaObject,
const QVariantHash &params,
QPointer<ViewModel> parent,
quint32 requestCode);
private: private:
CoreAppPrivate(); CoreAppPrivate();

2
src/mvvmcore/ipresenter.h
View File

@ -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;
}; };
} }

540
src/mvvmcore/message.cpp
View File

@ -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: void MessageConfig::resetSubType()
case Input: {
d->positiveAction = tr("Ok"); if(d->type == TypeMessageBox)
break; d->subType = SubTypeInformation;
case Question: else if(d->type == TypeInputDialog)
d->positiveAction = tr("Yes"); d->subType = QMetaType::typeName(QMetaType::QString);
break; else
default: d->subType.clear();
Q_UNREACHABLE(); }
break;
} void MessageConfig::resetButtons()
{
if(d->type == TypeMessageBox) {
if(d->subType == SubTypeQuestion)
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 MessageConfig::resetNegativeAction() void MessageResult::setCloseTarget(QObject *closeObject, const QMetaMethod &closeMethod)
{ {
switch (d->type) { Q_ASSERT_X(closeObject, Q_FUNC_INFO, "closeObject must not be null");
case Input: d->closeObject = closeObject;
d->negativeAction = tr("Cancel"); 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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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);

Write Preview
Loading…
Cancel
Save