func parseSignalType(text, context string) (job *PasteJob, ok bool) {
var scopeMap = map[string]string{
"local": "Local",
"global": "Global",
"": "Global",
}
var modeMap = map[string]string{
"sync": "Isochronous",
"async": "Asynchronous",
"": "Asynchronous",
}
xmlst := backend.XmlSignalType{}
_, xmlerr := xmlst.Read([]byte(text))
if xmlerr != nil {
return
}
signalTypes := freesp.GetRegisteredSignalTypes()
for true {
valid := true
for _, reg := range signalTypes {
if reg == xmlst.Name {
valid = false
}
}
if valid {
break
}
xmlst.Name = createNextNameCandidate(xmlst.Name)
}
job = PasteJobNew()
job.context = context
stjob := NewElementJobNew(context, eSignalType)
stjob.input[iSignalTypeName] = xmlst.Name
stjob.input[iCType] = xmlst.Ctype
stjob.input[iChannelId] = xmlst.Msgid
stjob.input[iScope] = scopeMap[xmlst.Scope]
stjob.input[iSignalMode] = modeMap[xmlst.Mode]
job.newElements = append(job.newElements, stjob)
ok = true
return
}
func (dialog *EditDialog) setCurrentValues(context string) {
obj, err := dialog.fts.GetObjectById(context)
if err != nil {
log.Fatalf("editdialog.go: getActiveElementType error: failed to get context: %s\n", err)
}
var i int
var t string
switch obj.(type) {
case bh.NodeIf:
// TODO: check auto-generated types
if len(obj.(bh.NodeIf).InPorts()) > 0 {
if len(obj.(bh.NodeIf).OutPorts()) > 0 {
dialog.nodeNameEntry.SetText(obj.(bh.NodeIf).Name())
for i, t = range freesp.GetRegisteredNodeTypes() {
if obj.(bh.NodeIf).ItsType().TypeName() == t {
break
}
}
dialog.nodeTypeSelector.SetActive(i)
dialog.nodeTypeSelector.SetSensitive(false)
} else {
// assume one input port
dialog.outputNodeNameEntry.SetText(obj.(bh.NodeIf).Name())
for i, t = range freesp.GetRegisteredSignalTypes() {
if obj.(bh.NodeIf).InPorts()[0].SignalType().TypeName() == t {
break
}
}
dialog.outputTypeSelector.SetActive(i)
dialog.outputTypeSelector.SetSensitive(false)
}
} else {
// assume one output port
dialog.inputNodeNameEntry.SetText(obj.(bh.NodeIf).Name())
for i, t = range freesp.GetRegisteredSignalTypes() {
if obj.(bh.NodeIf).OutPorts()[0].SignalType().TypeName() == t {
break
}
}
dialog.inputTypeSelector.SetActive(i)
dialog.inputTypeSelector.SetSensitive(false)
}
case bh.NodeTypeIf:
dialog.typeNameEntry.SetText(obj.(bh.NodeTypeIf).TypeName())
case bh.PortTypeIf:
dialog.portNameEntry.SetText(obj.(bh.PortTypeIf).Name())
if obj.(bh.PortTypeIf).Direction() == gr.OutPort {
dialog.directionSelector.SetActive(1)
}
for i, t = range freesp.GetRegisteredSignalTypes() {
if obj.(bh.PortTypeIf).SignalType().TypeName() == t {
break
}
}
dialog.signalTypeSelector.SetActive(i)
dialog.directionSelector.SetSensitive(false)
case bh.SignalTypeIf:
st := obj.(bh.SignalTypeIf)
dialog.signalTypeNameEntry.SetText(st.TypeName())
dialog.cTypeEntry.SetText(st.CType())
dialog.channelIdEntry.SetText(st.ChannelId())
dialog.scopeSelector.SetActive(int(st.Scope()))
dialog.modeSelector.SetActive(int(st.Mode()))
case bh.ImplementationIf:
dialog.implNameEntry.SetText(obj.(bh.ImplementationIf).ElementName())
case pf.ArchIf:
dialog.archNameEntry.SetText(obj.(pf.ArchIf).Name())
case pf.ProcessIf:
dialog.processNameEntry.SetText(obj.(pf.ProcessIf).Name())
case pf.IOTypeIf:
dialog.ioTypeNameEntry.SetText(obj.(pf.IOTypeIf).Name())
for i, t = range ioModeStrings {
if string(obj.(pf.IOTypeIf).IOMode()) == t {
break
}
}
dialog.ioModeSelector.SetActive(i)
case pf.ChannelIf:
if obj.(pf.ChannelIf).Direction() == gr.OutPort {
dialog.channelDirectionSelector.SetActive(1)
}
dialog.channelDirectionSelector.SetSensitive(false)
for i, t = range freesp.GetRegisteredIOTypes() {
if obj.(pf.ChannelIf).IOType().Name() == t {
break
}
}
dialog.ioTypeSelector.SetActive(i)
pr := getOtherProcesses(dialog.fts, obj)
var p pf.ProcessIf
for i, p = range pr {
if obj.(pf.ChannelIf).Link().Process() == p {
break
}
}
dialog.processSelector.SetActive(i)
dialog.processSelector.SetSensitive(false)
case mp.MappedElementIf:
pr, _ := obj.(mp.MappedElementIf).Process()
i := 0
for _, a := range obj.(mp.MappedElementIf).Mapping().Platform().Arch() {
for _, p := range a.Processes() {
if pr == p {
dialog.processMapSelector.SetActive(i)
return
}
i++
}
}
dialog.processMapSelector.SetActive(i)
default:
log.Fatalf("editdialog.go: getActiveElementType error: invalid active object type %T\n", obj)
}
return
}
},
},
iNodeTypeSelect: {"Select node type:",
func(dialog *EditMenuDialog) string {
return dialog.nodeTypeSelector.GetActiveText()
},
func(dialog *EditMenuDialog) (obj *gtk.Widget, err error) {
return newComboBox(&dialog.nodeTypeSelector, freesp.GetRegisteredNodeTypes())
},
},
iSignalTypeSelect: {"Select signal type:",
func(dialog *EditMenuDialog) string {
return dialog.signalTypeSelector.GetActiveText()
},
func(dialog *EditMenuDialog) (obj *gtk.Widget, err error) {
return newComboBox(&dialog.signalTypeSelector, freesp.GetRegisteredSignalTypes())
},
},
iInputTypeSelect: {"Select signal type:",
func(dialog *EditMenuDialog) string {
return dialog.inputTypeSelector.GetActiveText()
},
func(dialog *EditMenuDialog) (obj *gtk.Widget, err error) {
return newComboBox(&dialog.inputTypeSelector, freesp.GetRegisteredSignalTypes())
},
},
iOutputTypeSelect: {"Select signal type:",
func(dialog *EditMenuDialog) string {
return dialog.outputTypeSelector.GetActiveText()
},
func(dialog *EditMenuDialog) (obj *gtk.Widget, err error) {
