func MenuViewCurrent(menu *GoAppMenu, g *Global) {
fts := g.FTS().(tr.TreeIf)
cursor := fts.Current()
menu.viewExpand.SetSensitive(false)
menu.viewCollapse.SetSensitive(false)
if len(cursor.Path) == 0 {
return
}
obj := fts.Object(cursor)
var n bh.NodeIf
switch obj.(type) {
case bh.NodeIf:
n = obj.(bh.NodeIf)
//case mp.MappedElementIf:
// n = obj.(mp.MappedElementIf).Node()
default:
return
}
impl := n.ItsType().Implementation()
for _, i := range impl {
if i.ImplementationType() == bh.NodeTypeGraph {
menu.viewExpand.SetSensitive(true)
menu.viewCollapse.SetSensitive(true)
break
}
}
}
func IsProcessingNode(n bh.NodeIf) bool {
if len(n.InPorts()) == 0 {
return false
}
if len(n.OutPorts()) == 0 {
return false
}
return true
}
func (t *signalGraphType) AddNewObject(tree tr.TreeIf, cursor tr.Cursor, obj tr.TreeElementIf) (newCursor tr.Cursor, err error) {
switch obj.(type) {
case bh.NodeIf:
// TODO: Check if IO node and exists: copy position only and return
n := obj.(bh.NodeIf)
err = t.AddNode(n)
if err != nil {
err = fmt.Errorf("signalGraphType.AddNewObject error: %s", err)
nt := n.ItsType().(*nodeType)
if nt != nil {
ok, _ := nt.instances.Find(n)
if ok {
nt.instances.Remove(n)
}
}
return
}
newCursor = t.treeAddNewObject(tree, cursor, n)
parent := tree.Object(cursor)
switch parent.(type) {
case bh.SignalGraphIf:
case bh.ImplementationIf:
// propagate new node to all instances of embracing type
pCursor := tree.Parent(cursor)
nt := tree.Object(pCursor)
for _, nn := range nt.(bh.NodeTypeIf).Instances() {
nCursor := tree.Cursor(nn)
tCursor := tree.CursorAt(nCursor, parent)
tCursor.Position = cursor.Position
t.treeAddNewObject(tree, tCursor, n)
}
default:
log.Fatalf("signalGraphType.AddNewObject error: wrong parent type %T: %v\n", parent, parent)
}
case bh.ConnectionIf:
conn := obj.(bh.ConnectionIf)
var n bh.NodeIf
var p bh.PortIf
for _, n = range t.Nodes() {
if n.Name() == conn.From().Node().Name() {
nCursor := tree.CursorAt(cursor, n)
for _, p = range n.OutPorts() {
if conn.From().Name() == p.Name() {
pCursor := tree.CursorAt(nCursor, p)
return p.AddNewObject(tree, pCursor, obj)
}
}
}
}
default:
log.Fatalf("signalGraphType.AddNewObject error: wrong type %t: %v\n", obj, obj)
}
return
}
func mapelemNew(n bh.NodeIf, nId bh.NodeIdIf, p pf.ProcessIf, mapping mp.MappingIf) (m *mapelem) {
m = &mapelem{*gr.ModePositionerObjectNew(), n, nId, p, mapping, false,
make([]gr.ModePositionerObject, len(n.InPorts())),
make([]gr.ModePositionerObject, len(n.OutPorts()))}
for i := 0; i < len(m.inports); i++ {
m.inports[i] = *gr.ModePositionerObjectNew()
}
for i := 0; i < len(m.outports); i++ {
m.outports[i] = *gr.ModePositionerObjectNew()
}
return
}
func (t *signalGraphType) RemoveNode(n bh.NodeIf) {
for _, p := range n.(*node).inPort.Ports() {
for _, c := range p.Connections() {
c.RemoveConnection(p)
}
}
t.nodes.Remove(n)
RemNode(&t.inputNodes, n.(*node))
RemNode(&t.outputNodes, n.(*node))
RemNode(&t.processingNodes, n.(*node))
n.ItsType().(*nodeType).removeInstance(n.(*node))
}
func (t *signalGraphType) AddNode(n bh.NodeIf) error {
nType := n.ItsType()
if !isAutoType(nType) {
libname := nType.DefinedAt()
if len(libname) == 0 {
return fmt.Errorf("signalGraphType.AddNode error: node type %s has no DefinedAt...", nType.TypeName())
}
if !t.containsLibRef(libname) {
lib, ok := freesp.GetLibraryByName(libname)
if !ok {
return fmt.Errorf("signalGraphType.AddNode error: library %s not registered", libname)
}
t.libraries = append(t.libraries, lib)
}
}
return t.addNode(n)
}
func CreateXmlProcessingNode(n bh.NodeIf) *backend.XmlProcessingNode {
ret := backend.XmlProcessingNodeNew(n.Name(), n.ItsType().TypeName())
for _, p := range n.InPorts() {
ret.InPort = append(ret.InPort, *CreateXmlInPort(p))
}
for _, p := range n.OutPorts() {
ret.OutPort = append(ret.OutPort, *CreateXmlOutPort(p))
}
return ret
}
func (t *nodeType) treeNewObject(tree tr.TreeIf, cursor tr.Cursor, obj tr.TreeElementIf) (newCursor tr.Cursor) {
switch obj.(type) {
case bh.ImplementationIf:
cursor.Position = len(t.Implementation()) - 1
newCursor = tree.Insert(cursor)
obj.(bh.ImplementationIf).AddToTree(tree, newCursor)
case bh.PortTypeIf:
pt := obj.(bh.PortTypeIf)
newCursor = tree.Insert(cursor)
pt.AddToTree(tree, newCursor)
for _, impl := range t.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
// bh.NodeIf linked to outer port
g := impl.Graph().(*signalGraphType)
var n bh.NodeIf
index := -len(t.Implementation())
if pt.Direction() == gr.InPort {
n = g.findInputNodeFromPortType(pt)
if cursor.Position == tr.AppendCursor {
index += len(g.InputNodes())
}
} else {
n = g.findOutputNodeFromPortType(pt)
if cursor.Position == tr.AppendCursor {
index += len(g.InputNodes()) + len(g.OutputNodes())
}
}
if n == nil {
log.Fatalf("nodeType.AddNewObject error: invalid implementation...\n")
}
if cursor.Position != tr.AppendCursor {
index += cursor.Position
}
gCursor := tree.CursorAt(cursor, impl)
gCursor.Position = index
n.AddToTree(tree, tree.Insert(gCursor))
}
}
default:
log.Fatalf("nodeType.AddNewObject error: invalid type %T\n", obj)
}
return
}
func addExpandedMappings(m mp.MappingIf, n bh.NodeIf, parentId bh.NodeIdIf) {
idlist := m.MappedIds()
nId := behaviour.NodeIdNew(parentId, n.Name())
for _, id := range idlist {
if nId.String() == id.String() {
return
}
}
melem := m.AddMapping(n, nId, nil)
melem.SetExpanded(true)
for _, impl := range n.ItsType().Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
for _, nn := range impl.Graph().ProcessingNodes() {
addExpandedMappings(m, nn, nId)
}
}
}
}
func CreateXmlNodeMapList(m mp.MappingIf, n bh.NodeIf, path string) (xmln []backend.XmlNodeMap) {
p, ok := m.Mapped(n.Name())
if ok { // entire node is mapped to p:
pname := fmt.Sprintf("%s/%s", p.Arch().Name(), p.Name())
xmln = append(xmln, *CreateXmlNodeMap(path, pname))
}
nt := n.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
for _, nn := range impl.Graph().ProcessingNodes() {
xmlnn := CreateXmlNodeMapList(m, nn, fmt.Sprintf("%s/%s", path, nn.Name()))
for _, x := range xmlnn {
xmln = append(xmln, x)
}
}
}
}
return
}
func (g *Global) nodePath(n bh.NodeIf, nCursor tr.Cursor, selectId bh.NodeIdIf) (cursor tr.Cursor) {
ids := strings.Split(selectId.String(), "/")
if len(ids) == 1 {
cursor = nCursor
return
}
nt := n.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
for _, nn := range impl.Graph().ProcessingNodes() {
if nn.Name() == ids[1] {
nnId := behaviour.NodeIdFromString(strings.Join(ids[1:], "/"), selectId.Filename())
cursor = g.nodePath(nn, g.fts.CursorAt(nCursor, nn), nnId)
break
}
}
break
}
}
return
}
func NodeNew(getPositioner GetPositioner, n bh.NodeIf, nId bh.NodeIdIf) (ret *Node) {
positioner := getPositioner(nId)
pos := positioner.Position()
dy := NumericOption(PortDY)
box := image.Rect(pos.X, pos.Y, pos.X+global.nodeWidth, pos.Y+global.nodeHeight+numPorts(n)*dy)
config := DrawConfig{ColorInit(ColorOption(NodeNormal)),
ColorInit(ColorOption(NodeHighlight)),
ColorInit(ColorOption(NodeSelected)),
ColorInit(ColorOption(BoxFrame)),
ColorInit(ColorOption(Text)),
image.Point{global.padX, global.padY}}
ret = &Node{NamedBoxObjectInit(box, config, n), n, positioner, nil, -1}
ret.RegisterOnHighlight(func(hit bool, pos image.Point) bool {
return ret.onHighlight(hit, pos)
})
ret.RegisterOnSelect(func() bool {
return ret.onSelect()
}, func() bool {
return ret.onDeselect()
})
portBox := image.Rect(0, 0, global.portW, global.portH)
portBox = portBox.Add(box.Min)
shiftIn := image.Point{global.padX + global.portX0, global.padY + global.portY0}
shiftOut := image.Point{box.Size().X - global.padX - global.portW - global.portX0, global.padY + global.portY0}
b := portBox.Add(shiftIn)
for _, p := range n.InPorts() {
p := PortNew(b, p)
ret.ports = append(ret.ports, p)
b = b.Add(image.Point{0, global.portDY})
}
b = portBox.Add(shiftOut)
for _, p := range n.OutPorts() {
p := PortNew(b, p)
ret.ports = append(ret.ports, p)
b = b.Add(image.Point{0, global.portDY})
}
return
}
func CreateXmlOutputNode(n bh.NodeIf) *backend.XmlOutputNode {
tName := n.ItsType().TypeName()
if strings.HasPrefix(tName, "autoOutputNodeType-") {
tName = ""
}
ret := backend.XmlOutputNodeNew(n.Name(), tName)
if n.(*node).portlink != nil {
ret.NPort = n.(*node).portlink.Name()
}
for _, p := range n.InPorts() {
ret.InPort = append(ret.InPort, *CreateXmlInPort(p))
}
return ret
}
func (t *signalGraphType) addNode(n bh.NodeIf) error {
if len(n.InPorts()) > 0 {
if len(n.OutPorts()) > 0 {
t.processingNodes = append(t.processingNodes, n.(*node))
} else {
t.outputNodes = append(t.outputNodes, n.(*node))
}
} else {
if len(n.OutPorts()) > 0 {
t.inputNodes = append(t.inputNodes, n.(*node))
} else {
return fmt.Errorf("signalGraphType.AddNode error: node has no ports")
}
}
t.nodes.Append(n.(*node))
return nil
}
func CreateXmlNodePosHint(nd bh.NodeIf, path string) (xmln []backend.XmlNodePosHint) {
xmlnd := CreateXmlIONodePosHint(nd, path)
xmlnd.Expanded = nd.Expanded()
xmln = append(xmln, *xmlnd)
nt := nd.ItsType()
for _, impl := range nt.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
for _, n := range impl.Graph().ProcessingNodes() {
var p string
if len(path) == 0 {
p = nd.Name()
} else {
p = fmt.Sprintf("%s/%s", path, nd.Name())
}
hintlist := CreateXmlNodePosHint(n, p)
for _, h := range hintlist {
xmln = append(xmln, h)
}
}
break
}
}
return
}
func findNodeInIdList(n bh.NodeIf, parent bh.NodeIdIf, idlist []bh.NodeIdIf) bool {
nId := behaviour.NodeIdNew(parent, n.Name())
log.Printf("findNodeInIdList: n=%s, parent=%v\n", n.Name(), parent)
for _, id := range idlist {
if nId.String() == id.String() {
return true
}
}
for _, impl := range n.ItsType().Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
for _, nn := range impl.Graph().ProcessingNodes() {
if !findNodeInIdList(nn, nId, idlist) {
return false
}
}
return true
}
}
return false
}
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
}
func (t *signalGraphType) treeAddNewObject(tree tr.TreeIf, cursor tr.Cursor, n bh.NodeIf) (newCursor tr.Cursor) {
newCursor = tree.Insert(cursor)
n.AddToTree(tree, newCursor)
return
}
func (j *NewElementJob) CreateObject(fts *models.FilesTreeStore) (ret tr.TreeElementIf, err error) {
var parentObject tr.TreeElementIf
parentObject, err = fts.GetObjectById(j.parentId)
if err != nil {
log.Fatal("NewElementJob.CreateObject error: referenced parentObject run away...")
}
switch j.elemType {
case eNode, eInputNode, eOutputNode:
var context bh.SignalGraphTypeIf
switch parentObject.(type) {
case bh.NodeIf:
context = parentObject.(bh.NodeIf).Context()
j.parentId = getParentId(j.parentId)
case bh.SignalGraphIf:
context = parentObject.(bh.SignalGraphIf).ItsType()
case bh.SignalGraphTypeIf:
context = parentObject.(bh.SignalGraphTypeIf)
case bh.ImplementationIf:
if parentObject.(bh.ImplementationIf).ImplementationType() == bh.NodeTypeGraph {
context = parentObject.(bh.ImplementationIf).Graph()
} else {
log.Fatal("NewElementJob.CreateObject(eNode) error: parent implementation is no graph...")
}
default:
log.Fatal("NewElementJob.CreateObject(eNode) error: referenced parentObject wrong type...")
}
if j.elemType == eNode {
ntype, ok := freesp.GetNodeTypeByName(j.input[iNodeTypeSelect])
if !ok {
log.Fatal("NewElementJob.CreateObject(eNode) error: referenced parentObject type wrong...")
}
ret, err = behaviour.NodeNew(j.input[iNodeName], ntype, context)
} else if j.elemType == eInputNode {
ret, err = behaviour.InputNodeNew(j.input[iInputNodeName], j.input[iInputTypeSelect], context)
} else {
ret, err = behaviour.OutputNodeNew(j.input[iOutputNodeName], j.input[iOutputTypeSelect], context)
}
if len(j.extra) > 0 {
coords := strings.Split(j.extra, "|")
var x, y int
fmt.Sscanf(coords[0], "%d", &x)
fmt.Sscanf(coords[1], "%d", &y)
//pos := image.Point{x, y}
//log.Printf("NewElementJob.CreateObject(eNode) setting position %s: %v\n", j.extra, pos)
//ret.(bh.NodeIf).SetPosition(pos)
// TODO: SetModePosition...
}
case eNodeType:
var context string
switch parentObject.(type) {
case bh.NodeTypeIf:
context = parentObject.(bh.NodeTypeIf).DefinedAt()
j.parentId = getParentId(j.parentId)
case bh.SignalTypeIf:
j.parentId = getParentId(j.parentId)
parentObject, err = fts.GetObjectById(j.parentId)
context = parentObject.(bh.LibraryIf).Filename()
case bh.LibraryIf:
context = parentObject.(bh.LibraryIf).Filename()
default:
log.Fatal("NewElementJob.CreateObject(eNodeType) error: referenced parentObject wrong type...")
}
ret = behaviour.NodeTypeNew(j.input[iTypeName], context)
case eConnection:
switch parentObject.(type) {
case bh.PortIf:
case bh.SignalGraphTypeIf:
fromTo := strings.Split(j.extra, "/")
var n bh.NodeIf
for _, n = range parentObject.(bh.SignalGraphTypeIf).Nodes() {
if n.Name() == fromTo[0] {
for _, parentObject = range n.OutPorts() {
if parentObject.(bh.PortIf).Name() == fromTo[1] {
break
}
}
break
}
}
if parentObject == nil {
log.Fatalf("NewElementJob.CreateObject(eNodeType) error: no valid FROM port for edge job %v\n", j)
}
_ = parentObject.(bh.PortIf)
case bh.ImplementationIf:
fromTo := strings.Split(j.extra, "/")
var n bh.NodeIf
for _, n = range parentObject.(bh.ImplementationIf).Graph().Nodes() {
if n.Name() == fromTo[0] {
for _, parentObject = range n.OutPorts() {
if parentObject.(bh.PortIf).Name() == fromTo[1] {
break
}
}
break
}
}
if parentObject == nil {
log.Fatalf("NewElementJob.CreateObject(eNodeType) error: no valid FROM port for edge job %v\n", j)
}
_ = parentObject.(bh.PortIf)
default:
log.Fatalf("NewElementJob.CreateObject(eConnection) error: referenced parentObject wrong type %T\n", parentObject)
}
ports := getMatchingPorts(fts, parentObject)
for _, p := range ports {
s := fmt.Sprintf("%s/%s", p.Node().Name(), p.Name())
if j.input[iPortSelect] == s {
var from, to bh.PortIf
if p.Direction() == gr.InPort {
from = parentObject.(bh.PortIf)
to = p
} else {
from = p
to = parentObject.(bh.PortIf)
}
ret = behaviour.ConnectionNew(from, to)
break
}
}
case ePortType:
switch parentObject.(type) {
case bh.PortTypeIf:
j.parentId = getParentId(j.parentId)
case bh.NodeTypeIf:
default:
log.Fatal("NewElementJob.CreateObject(ePortType) error: referenced parentObject wrong type...")
}
_, ok := freesp.GetSignalTypeByName(j.input[iSignalTypeSelect])
if !ok {
err = fmt.Errorf("NewElementJob.CreateObject(ePortType) error: referenced signal type wrong...")
return
}
ret = behaviour.PortTypeNew(j.input[iPortName], j.input[iSignalTypeSelect], string2direction[j.input[iDirection]])
case eSignalType:
switch parentObject.(type) {
case bh.SignalTypeIf:
j.parentId = getParentId(j.parentId)
case bh.NodeTypeIf:
j.parentId = getParentId(j.parentId)
case bh.LibraryIf:
default:
log.Fatalf("NewElementJob.CreateObject(eSignalType) error: referenced parentObject wrong type %T\n", parentObject)
}
parentObject, err = fts.GetObjectById(j.parentId)
if err != nil {
log.Fatalf("NewElementJob.CreateObject(eSignalType) error: parent library object not found\n")
}
name := j.input[iSignalTypeName]
cType := j.input[iCType]
channelId := j.input[iChannelId]
scope := string2scope[j.input[iScope]]
mode := string2mode[j.input[iSignalMode]]
ret, err = behaviour.SignalTypeNew(name, cType, channelId, scope, mode, parentObject.(bh.LibraryIf).Filename())
if err != nil {
log.Printf("NewElementJob.CreateObject(eSignalType) error: SignalTypeNew failed: %s\n", err)
return
}
case eImplementation:
switch parentObject.(type) {
case bh.ImplementationIf:
j.parentId = getParentId(j.parentId)
case bh.NodeTypeIf:
default:
log.Fatalf("NewElementJob.CreateObject(eSignalType) error: referenced parentObject wrong type %T\n", parentObject)
}
implType := string2implType[j.input[iImplementationType]]
ret = behaviour.ImplementationNew(j.input[iImplName], implType, &global)
case eArch:
switch parentObject.(type) {
case pf.ArchIf:
j.parentId = getParentId(j.parentId)
parentObject = parentObject.(pf.ArchIf).Platform()
case pf.PlatformIf:
default:
log.Fatalf("NewElementJob.CreateObject(eArch) error: referenced parentObject wrong type %T\n", parentObject)
}
ret = platform.ArchNew(j.input[iArchName], parentObject.(pf.PlatformIf))
case eIOType:
var p pf.PlatformIf
switch parentObject.(type) {
case pf.IOTypeIf:
j.parentId = getParentId(j.parentId)
p = parentObject.(pf.IOTypeIf).Platform()
case pf.ArchIf:
p = parentObject.(pf.ArchIf).Platform()
default:
log.Fatalf("NewElementJob.CreateObject(eIOType) error: referenced parentObject wrong type %T\n", parentObject)
}
ret, err = platform.IOTypeNew(j.input[iIOTypeName], gr.IOMode(j.input[iIOModeSelect]), p)
case eProcess:
switch parentObject.(type) {
case pf.ProcessIf:
j.parentId = getParentId(j.parentId)
parentObject = parentObject.(pf.ProcessIf).Arch()
case pf.ArchIf:
default:
log.Fatalf("NewElementJob.CreateObject(eProcess) error: referenced parentObject wrong type %T\n", parentObject)
}
ret = platform.ProcessNew(j.input[iProcessName], parentObject.(pf.ArchIf))
case eChannel:
switch parentObject.(type) {
case pf.ChannelIf:
j.parentId = getParentId(j.parentId)
parentObject = parentObject.(pf.ChannelIf).Process()
case pf.ProcessIf:
default:
log.Fatalf("NewElementJob.CreateObject(eChannel) error: referenced parentObject wrong type %T\n", parentObject)
}
processes := getOtherProcesses(fts, parentObject)
var p pf.ProcessIf
for _, p = range processes {
s := fmt.Sprintf("%s/%s", p.Arch().Name(), p.Name())
if s == j.input[iChannelLinkSelect] {
break
}
}
if p == nil {
log.Fatalf("NewElementJob.CreateObject(eChannel) error: can't find chosen process\n", j.input[iChannelLinkSelect])
}
ioType, ok := freesp.GetIOTypeByName(j.input[iIOTypeSelect])
if !ok {
log.Fatalf("NewElementJob.CreateObject(eChannel) error: can't find chosen ioType\n", j.input[iIOTypeSelect])
}
ret = platform.ChannelNew(string2direction[j.input[iChannelDirection]], ioType, parentObject.(pf.ProcessIf), j.input[iChannelLinkSelect])
default:
log.Fatal("NewElementJob.CreateObject error: invalid elemType ", j.elemType)
}
return
}
func (t *nodeType) treeRemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) {
parentId := tree.Parent(cursor)
if t != tree.Object(parentId) {
log.Fatal("nodeType.RemoveObject error: not removing child of mine.")
}
obj := tree.Object(cursor)
switch obj.(type) {
case bh.ImplementationIf:
impl := obj.(bh.ImplementationIf)
if impl.ImplementationType() == bh.NodeTypeGraph {
// TODO: This is redundant with implementation.go
// Simply remove all nodes? Do not traverse a modifying list...
// Removed Input- and Output nodes are NOT stored (they are
// created automatically when adding the implementation graph).
// Return all removed edges ...
for _, n := range impl.Graph().Nodes() {
nCursor := tree.Cursor(n)
for _, p := range n.OutPorts() {
pCursor := tree.CursorAt(nCursor, p)
for index, c := range p.Connections() {
conn := p.Connection(c)
removed = append(removed, tr.IdWithObject{pCursor.Path, index, conn})
}
}
}
// ... and processing nodes
for _, n := range impl.Graph().ProcessingNodes() {
nCursor := tree.Cursor(n)
gCursor := tree.Parent(nCursor)
nIndex := gCursor.Position
removed = append(removed, tr.IdWithObject{nCursor.Path, nIndex, n})
}
}
case bh.PortTypeIf:
nt := obj.(bh.PortTypeIf)
for _, impl := range t.Implementation() {
if impl.ImplementationType() == bh.NodeTypeGraph {
// Remove and store all edges connected to the nodes linked to the outer ports
g := impl.Graph().(*signalGraphType)
var n bh.NodeIf
if nt.Direction() == gr.InPort {
n = g.findInputNodeFromPortType(nt)
} else {
n = g.findOutputNodeFromPortType(nt)
}
if n == nil {
log.Fatalf("nodeType.RemoveObject error: invalid implementation...\n")
}
nCursor := tree.CursorAt(parentId, n)
for _, p := range n.InPorts() {
pCursor := tree.CursorAt(nCursor, p)
for _, c := range p.Connections() {
conn := p.Connection(c)
removed = append(removed, tr.IdWithObject{pCursor.Path, -1, conn})
}
}
for _, p := range n.OutPorts() {
pCursor := tree.CursorAt(nCursor, p)
for _, c := range p.Connections() {
conn := p.Connection(c)
removed = append(removed, tr.IdWithObject{pCursor.Path, -1, conn})
}
}
// Remove (but dont store) the nodes linked to the outer ports:
tree.Remove(nCursor)
}
}
default:
log.Fatalf("nodeType.RemoveObject error: invalid type %T\n", obj)
}
return
}
func CreateXmlIONodePosHint(n bh.NodeIf, path string) (xmln *backend.XmlNodePosHint) {
if len(path) == 0 {
xmln = backend.XmlNodePosHintNew(n.Name())
} else {
xmln = backend.XmlNodePosHintNew(fmt.Sprintf("%s/%s", path, n.Name()))
}
empty := image.Point{}
for _, p := range n.PathList() {
for _, m := range gr.ValidModes {
xmlp := string(gr.CreatePathMode(p, m))
pos := n.PathModePosition(p, m)
if pos != empty {
xmln.Entry = append(xmln.Entry, *backend.XmlModeHintEntryNew(xmlp, pos.X, pos.Y))
}
}
}
for _, p := range n.InPorts() {
xmlp := backend.XmlPortPosHintNew(p.Name())
xmlp.Entry = freesp.CreateXmlModePosition(p).Entry
xmln.InPorts = append(xmln.InPorts, *xmlp)
}
for _, p := range n.OutPorts() {
xmlp := backend.XmlPortPosHintNew(p.Name())
xmlp.Entry = freesp.CreateXmlModePosition(p).Entry
xmln.OutPorts = append(xmln.OutPorts, *xmlp)
}
return
}