bool CustomConnection::UnBind()
{
bool result = true;
while (true)
{
if (!isConnected)
{
NGT_WARNING_MSG("Connection is not connected\n");
break;
}
if (!m_inputSlot->Disconnect(m_id, m_outputSlot))
{
result = false;
NGT_ERROR_MSG("Failed to disconnect input slot with output slot\n");
break;
}
if (!m_outputSlot->Disconnect(m_id, m_inputSlot))
{
result = false;
NGT_ERROR_MSG("Failed to disconnect output slot with input slot\n");
break;
}
m_inputSlot = nullptr;
m_outputSlot = nullptr;
isConnected = false;
break;
}
return result;
}
//------------------------------------------------------------------------------
void InvertFilterObject::setSubFilter(QObject* subFilter)
{
pSubFilter_ = dynamic_cast<QtFilterObject*>(subFilter);
if (subFilter && !pSubFilter_)
{
NGT_ERROR_MSG("InvertFilterObject: filter must be native");
}
if (pSubFilter_ && !pSubFilter_->filterAcceptsRowValid())
{
NGT_ERROR_MSG("InvertFilterObject: filter must have valid filterAcceptsRow");
pSubFilter_ = nullptr;
}
}
bool CustomConnection::Bind(ObjectHandleT<ISlot> outputSlot, ObjectHandleT<ISlot> inputSlot)
{
bool result = false;
if (outputSlot == nullptr || inputSlot == nullptr)
{
NGT_ERROR_MSG("Input arguments are null\n");
return result;
}
if (isConnected)
{
NGT_ERROR_MSG("Connection is already connected\n");
return result;
}
while (true)
{
result = outputSlot->CanConnect(inputSlot);
if (!result)
break;
result = inputSlot->CanConnect(outputSlot);
if (!result)
break;
if (outputSlot->Connect(m_id, inputSlot) && inputSlot->Connect(m_id, outputSlot))
{
m_inputSlot = inputSlot.get();
m_outputSlot = outputSlot.get();
isConnected = true;
}
else
{
result = false;
NGT_ERROR_MSG("Failed to connect input and output slots\n");
outputSlot->Disconnect(m_id, inputSlot);
inputSlot->Disconnect(m_id, outputSlot);
}
break;
}
return result;
}
virtual bool error( const QXmlParseException & exception ) override
{
NGT_ERROR_MSG( "%d, %d: %s\n",
exception.lineNumber(),
exception.columnNumber(),
exception.message().toUtf8().constData() );
return true;
}
virtual bool fatalError( const QXmlParseException & exception ) override
{
NGT_ERROR_MSG( "%d, %d: %s\n",
exception.lineNumber(),
exception.columnNumber(),
exception.message().toUtf8().constData() );
assert( false && "Fatal error" );
return false;
}
void NodeEditor::SetGraph(std::shared_ptr<IGraph> graph)
{
if (graph == nullptr)
{
NGT_ERROR_MSG("Graph is Null");
return;
}
graphModel.clear();
graphModel.push_back(graph);
}
bool PythonPanel::addPanel()
{
auto viewCreator = get< IViewCreator >();
if (viewCreator == nullptr)
{
NGT_ERROR_MSG("Failed to find IViewCreator\n");
return false;
}
viewCreator->createView(
"Python27UITest/PythonObjectTestPanel.qml", contextObject_, pythonView_ );
return true;
}
void QtActionManager::loadActionData( QIODevice & source )
{
QXmlSimpleReader actions;
QtActionContentHandler contentHandler( *this );
actions.setContentHandler( &contentHandler );
QtActionErrorHandler errorHandler;
actions.setErrorHandler( &errorHandler );
const auto result = actions.parse( QXmlInputSource( &source ) );
if (!result)
{
NGT_ERROR_MSG( "Failed to parse actions\n" );
}
}
void FileSystemAssetBrowserModel::addAssetPath(const std::string& path)
{
if (std::find(impl_->assetPaths_.begin(), impl_->assetPaths_.end(), path) == impl_->assetPaths_.end())
{
if (!impl_->fileSystem_.exists(path.c_str()))
{
NGT_ERROR_MSG("TestAssetBrowserModel::addAssetPath: "
"asset folder path does not exist: %s\n",
path.c_str());
return;
}
impl_->assetPaths_.push_back(path);
}
}
void PythonPanel::removePanel()
{
auto uiApplication = get< IUIApplication >();
if (uiApplication == nullptr)
{
NGT_ERROR_MSG( "Failed to find IUIApplication\n" );
return;
}
if (pythonView_ != nullptr)
{
uiApplication->removeView( *pythonView_ );
}
}
//-----------------------------------------------------------------------------
void FolderFilterObject::setFilterRole(FolderFilterRole filterRole)
{
filterRole_ = filterRole;
switch (filterRole_)
{
case FolderFilterObject::Directory:
filterRoleId_ = ItemRole::isDirectoryId;
break;
case FolderFilterObject::Folder:
filterRoleId_ = ItemRole::isFolderId;
break;
default:
filterRoleId_ = ItemRole::isDirectoryId;
NGT_ERROR_MSG("FolderFilterObject: Unknown filter role set");
}
}
bool MappingIterator::setValue(const Variant& value) const /* override */
{
if (!key_.exists() || (index_ < 0) || (index_ >= container_.size()))
{
NGT_ERROR_MSG("KeyError: %s\n", key_.str(PyScript::ScriptErrorPrint()).c_str());
return false;
}
PyScript::ScriptObject scriptValue;
const bool success = typeConverters_.toScriptType(value, scriptValue);
if (!success)
{
return false;
}
return container_.setItem(key_, scriptValue, PyScript::ScriptErrorPrint());
}
bool SequenceIterator<T>::setValue(const Variant& value) const /* override */
{
if ((index_ < 0) || (index_ >= container_.size()))
{
NGT_ERROR_MSG("IndexError: sequence assignment index out of range\n");
return false;
}
PyScript::ScriptObject scriptValue;
const bool success = typeConverters_.toScriptType(value, scriptValue);
if (!success)
{
return false;
}
return SequenceIterator_Detail::setItem<T>(container_, index_, scriptValue);
}
Variant SequenceIterator<T>::value() const /* override */
{
if ((index_ < 0) || (index_ >= container_.size()))
{
NGT_ERROR_MSG("IndexError: sequence index out of range\n");
return Variant();
}
PyScript::ScriptObject item = SequenceIterator_Detail::getItem<T>(container_, index_);
Variant result;
std::string childPath;
childPath += IClassDefinition::INDEX_OPEN;
childPath += std::to_string(index_);
childPath += IClassDefinition::INDEX_CLOSE;
const bool success = typeConverters_.toVariant(item, result, containerHandle_, childPath);
return result;
}
Variant MappingIterator::value() const /* override */
{
if (!key_.exists() || (index_ < 0) || (index_ >= container_.size()))
{
NGT_ERROR_MSG("KeyError: %s\n", key_.str(PyScript::ScriptErrorPrint()).c_str());
return Variant();
}
PyScript::ScriptObject item = container_.getItem(key_, PyScript::ScriptErrorPrint());
Variant result;
std::string childPath;
childPath += Collection::getIndexOpen();
childPath += key_.str(PyScript::ScriptErrorPrint()).c_str();
childPath += Collection::getIndexClose();
const bool success = typeConverters_.toVariant(item, result, containerHandle_, childPath);
assert(success);
return result;
}
void QtMenuBar::removeAction(IAction& action)
{
auto qAction = getQAction(action);
if (qAction == nullptr)
{
NGT_ERROR_MSG("Target action '%s' '%s' does not exist\n", action.text(),
StringUtils::join(action.paths(), ';').c_str());
return;
}
auto menus = qMenuBar_.findChildren<QMenu*>(QString(), Qt::FindDirectChildrenOnly);
for (auto& menu : menus)
{
QtMenu::removeMenuAction(*menu, *qAction);
if (menu->isEmpty())
{
delete menu;
}
}
destroyQAction(action);
}
ObjectHandleT<ISlot> IntToStringNode::GetSlotById(size_t slotId) const
{
auto inputSlotPos =
std::find_if(m_inputSlotsModel.begin(), m_inputSlotsModel.end(),
[slotId](const ObjectHandleT<ISlot>& inputSlot) { return slotId == inputSlot->Id(); });
if (inputSlotPos != m_inputSlotsModel.end())
{
return *inputSlotPos;
}
auto outputSlotPos =
std::find_if(m_outputSlotsModel.begin(), m_outputSlotsModel.end(),
[slotId](const ObjectHandleT<ISlot>& outputSlot) { return slotId == outputSlot->Id(); });
if (outputSlotPos != m_outputSlotsModel.end())
{
return *outputSlotPos;
}
NGT_ERROR_MSG("Slot with id: %d not found\n", slotId);
return nullptr;
}
bool IntToStringNode::Validate(std::string& errorMessage)
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
return true;
}
void IntToStringNode::OnDisconnect(ObjectHandleT<ISlot> mySlot, ObjectHandleT<ISlot> otherSlot)
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
}
MetaType* StringSlot::Type() const
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
return nullptr;
}
bool NodeEditor::Disconnect(size_t nodeIdFrom, size_t slotIdFrom,
size_t nodeIdTo, size_t slotIdTo)
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
return false;
}
bool NodeEditor::DeleteNode(size_t id)
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
return false;
}
INode* NodeEditor::GetNode(size_t id)
{
NGT_ERROR_MSG("METHOD IS NOT IMPLEMENTED\n");
return nullptr;
}
