Beispiel #1
0
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
		}
	}
}
Beispiel #2
0
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
}
Beispiel #3
0
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))
}
Beispiel #4
0
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
}
Beispiel #5
0
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)
}
Beispiel #6
0
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)
			}
		}
	}
}
Beispiel #7
0
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
}
Beispiel #8
0
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
}
Beispiel #9
0
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
}
Beispiel #10
0
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
}
Beispiel #11
0
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
}