void ContextModel::setContext( QSharedPointer<fugio::ContextInterface> pContext )
{
clearContext();
mContext = pContext;
fugio::ContextSignals *CS = mContext->qobject();
connect( CS, SIGNAL(clearContext()), this, SLOT(clearContext()) );
connect( CS, SIGNAL(nodeAdded(QUuid)), this, SLOT(nodeAdded(QUuid)) );
connect( CS, SIGNAL(nodeRemoved(QUuid)), this, SLOT(nodeRemoved(QUuid)) );
connect( CS, SIGNAL(nodeRenamed(QUuid,QUuid)), this, SLOT(nodeRenamed(QUuid,QUuid)) );
connect( CS, SIGNAL(pinAdded(QUuid,QUuid)), this, SLOT(pinAdded(QUuid,QUuid)) );
connect( CS, SIGNAL(pinRemoved(QUuid,QUuid)), this, SLOT(pinRemoved(QUuid,QUuid)) );
connect( CS, SIGNAL(pinRenamed(QUuid,QUuid,QUuid)), this, SLOT(pinRenamed(QUuid,QUuid,QUuid)) );
connect( CS, SIGNAL(loadStart(QSettings&,bool)), this, SLOT(loadStarted(QSettings&,bool)) );
connect( CS, SIGNAL(loadEnd(QSettings&,bool)), this, SLOT(loadEnded(QSettings&,bool)) );
// if( QSharedPointer<ContextPrivate> C = qSharedPointerCast<ContextPrivate>( mContext ) )
// {
// connect( C.data(), SIGNAL(loading(QSettings&,bool)), this, SLOT(loadContext(QSettings&,bool)) );
// connect( C.data(), SIGNAL(saving(QSettings&)), this, SLOT(saveContext(QSettings&)) );
// connect( C.data(), SIGNAL(nodeUpdated(QUuid)), this, SLOT(nodeChanged(QUuid)) );
// connect( C.data(), SIGNAL(nodeActivated(QUuid)), this, SLOT(nodeActivated(QUuid)) );
// connect( C.data(), SIGNAL(linkAdded(QUuid,QUuid)), this, SLOT(linkAdded(QUuid,QUuid)) );
// connect( C.data(), SIGNAL(linkRemoved(QUuid,QUuid)), this, SLOT(linkRemoved(QUuid,QUuid)) );
// }
MainWindow *MW = gApp->mainWindow();
QDockWidget *DW = new QDockWidget( "Context Model", MW );
DW->setObjectName( "ContextModel" );
QTreeView *TV = new QTreeView( DW );
TV->setModel( this );
DW->setWidget( TV );
MW->addDockWidget( Qt::RightDockWidgetArea, DW );
}
void QSGAbstractSoftwareRenderer::nodeChanged(QSGNode *node, QSGNode::DirtyState state)
{
if (state & QSGNode::DirtyGeometry) {
nodeGeometryUpdated(node);
}
if (state & QSGNode::DirtyMaterial) {
nodeMaterialUpdated(node);
}
if (state & QSGNode::DirtyMatrix) {
nodeMatrixUpdated(node);
}
if (state & QSGNode::DirtyNodeAdded) {
nodeAdded(node);
}
if (state & QSGNode::DirtyNodeRemoved) {
nodeRemoved(node);
}
if (state & QSGNode::DirtyOpacity) {
nodeOpacityUpdated(node);
}
if (state & QSGNode::DirtySubtreeBlocked) {
m_nodeUpdater->updateNodes(node);
}
if (state & QSGNode::DirtyForceUpdate) {
m_nodeUpdater->updateNodes(node);
}
QSGRenderer::nodeChanged(node, state);
}
void ContextPrivate::registerNode( QSharedPointer<fugio::NodeInterface> pNode )
{
if( mNodeHash.contains( pNode->uuid() ) )
{
if( NodePrivate *NP = qobject_cast<NodePrivate *>( pNode->qobject() ) )
{
NP->setUuid( QUuid::createUuid() );
}
}
pNode->setContext( this );
mNodeHash.insert( pNode->uuid(), pNode );
fugio::NodeSignals *N = pNode->qobject();
connect( N, SIGNAL(controlChanged(QSharedPointer<fugio::NodeInterface>)), this, SLOT(nodeControlChanged(QSharedPointer<fugio::NodeInterface>)) );
connect( N, SIGNAL(nameChanged(QSharedPointer<fugio::NodeInterface>)), this, SLOT(nodeNameChanged(QSharedPointer<fugio::NodeInterface>)) );
connect( N, SIGNAL(activationChanged(QSharedPointer<fugio::NodeInterface>)), this, SLOT(onNodeActivationChanged(QSharedPointer<fugio::NodeInterface>)) );
connect( N, SIGNAL(pinAdded(QSharedPointer<fugio::NodeInterface>,QSharedPointer<fugio::PinInterface>)), this, SLOT(onPinAdded(QSharedPointer<fugio::NodeInterface>,QSharedPointer<fugio::PinInterface>)) );
connect( N, SIGNAL(pinRemoved(QSharedPointer<fugio::NodeInterface>,QSharedPointer<fugio::PinInterface>)), this, SLOT(onPinRemoved(QSharedPointer<fugio::NodeInterface>,QSharedPointer<fugio::PinInterface>)) );
addDeferredNode( pNode );
mNodeDeferProcess = true;
emit nodeAdded( pNode->uuid() );
}
SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) {
_nodeHashMutex.lock();
if (!_nodeHash.contains(uuid)) {
// we didn't have this node, so add them
Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket);
SharedNodePointer newNodeSharedPointer(newNode, &QObject::deleteLater);
_nodeHash.insert(newNode->getUUID(), newNodeSharedPointer);
_nodeHashMutex.unlock();
qDebug() << "Added" << *newNode;
emit nodeAdded(newNodeSharedPointer);
return newNodeSharedPointer;
} else {
_nodeHashMutex.unlock();
return updateSocketsForNode(uuid, publicSocket, localSocket);
}
}
void MetavoxelSystem::init() {
if (!_program.isLinked()) {
switchToResourcesParentIfRequired();
_program.addShaderFromSourceFile(QGLShader::Vertex, "resources/shaders/metavoxel_point.vert");
_program.link();
_pointScaleLocation = _program.uniformLocation("pointScale");
}
NodeList* nodeList = NodeList::getInstance();
connect(nodeList, SIGNAL(nodeAdded(SharedNodePointer)), SLOT(nodeAdded(SharedNodePointer)));
connect(nodeList, SIGNAL(nodeKilled(SharedNodePointer)), SLOT(nodeKilled(SharedNodePointer)));
_buffer.setUsagePattern(QOpenGLBuffer::DynamicDraw);
_buffer.create();
}
bool Round::NodeFinderObserver::notificationReceived(NotificationType type, void *object) {
switch (type) {
case NodeFinderObserverTypeAdd:
return nodeAdded((Round::Node *)object);
case NodeFinderObserverTypeRemove:
return nodeRemoved((Round::Node *)object);
}
return false;
}
NodeModel::NodeModel(QObject *parent) :
QAbstractListModel(parent),
m_qmlNode(0)
{
Settings *s = Settings::get();
m_nodes = s->nodes();
connect(s, SIGNAL(nodeAdded(Node)), this, SLOT(addNode(Node)));
connect(s, SIGNAL(nodeUpdated(Node)), this, SLOT(updateNode(Node)));
}
void
AnimationModule::addNode(const NodeGuiPtr& nodeGui)
{
// Check if it already exists
for (std::list<NodeAnimPtr>::const_iterator it = _imp->nodes.begin(); it != _imp->nodes.end(); ++it) {
if ((*it)->getNodeGui() == nodeGui) {
(*it)->refreshVisibility();
return;
}
}
// Determinate the node type
// It will be useful to identify and sort tree items
AnimatedItemTypeEnum nodeType = eAnimatedItemTypeCommon;
NodePtr node = nodeGui->getNode();
assert(node && node->getGroup());
if ( !node || !node->getGroup() ) {
return;
}
EffectInstancePtr effectInstance = node->getEffectInstance();
// Don't add an item for this node if it doesn't have any knob that may animate
//if ( !getNodeCanAnimate(node) ) {
// return;
//}
std::string pluginID = node->getPluginID();
NodeGroupPtr isGroup = toNodeGroup(effectInstance);
if (effectInstance->isReader()) {
nodeType = eAnimatedItemTypeReader;
} else if (isGroup) {
nodeType = eAnimatedItemTypeGroup;
} else if (pluginID == PLUGINID_OFX_RETIME) {
nodeType = eAnimatedItemTypeRetime;
} else if (pluginID == PLUGINID_OFX_TIMEOFFSET) {
nodeType = eAnimatedItemTypeTimeOffset;
} else if (pluginID == PLUGINID_OFX_FRAMERANGE) {
nodeType = eAnimatedItemTypeFrameRange;
}
// The NodeAnim should not be created if there's no settings panel.
assert(nodeGui->getSettingPanel());
NodeAnimPtr anim(NodeAnim::create(toAnimationModule(shared_from_this()), nodeType, nodeGui) );
_imp->nodes.push_back(anim);
Q_EMIT nodeAdded(anim);
} // AnimationModule::addNode
bool CircuitICNDocument::registerItem( KtlQCanvasItem *qcanvasItem )
{
if(!qcanvasItem) return false;
if ( !ItemDocument::registerItem(qcanvasItem) ) {
if ( ECNode * node = dynamic_cast<ECNode*>(qcanvasItem) ) {
m_ecNodeList[ node->id() ] = node;
emit nodeAdded( (Node*)node );
} else if ( Connector * connector = dynamic_cast<Connector*>(qcanvasItem) ) {
m_connectorList.append(connector);
emit connectorAdded(connector);
} else {
kError() << k_funcinfo << "Unrecognised item"<<endl;
return false;
}
}
requestRerouteInvalidatedConnectors();
return true;
}