DIWNE::Pin ​

#include "DIWNE/Core/Elements/Pin.h"

Inherits from DIWNE::DiwneObject, std::enable_shared_from_this< DiwneObject >

Inherited by Workspace::CorePin

Public Functions ​

Protected Functions ​

Public Attributes ​

Protected Attributes ​

Additional inherited members ​

Public Functions inherited from DIWNE::DiwneObject

Protected Functions inherited from DIWNE::DiwneObject

Public Attributes inherited from DIWNE::DiwneObject

Protected Attributes inherited from DIWNE::DiwneObject

Public Functions Documentation ​

function Pin ​

Pin(
    NodeEditor & diwne,
    Node * node,
    bool isInput,
    std::string labelDiwne ="DiwnePin"
)

Pin(
    NodeEditor & diwne,
    Node * node,
    bool isInput,
    std::string labelDiwne ="DiwnePin"
)

function afterDraw ​

virtual void afterDraw(
    DrawInfo & context
) override

virtual void afterDraw(
    DrawInfo & context
) override

Called last during drawing.

Reimplements: DIWNE::DiwneObject::afterDraw

At this point the m_rect of the object should be calculated in the updateLayout() method and this method should be able to work with it. Because of that the drawing code within shouldn't affect the objects size anymore. Interactions are processed before this method and thus interaction related member variables can be used within.

function allowConnection ​

virtual bool allowConnection() const

virtual bool allowConnection() const

A condition for starting and receiving a link connection.

Reimplemented by: Workspace::CorePin::allowConnection

Can be used to specify an area where the pin can be dragged from or a link dropped at.

function allowDragStart ​

virtual bool allowDragStart() const override

virtual bool allowDragStart() const override

Determines whether a drag operation can start from this object.

See: isDraggedDiwne(), allowPress()

Reimplements: DIWNE::DiwneObject::allowDragStart

By default the only requirement is the object to be pressed.

function allowPopup ​

virtual bool allowPopup() const override

virtual bool allowPopup() const override

Determines whether a popup can be raised over the object.

See: processPopupDiwne()

Reimplements: DIWNE::DiwneObject::allowPopup

Allowed by default.

function begin ​

virtual void begin(
    DrawInfo & context
) override

virtual void begin(
    DrawInfo & context
) override

First method to be called during object drawing.

Reimplements: DIWNE::DiwneObject::begin

Can be used to initialize drawing code.

function canPlug ​

virtual bool canPlug(
    Pin * other
) const

virtual bool canPlug(
    Pin * other
) const

Quick check of compatibility between this and some other pin.

See: preparePlug()

Used for invalid pin dimming. The check in preparePlug() is expected to be more precise and potentially more demanding (checking of loops), that's why this "quick" check exists, since it gets called very often from all pins on the screen when dragging.

function connectionChanged ​

bool connectionChanged() const

bool connectionChanged() const

function content ​

virtual void content(
    DrawInfo & context
) override

virtual void content(
    DrawInfo & context
) override

Called after begin() during drawing.

Reimplements: DIWNE::DiwneObject::content

Draws object content.

function createLink ​

virtual std::shared_ptr< Link > createLink()

virtual std::shared_ptr< Link > createLink()

Method responsible for constructing a new link for this pin.

Return: The new Link instance, it is already registered with the current editor and has no connections yet.

Reimplemented by: Workspace::CorePin::createLink

By default a standard Link object is used, however this method can be overriden to allow specific pins to use specialized link subclasses.

function end ​

virtual void end(
    DrawInfo & context
) override

virtual void end(
    DrawInfo & context
) override

Called after content().

Reimplements: DIWNE::DiwneObject::end

Used to end content drawing.

function getConnectionPoint ​

virtual const ImVec2 & getConnectionPoint()

virtual const ImVec2 & getConnectionPoint()

function getDragRect ​

const ImRect & getDragRect() const

const ImRect & getDragRect() const

See: m_dragRect

function getLink ​

Link * getLink(
    size_t index =0
)

Link * getLink(
    size_t index =0
)

function getNode ​

template <typename T  =Node>
inline T * getNode()

template <typename T  =Node>
inline T * getNode()

function getNode ​

Node * getNode()

Node * getNode()

function getPinRect ​

const ImRect & getPinRect() const

const ImRect & getPinRect() const

See: m_pinRect

function initialize ​

virtual void initialize(
    DrawInfo & context
) override

virtual void initialize(
    DrawInfo & context
) override

First method to be called every frame.

Reimplements: DIWNE::DiwneObject::initialize

Does not handle drawing.

function isDisabled ​

virtual bool isDisabled() const

virtual bool isDisabled() const

/// Whether the pin is disabled or not. When disabled it cannot be plugged in.

Reimplemented by: Workspace::CorePin::isDisabled

function isDragAreaHovered ​

virtual bool isDragAreaHovered() const

virtual bool isDragAreaHovered() const

Condition determining when a new link can be created from the pin on drag.

The drag area is defined by the m_dragRect, or the m_pinRect if dragging by labels is disabled.

function isInput ​

bool isInput() const

bool isInput() const

Whether this is an input or output pin.

See: isLeft()

Input pins are restricted to only accept at most one connection. They also force links to always end in them, meaning a link can't begin in an input pin. Output pins have no such restrictions. They can be on either end of a link and have any amount of connections, when m_allowMultipleConnections is enabled. For input pins that flag is forced to false.

function isLeft ​

bool isLeft() const

bool isLeft() const

Whether the pin is rendered on the left side of a node.

Usually input pins are rendered on the left but they don't always have to. Hence one shouldn't rely on this method returning the same as isInput()

function isPlugged ​

bool isPlugged() const

bool isPlugged() const

function makeInput ​

void makeInput()

void makeInput()

Called to initialize an input pin or to switch to being one.

function makeOutput ​

void makeOutput()

void makeOutput()

Called to initialize an output pin or to switch to being one.

function onDestroy ​

virtual void onDestroy(
    bool logEvent
) override

virtual void onDestroy(
    bool logEvent
) override

Gets called the moment the object is marked for deletion by destroy().

See: destroy()

Warning: It is possible that the onDestroy() callback is never called when destroy() wasn't properly called. DiwneObjects containing other DiwneObjects should always ensure to destroy their children in their onDestroy().

Reimplements: DIWNE::DiwneObject::onDestroy

It is called only once per object.

function onDrag ​

virtual void onDrag(
    DrawInfo & context,
    bool dragStart,
    bool dragEnd
) override

virtual void onDrag(
    DrawInfo & context,
    bool dragStart,
    bool dragEnd
) override

This method gets called when the object is being dragged.

Parameters:

• dragStart The drag has just started this frame.
• dragEnd The drag is ending this frame.

See: processDragDiwne(), processPressAndReleaseDiwne()

Reimplements: DIWNE::DiwneObject::onDrag

Drag begins when the object is pressed and isDraggedDiwne() returns true.

A call with dragStart true, should always be followed by a call with dragEnd true.

Reset valid flag

function onPlug ​

virtual void onPlug(
    Pin * otherPin,
    Link * link,
    bool isStartPin,
    bool logEvent =true
)

virtual void onPlug(
    Pin * otherPin,
    Link * link,
    bool isStartPin,
    bool logEvent =true
)

Called after the pin has been connected to another pin using a link.

Parameters:

• otherPin The pin on the other side of the link. Cannot be null.
• link The link of the new connection with both ends plugged.
• isStartPin Whether this pin is the start of the connection (otherwise it's the end).
• logEvent The flag passed to the origin of the action.

Reimplemented by: Workspace::CorePin::onPlug

function onUnplug ​

virtual void onUnplug(
    Pin * otherPin,
    Link * link,
    bool wasStartPin,
    bool logEvent =true
)

virtual void onUnplug(
    Pin * otherPin,
    Link * link,
    bool wasStartPin,
    bool logEvent =true
)

Called after the link connecting this pin to another is disconnected.

Parameters:

• otherPin The pin on the other side of the link. Can be null.
• link The link of the disconnected connection.
• wasStartPin Whether this pin was the start of the connection (otherwise it was the end).
• logEvent The flag passed to the origin of the action.

Reimplemented by: Workspace::CorePin::onUnplug

function plug ​

virtual bool plug(
    Pin * otherPin,
    bool logEvent =true
)

virtual bool plug(
    Pin * otherPin,
    bool logEvent =true
)

Create a new link between this pin and the other pin.

Parameters:

• otherPin The other pin on the other side of the new link.
• logEvent The boolean flag passed to onPlug() on successful connect

Return: True on success, false otherwise

The other pin is considered the start of the link, except when it is an input pin. Both pins cannot be input pins.

function plug ​

template <typename T >
bool plug(
    Pin * otherPin,
    T logEvent
) =delete

template <typename T >
bool plug(
    Pin * otherPin,
    T logEvent
) =delete

function plugLink ​

virtual bool plugLink(
    Pin * otherPin,
    Link * link,
    bool logEvent =true
)

virtual bool plugLink(
    Pin * otherPin,
    Link * link,
    bool logEvent =true
)

Connect this and some other pin together using an existing link.

Parameters:

• otherPin The other pin on the other side of the link.
• link
• logEvent The boolean flag passed to onUnplug() on successful disconnect

Return: true

Reimplemented by: Workspace::CorePin::plugLink

The other pin is considered the start of the link, except when it is an input pin. Both pins cannot be input pins. The link will get unplugged from other pins if necessary.

function preparePlug ​

virtual bool preparePlug(
    Pin * otherPin,
    Link * link,
    bool hovering,
    DIWNE::DrawInfo & context
)

virtual bool preparePlug(
    Pin * otherPin,
    Link * link,
    bool hovering,
    DIWNE::DrawInfo & context
)

Called when the mouse is dragging a new link and is hovering over this pin as well as when it is released.

Parameters:

• otherPin The other pin, usually the starting pin of the link, but it can be the end pin as well.
• link The link that's being prepared for plugging
• hovering True when the mouse is only hovering over the pin and it shouldn't be plugged in yet.

See: canPlug()

Return: Whether the link is ready to be plugged in.

When the hovering argument is false, the mouse was released and the link should be connected. The method is responsible for the underlying plug in logic and determining whether the connection is valid.

function processInteractions ​

virtual void processInteractions(
    DrawInfo & context
) override

virtual void processInteractions(
    DrawInfo & context
) override

Method for reacting to user input after the object is fully drawn and its dimensions are known.

Reimplements: DIWNE::DiwneObject::processInteractions

It is called after end() and updateLayout(), but before the afterDraw() lifecycle method. Internal interactions are processed right before.

function registerLink ​

bool registerLink(
    Link * link
)

bool registerLink(
    Link * link
)

Adds the link to the pin's list of links.

Return: true if the link was added, false if it already existed

function setConnectionPointDiwne ​

virtual void setConnectionPointDiwne(
    const ImVec2 & value
)

virtual void setConnectionPointDiwne(
    const ImVec2 & value
)

Set the point to which connected links are attached.

function translate ​

virtual void translate(
    const ImVec2 & vec
) override

virtual void translate(
    const ImVec2 & vec
) override

Move the object's rect and any other associated positional data.

Reimplements: DIWNE::DiwneObject::translate

function unplug ​

virtual bool unplug(
    bool logEvent =true,
    bool deleteLinks =true
)

virtual bool unplug(
    bool logEvent =true,
    bool deleteLinks =true
)

Unplug all links from this pin.

Parameters:

• logEvent The boolean flag passed to onUnplug() on successful disconnect
• deleteLinks Whether to also destroy the links after unplugging.

Return: True on success, false otherwise

function unregisterLink ​

bool unregisterLink(
    Link * link
)

bool unregisterLink(
    Link * link
)

Removes the link from the pin's list of links.

Return: true if removed, false if it didn't exist

function updateLayout ​

virtual void updateLayout(
    DrawInfo & context
) override

virtual void updateLayout(
    DrawInfo & context
) override

Updates object's m_rect, m_displayRect and any other object size variables.

See: m_rect, m_displayRect

Reimplements: DIWNE::DiwneObject::updateLayout

In other words this method is responsible for keeping track of the objects size.

IMPORTANT: This method should only update the m_rect's size, NOT it's position.

The object's rectangle is often set directly from ImGui's last item rectangle. But ImGui coordinates are aligned to pixel boundries via truncation of the coordinates, if the object's rect was updated directly using the screen space ImGui rectangle, there might be a slight discrepancy in the new position converted back to DIWNE coordinates which would cause the object to drift in a feedback loop.

m_displayRect should be updated together with m_rect to preserve correct pixel-aligned rendering in afterDraw(). TODO: Figure out if m_displayRect.Max should be aligned as well or not

This method is called after end() and before the afterDraw() method which can use the calculated size values for final drawing.

Protected Functions Documentation ​

function drawPinBackground ​

void drawPinBackground()

void drawPinBackground()

function updateConnectionPoint ​

virtual void updateConnectionPoint()

virtual void updateConnectionPoint()

Updates the connection point.

Public Attributes Documentation ​

variable m_allowMultipleConnections ​

bool m_allowMultipleConnections {true};

bool m_allowMultipleConnections {true};

Only allow one link to be connected, set to false for input pins.

variable m_isInput ​

bool m_isInput {false};

bool m_isInput {false};

Whether this is an input or output pin,.

See: isInput()

variable m_isLeft ​

bool m_isLeft {true};

bool m_isLeft {true};

Whether this pin is on the left or right side of a node Determined from m_isInput by default (inputs are on the right)

variable m_pinIconData ​

PinIconDrawData m_pinIconData;

PinIconDrawData m_pinIconData;

Temporary data used while drawing the pin.

Protected Attributes Documentation ​

variable m_connectionChanged ​

bool m_connectionChanged;

bool m_connectionChanged;

Flag indicating that the pin has been plugged or unplugged last time the pin was drawn.

Note: This flag gets reset the moment the pin is drawn. Meaning if the node owning this pin needs that information AFTER the pin is drawn, it is a good idea to save or react to this flag during initialize() or begin().

variable m_connectionPoint ​

ImVec2 m_connectionPoint {ImVec2(0, 0)};

ImVec2 m_connectionPoint {ImVec2(0, 0)};

Point where a link connects to this pin.

variable m_dragRect ​

ImRect m_dragRect;

ImRect m_dragRect;

Rect of the area that can be dragged to start a new connection.

variable m_links ​

std::vector< Link * > m_links;

std::vector< Link * > m_links;

Links connected to this pin.

variable m_node ​

Node * m_node;

Node * m_node;

Node this pin belongs to.

variable m_pinRect ​

ImRect m_pinRect;

ImRect m_pinRect;

Rect of the pin icon/socket. Links will connect to this.

variable m_previewPlugged ​

bool m_previewPlugged {false};

bool m_previewPlugged {false};

Style the pin as if it was plugged in.

variable m_previewPluggedInternal ​

bool m_previewPluggedInternal {false};

bool m_previewPluggedInternal {false};

Temp flag during drawing.

Updated on 2025-05-31 at 12:55:31 +0000