// the structure of this file:

//

// [SECTION] internal data structures

// [SECTION] global struct

// [SECTION] editor context definition

// [SECTION] ui state logic

// [SECTION] render helpers

// [SECTION] API implementation

#include "imnodes.h"

#include "imgui.h"

#define IMGUI_DEFINE_MATH_OPERATORS

#include "imgui_internal.h"

// Check minimum ImGui version

#define MINIMUM_COMPATIBLE_IMGUI_VERSION 16401

#if IMGUI_VERSION_NUM < MINIMUM_COMPATIBLE_IMGUI_VERSION

#error \

"Minimum ImGui version requirement not met -- please use a newer version!"

#endif

#include <assert.h>

#include <math.h>

#include <new>

#include <stdint.h>

#include <string.h> // strlen, strncmp

#include <stdio.h> // for fwrite, ssprintf, sscanf

#include <stdlib.h>

namespace imnodes

{

namespace

{

bool initialized = false;

enum ScopeFlags

};

enum Channels

};

enum AttributeType

};

// Emulates std::optional<int> using the sentinel value `invalid_index`.

struct OptionalIndex

};

// [SECTION] internal data structures

// The object T must have the following interface:

//

// struct T

// {

// T();

//

// int id;

// };

template<typename T>

struct ObjectPool

};

struct NodeData

};

struct PinData

};

struct LinkData

};

struct LinkPredicate

};

// This represents a link which the user starts to dragging from a pin, i.e. it

// is not yet complete.

struct PartialLink

};

struct BezierCurve

};

struct LinkBezierData

};

enum BoxSelectorState

};

struct BoxSelector

};

enum NodeInteractionState

};

struct NodeInteraction

};

struct ColorStyleElement

};

struct StyleElement

};

// [SECTION] global struct

// this stores data which only lives for one frame

struct

{

EditorContext* default_editor_ctx;

EditorContext* editor_ctx;

ImDrawList* canvas_draw_list;

ImVec2 canvas_origin_screen_space;

ImRect canvas_rect_screen_space;

ScopeFlags current_scope;

Style style;

ImVector<ColorStyleElement> color_modifier_stack;

ImVector<StyleElement> style_modifier_stack;

ImGuiTextBuffer text_buffer;

// TODO: these are just used to indicate the current node, attribute, pin

// being created by the user. In the long run, it may be much more efficient

// just to stick an optional reference here, so we don't need to do an

// editor->pool->index operation everytime we need to do something small

// with the node or pin.

// Indexes into the node pool array

OptionalIndex current_node_idx;

// This field indexes into the current node data's attribute array

OptionalIndex current_attribute_idx;

// Indexes into the pin pool array

OptionalIndex current_pin_idx;

struct

{

OptionalIndex node_idx;

OptionalIndex attribute_idx;

} active_item;

OptionalIndex hovered_node_idx;

OptionalIndex hovered_link_idx;

OptionalIndex hovered_pin_idx;

bool link_dropped;

} g;

EditorContext& editor_context_get()

{

assert(g.editor_ctx != NULL);

return *g.editor_ctx;

}

inline bool is_mouse_hovering_near_point(const ImVec2& point, float radius)

}

inline ImVec2 eval_bezier(float t, const BezierCurve& bezier)

}

// Divides the bezier curve into n segments. Evaluates the distance to each

// segment. Chooses the segment with the smallest distance, and repeats the

// algorithm on that segment, for the given number of iterations.

inline float get_closest_point_on_cubic_bezier(

}

inline float get_distance_to_cubic_bezier(

}

inline ImRect get_containing_rect_for_bezier_curve(const BezierCurve& bezier)

}

inline LinkBezierData get_link_renderable(

}

inline bool is_mouse_hovering_near_link(const BezierCurve& bezier)

}

inline float eval_implicit_line_eq(

}

inline int sign(float val) { return int(val > 0.0f) - int(val < 0.0f); }

inline bool rectangle_overlaps_line_segment(

}

inline bool rectangle_overlaps_bezier(

}

inline bool rectangle_overlaps_link(

}

} // namespace

// [SECTION] editor context definition

struct EditorContext

};

namespace

{

// [SECTION] ui state logic

ImVec2 get_screen_space_pin_coordinates(

}

ImVec2 get_screen_space_pin_coordinates(

}

// These functions are here, and not members of the BoxSelector struct, because

// implementing a C API in C++ is frustrating. EditorContext has a BoxSelector

// field, but the state changes depend on the editor. So, these are implemented

// as C-style free functions so that the code is not too much of a mish-mash of

// C functions and C++ method definitions.

void box_selector_begin(BoxSelector& box_selector)

{

box_selector.state = BoxSelectorState_Started;

}

bool box_selector_active(const BoxSelector& box_selector)

{

return box_selector.state != BoxSelectorState_None;

}

void box_selector_process(

}

void box_selector_update(

}

void node_interaction_begin(EditorContext& editor, const int node_idx)

}

void node_interaction_update(EditorContext& editor)

}

// [SECTION] render helpers

inline ImVec2 screen_space_to_grid_space(const ImVec2& v)

}

inline ImVec2 grid_space_to_editor_space(const ImVec2& v)

}

inline ImVec2 editor_space_to_screen_space(const ImVec2& v)

{

return g.canvas_origin_screen_space + v;

}

inline ImRect get_item_rect()

{

return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());

}

inline ImVec2 get_node_title_bar_origin(const NodeData& node)

{

return node.origin + node.layout_style.padding;

}

inline ImVec2 get_node_content_origin(const NodeData& node)

}

void draw_grid(EditorContext& editor, const ImVec2& canvas_size)