func parseNode(text, context string, graph bh.SignalGraphTypeIf) (job *PasteJob, ok bool) {
xmln := backend.XmlNode{}
_, xmlerr := xmln.Read([]byte(text))
if xmlerr != nil {
return
}
nodes := graph.Nodes()
for true {
valid := true
for _, reg := range nodes {
if reg.Name() == xmln.NName {
valid = false
}
}
if valid {
break
}
xmln.NName = createNextNameCandidate(xmln.NName)
}
_, validType := freesp.GetNodeTypeByName(xmln.NType)
var njob *NewElementJob
switch {
case validType:
njob = NewElementJobNew(context, eNode)
njob.input[iNodeName] = xmln.NName
njob.input[iNodeTypeSelect] = xmln.NType
case len(xmln.InPort) == 0:
if len(xmln.OutPort) == 0 {
fmt.Printf("parseNode error: no ports.\n")
return
}
njob = NewElementJobNew(context, eInputNode)
njob.input[iInputNodeName] = xmln.NName
njob.input[iInputTypeSelect] = xmln.OutPort[0].PType // TODO
case len(xmln.OutPort) == 0:
njob = NewElementJobNew(context, eOutputNode)
njob.input[iOutputNodeName] = xmln.NName
njob.input[iOutputTypeSelect] = xmln.InPort[0].PType // TODO
default:
if !validType {
fmt.Printf("parseNode error: node type %s not registered.\n", xmln.NType)
return
}
// TODO: Create node type??
njob = NewElementJobNew(context, eNode)
njob.input[iNodeName] = xmln.NName
njob.input[iNodeTypeSelect] = xmln.NType
}
job = PasteJobNew()
job.context = context
job.newElements = append(job.newElements, njob)
ok = true
return
}
func TestGraph(t *testing.T) {
case1 := []struct {
library, graph string
nodes, connections int
}{
{`<library xmlns="http://www.freesp.de/xml/freeSP" version="1.0">
<signal-type name="s1" scope="" mode="" c-type="" message-id=""></signal-type>
<node-type name="Test">
<intype port="" type="s1"></intype>
<outtype port="" type="s1"></outtype>
</node-type>
</library>
`, `<?xml version="1.0" encoding="UTF-8"?>
<signal-graph xmlns="http://www.freesp.de/xml/freeSP" version="1.0">
<nodes>
<input name="sensor">
<outtype type="s1"/>
</input>
<output name="actuator">
<intype type="s1"/>
</output>
<processing-node name="test" type="Test"></processing-node>
</nodes>
<connections>
<connect from="sensor" to="test"/>
<connect from="test" to="actuator"/>
</connections>
</signal-graph>
`, 3, 2},
}
for i, c := range case1 {
freesp.Init()
var l bh.LibraryIf = LibraryNew("test.alml", nil)
buf := copyBuf(c.library)
_, err := l.Read(buf)
if err != nil {
t.Errorf("Testcase %d: Failed to read from buffer: %v", i, err)
return
}
var sg bh.SignalGraphIf = SignalGraphNew("test.sml", nil)
buf = copyBuf(c.graph)
_, err = sg.Read(buf)
if err != nil {
t.Errorf("Testcase %d: Failed to read from buffer: %v", i, err)
return
}
var st bh.SignalGraphTypeIf = sg.ItsType()
if len(st.Nodes()) != c.nodes {
t.Errorf("Testcase %d: NodeIf count mismatch", i)
return
}
}
}
func SignalGraphTypeUsesNodeType(t bh.SignalGraphTypeIf, nt bh.NodeTypeIf) bool {
for _, n := range t.Nodes() {
if n.ItsType().TypeName() == nt.TypeName() {
return true
}
for _, impl := range n.ItsType().Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
if SignalGraphTypeUsesNodeType(impl.Graph(), nt) {
return true
}
}
}
}
return false
}
func NodesApplyHints(path string, g bh.SignalGraphTypeIf, xmlh []backend.XmlNodePosHint) {
for _, n := range g.ProcessingNodes() {
var p string
if len(path) == 0 {
p = n.Name()
} else {
p = fmt.Sprintf("%s/%s", path, n.Name())
}
ok := false
var xmln backend.XmlNodePosHint
for _, xmln = range xmlh {
if p == xmln.Name {
ok = true
break
}
}
if ok {
n.SetExpanded(xmln.Expanded)
freesp.PathModePositionerApplyHints(n, xmln.XmlModeHint)
for i, p := range n.InPorts() {
ok = p.Name() == xmln.InPorts[i].Name
if !ok {
log.Printf("NodesApplyHints FIXME: name mismatch\n")
continue
}
freesp.ModePositionerApplyHints(p, xmln.InPorts[i].XmlModeHint)
}
for i, p := range n.OutPorts() {
ok = p.Name() == xmln.OutPorts[i].Name
if !ok {
log.Printf("NodesApplyHints FIXME: name mismatch\n")
continue
}
freesp.ModePositionerApplyHints(p, xmln.OutPorts[i].XmlModeHint)
}
}
nt := n.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
NodesApplyHints(p, impl.Graph(), xmlh)
break
}
}
}
}
func SignalGraphTypeUsesSignalType(t bh.SignalGraphTypeIf, st bh.SignalTypeIf) bool {
for _, n := range t.Nodes() {
for _, p := range n.InPorts() {
if p.SignalType() == st {
return true
}
}
for _, p := range n.OutPorts() {
if p.SignalType() == st {
return true
}
}
for _, impl := range n.ItsType().Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
if SignalGraphTypeUsesSignalType(impl.Graph(), st) {
return true
}
}
}
}
return false
}
func NodeNew(name string, ntype bh.NodeTypeIf, context bh.SignalGraphTypeIf) (ret *node, err error) {
for _, n := range context.Nodes() {
if n.Name() == name {
err = fmt.Errorf("NodeNew error: node '%s' already exists in context.", name)
return
}
}
if len(ntype.InPorts())+len(ntype.OutPorts()) == 0 {
err = fmt.Errorf("NodeNew error: type '%s' has no ports.", ntype.TypeName())
return
}
ret = &node{*gr.PathModePositionerObjectNew(), context, name, ntype,
portListInit(), portListInit(), nil, false}
for _, p := range ntype.InPorts() {
ret.addInPort(p)
}
for _, p := range ntype.OutPorts() {
ret.addOutPort(p)
}
ntype.(*nodeType).addInstance(ret)
return
}
func CreateXmlSignalGraphType(t bh.SignalGraphTypeIf) *backend.XmlSignalGraph {
ret := backend.XmlSignalGraphNew()
for _, l := range t.Libraries() {
ret.Libraries = append(ret.Libraries, *CreateXmlLibraryRef(l.Filename()))
}
for _, n := range t.InputNodes() {
ret.InputNodes = append(ret.InputNodes, *CreateXmlInputNode(n))
}
for _, n := range t.OutputNodes() {
ret.OutputNodes = append(ret.OutputNodes, *CreateXmlOutputNode(n))
}
for _, n := range t.ProcessingNodes() {
ret.ProcessingNodes = append(ret.ProcessingNodes, *CreateXmlProcessingNode(n))
}
for _, n := range t.Nodes() {
for _, p := range n.OutPorts() {
for _, c := range p.Connections() {
conn := p.Connection(c)
ret.Connections = append(ret.Connections, *CreateXmlConnection(conn))
}
}
}
return ret
}
func ExpandedNodeNew(getPositioner GetPositioner, userObj bh.NodeIf, nId bh.NodeIdIf) (ret *ExpandedNode) {
positioner := getPositioner(nId)
pos := positioner.Position()
path := nId.String()
config := DrawConfig{ColorInit(ColorOption(NormalExpandedNode)),
ColorInit(ColorOption(HighlightExpandedNode)),
ColorInit(ColorOption(SelectExpandedNode)),
ColorInit(ColorOption(BoxFrame)),
ColorInit(ColorOption(Text)),
image.Point{global.padX, global.padY}}
cconfig := ContainerConfig{expandedPortWidth, expandedPortHeight, 120, 80}
// Add children
var g bh.SignalGraphTypeIf
nt := userObj.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
g = impl.Graph()
break
}
}
var children []ContainerChild
if g != nil {
empty := image.Point{}
first := image.Point{16, 32}
shift := image.Point{16, 16}
for i, n := range g.ProcessingNodes() {
var ch ContainerChild
var mode gr.PositionMode
if n.Expanded() {
mode = gr.PositionModeExpanded
} else {
mode = gr.PositionModeNormal
}
proxy := gr.PathModePositionerProxyNew(n)
proxy.SetActivePath(path)
proxy.SetActiveMode(mode)
log.Printf("ExpandedNodeNew TODO: position of child nodes. path=%s, mode=%v\n", path, mode)
chpos := proxy.Position()
if chpos == empty {
chpos = pos.Add(first.Add(shift.Mul(i)))
proxy.SetPosition(chpos)
}
id := freesp.NodeIdNew(nId, n.Name())
if n.Expanded() {
ch = ExpandedNodeNew(getPositioner, n, id)
} else {
ch = NodeNew(getPositioner, n, id)
}
children = append(children, ch)
}
}
ret = &ExpandedNode{ContainerInit(children, config, userObj, cconfig),
userObj, positioner, nil, nil}
ret.ContainerInit()
empty := image.Point{}
config = DrawConfig{ColorInit(ColorOption(InputPort)),
ColorInit(ColorOption(HighlightInPort)),
ColorInit(ColorOption(SelectInPort)),
ColorInit(ColorOption(BoxFrame)),
Color{},
image.Point{}}
for i, p := range userObj.InPorts() {
pos := p.ModePosition(gr.PositionModeExpanded)
if pos == empty {
pos = ret.CalcInPortPos(i)
}
positioner := gr.ModePositionerProxyNew(p, gr.PositionModeExpanded)
ret.AddPort(config, p, positioner)
}
config = DrawConfig{ColorInit(ColorOption(OutputPort)),
ColorInit(ColorOption(HighlightOutPort)),
ColorInit(ColorOption(SelectOutPort)),
ColorInit(ColorOption(BoxFrame)),
Color{},
image.Point{}}
for i, p := range userObj.OutPorts() {
pos := p.ModePosition(gr.PositionModeExpanded)
if pos == empty {
pos = ret.CalcOutPortPos(i)
}
positioner := gr.ModePositionerProxyNew(p, gr.PositionModeExpanded)
ret.AddPort(config, p, positioner)
}
for _, n := range g.ProcessingNodes() {
from, ok := ret.ChildByName(n.Name())
if !ok {
log.Printf("ExpandedNodeNew error: node %s not found\n", n.Name())
continue
}
for _, p := range n.OutPorts() {
fromId := from.OutPortIndex(p.Name())
for _, c := range p.Connections() {
to, ok := ret.ChildByName(c.Node().Name())
if ok {
toId := to.InPortIndex(c.Name())
ret.connections = append(ret.connections, ConnectionNew(from, to, fromId, toId))
} else {
portname, ok := c.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: output node %s not linked\n", c.Node().Name())
continue
}
ownPort, ok := ret.OutPortByName(portname)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of output node %s not found\n", portname, c.Node().Name())
continue
}
nodePort, ok := from.OutPortByName(p.Name())
if !ok {
log.Printf("ExpandedNodeNew error: port %s of output node %s not found\n", p.Name(), from.Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(nodePort, ownPort))
}
}
}
}
for _, n := range g.InputNodes() {
for _, p := range n.OutPorts() {
fromlink, ok := p.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: input node %s not linked\n", p.Node().Name())
continue
}
fromPort, ok := ret.InPortByName(fromlink)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of input node %s not found\n", fromlink, n.Name())
continue
}
for _, c := range p.Connections() {
to, ok := ret.ChildByName(c.Node().Name())
if ok {
// TODO: connect with node
toPort, ok := to.InPortByName(c.Name())
if !ok {
log.Printf("ExpandedNodeNew error: port %s of node %s not found\n", c.Name(), to.Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(fromPort, toPort))
} else {
tolink, ok := c.Node().PortLink()
if !ok {
log.Printf("ExpandedNodeNew error: output node %s not linked\n", c.Node().Name())
continue
}
toPort, ok := ret.OutPortByName(tolink)
if !ok {
log.Printf("ExpandedNodeNew error: linked port %s of output node %s not found\n", tolink, c.Node().Name())
continue
}
ret.portconn = append(ret.portconn, PortConnectorNew(fromPort, toPort))
}
}
}
}
ret.RegisterOnDraw(func(ctxt interface{}) {
expandedNodeOnDraw(ret, ctxt)
})
return
}
