bool MoveItemDataCommand::redo(const ObjectHandle& arguments) const /* override */
{
if (!arguments.isValid())
{
return false;
}
auto pCommandArgs = arguments.getBase<MoveItemDataCommandArgument>();
if (!MoveItemDataCommand_Detail::isValid(pCommandArgs))
{
return false;
}
const auto& dir = (pCommandArgs->direction_);
auto& model = (*pCommandArgs->pModel_);
const auto& startPos = (pCommandArgs->startPos_);
const auto& endPos = (pCommandArgs->endPos_);
const auto& count = (pCommandArgs->count_);
const auto& startParent = (pCommandArgs->startParent_);
const auto& endParent = (pCommandArgs->endParent_);
if (dir == MoveItemDataCommandArgument::Direction::ROW)
{
return model.moveRows(startParent, startPos, count, endParent, endPos);
}
return false;
}
ObjectHandle MoveItemDataCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*get<IDefinitionManager>());
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<MoveItemDataCommandArgument>();
if (!MoveItemDataCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
genericObject.set("Name", "Move");
genericObject.set("Type", "Move");
return ObjectHandle(std::move(handle));
}
CommandDescription RemoveItemCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto object = GenericObject::create();
if (!arguments.isValid())
{
object->set("Name", "Invalid");
object->set("Type", "Remove");
}
else
{
auto pCommandArgs = arguments.getBase<RemoveItemCommandArgument>();
if (!RemoveItemCommand_Detail::isValid(pCommandArgs))
{
object->set("Name", "Invalid");
object->set("Type", "Remove");
}
else
{
object->set("Id", pCommandArgs->key_);
object->set("Name", "Remove");
object->set("Type", "Remove");
object->set("PreValue", pCommandArgs->value_);
}
}
return std::move(object);
}
ObjectHandle InsertItemCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*definitionManager_);
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Insert");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<InsertItemCommandArgument>();
if (!InsertItemCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Insert");
return ObjectHandle(std::move(handle));
}
genericObject.set("Id", pCommandArgs->key_);
genericObject.set("Name", "Insert");
genericObject.set("Type", "Insert");
genericObject.set("PostValue", pCommandArgs->value_);
return ObjectHandle(std::move(handle));
}
ObjectHandle SetItemDataCommand::getCommandDescription(const ObjectHandle& arguments) const /* override */
{
auto handle = GenericObject::create(*definitionManager_);
assert(handle.get() != nullptr);
auto& genericObject = (*handle);
if (!arguments.isValid())
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Data");
return ObjectHandle(std::move(handle));
}
auto pCommandArgs = arguments.getBase<SetItemDataCommandArgument>();
if (!SetItemDataCommand_Detail::isValid(pCommandArgs))
{
genericObject.set("Name", "Invalid");
genericObject.set("Type", "Data");
return ObjectHandle(std::move(handle));
}
genericObject.set("Name", "Data");
genericObject.set("Type", "Data");
const auto& oldValue = (pCommandArgs->oldValue_);
const auto& newValue = (pCommandArgs->newValue_);
genericObject.set("PreValue", oldValue);
genericObject.set("PostValue", newValue);
return ObjectHandle(std::move(handle));
}
//==============================================================================
ObjectHandle SetReflectedPropertyCommand::execute(
const ObjectHandle & arguments ) const
{
ReflectedPropertyCommandArgument * commandArgs =
arguments.getBase< ReflectedPropertyCommandArgument >();
auto objManager = definitionManager_.getObjectManager();
assert( objManager != nullptr );
ObjectHandle object = objManager->getObject( commandArgs->getContextId() );
if (!object.isValid())
{
return CommandErrorCode::INVALID_ARGUMENTS;
}
PropertyAccessor property = object.getDefinition( definitionManager_ )->bindProperty(
commandArgs->getPropertyPath(), object );
if (property.isValid() == false)
{
//Can't set
return CommandErrorCode::INVALID_ARGUMENTS;
}
const Variant & data = commandArgs->getPropertyValue();
bool br = property.setValue( data );
if (!br)
{
return CommandErrorCode::INVALID_VALUE;
}
// Do not return the object
// CommandInstance will hold a reference to the return value
// and the CommandInstance is stored in the undo/redo history forever
// This is due to a circular reference in CommandManagerImpl::pushFrame
return nullptr;
}
bool RemoveItemCommand::redo(const ObjectHandle& arguments) const /* override */
{
if (!arguments.isValid())
{
return false;
}
auto pCommandArgs = arguments.getBase<RemoveItemCommandArgument>();
if (!RemoveItemCommand_Detail::isValid(pCommandArgs))
{
return false;
}
auto& model = (*static_cast<CollectionModel*>(pCommandArgs->pModel_));
const auto& key = (pCommandArgs->key_);
return model.removeItem(key);
}
//==============================================================================
bool SetReflectedPropertyCommand::validateArguments(const ObjectHandle& arguments) const
{
if ( !arguments.isValid() )
{
return false;
}
auto commandArgs = arguments.getBase< ReflectedPropertyCommandArgument >();
if ( commandArgs == nullptr )
{
return false;
}
auto objManager = definitionManager_.getObjectManager();
if ( objManager == nullptr )
{
return false;
}
const ObjectHandle & object = objManager->getObject( commandArgs->getContextId() );
if (!object.isValid())
{
return false;
}
const IClassDefinition* defn = object.getDefinition( definitionManager_ );
PropertyAccessor property = defn->bindProperty(commandArgs->getPropertyPath(), object );
if (property.isValid() == false)
{
return false;
}
const MetaType * dataType = commandArgs->getPropertyValue().type();
const MetaType * propertyValueType = property.getValue().type();
if ( !dataType->canConvertTo(propertyValueType) )
{
return false;
}
return true;
}
//------------------------------------------------------------------------------
ObjectHandle reflectedRoot(const ObjectHandle& source, const IDefinitionManager& definitionManager)
{
if (!source.isValid())
{
return source;
}
auto root = source.storage();
auto reflectedRoot = definitionManager.getObjectDefinition(root) != nullptr ? root : nullptr;
for (;;)
{
auto inner = root->inner();
if (inner == nullptr)
{
break;
}
root = inner;
reflectedRoot = definitionManager.getObjectDefinition(root) != nullptr ? root : nullptr;
}
return ObjectHandle(reflectedRoot);
}
bool SetItemDataCommand::redo(const ObjectHandle& arguments) const /* override */
{
if (!arguments.isValid())
{
return false;
}
auto pCommandArgs = arguments.getBase<SetItemDataCommandArgument>();
if (!SetItemDataCommand_Detail::isValid(pCommandArgs))
{
return false;
}
auto& model = (*pCommandArgs->pModel_);
const auto& index = (pCommandArgs->index_);
const auto& roleId = (pCommandArgs->roleId_);
const auto& newValue = (pCommandArgs->newValue_);
auto pItem = model.item(index);
assert(pItem != nullptr);
return pItem->setData(index.row_, index.column_, roleId, newValue);
}
void BaseEditor::updateCheckoutState(const ObjectHandle& handle)
{
if (!handle.isValid())
{
return;
}
ObjectHandle root = handle;
while (root.parent().isValid())
{
root = root.parent();
}
auto path = getResourceFileName(root);
if (path == nullptr || *path == char(0))
{
return;
}
updateCheckoutState(path);
}
