bool ThermalStorageIceDetailed_Impl::addToNode(Node & node)
{
if( auto plant = node.plantLoop() ) {
if( ! plant->demandComponent(node.handle()) ) {
return StraightComponent_Impl::addToNode( node );
}
}
return false;
}
bool CoilHeatingDesuperheater_Impl::addToNode(Node & node) {
if( boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC() )
{
if( airLoop->supplyComponent(node.handle()) )
{
return StraightComponent_Impl::addToNode(node);
}
}
return false;
}
bool SetpointManagerOutdoorAirReset_Impl::addToNode(Node & node) {
bool added = SetpointManager_Impl::addToNode( node );
if( added ) {
return added;
} else if( boost::optional<PlantLoop> plantLoop = node.plantLoop() ) {
if( plantLoop->supplyComponent(node.handle()) ) {
return this->setSetpointNode(node);
}
}
return added;
}
bool DistrictCooling_Impl::addToNode(Node & node)
{
if( boost::optional<PlantLoop> plant = node.plantLoop() )
{
if( plant->supplyComponent(node.handle()) )
{
return StraightComponent_Impl::addToNode(node);
}
}
return false;
}
bool WaterUseConnections_Impl::addToNode(Node & node)
{
if( boost::optional<PlantLoop> plant = node.plantLoop() )
{
if( plant->demandComponent(node.handle()) )
{
return StraightComponent_Impl::addToNode(node);
}
}
return false;
}
bool CoilCoolingLowTempRadiantConstFlow_Impl::addToNode(Node & node)
{
if( boost::optional<PlantLoop> plant = node.plantLoop() )
{
if( plant->demandComponent(node.handle()) )
{
return StraightComponent_Impl::addToNode(node);
}
}
return false;
}
/* Only allow connection on the demand side of a plantLoop */
bool CoilHeatingFourPipeBeam_Impl::addToNode(Node & node)
{
if( boost::optional<PlantLoop> plant = node.plantLoop() )
{
if( plant->demandComponent(node.handle()) )
{
return StraightComponent_Impl::addToNode(node);
}
}
return false;
}
bool WaterToWaterComponent_Impl::addToNode(Node & node)
{
auto _model = node.model();
auto thisModelObject = getObject<ModelObject>();
auto t_plantLoop = node.plantLoop();
boost::optional<unsigned> componentInletPort;
boost::optional<unsigned> componentOutletPort;
boost::optional<HVACComponent> systemStartComponent;
boost::optional<HVACComponent> systemEndComponent;
if( node.getImpl<Node_Impl>()->isConnected(thisModelObject) ) return false;
if( t_plantLoop ) {
if( t_plantLoop->supplyComponent(node.handle()) ) {
systemStartComponent = t_plantLoop->supplyInletNode();
systemEndComponent = t_plantLoop->supplyOutletNode();
componentInletPort = supplyInletPort();
componentOutletPort = supplyOutletPort();
removeFromPlantLoop();
} else if( t_plantLoop->demandComponent(node.handle()) ) {
systemStartComponent = t_plantLoop->demandInletNode();
systemEndComponent = t_plantLoop->demandOutletNode();
componentInletPort = demandInletPort();
componentOutletPort = demandOutletPort();
removeFromSecondaryPlantLoop();
}
}
if( systemStartComponent && systemEndComponent && componentOutletPort && componentInletPort ) {
return HVACComponent_Impl::addToNode(node,systemStartComponent.get(),systemEndComponent.get(),componentInletPort.get(),componentOutletPort.get());
} else {
return false;
}
}
bool ConnectorSplitter_Impl::addToNode(Node & node)
{
auto t_model = model();
if( node.model() != t_model ) {
return false;
}
if( loop() ) {
return false;
}
if( ! outletModelObjects().empty() ) {
LOG(Warn, briefDescription() << " must not have existing outlet connections to use addToNode method.");
return false;
}
auto t_nodeAirLoop = node.airLoopHVAC();
if( ! t_nodeAirLoop ) {
LOG(Warn, briefDescription() << " must be added to an AirLoopHVAC supply node use addToNode method.");
return false;
}
if( ! t_nodeAirLoop->supplyComponent(node.handle()) ) {
LOG(Warn, briefDescription() << " must be added to an AirLoopHVAC supply node use addToNode method.");
return false;
}
if( ! t_nodeAirLoop->supplyComponents(iddObjectType()).empty() ) {
LOG(Warn, briefDescription() << " already has a splitter.");
return false;
}
auto supplyInletNode = t_nodeAirLoop->supplyInletNode();
auto supplyOutletNode = t_nodeAirLoop->supplyOutletNode();
// Hook Up Duct "A"
auto t_inletPort = inletPort();
auto portA = nextOutletPort();
HVACComponent_Impl::addToNode(node, supplyInletNode, supplyOutletNode, t_inletPort, portA);
// Hook Up Duct "B"
Node supplyOutletNodeB(t_model);
auto thisObject = getObject<model::HVACComponent>();
auto portB = nextOutletPort();
t_model.connect(thisObject,portB,supplyOutletNodeB,supplyOutletNodeB.inletPort());
t_model.connect(supplyOutletNodeB,supplyOutletNodeB.outletPort(),t_nodeAirLoop.get(),t_nodeAirLoop->getImpl<detail::AirLoopHVAC_Impl>()->supplyOutletPortB());
return true;
}
bool EvaporativeCoolerIndirectResearchSpecial_Impl::addToNode(Node & node)
{
if( boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC() )
{
if( ! airLoop->demandComponent(node.handle()) )
{
if( StraightComponent_Impl::addToNode( node ) )
{
return true;
}
}
}
return false;
}
bool SolarCollectorIntegralCollectorStorage_Impl::addToNode(Node & node)
{
if (boost::optional<PlantLoop> plantLoop = node.plantLoop())
{
if (plantLoop->supplyComponent(node.handle()))
{
if (StraightComponent_Impl::addToNode(node))
{
return true;
}
}
}
return false;
}
void MouseEventImpl::initMouseEvent(const DOMString &typeArg,
bool canBubbleArg,
bool cancelableArg,
AbstractViewImpl* viewArg,
long detailArg,
long screenXArg,
long screenYArg,
long clientXArg,
long clientYArg,
bool ctrlKeyArg,
bool altKeyArg,
bool shiftKeyArg,
bool metaKeyArg,
unsigned short buttonArg,
const Node &relatedTargetArg,
Orientation orient)
{
UIEventImpl::initUIEvent(typeArg,canBubbleArg,cancelableArg,viewArg,detailArg);
if (m_relatedTarget)
m_relatedTarget->deref();
m_screenX = screenXArg;
m_screenY = screenYArg;
m_clientX = clientXArg;
m_clientY = clientYArg;
m_pageX = clientXArg;
m_pageY = clientYArg;
KHTMLView* v;
if ( view() && view()->document() && ( v = view()->document()->view() ) ) {
m_pageX += v->contentsX();
m_pageY += v->contentsY();
}
m_ctrlKey = ctrlKeyArg;
m_altKey = altKeyArg;
m_shiftKey = shiftKeyArg;
m_metaKey = metaKeyArg;
m_button = buttonArg;
m_relatedTarget = relatedTargetArg.handle();
if (m_relatedTarget)
m_relatedTarget->ref();
m_orientation = orient;
// ### make this on-demand. it is soo sloooow
computeLayerPos();
m_qevent = 0;
}
bool EvaporativeFluidCoolerSingleSpeed_Impl::addToNode(Node& node)
{
Model _model = node.model();
if( boost::optional<PlantLoop> _plantLoop = node.plantLoop() )
{
PlantLoop plantLoop = _plantLoop.get();
if( plantLoop.supplyComponent(node.handle()) )
{
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
if( outlet->optionalCast<ConnectorMixer>() )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<ConnectorSplitter> splitter = inlet->optionalCast<ConnectorSplitter>() )
{
boost::optional<ModelObject> sourceModelObject = inlet;
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
Node inletNode(_model);
_model.connect( sourceModelObject.get(),
sourcePort.get(),
inletNode,
inletNode.inletPort() );
_model.connect( inletNode,
inletNode.outletPort(),
this->getObject<ModelObject>(),
this->inletPort() );
_model.connect( this->getObject<ModelObject>(),
outletPort(),
node,
node.inletPort() );
return true;
}
}
}
}
}
}
}
return false;
}
bool BoilerSteam_Impl::addToNode(Node & node)
{
if( boost::optional<PlantLoop> plant = node.plantLoop() )
{
if( plant->supplyComponent(node.handle()) )
{
if( StraightComponent_Impl::addToNode(node) )
{
plant->setFluidType("Steam");
return true;
}
}
}
return false;
}
MutationEventImpl::MutationEventImpl(EventId _id, bool canBubbleArg, bool cancelableArg, const Node &relatedNodeArg, const DOMString &prevValueArg,
const DOMString &newValueArg, const DOMString &attrNameArg, unsigned short attrChangeArg)
: EventImpl(_id, canBubbleArg, cancelableArg)
{
m_relatedNode = relatedNodeArg.handle();
if(m_relatedNode)
m_relatedNode->ref();
m_prevValue = prevValueArg.implementation();
if(m_prevValue)
m_prevValue->ref();
m_newValue = newValueArg.implementation();
if(m_newValue)
m_newValue->ref();
m_attrName = attrNameArg.implementation();
if(m_attrName)
m_attrName->ref();
m_attrChange = attrChangeArg;
}
bool CoilHeatingElectric_Impl::addToNode(Node & node)
{
if( boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC() )
{
if( ! airLoop->demandComponent(node.handle()) )
{
if( StraightComponent_Impl::addToNode( node ) )
{
if( boost::optional<Node> node = outletModelObject()->optionalCast<Node>() )
{
setTemperatureSetpointNode(node.get());
}
return true;
}
}
}
return false;
}
bool EvaporativeCoolerDirectResearchSpecial_Impl::addToNode(Node & node)
{
if( boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC() )
{
if( ! airLoop->demandComponent(node.handle()) )
{
if( StraightComponent_Impl::addToNode( node ) )
{
if( boost::optional<Node> node = this->outletModelObject()->optionalCast<Node>() )
{
this->setSensorNode(node.get());
}
return true;
}
}
}
return false;
}
void CoilHeatingElectric_Impl::setTemperatureSetpointNode(Node & temperatureSetpointNode) {
setPointer(OS_Coil_Heating_ElectricFields::TemperatureSetpointNodeName, temperatureSetpointNode.handle());
}
bool SetpointManagerScheduledDualSetpoint_Impl::setSetpointNode( const Node & node )
{
return setPointer(OS_SetpointManager_Scheduled_DualSetpointFields::SetpointNodeorNodeListName,node.handle());
}
bool WaterToAirComponent_Impl::addToNode(Node & node)
{
Model _model = node.model();
ModelObject thisModelObject = getObject<ModelObject>();
boost::optional<AirLoopHVACOutdoorAirSystem> oaSystem = node.airLoopHVACOutdoorAirSystem();
if( node.airLoopHVAC() && ! oaSystem )
{
AirLoopHVAC airLoop = node.airLoopHVAC().get();
if( airLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( airLoopHVAC() )
{
removeFromAirLoopHVAC();
}
if( node == airLoop.supplyOutletNode() &&
node.inletModelObject().get() == airLoop.supplyInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
if( node == airLoop.supplyInletNode() &&
node.outletModelObject().get() == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.outletModelObject().get();
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else if( node.plantLoop() )
{
PlantLoop _plantLoop = node.plantLoop().get();
if( ! _plantLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( plantLoop() )
{
removeFromPlantLoop();
}
if( node == _plantLoop.demandOutletNode() &&
node.inletModelObject().get() == _plantLoop.demandInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == _plantLoop.demandOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else
{
return false;
}
}
void EvaporativeCoolerDirectResearchSpecial_Impl::setSensorNode( const Node & node )
{
this->setPointer(OS_EvaporativeCooler_Direct_ResearchSpecialFields::SensorNodeName,node.handle());
}
void ControllerWaterCoil_Impl::setActuatorNode( Node & node )
{
this->setPointer(OS_Controller_WaterCoilFields::ActuatorNodeName,node.handle());
}
bool SetpointManagerFollowOutdoorAirTemperature_Impl::setSetpointNode(const Node & node )
{
return setPointer(OS_SetpointManager_FollowOutdoorAirTemperatureFields::SetpointNodeorNodeListName,node.handle());
}
bool SetpointManagerMultiZoneHumidityMaximum_Impl::setSetpointNode(const Node& node) {
bool result = setPointer(OS_SetpointManager_MultiZone_Humidity_MaximumFields::SetpointNodeorNodeListName, node.handle());
return result;
}
bool SetpointManagerOutdoorAirReset_Impl::setSetpointNode(const Node& node) {
return setPointer(OS_SetpointManager_OutdoorAirResetFields::SetpointNodeorNodeListName, node.handle());
}
bool SetpointManagerSingleZoneReheat_Impl::setSetpointNode( const Node & node )
{
return setPointer(OS_SetpointManager_SingleZone_ReheatFields::SetpointNodeorNodeListName, node.handle());
}
bool SetpointManagerOutdoorAirPretreat_Impl::setSetpointNode(const Node& node) {
bool result = setPointer(OS_SetpointManager_OutdoorAirPretreatFields::SetpointNodeorNodeListName, node.handle());
return result;
}
bool SetpointManagerOutdoorAirPretreat_Impl::setMixedAirStreamNode(const Node& node) {
bool result = setPointer(OS_SetpointManager_OutdoorAirPretreatFields::MixedAirStreamNodeName, node.handle());
return result;
}
bool EvaporativeCoolerIndirectResearchSpecial_Impl::setReliefAirInletNode(const Node & node)
{
return setPointer(OS_EvaporativeCooler_Indirect_ResearchSpecialFields::ReliefAirInletNode, node.handle());
}
void SetpointManagerFollowOutdoorAirTemperature_Impl::setSetpointNode( Node & node )
{
SetpointManagerFollowOutdoorAirTemperature thisModelObject = this->getObject<SetpointManagerFollowOutdoorAirTemperature>();
thisModelObject.setPointer(OS_SetpointManager_FollowOutdoorAirTemperatureFields::SetpointNodeorNodeListName,node.handle());
}
