def processField(self, fieldName, field, fldCat):
S = ""
itemName = '_' + fieldName + '_item'
if fldCat == 'func': return ''
typeSpec = field['typeSpec']
if progSpec.isAContainer(typeSpec):
if (progSpec.getDatastructID(typeSpec) == "list"):
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
itemName = '_' + fieldName + '_item'
calcdName = fieldName + '["+toString(' + itemName + '_key)+"]'
S += " withEach " + itemName + " in " + fieldName + "{\n"
S += " " + self.displayTextFieldAction(
calcdName, itemName, field, fldCatInner) + " }\n"
else:
cdlog(2, "Map not supported")
else:
S += self.displayTextFieldAction(fieldName, fieldName, field,
fldCat)
if progSpec.typeIsPointer(typeSpec):
T = " if(" + fieldName + ' == NULL){SRet_ <- SRet_ + ' + 'indent + dispFieldAsText("' + fieldName + '", 15)+"NULL\\n"}\n'
T += " else{\n " + S + " }\n"
S = T
self.textFuncBody += S
def writeNonTermParseRule(classes, tags, modelName, fields, SeqOrAlt, nameSuffix, logLvl):
global nextParseNameID
nameIn=modelName+nameSuffix
# Allocate or fetch a rule identifier for each '>' field.
partIndexes=[]
for field in fields:
fname=field['fieldName']
if fname==None: fname=''
else: fname='_'+fname
typeSpec =field['typeSpec']
if(field['isNext']==True): # means in the parse there was a '>' symbol, a sequence seperator
firstItm=progSpec.getFieldType(field['typeSpec'])[0]
if firstItm=='[' or firstItm=='{': # Handle an ALT or SEQ sub structure
cdlog(logLvl, "NonTERM: {} = {}".format(fname, firstItm))
nextParseNameID+=1
if firstItm=='[':
innerSeqOrAlt='parseALT'
newNameSuffix = nameSuffix+fname+'_ALT'+str(nextParseNameID)
else:
innerSeqOrAlt='parseSEQ'
newNameSuffix = nameSuffix+fname+'_SEQ'+str(nextParseNameID)
innerFields=field['innerDefs']
ruleIdxStr = writeNonTermParseRule(classes, tags, modelName, innerFields, innerSeqOrAlt, newNameSuffix, logLvl+1)
field['parseRule']=ruleIdxStr
if progSpec.isAContainer(typeSpec):
# anything with [] is a container: lists and optionals
global rules
containerSpec = progSpec.getContainerSpec(typeSpec)
idxType=''
if 'indexType' in containerSpec:
idxType=containerSpec['indexType']
if(isinstance(containerSpec['datastructID'], str)):
datastructID = containerSpec['datastructID']
else: # it's a parseResult
datastructID = containerSpec['datastructID'][0]
if idxType[0:4]=='uint': pass
if(datastructID=='list'):
ruleIdxStr=appendRule(ruleIdxStr+'_REP', "nonterm", "parseREP", [ruleIdxStr, 0, 0])
elif datastructID=='opt':
ruleIdxStr=appendRule(ruleIdxStr+'_OPT', "nonterm", "parseREP", [ruleIdxStr, 0, 1])
else:
ruleIdxStr = fetchOrWriteTerminalParseRule(modelName, field, logLvl)
partIndexes.append(ruleIdxStr)
else: pass; # These fields probably have corresponding cofactuals
nameOut=appendRule(nameIn, "nonterm", SeqOrAlt, partIndexes)
return nameOut
def xlateLangType(TypeSpec, owner, fieldType, varMode, actionOrField, xlator):
# varMode is 'var' or 'arg'.
if (isinstance(fieldType, basestring)):
if (fieldType == 'uint8' or fieldType == 'uint16'):
fieldType = 'uint32'
elif (fieldType == 'int8' or fieldType == 'int16'):
fieldType = 'int32'
langType = convertToJavaType(fieldType)
else:
langType = progSpec.flattenObjectName(fieldType[0])
langType = applyOwner(owner, langType, 'Itr-Error', 'ITR-ERROR',
actionOrField, varMode)
if langType == 'TYPE ERROR': print langType, owner, fieldType
InnerLangType = langType
if 'fieldType' in TypeSpec and not (isinstance(
TypeSpec['fieldType'],
basestring)) and TypeSpec['fieldType'][0] == 'DblLinkedList':
print "xlateLangType DblLinkedList"
return [langType, InnerLangType]
if progSpec.isAContainer(TypeSpec):
containerSpec = progSpec.getContainerSpec(TypeSpec)
if (containerSpec): # Make list, map, etc
[containerType, idxType,
owner] = getContainerType(TypeSpec, actionOrField)
if 'owner' in containerSpec:
containerOwner = containerSpec['owner']
else:
containerOwner = 'me'
if idxType == 'int': idxType = "Integer"
if langType == 'int':
langType = "Integer"
InnerLangType = "Integer"
if idxType == 'long': idxType = "Long"
if langType == 'long': langType = "Long"
if idxType == 'timeValue':
idxType = "Long" # this is hack and should be removed ASAP
if containerType == 'ArrayList':
langType = "ArrayList<" + langType + ">"
elif containerType == 'TreeMap':
langType = "TreeMap<" + idxType + ', ' + langType + ">"
elif containerType == 'multimap':
langType = "multimap<" + idxType + ', ' + langType + ">"
if varMode != 'alloc':
langType = applyOwner(containerOwner, langType, InnerLangType,
idxType, actionOrField, varMode)
if owner == "const":
InnerLangType = fieldType
return [langType, InnerLangType]
def getFieldSpec(fldCat, field):
parameters={}
if fldCat=='mode': fldCat='enum'
elif fldCat=='double': fldCat='float'
if fldCat=='enum':
parameters=field['typeSpec']['enumList']
elif fldCat=='RANGE':
parameters={1, 10}
typeSpec=field['typeSpec']
if progSpec.isAContainer(typeSpec):
innerFieldType=typeSpec['fieldType']
datastructID = progSpec.getDatastructID(typeSpec)
return [datastructID, innerFieldType]
else:
if fldCat=='struct':
fldCat='struct' #field['typeSpec']['fieldType'][0]
return [fldCat, parameters]
def processField(self, fieldName, field, fldCat):
S = ""
if fldCat == 'func': return ''
typeSpec = field['typeSpec']
if progSpec.isAContainer(typeSpec):
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
calcdName = fieldName + '["+toString(_item_key)+"]'
S += " withEach _item in " + fieldName + "{\n"
S += " " + self.toProteusTextFieldAction(
calcdName, '_item', field, fldCatInner) + " }\n"
else:
S += " " + self.toProteusTextFieldAction(
fieldName, fieldName, field, fldCat)
if progSpec.typeIsPointer(typeSpec):
T = " if(" + fieldName + ' == NULL){S <- S + ' + 'indent, dispFieldAsText("' + fieldName + '", 15)+"NULL\\n")}\n'
T += " else{\n " + S + " }\n"
S = T
self.textFuncBody += S
def codeListWidgetManagerClassOverride(classes, listManagerStructName, structTypeName):
funcTextToUpdateViewWidget = ''
funcTextToUpdateEditWidget = ''
funcTextToUpdateCrntFromWidget = ''
funcTextToPushCrntToListView = ''
rowHeaderCode = ''
rowViewCode = ''
# Find the model
modelRef = progSpec.findSpecOf(classes[0], structTypeName, 'model')
currentModelSpec = modelRef
if modelRef==None:
cdErr('To build a list GUI for list of "'+structTypeName+'" a model is needed but is not found.')
### Write code for each field
for field in modelRef['fields']:
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
fieldName = field['fieldName']
label = deCamelCase(fieldName)
CasedFieldName = fieldName[0].upper() + fieldName[1:]
widgetName = CasedFieldName + 'Widget'
if not progSpec.isAContainer(typeSpec):
if(fldCat!='struct'):
rowHeaderCode += ' their GUI_Frame: '+fieldName + '_header <- makeLabelWidget("'+fieldName+'")\n'
rowHeaderCode += ' setLabelWidth('+fieldName+'_header, 15)\n'
rowHeaderCode += ' addToContainer(headerBox, '+fieldName+'_header)\n'
if fldCat=='struct':
funcTextToUpdateViewWidget += ''
funcTextToUpdateEditWidget += ' /- updateWidgetFromVars()\n'
funcTextToUpdateCrntFromWidget += ' /- updateVarsFromWidget()\n'
elif fldCat=='enum' or fldCat=='mode':
funcTextToUpdateViewWidget += ''
funcTextToUpdateEditWidget += ''
funcTextToUpdateCrntFromWidget += ''# crntRecord.'+fieldName+' <- dialog.' + widgetName + '.getValue()\n'
elif fldCat=='bool':
funcTextToUpdateViewWidget += ''
funcTextToUpdateEditWidget += ''
funcTextToUpdateCrntFromWidget += ' crntRecord.'+fieldName+' <- dialog.' + widgetName + '.getValue()\n'
elif fldCat=='string':
funcTextToUpdateViewWidget += ''
funcTextToUpdateEditWidget += ' dialog.' + widgetName + '.setValue('+structTypeName+'_ListData[N].'+fieldName+')\n'
funcTextToUpdateCrntFromWidget += ' me string: '+widgetName+'Str <- string(dialog.' + widgetName + '.getValue())\n'
funcTextToUpdateCrntFromWidget += ' crntRecord.'+fieldName+' <- '+widgetName+'Str\n'
rowViewCode += ' their GUI_Frame: '+fieldName + '_value <- makeLabelWidget(crntRecord.'+fieldName+'.data())\n'
rowViewCode += ' setLabelWidth('+fieldName+'_value, 15)\n'
rowViewCode += ' addToContainer(rowBox, '+fieldName+'_value)\n'
rowViewCode += ' showWidget('+fieldName+'_value)\n'
elif fldCat=='int':
funcTextToUpdateViewWidget += ''
funcTextToUpdateEditWidget += ' dialog.' + widgetName + '.setValue('+structTypeName+'_ListData[N].'+fieldName+')\n'
#funcTextToUpdateCrntFromWidget += ' me string: '+widgetName+'Str <- string(dialog.' + widgetName + '.getValue())\n'
#funcTextToUpdateCrntFromWidget += ' crntRecord.'+fieldName+' <- dataStr\n'
rowViewCode += ' their GUI_Frame: '+fieldName + '_value <- makeLabelWidget(toString(crntRecord.'+fieldName+').data())\n'
rowViewCode += ' setLabelWidth('+fieldName+'_value, 15)\n'
rowViewCode += ' addToContainer(rowBox, '+fieldName+'_value)\n'
rowViewCode += ' showWidget('+fieldName+'_value)\n'
else: print"pattern_MakeGUI.codeListWidgetManagerClassOverride fldCat not specified: ", fldCat; exit(2)
###############
CODE = 'struct '+listManagerStructName+''': inherits=ListWidgetManager{
our <STRUCTNAME>: crntRecord
our <STRUCTNAME>[our list]: <STRUCTNAME>_ListData
me <STRUCTNAME>_Dialog_GUI: dialog
their GUI_Frame: listViewWidget
their GUI_Frame[their list]:rows
their GUI_Frame: crntRow
/- Override all these for each new list editing widget
their GUI_Frame: makeListHeader() <- {
their GUI_Frame: box <- makeFrameWidget()
their GUI_Frame: headerRow <- makeRowWidget("")
their GUI_Frame: headerBox <- makeXStackWidget("")
<ROWHEADERCODE>
addToContainer(headerRow, headerBox)
addToContainer(box, headerRow)
return(box)
}
their GUI_Frame: makeRowView(our <STRUCTNAME>: item) <- {
crntRecord <- item
their GUI_Frame: rowBox <- makeXStackWidget("")
<ROWVIEWCODE>
showWidget(rowBox)
return(rowBox)
}
their listWidget: makeListViewWidget() <- {
listViewWidget <- makeListWidget("")
setListWidgetSelectionMode (listViewWidget, SINGLE)
withEach item in <STRUCTNAME>_ListData {
their GUI_Frame: row <- makeRowView(item)
addToContainer(listViewWidget, row)
}
return(listViewWidget)
}
me int: pushCrntToList(me int: N) <- {
<STRUCTNAME>_ListData.pushLast(crntRecord);
me int: listLength <- getListLength()
print("listLength: ", listLength)
their GUI_Frame: row <- makeRowView(crntRecord)
rows.pushLast(row)
addToContainer(listViewWidget, row)
return(listLength)
}
void: deleteNthRow(me int: N) <- {
rows.deleteNth(N)
}
their GUI_Frame: getNthRow(me int: N) <-{
crntRow <- rows[N]
}
me int: deleteNthItem(me int: N) <- {
<STRUCTNAME>_ListData.deleteNth(N)
me int: retVal <- getListLength()
return(retVal)
}
void: updateViewableWidget() <- {<funcTextToUpdateViewWidget>}
their GUI_item: makeEditableWidget() <- {return(dialog.make<STRUCTNAME>Widget(crntRecord))}
void: updateEditableWidget(me int: N) <- {<funcTextToUpdateEditWidget>}
void: updateCrntFromEdited(me int: N) <- {<funcTextToUpdateCrntFromWidget>}
void: allocateNewCurrentItem() <- {Allocate(crntRecord)}
void: copyCrntBackToList(me int: N) <- {<STRUCTNAME>_ListData[N] <- crntRecord}
void: copyCrntBackToListView(me int: N) <- {
print("copyCrntBackToListView ", N)
}
void: setCurrentItem(me int: idx) <- {crntRecord <- <STRUCTNAME>_ListData[idx]}
void: setValue(our <STRUCTNAME>[our list]: ListData) <- {<STRUCTNAME>_ListData <- ListData}
me int: getListLength() <- {return(<STRUCTNAME>_ListData.size())}
their GUI_item: initWidget(our <STRUCTNAME>[our list]: Data) <- {
<STRUCTNAME>_ListData <- Data
Allocate(rows)
return(ListEdBox.init_dialog(self))
}
}
'''
CODE = CODE.replace('<STRUCTNAME>', structTypeName)
CODE = CODE.replace('<funcTextToUpdateViewWidget>', funcTextToUpdateViewWidget)
CODE = CODE.replace('<funcTextToUpdateEditWidget>', funcTextToUpdateEditWidget)
CODE = CODE.replace('<funcTextToUpdateCrntFromWidget>', funcTextToUpdateCrntFromWidget)
CODE = CODE.replace('<funcTextToPushCrntToListView>', funcTextToPushCrntToListView)
CODE = CODE.replace('<ROWHEADERCODE>', rowHeaderCode)
CODE = CODE.replace('<ROWVIEWCODE>', rowViewCode)
#print '==========================================================\n'+CODE
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, listManagerStructName)
def BuildGuiForStruct(classes, className, dialogStyle, newStructName):
# This makes 4 types of changes to the class:
# It adds a widget variable for items in model // newWidgetFields: ' their '+typeName+': '+widgetName
# It adds a set Widget from Vars function // widgetFromVarsCode: Func UpdateWidgetFromVars()
# It adds a set Vars from Widget function // varsFromWidgetCode: Func UpdateVarsFromWidget()
# It add an initialize Widgets function. // widgetInitFuncCode: widgetName+' <- '+makeTypeNameCall+'\n addToContainer(box, '+widgetName+')\n'
# dialogStyles: 'Z_stack', 'X_stack', 'Y_stack', 'TabbedStack', 'FlowStack', 'WizardStack', 'Dialog', 'SectionedDialogStack', 'V_viewable'
# also, handle non-modal dialogs
global classesEncoded
global currentClassName
global currentModelSpec
classesEncoded[className]=1
currentClassName = className
# reset the string vars that accumulate the code
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
newWidgetFields=''
widgetInitFuncCode=''
widgetFromVarsCode=''
varsFromWidgetCode=''
# Find the model
modelRef = progSpec.findSpecOf(classes[0], className, 'model')
currentModelSpec = modelRef
if modelRef==None: cdErr('To build a GUI for class "'+className+'" a model is needed but is not found.')
#TODO: write func body for: widgetFromVarsCode(selected item & click edit) & varsFromWidgetCode(ckick OK from editMode)
### Write code for each field
for field in modelRef['fields']:
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
fieldName = field['fieldName']
labelText = deCamelCase(fieldName)
if fieldName=='settings':
# add settings
continue
structTypeName=''
if fldCat=='struct': # Add a new class to be processed
structTypeName =typeSpec['fieldType'][0]
if (progSpec.doesClassDirectlyImlementThisField(classes, structTypeName, structTypeName+':managedWidget')
or structTypeName.endswith('Widget')):
fldCat = 'widget'
else:
newGUIStyle = 'Dialog'
guiStructName = structTypeName+'_'+newGUIStyle+'_GUI'
addNewStructToProcess(guiStructName, structTypeName, 'struct', 'Dialog')
if fldCat != 'widget' and progSpec.isAContainer(typeSpec):# Add a new list to be processed
structTypeName = typeSpec['fieldType'][0]
guiStructName = structTypeName+'_LIST_View'
addNewStructToProcess(guiStructName, structTypeName, 'list', 'Dialog')
#TODO: make actions for each function
if fldCat=='func':
if fieldName[-4:]== '_btn':
buttonLabel = deCamelCase(fieldName[:-4])
# Add a button whose click calls this.
print "ADDING BUTTON FOR:", fieldName
getButtonHandlingCode(classes, buttonLabel, fieldName)
else: # Here is the main case where code to edit this field is written
getWidgetHandlingCode(classes, fldCat, fieldName, field, structTypeName, dialogStyle, '')
# Parse everything
initFuncName = 'make'+className[0].upper() + className[1:]+'Widget'
if dialogStyle == 'Z_stack': containerWidget='makeStoryBoardWidget("makeStoryBoardWidget")'
elif dialogStyle == 'TabbedStack': containerWidget='makeTabbedWidget("makeTabbedWidget")'
else: containerWidget='makeFrameWidget()'
CODE = '''
struct <CLASSNAME> {}
struct <NEWSTRUCTNAME> {
<NEWWIDGETFIELDS>
our <CLASSNAME>: <CLASSNAME>_data
their GUI_Frame: <INITFUNCNAME>(our <CLASSNAME>: Data) <- {
<CLASSNAME>_data<-Data
their GUI_Frame:box <- <CONTAINERWIDGET>
<WIDGETINITFUNCCODE>
return(box)
}
void: setValue(our <CLASSNAME>: var) <- {
<WIDGETFROMVARSCODE>
}
void: getValue() <- {
<VARSFROMWIDGETCODE>
}
}\n''' # TODO: add <VARSFROMWIDGETCODE>
CODE = CODE.replace('<NEWSTRUCTNAME>', newStructName)
CODE = CODE.replace('<NEWWIDGETFIELDS>', newWidgetFields)
CODE = CODE.replace('<CLASSNAME>', className)
CODE = CODE.replace('<WIDGETINITFUNCCODE>', widgetInitFuncCode)
CODE = CODE.replace('<INITFUNCNAME>', initFuncName)
CODE = CODE.replace('<WIDGETFROMVARSCODE>', widgetFromVarsCode)
CODE = CODE.replace('<VARSFROMWIDGETCODE>', varsFromWidgetCode)
CODE = CODE.replace('<CONTAINERWIDGET>', containerWidget)
if newStructName == "EntryPad_Dialog_GUI":print '==========================================================\n'+CODE
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, newStructName)
def BuildGuiForList(classes, className, dialogStyle, newStructName):
# This makes 4 types of changes to the class:
# It adds a widget variable for items in model // newWidgetFields: ' their '+typeName+': '+widgetName
# It adds a set Widget from Vars function // widgetFromVarsCode: Func UpdateWidgetFromVars()
# It adds a set Vars from Widget function // varsFromWidgetCode: Func UpdateVarsFromWidget()
# It add an initialize Widgets function. // widgetInitFuncCode: widgetName+' <- '+makeTypeNameCall+'\n addToContainer(box, '+widgetName+')\n'
# dialogStyles: 'Z_stack', 'X_stack', 'Y_stack', 'TabbedStack', 'FlowStack', 'WizardStack', 'Dialog', 'SectionedDialogStack'
# also, handle non-modal dialogs
global classesEncoded
global currentClassName
global currentModelSpec
classesEncoded[className]=1
currentClassName = className
# reset the string vars that accumulate the code
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
newWidgetFields=''
widgetInitFuncCode=''
widgetFromVarsCode=''
varsFromWidgetCode=''
# Find the model
modelRef = progSpec.findSpecOf(classes[0], className, 'model')
if modelRef==None: cdErr('To build a GUI for a list of "'+className+'" a model is needed but is not found.')
currentModelSpec = modelRef
rowHeaderCode = ''
rowViewCode = ''
for field in modelRef['fields']:
fieldName = field['fieldName']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
fieldType = progSpec.fieldTypeKeyword(field['typeSpec']['fieldType'])
[fieldSpec, params] = getFieldSpec(fldCat, field)
structTypeName =''
if fldCat=='struct': # Add a new class to be processed
structTypeName =typeSpec['fieldType'][0]
newGUIStyle = 'Dialog'
guiStructName = structTypeName+'_'+newGUIStyle+'_GUI'
addNewStructToProcess(guiStructName, structTypeName, 'struct', 'Dialog')
if progSpec.isAContainer(typeSpec):# Add a new list to be processed
structTypeName = typeSpec['fieldType'][0]
guiStructName = structTypeName+'_LIST_View'
addNewStructToProcess(guiStructName, structTypeName, 'list', 'Dialog')
CODE = '''struct <NEWSTRUCTNAME>{
our <CLASSNAME>[our list]: <CLASSNAME>_ListData
our <CLASSNAME>: crntRecord
}
'''
CODE = CODE.replace('<NEWSTRUCTNAME>', newStructName)
CODE = CODE.replace('<CLASSNAME>', className)
CODE = CODE.replace('<NEWWIDGETFIELDS>', newWidgetFields)
CODE = CODE.replace('<WIDGETFROMVARSCODE>', widgetFromVarsCode)
CODE = CODE.replace('<VARSFROMWIDGETCODE>', varsFromWidgetCode)
#print '==========================================================\n'+CODE
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, newStructName)
def getWidgetHandlingCode(classes, fldCat, fieldName, field, structTypeName, dialogStyle, indent):
# _Dialog_GUI is editable widget
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
label = deCamelCase(fieldName)
[fieldSpec, params] = getFieldSpec(fldCat, field)
typeName = fieldSpec+'Widget'
CasedFieldName = fieldName[0].upper() + fieldName[1:]
widgetName = CasedFieldName + 'Widget'
fieldType = field['typeSpec']['fieldType'][0]
typeSpec = field['typeSpec']
widgetBoxName = widgetName
localWidgetVarName = widgetName
if fieldType=='timeValue':
typeName = 'dateWidget'
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeDateWidget("'+label+'")\n'
widgetFromVarsCode += " " + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += " "+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='widget':
typeName = CasedFieldName +'Widget'
widgetName = fieldName +'Widget'
widgetBoxName = fieldName
localWidgetVarName = fieldName
newWidgetFields += ' their GUI_item' + ': ' + fieldName + '\n'
makeTypeNameCall = widgetName+" <- Data." + fieldName + "\n" + fieldName + '<- '+widgetName+".init()\n"
elif fieldSpec=='struct':
typeName = 'GUI_Frame'
guiStructName = structTypeName + '_Dialog_GUI'
guiMgrName = fieldType + '_GUI_Mgr'
if progSpec.typeIsPointer(typeSpec): widgetInitFuncCode += ' Allocate('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' Allocate('+guiMgrName+')\n'
makeTypeNameCall = widgetName+' <- '+guiMgrName+'.make'+structTypeName+'Widget('+currentClassName+'_data.'+fieldName+')\n'
newWidgetFields += ' our ' + guiStructName + ': '+ guiMgrName+'\n'
widgetFromVarsCode += ' ' + guiMgrName+ '.setValue(var.'+fieldName+')\n'
varsFromWidgetCode += ' ' + guiMgrName + '.getValue()\n'
elif fieldSpec=='enum':
typeName = 'enumWidget'
EnumItems=[]
for enumItem in params: EnumItems.append('"'+deCamelCase(enumItem)+'"')
optionString = '[' + ', '.join(EnumItems) + ']'
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName+' <- '+ widgetName+'.makeEnumWidget("'+label+'", '+optionString+')\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' '+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='string':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeStringWidget("'+label+'")\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' +currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='int':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeIntWidget("'+label+'")\n'
widgetFromVarsCode += " " + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += " "+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='bool':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeBoolWidget("'+label+'")\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='list' or fieldSpec=='map': pass
else: print"pattern_MakeGUI.getWidgetHandlingCode fieldSpec not specified: ", fieldSpec; exit(2)
# If this is a list or map, populate it
if progSpec.isAContainer(typeSpec):
makeTypeNameCall = widgetName+' <- make'+typeName[0].upper() + typeName[1:]+'("'+label+'")\n'
innerFieldType = typeSpec['fieldType']
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
# If it hasn't already been added, make a struct <ItemType>_ListWidgetManager:ListWidgetManager{}
listManagerStructName = structTypeName+'_ListWidgetManager'
codeListWidgetManagerClassOverride(classes, listManagerStructName, structTypeName)
listWidMgrName = widgetName+'_LEWM'
newWidgetFields += ' me '+listManagerStructName+': '+listWidMgrName+'\n'
widgetListEditorName = widgetName+'_Editor'
localWidgetVarName = widgetListEditorName
if progSpec.typeIsPointer(typeSpec): widgetInitFuncCode += ' Allocate('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' their GUI_item: '+widgetListEditorName+' <- '+listWidMgrName+'.initWidget('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' addToContainer(box, '+widgetListEditorName+')\n'
widgetFromVarsCode += " " + listWidMgrName + '.setValue(var.'+ fieldName +')\n'
# varsFromWidgetCode += " " + listWidMgrName + ' <- ' + widgetName + '.getValue()\n'
else: # Not an ArraySpec:
newWidgetFields += ' our '+typeName+': '+widgetName+'\n'
widgetInitFuncCode += ' '+makeTypeNameCall
widgetInitFuncCode += ' addToContainer(box, '+widgetBoxName+')\n'
if dialogStyle == 'TabbedStack':
widgetInitFuncCode+=' '+'gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(box), '+ localWidgetVarName+', "'+label+'")\n'
def getDashDeclAndUpdateCode(self, owner, fieldLabel, fieldRef, fieldName,
field, skipFlags, indent):
global classesToProcess
global classesEncoded
itemName = '_' + fieldName + '_item'
dashKeyName = '_' + fieldName + '_dash_key'
OldElementsName = '_' + fieldName + 'OldElements'
[
structText, updateFuncText, setPosFuncText, drawFuncText,
handleClicksFuncText
] = ['', '', '', '', '']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
if fldCat == 'func': return ['', '', '', '', '']
if progSpec.typeIsPointer(
typeSpec) and skipFlags != 'skipPtr': # Header for a POINTER
fieldName += 'Ptr'
if fieldRef == 'data.itmItr':
innerUpdateFuncStr = '"ItmItr"' # TODO: unhard code this reference to itmItr
else:
innerUpdateFuncStr = fieldRef + '.mySymbol(' + fieldRef + ')'
updateFuncText += ' ' + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '))\n'
structText += " " + owner + " ptrToItem: " + fieldName + "\n"
elif progSpec.isAContainer(
typeSpec
) and skipFlags != 'skipLists': # Header and items for LIST
dispStructTypeName = "display_" + progSpec.getFieldType(
field['typeSpec'])[0]
innerUpdateFuncStr = '"Size:"+toString(data.' + fieldName + '.size())'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += ' ' + 'our dash[our list]: ' + OldElementsName + ' <- ' + fieldName + '.elements\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '), true)\n'
## Now push each item
innerFieldType = progSpec.getFieldType(typeSpec)
containerTypeSpec = progSpec.getContainerSpec(typeSpec)
if len(containerTypeSpec) > 3 and (
containerTypeSpec[1] == 'map' or containerTypeSpec[1]
== 'multimap') and containerTypeSpec[2][0] == 'string':
itemKeyCode = itemName + '_key'
else:
itemKeyCode = 'toString(' + itemName + '_key)'
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
if fieldRef == 'data.itmItr' or fieldRef == 'data.items':
newFieldRef = itemName + '' # TODO: unhard code this reference to itmItr
else:
newFieldRef = 'data.' + fieldName + '[' + itemName + '_key]'
newFieldLabel = '"["+' + itemKeyCode + '+"] "+ ' + itemName + '.mySymbol(' + itemName + ')'
updateFuncText += '\n ' + 'me int64: ' + dashKeyName + ' <- 0'
updateFuncText += "\n withEach " + itemName + " in data." + fieldName + "{\n"
[
innerStructText, innerUpdateFuncText, innerDrawFuncText,
innerSetPosFuncText, innerHandleClicksFuncText
] = self.getDashDeclAndUpdateCode('our', newFieldLabel,
newFieldRef, 'newItem', field,
'skipLists', ' ')
updateFuncText += ' ' + innerStructText
updateFuncText += ' me bool: _elementExists <- false\n'
updateFuncText += ' ' + 'if(' + OldElementsName + '!=NULL){\n'
updateFuncText += ' ' + 'withEach _ElItem in ' + OldElementsName + '{\n'
updateFuncText += ' ' + 'if(asClass(' + dispStructTypeName + ', _ElItem).data === ' + itemName + '){\n'
updateFuncText += ' ' + '_elementExists <- true; break();\n'
updateFuncText += ' ' + '}}}\n'
updateFuncText += ' ' + 'if(!_elementExists){\n'
updateFuncText += ' Allocate(newItem)\n'
updateFuncText += ' newItem.dashParent <- self\n'
updateFuncText += ' ' + 'addDependent(' + itemName + '.mySymbol(' + itemName + '), newItem)'
updateFuncText += '\n } else {\n newItem <- asClass(' + dispStructTypeName + ', ' + OldElementsName + '[' + dashKeyName + '])\n ' + dashKeyName + ' <- ' + dashKeyName + ' + 1'
updateFuncText += '\n }'
updateFuncText += '\n ' + innerUpdateFuncText
updateFuncText += ' ' + fieldName + '.updatePush(newItem)'
updateFuncText += '\n }\n'
structText += ' ' + owner + ' listOfItems: ' + fieldName + '\n'
elif (fldCat == 'struct'): # Header for a STRUCT
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ">", ' + fieldRef + ')\n'
structTypeName = progSpec.getNewContainerFirstElementTypeTempFunc(
typeSpec)
if structTypeName == None:
structTypeName = progSpec.getFieldType(typeSpec)[0]
structText += " " + owner + " display_" + structTypeName + ': ' + fieldName + "\n"
# Add new classname to a list so it can be encoded.
if not (structTypeName in classesToProcess):
classesToProcess.append(structTypeName)
else: # Display field for a BASIC TYPES
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(data.' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = '"\'"+' + 'data.' + fieldName + '+"\'"'
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'toString((data.' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = fieldRef + 'Strings[data.' + fieldName + '] '
updateFuncText = " " + fieldName + '.update(100, 180, ' + fieldLabel + ', ' + valStr + ', isNull(' + valStr + '))\n'
structText += " " + owner + " dataField: " + fieldName + "\n"
drawFuncText = " " + fieldName + '.draw(cr)\n'
setPosFuncText += ''' if(!<fieldName>.isNullLike or displayMode==fullDisplay){
<fieldName>.setPos(x,y,extC)
extC <- <fieldName>.extC
y <- y + <fieldName>.height
extX <- max(extX, <fieldName>.extX)
extY <- max(extY, <fieldName>.extY)
width<- max(width, <fieldName>.width)
<fieldName>.isHidden<-false
} else {<fieldName>.isHidden<-true}
'''.replace('<fieldName>', fieldName)
# updateFuncText+=' if(crntWidth<'+fieldName+'.width){crntWidth <- '+fieldName+'.width}'
handleClicksFuncText = ' ' + fieldName + '.primaryClick(event)'
return [
structText, updateFuncText, drawFuncText, setPosFuncText,
handleClicksFuncText
]
def BuildGuiForStruct(classes, className, dialogStyle, newStructName):
# This makes 4 types of changes to the class:
# It adds a widget variable for items in model // newWidgetFields: ' their '+typeName+': '+widgetName
# It adds a set Widget from Vars function // widgetFromVarsCode: Func setValue()
# It adds a set Vars from Widget function // varsFromWidgetCode: Func getValue()
# It add an initialize Widgets function. // widgetInitFuncCode: widgetName+' <- '+makeTypeNameCall+'\n addToContainer(box, '+widgetName+')\n'
# dialogStyles: 'Z_stack', 'X_stack', 'Y_stack', 'TabbedStack', 'FlowStack', 'WizardStack', 'Dialog', 'SectionedDialogStack', 'V_viewable'
# also, handle non-modal dialogs
global classesEncoded
global currentClassName
global currentModelSpec
classesEncoded[className] = 1
currentClassName = className
# reset the string vars that accumulate the code
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
global clearWidgetCode
newWidgetFields = ''
widgetInitFuncCode = ''
widgetFromVarsCode = ''
varsFromWidgetCode = ''
clearWidgetCode = ''
containerWidget = ''
boxFooterCode = ''
scrollerCode = ''
onLoadedCode = ''
tagCode = ''
makeBoxFooter = False
makeBackBtn = False
makeNextBtn = False
makeVScroller = False
# Find the model
modelRef = findModelRef(classes[0], className)
currentModelSpec = modelRef
classPrimaryGuiItem = progSpec.searchATagStore(modelRef['tags'],
'primaryGuiItem')
if classPrimaryGuiItem != None: # This GUI Item is important visually
classPrimaryGuiItem = classPrimaryGuiItem[0]
classOptionsTags = progSpec.searchATagStore(modelRef['tags'],
'classOptions')
guiStyleTag = progSpec.searchATagStore(modelRef['tags'], 'dialogStyle')
if guiStyleTag != None: # This GUI Item is important visually
guiStyleTag = guiStyleTag[0]
if guiStyleTag == 'WizardStack': dialogStyle = 'WizardStack'
if guiStyleTag == 'Z_stack': dialogStyle = 'Z_stack'
if guiStyleTag == 'WizardChild':
dialogStyle = 'WizardChild'
makeBoxFooter = True
makeBackBtn = True
makeNextBtn = True
clickNextLabel = "Next"
if guiStyleTag == 'WizardChildLast':
dialogStyle = 'WizardChild'
makeBoxFooter = True
makeBackBtn = True
makeNextBtn = True
clickNextLabel = "Done"
if guiStyleTag == 'WizardChildFirst':
dialogStyle = 'WizardChild'
makeBoxFooter = True
makeNextBtn = True
clickNextLabel = "Next"
classProperties = progSpec.searchATagStore(modelRef['tags'], 'properties')
if classProperties != None:
for classProperty in classProperties:
if classProperty[0] == 'vScroller': makeVScroller = True
### Write code for each field
for field in modelRef['fields']:
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
fieldName = field['fieldName']
labelText = deCamelCase(fieldName)
fieldType = typeSpec['fieldType']
if fieldName == 'settings':
# add settings
continue
structTypeName = ''
if fldCat == 'struct': # Add a new class to be processed
structTypeName = typeSpec['fieldType'][0]
if (progSpec.doesClassDirectlyImlementThisField(
classes, structTypeName, structTypeName + ':managedWidget')
or structTypeName.endswith('Widget')):
fldCat = 'widget'
else:
newGUIStyle = 'Dialog'
guiStructName = structTypeName + '_' + newGUIStyle + '_GUI'
addNewStructToProcess(guiStructName, structTypeName, 'struct',
'Dialog')
if fldCat != 'widget' and progSpec.isAContainer(
typeSpec): # Add a new list to be processed
if not isinstance(fieldType, str): fieldType = fieldType[0]
structTypeName = fieldType
guiStructName = structTypeName + '_ROW_View'
addNewStructToProcess(guiStructName, structTypeName, 'list',
'Dialog')
#TODO: make actions for each function
if fldCat == 'func':
if fieldName[-4:] == '_btn':
buttonLabel = deCamelCase(fieldName[:-4])
# Add a button whose click calls this.
print('ADDING BUTTON FOR:', fieldName)
getButtonHandlingCode(classes, buttonLabel, fieldName)
else: # Here is the main case where code to edit this field is written
getWidgetHandlingCode(classes, fldCat, fieldName, field,
structTypeName, dialogStyle,
classPrimaryGuiItem, classOptionsTags, '')
onLoadedCode = 'onLoaded()\n'
returnCode = ' return(box)'
if dialogStyle == 'Z_stack':
newWidgetFields += ' their GUI_ZStack: Zbox\n'
newWidgetFields += ' me List<me string>: children\n'
newWidgetFields += ' me int: activeScreenIdx <-1\n'
newWidgetFields += ' void: setActiveChild(me int: N) <- {\n'
newWidgetFields += ' if (N >= 0 and N < children.size()){'
newWidgetFields += ' me string: childName <- children[N]\n'
#newWidgetFields += ' print("^^^setZStackActive: ",N)\n'
newWidgetFields += ' setZStackActive(Zbox, childName)\n'
newWidgetFields += ' activeScreenIdx <- N\n'
newWidgetFields += ' }\n'
newWidgetFields += ' }\n'
containerWidget = 'Zbox <- makeZStack("' + className + '")\n'
onLoadedCode = 'setActiveChild(0)\n'
onLoadedCode += ' onLoaded()\n'
returnCode = ' return(Zbox)\n'
elif dialogStyle == 'TabbedStack':
containerWidget = 'their GUI_Frame:box <- makeTabbedWidget("makeTabbedWidget")'
elif dialogStyle == 'WizardStack':
newWidgetFields += ' our wizardWidget: wiz\n'
newWidgetFields += ' their GUI_Frame: box\n'
newWidgetFields += ''' void: clickNext() <-{
me int: size <- wiz.children.size()
if (wiz.activeScreenIdx == size-1){
_data.wizardFinished(wiz.widgetID)
}
else if (wiz.activeScreenIdx < size-1){
wiz.activeScreenIdx <- wiz.activeScreenIdx+1
wiz.setActiveChild(wiz.activeScreenIdx)
}
}\n'''
newWidgetFields += ''' void: clickBack() <-{
me int: size <- wiz.children.size()
if (wiz.activeScreenIdx > 0){wiz.activeScreenIdx <- wiz.activeScreenIdx-1}
wiz.setActiveChild(wiz.activeScreenIdx)
}\n'''
containerWidget = 'Allocate(wiz)\n'
containerWidget += ' box <- wiz.initWidget("' + currentClassName + '")\n'
containerWidget += ' wiz._data <- _data\n'
containerWidget += ' wiz.parentGuiMgr <- self\n'
widgetInitFuncCode += ' wiz.activeScreenIdx <- 0\n'
widgetInitFuncCode += ' wiz.setActiveChild(wiz.activeScreenIdx)\n'
elif dialogStyle == 'X_stack':
newWidgetFields += ' their GUI_XStack:box\n'
containerWidget = 'box <- makeXStack("")'
elif dialogStyle == 'rowWidget':
newWidgetFields += ' their GUI_XStack: box\n'
containerWidget = 'box <- makeXStack("")'
else:
newWidgetFields += ' their GUI_Frame:box\n'
containerWidget = 'box <- makeYStack("")'
if makeBoxFooter:
newWidgetFields += ' their GUI_Frame: boxFooter\n'
boxFooterCode += 'boxFooter <- makeXStack("")\n'
if makeBackBtn:
newWidgetFields += ' their GUI_button: backBtn\n'
newWidgetFields += ' void: clickBack() <-{parentGuiMgr.clickBack()}\n'
boxFooterCode += ' backBtn <- makeButtonWidget("Back")\n'
boxFooterCode += ' GUI.setBtnCallback(backBtn, "clicked", clickBack, this)\n'
boxFooterCode += ' addToContainer(boxFooter, backBtn)\n'
tagCode += ''
if makeNextBtn:
newWidgetFields += ' their GUI_button: nextBtn\n'
newWidgetFields += ''' void: clickNext() <-{
if(isComplete()){
save()
parentGuiMgr.clickNext()
}
}\n'''
newWidgetFields += ''' void: setNextBtnActive(me bool: checkState) <-{
nextBtn.setWidgetActive(checkState)
}\n'''
newWidgetFields += ''' void: onChanged() <- {
getValue()
setNextBtnActive(isComplete())
}\n'''
boxFooterCode += ' nextBtn <- makeButtonWidget("' + clickNextLabel + '")\n'
boxFooterCode += ' nextBtn.setWidgetActive(false)\n'
boxFooterCode += ' GUI.setBtnCallback(nextBtn, "clicked", clickNext, this)\n'
boxFooterCode += ' addToContainer(boxFooter, nextBtn)\n'
tagCode += ''
boxFooterCode += ' addToContainer(box, boxFooter)\n'
if makeVScroller:
scrollerCode = 'their GUI_VerticalScroller: scroller <- makeVerticalScroller()\n'
scrollerCode += 'addToContainerAndExpand(scroller, box)\n'
returnCode = 'return (scroller)'
CODE = '''
struct <CLASSNAME>:inherits=appComponentData{}
struct <NEWSTRUCTNAME>:inherits=appComponentGUI '''+tagCode+'''{
'''+newWidgetFields+'''
our <CLASSNAME>: _data
their GUI_Frame: initWidget(our <CLASSNAME>: Data) <- {
_data <- Data
_data.guiMgr <- self
'''+containerWidget+'''
'''+widgetInitFuncCode+'''
'''+boxFooterCode+'''
'''+scrollerCode+'''
'''+onLoadedCode+'''
'''+returnCode+'''
}
void: setValue(our <CLASSNAME>: var) <- {
'''+widgetFromVarsCode+'''
}
void: getValue() <- {
'''+varsFromWidgetCode+'''
}
void: clear() <- {
'''+clearWidgetCode+'''
}
}\n''' # TODO: add <VARSFROMWIDGETCODE>
CODE = CODE.replace('<NEWSTRUCTNAME>', newStructName)
CODE = CODE.replace('<CLASSNAME>', className)
#print ('==========================================================\n'+CODE)
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE,
newStructName)
def buildListRowView(classes, className, dialogStyle, newStructName):
# This makes 4 types of changes to the class:
# It adds a widget variable for items in model // newWidgetFields: ' their '+typeName+': '+widgetName
# It adds a set Widget from Vars function // widgetFromVarsCode: Func UpdateWidgetFromVars()
# It adds a set Vars from Widget function // varsFromWidgetCode: Func UpdateVarsFromWidget()
# It add an initialize Widgets function. // widgetInitFuncCode: widgetName+' <- '+makeTypeNameCall+'\n addToContainer(box, '+widgetName+')\n'
# dialogStyles: 'Z_stack', 'X_stack', 'Y_stack', 'TabbedStack', 'FlowStack', 'WizardStack', 'Dialog', 'SectionedDialogStack'
# also, handle non-modal dialogs
global classesEncoded
global currentClassName
global currentModelSpec
classesEncoded[className] = 1
currentClassName = className
# reset the string vars that accumulate the code
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
global clearWidgetCode
newWidgetFields = ''
widgetInitFuncCode = ''
widgetFromVarsCode = ''
varsFromWidgetCode = ''
clearWidgetCode = ''
funcTextToUpdateViewWidget = ''
funcTextToUpdateEditWidget = ''
funcTextToUpdateCrntFromWidget = ''
# Find the model
modelRef = findModelRef(classes[0], className)
currentModelSpec = modelRef
rowHeaderCode = ''
rowViewCode = ''
for field in modelRef['fields']:
fieldName = field['fieldName']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
fieldType = progSpec.fieldTypeKeyword(field['typeSpec']['fieldType'])
[fieldSpec, params] = getFieldSpec(fldCat, field)
structTypeName = ''
if fldCat == 'struct': # Add a new class to be processed
structTypeName = typeSpec['fieldType'][0]
newGUIStyle = 'Dialog'
guiStructName = structTypeName + '_' + newGUIStyle + '_GUI'
addNewStructToProcess(guiStructName, structTypeName, 'struct',
'Dialog')
if progSpec.isAContainer(typeSpec): # Add a new list to be processed
structTypeName = typeSpec['fieldType'][0]
guiStructName = structTypeName + '_ROW_View'
addNewStructToProcess(guiStructName, structTypeName, 'list',
'Dialog')
else:
print("field::", fieldName, fldCat)
if (fldCat != 'struct'):
rowHeaderCode += ' their GUI_Label: ' + fieldName + '_header <- makeLabelWidget("' + fieldName + '")\n'
rowHeaderCode += ' setLabelWidth(' + fieldName + '_header, 15)\n'
rowHeaderCode += ' addToContainer(headerBox, ' + fieldName + '_header)\n'
if fldCat == 'struct':
funcTextToUpdateViewWidget += ''
elif fldCat == 'enum' or fldCat == 'mode':
funcTextToUpdateViewWidget += ''
#funcTextToUpdateEditWidget += ''
funcTextToUpdateCrntFromWidget += '' # crntRecord.'+fieldName+' <- dialog.' + widgetName + '.getValue()\n'
elif fldCat == 'bool':
funcTextToUpdateViewWidget += ''
elif fldCat == 'string':
#funcTextToUpdateViewWidget += ''
#funcTextToUpdateEditWidget += ' dialog.' + widgetName + '.setValue('+structTypeName+'_ListData[N].'+fieldName+')\n'
#funcTextToUpdateCrntFromWidget += ' me string: '+widgetName+'Str <- dialog.' + widgetName + '.getValue()\n'
#funcTextToUpdateCrntFromWidget += ' crntRecord.'+fieldName+' <- '+widgetName+'Str\n'
rowViewCode += ' their GUI_Label: ' + fieldName + '_value <- makeLabelWidget2(Data.' + fieldName + ')\n'
rowViewCode += ' setLabelWidth(' + fieldName + '_value, 15)\n'
rowViewCode += ' addToContainer(box, ' + fieldName + '_value)\n'
rowViewCode += ' showWidget(' + fieldName + '_value)\n'
elif fldCat == 'int':
funcTextToUpdateViewWidget += ''
#funcTextToUpdateEditWidget += ' dialog.' + widgetName + '.setValue('+structTypeName+'_ListData[N].'+fieldName+')\n'
#funcTextToUpdateCrntFromWidget += ' me string: '+widgetName+'Str <- string(dialog.' + widgetName + '.getValue())\n'
#funcTextToUpdateCrntFromWidget += ' crntRecord.'+fieldName+' <- dataStr\n'
rowViewCode += ' their GUI_Label: ' + fieldName + '_value <- makeLabelWidget2(toString(Data.' + fieldName + '))\n'
rowViewCode += ' setLabelWidth(' + fieldName + '_value, 15)\n'
rowViewCode += ' addToContainer(box, ' + fieldName + '_value)\n'
rowViewCode += ' showWidget(' + fieldName + '_value)\n'
else:
print(
'pattern_MakeGUI.codeListWidgetManagerClassOverride fldCat not specified: ',
fldCat)
exit(2)
CODE = '''struct ''' + newStructName + '''{
their GUI_Frame: box
their GUI_Frame: makeHeaderView() <- {
their GUI_Frame: headerBox <- makeXStack("")
''' + rowHeaderCode + '''
showWidget(headerBox)
return(headerBox)
}
their GUI_Frame: initWidget(their ''' + className + ''': Data) <- {
box <- makeXStack("")
''' + rowViewCode + '''
showWidget(box)
return(box)
}
}
'''
#print ('==========================================================\n'+CODE)
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE,
newStructName)
def getWidgetHandlingCode(classes, fldCat, fieldName, field, structTypeName,
dialogStyle, classPrimaryGuiItem, classOptionsTags,
indent):
# _Dialog_GUI is editable widget
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
global clearWidgetCode
label = deCamelCase(fieldName)
[fieldSpec, params] = getFieldSpec(fldCat, field)
typeName = fieldSpec + 'Widget'
CasedFieldName = fieldName[0].upper() + fieldName[1:]
widgetName = CasedFieldName + 'Widget'
typeSpec = field['typeSpec']
innerFieldType = typeSpec['fieldType']
fieldType = innerFieldType[0]
widgetBoxName = widgetName
localWidgetVarName = widgetName
makeTypeNameCall = ''
if fieldType == 'timeValue':
typeName = 'dateWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ');\n' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'Agreement':
typeName = 'AgreeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + fieldName + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ''
elif fieldType == 'DateValue':
typeName = 'DateWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'timeOfDay':
typeName = 'TimeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'DateTime':
typeName = 'DateTimeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'FoodData':
typeName = 'FoodDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
#varsFromWidgetCode += ' '+widgetName+'.getValue()\n'
elif fieldType == 'MedItemData':
typeName = 'MedItemDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
#varsFromWidgetCode += ' '+widgetName+'.getValue()\n'
elif fieldType == 'MedData':
typeName = 'MedBunchDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += 'Allocate(_data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'matterTerm':
typeName = 'MatterTermWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'widget':
typeName = fieldType
localWidgetVarName = fieldName
if fieldType == 'graphWidget':
widgetName = fieldName + 'Widget'
widgetBoxName = fieldName
newWidgetFields += ' their GUI_item' + ': ' + fieldName + '\n'
makeTypeNameCall = widgetName + ' <- Data.' + fieldName + '\n' + fieldName + '<- ' + widgetName + '.init("' + label + '")\n'
else:
widgetBoxName = widgetName + '.box'
dataType = changeDataFieldType(classes, structTypeName, typeSpec)
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
elif fieldSpec == 'struct':
typeName = 'GUI_Frame'
guiStructName = structTypeName + '_Dialog_GUI'
guiMgrName = fieldType + '_GUI_Mgr'
if progSpec.typeIsPointer(typeSpec):
widgetInitFuncCode += ' Allocate(_data.' + fieldName + ')\n'
widgetInitFuncCode += 'Allocate(' + guiMgrName + ')\n'
makeTypeNameCall = widgetName + ' <- ' + guiMgrName + '.initWidget(_data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + guiMgrName + '.parentGuiMgr <- self\n'
newWidgetFields += ' our ' + guiStructName + ': ' + guiMgrName + '\n'
widgetFromVarsCode += ' ' + guiMgrName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' ' + guiMgrName + '.getValue()\n'
clearWidgetCode += ' ' + guiMgrName + '.clear()\n'
makeTypeNameCall += ' ' + guiMgrName + '.load()\n'
elif fieldSpec == 'enum':
typeName = 'enumWidget'
EnumItems = []
for enumItem in params:
EnumItems.append('"' + deCamelCase(enumItem) + '"')
optionString = '[' + ', '.join(EnumItems) + ']'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", ' + optionString + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'string':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'int':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
if progSpec.typeIsNumRange(innerFieldType):
range1 = innerFieldType[0]
range2 = innerFieldType[2]
makeTypeNameCall += ' ' + widgetName + '.minValue <- ' + range1 + '\n ' + widgetName + '.maxValue <- ' + range2 + '\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'bool':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'list' or fieldSpec == 'map':
pass
else:
print(
'pattern_MakeGUI.getWidgetHandlingCode fieldSpec not specified: ',
fieldSpec)
exit(2)
if typeName == 'GUI_Frame': owner = 'their '
else: owner = 'our '
# If this is a list or map, populate it
if progSpec.isAContainer(typeSpec):
makeTypeNameCall = widgetName + ' <- make' + typeName[0].upper(
) + typeName[1:] + '("' + label + '")\n'
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
# If it hasn't already been added, make a struct <ItemType>_ListWidgetManager:ListWidgetManager{}
listManagerStructName = structTypeName + '_ListWidgetManager'
getListWidgetMgrCode(classes, listManagerStructName, structTypeName,
fieldName, classOptionsTags)
listWidMgrName = 'LEWM'
newWidgetFields += ' me ' + listManagerStructName + ': ' + listWidMgrName + '\n'
widgetListEditorName = widgetName + '_Editor'
localWidgetVarName = widgetListEditorName
if progSpec.typeIsPointer(typeSpec):
widgetInitFuncCode += 'Allocate(_data.' + fieldName + ')\n'
widgetInitFuncCode += ' their GUI_YStack: ' + widgetListEditorName + ' <- ' + listWidMgrName + '.initWidget(_data.' + fieldName + ', "' + label + '")\n'
if classPrimaryGuiItem == fieldName:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetListEditorName + ')\n'
else:
widgetInitFuncCode += ' addToContainer(box, ' + widgetListEditorName + ')\n'
# widgetFromVarsCode += ' ' + listWidMgrName + '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + listWidMgrName + '.getValue()\n'
clearWidgetCode += ' ' + listWidMgrName + '.clear()\n'
elif dialogStyle == 'WizardStack':
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall
widgetInitFuncCode += ' addToZStack(wiz.ZStack, ' + widgetBoxName + ', "' + CasedFieldName + '")\n'
widgetInitFuncCode += ' wiz.children.pushLast("' + CasedFieldName + '")\n'
elif dialogStyle == 'Z_stack':
widgetBoxName = guiMgrName + '.box'
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall + '\n'
widgetInitFuncCode += ' addToZStack(Zbox, ' + widgetBoxName + ', "' + CasedFieldName + '")\n'
widgetInitFuncCode += ' children.pushLast("' + CasedFieldName + '")\n'
else: # Not an ArraySpec:
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall
if classPrimaryGuiItem == fieldName:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetBoxName + ')\n'
else:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetBoxName + ')\n'
if dialogStyle == 'TabbedStack':
widgetInitFuncCode += ' ' + 'setTabLabelText(box, ' + localWidgetVarName + ', "' + label + '")\n'
def Write_fieldExtracter(classes, ToStructName, field, memObjFields, VarTagBase, VarName, advancePtr, indent, level, logLvl):
debugTmp=False # Erase this line
VarTag=VarTagBase+str(level)
################### G a t h e r N e e d e d I n f o r m a t i o n
global globalFieldCount
global globalTempVarIdx
S=''
fieldName = field['fieldName']
fieldIsNext= field['isNext']
fieldValue = field['value']
typeSpec = field['typeSpec']
fieldType = progSpec.getFieldType(typeSpec)
fieldOwner =typeSpec['owner']
fromIsEmbeddedAlt = (not isinstance(fieldType, str) and fieldType[0]=='[')
fromIsEmbeddedSeq = (not isinstance(fieldType, str) and fieldType[0]=='{')
fromIsEmbedded = fromIsEmbeddedAlt or fromIsEmbeddedSeq
if(fieldIsNext!=True): return '' # This field isn't in the parse stream.
[memObj, memVersionName]=fetchMemVersion(classes, ToStructName)
toField = progSpec.fetchFieldByName(memObjFields, fieldName)
if(toField==None):
#print " TOFIELD == None", fieldName
# Even tho there is no LVAL, we need to move the cursor. Also, there could be a co-factual.
toFieldType = progSpec.TypeSpecsMinimumBaseType(classes, typeSpec)
toTypeSpec=typeSpec
toFieldOwner="me"
else:
toTypeSpec = toField['typeSpec']
toFieldType = progSpec.getFieldType(toTypeSpec)
toFieldOwner = progSpec.getInnerContainerOwner(toTypeSpec)
if debugTmp:
print(' toFieldType:', toFieldType)
LHS_IsPointer=progSpec.typeIsPointer(toTypeSpec)
# print " CONVERTING:", fieldName, str(toFieldType)[:100]+'... ', str(typeSpec)[:100]+'... '
# print " TOFieldTYPE1:", str(toField)[:100]
# print " TOFieldTYPE :", toFieldOwner, toFieldType
# print " fieldValue:",ToStructName, fieldType, fieldValue
cdlog(logLvl, "FIELD {}: '{}'".format(fieldName, str(fieldValue)))
fields=[]
fromIsStruct=progSpec.isStruct(fieldType)
toIsStruct=progSpec.isStruct(toFieldType)
ToIsEmbedded = toIsStruct and (toFieldType[0]=='[' or toFieldType[0]=='{')
[fromIsALT, fields] = progSpec.isAltStruct(classes, fieldType)
fromIsOPT =False
fromIsList=False
toIsList =False
if progSpec.isAContainer(typeSpec):
datastructID = progSpec.getDatastructID(typeSpec)
if datastructID=='opt': fromIsOPT=True;
else: fromIsList=True
if progSpec.isAContainer(toTypeSpec):
if datastructID != 'opt': toIsList=True
if debugTmp:
print(' fromIsOPT:', fromIsOPT)
print(' fromIsList:', fromIsList)
print(' toIsList:', toIsList)
print(' fromIsStruct:', fromIsStruct)
print(' toIsStruct:', toIsStruct)
print(' fieldType:', fieldType)
print(' ToIsEmbedded:', ToIsEmbedded)
print(' ToStructName:', ToStructName)
print(' memVersionName:', memVersionName, "\n")
################### W r i t e L V A L R e f e r e n c e
finalCodeStr=''
CodeLVAR_Alloc=''
CODE_LVAR_v2=''
if VarName=='' or VarName=='memStruct': # Default to the target argument name
#if VarName=='': print " VARNAME was ''; FIELDNAME:", fieldName
VarName='memStruct'
if(fieldName==None): # Field hasn't a name so in memory it's a cofactual or this is a parser marker.
globalFieldCount+=1
# We need two versions in case this is set in a function instead of assignment
CODE_LVAR_v2 = 'S'+str(globalFieldCount)
CodeLVAR_Alloc=' me string: '+CODE_LVAR_v2
CODE_LVAR = CodeLVAR_Alloc
if debugTmp: print(' CODE_LVARS:', CODE_LVAR)
else:
CODE_LVAR = VarName+'.'+fieldName
if fieldName=='inf': CODE_LVAR = VarName
CODE_LVAR_v2 = CODE_LVAR
else:
CODE_LVAR = VarName
CODE_LVAR_v2 = CODE_LVAR
################### W r i t e R V A L C o d e
CODE_RVAL=''
objName=''
humanIDType= VarTag+' ('+str(fieldName)+' / '+str(fieldValue) + ' / '+str(fieldType)[:40] +')'
humanIDType=humanIDType.replace('"', "'")
#print humanIDType
if advancePtr:
S+=indent+VarTag+' <- getNextStateRec('+VarTag+')\n'
# UNCOMMENT FOR DEGUG: S+=' docPos('+str(level)+', '+VarTag+', "Get Next in SEQ for: '+humanIDType+'")\n'
if fieldOwner=='const'and (toField == None):
#print'CONSTFIELDVALUE("'+fieldValue+'")\n'
finalCodeStr += indent + 'tmpStr'+' <- makeStr('+VarTag+"<LVL_SUFFIX>"+'.child)\n'
else:
if toIsStruct:
if debugTmp: print(' toFieldType:', toFieldType)
if not ToIsEmbedded:
objName=toFieldType[0]
if progSpec.typeIsInteger(objName):
strFieldType = fieldType[0]
if(strFieldType == "BigInt"):
CODE_RVAL='makeStr('+VarTag+'.child'+')'
elif(strFieldType == "HexNum"):
CODE_RVAL='makeHexInt('+VarTag+'.child'+')'
elif(strFieldType == "BinNum"):
CODE_RVAL='makeBinInt('+VarTag+'.child'+')'
else:
CODE_RVAL='makeStr('+VarTag+'.child'+')'
toIsStruct=False; # false because it is really a base type.
elif (objName=='ws' or objName=='wsc' or objName=='quotedStr1' or objName=='quotedStr2' or objName=='CID' or objName=='UniID'
or objName=='printables' or objName=='toEOL' or objName=='alphaNumSeq'):
CODE_RVAL='makeStr('+VarTag+'.child'+')'
toIsStruct=False; # false because it is really a base type.
else:
#print "toObjName:", objName, memVersionName, fieldName
[toMemObj, toMemVersionName]=fetchMemVersion(classes, objName)
if toMemVersionName==None:
# make alternate finalCodeStr. Also, write the extractor that extracts toStruct fields to memVersion of this
childStr = ".child"
if fromIsOPT:
childStr += ".next"
finalCodeStr=(indent + CodeLVAR_Alloc + '\n' +indent+' '+getFunctionName(fieldType[0], memVersionName)+'('+VarTag+"<LVL_SUFFIX>"+childStr+', memStruct)\n')
objSpec = progSpec.findSpecOf(classes[0], objName, 'string')
ToFields=objSpec['fields']
FromStructName=objName
Write_Extracter(classes, ToStructName, FromStructName, logLvl+1)
else:
fromFieldTypeCID = fieldType[0].replace('::', '_')
toFieldTypeCID = toMemVersionName.replace('::', '_')
#print "FUNC:", getFunctionName(fromFieldTypeCID, toFieldTypeCID)
if fromFieldTypeCID != toFieldTypeCID:
Write_Extracter(classes, toFieldTypeCID, fromFieldTypeCID, logLvl+1)
finalCodeStr=indent + CodeLVAR_Alloc + '\n' +indent+' '+getFunctionName(fromFieldTypeCID, toFieldTypeCID)+'('+VarTag+"<LVL_SUFFIX>"+'.child, '+CODE_LVAR_v2+')\n'
else: pass
else:
CODE_RVAL = CodeRValExpr(toFieldType, VarTag, "")
#print "CODE_RVAL:", CODE_RVAL
################### H a n d l e o p t i o n a l a n d r e p e t i t i o n a n d a s s i g n m e n t c a s e s
gatherFieldCode=''
if fromIsList and toIsList:
CODE_RVAL='tmpVar'
globalFieldCount +=1
childRecName='SRec' + str(globalFieldCount)
gatherFieldCode+='\n'+indent+'\nour stateRec: '+childRecName+' <- '+VarTag+'.child.next'
gatherFieldCode+='\n'+indent+'while('+childRecName+'){\n'
if fromIsALT:
# print "ALT-#1"
gatherFieldCode+=Write_ALT_Extracter(classes, fieldType[0], fields, childRecName, '', 'tmpVar', indent+' ', level)
elif fromIsStruct and toIsStruct:
gatherFieldCode+='\n'+indent+toFieldOwner+' '+progSpec.baseStructName(toFieldType[0])+': tmpVar'
if toFieldOwner!='me':
gatherFieldCode+='\n'+indent+'Allocate('+CODE_RVAL+')'
#print "##### FUNCT:", getFunctionName(fieldType[0], fieldType[0])
gatherFieldCode+='\n'+indent+getFunctionName(fieldType[0], toFieldType[0])+'('+childRecName+'.child, tmpVar)\n'
else:
CODE_RVAL = CodeRValExpr(toFieldType, childRecName, ".next")
# Now code to push the chosen alternative into the data field# This is a LIST, not an OPT:
gatherFieldCode+='\n'+indent+CODE_LVAR+'.pushLast('+CODE_RVAL+')'
gatherFieldCode+=indent+' '+childRecName+' <- getNextStateRec('+childRecName+')\n'
# UNCOMMENT FOR DEGUG: S+= ' docPos('+str(level)+', '+VarTag+', "Get Next in LIST for: '+humanIDType+'")\n'
gatherFieldCode+='\n'+indent+'}\n'
if(fromIsOPT):
print("Handle when the optional item is a list.");
exit(2)
else:
if toIsList: print("Error: parsing a non-list to a list is not supported.\n"); exit(1);
levelSuffix=''
assignerCode=''
oldIndent=indent
if (fromIsOPT):
setTrueCode=''
assignerCode+='\n'+indent+'if('+VarTag+'.child.next' +' == NULL){'
if toFieldOwner=='me':
if debugTmp: print(' toFieldOwner:', toFieldOwner)
## if fieldName==None and a model of fromFieldType has no cooresponding model But we are in EXTRACT_ mode:
## Make a special form of Extract_fromFieldType_to_ToFieldType()
## Call that function instead of the one in Code_LVAR
# First, create a new flag field
if fieldName==None:
fieldName="TEMP"+str(globalTempVarIdx)
globalTempVarIdx += globalTempVarIdx
newFieldsName=fieldName #'has_'+fieldName
fieldDef=progSpec.packField(ToStructName, False, 'me', 'flag', None, None, newFieldsName, None, None, None, False)
progSpec.addField(classes[0], memVersionName, 'struct', fieldDef)
# Second, generate the code to set the flag
assignerCode+='\n'+indent+' '+VarName+'.'+newFieldsName+' <- false'
setTrueCode += VarName+'.'+newFieldsName+' <- true'
elif LHS_IsPointer: # If owner is my, our or their
assignerCode+='\n'+indent+' '+CODE_LVAR+' <- NULL'
else:
print("ERROR: OPTional fields must not be '"+toFieldOwner+"'.\n")
exit(1)
assignerCode+='\n'+indent+'} else {\n'
levelSuffix='.child.next'
indent+=' '
assignerCode+=indent+setTrueCode+'\n'
if fromIsALT or fromIsEmbeddedAlt:
if(fromIsEmbeddedAlt):
# print "ALT-#2"
assignerCode+=Write_ALT_Extracter(classes, ToStructName, field['innerDefs'], VarTagBase, levelSuffix, VarName, indent+' ', level+1, logLvl+1)
else:
# print "ALT-#3"
assignerCode+=Write_ALT_Extracter(classes, fieldType[0], fields, VarTagBase, levelSuffix, VarName+'X', indent+' ', level, logLvl+1)
assignerCode+=indent+CODE_LVAR+' <- '+(VarName+'X')+"\n"
elif fromIsEmbeddedSeq:
globalFieldCount +=1
childRecNameBase='childSRec' + str(globalFieldCount)
childRecName=childRecNameBase+str(level)
assignerCode+='\n'+indent+'our stateRec: '+childRecName+' <- '+VarTag+levelSuffix+'.child\n'
for innerField in field['innerDefs']:
assignerCode+=Write_fieldExtracter(classes, ToStructName, innerField, memObjFields, childRecNameBase, '', True, ' ', level, logLvl+1)
elif fromIsStruct and toIsStruct:
assignerCode+=finalCodeStr.replace("<LVL_SUFFIX>", levelSuffix);
if debugTmp: print(' assignerCode:', assignerCode)
else:
# if toFieldOwner == 'const': print "Error: Attempt to extract a parse to const field.\n"; exit(1);
if CODE_RVAL!="":
if LHS_IsPointer:
assignerCode+=' '+CODE_LVAR+' <deep- '+CODE_RVAL+"\n"
else: assignerCode+=' '+CODE_LVAR+' <- '+CODE_RVAL+"\n"
elif finalCodeStr!="": assignerCode+=finalCodeStr.replace("<LVL_SUFFIX>", levelSuffix);
if (fromIsOPT):
indent=oldIndent
assignerCode += indent+'}\n'
#print '######################\n'+assignerCode, memVersionName, '\n'
# exit(2)
gatherFieldCode = assignerCode
#print ("##########################\n",S,"\n#####################################\n")
if LHS_IsPointer: # LVAL is a pointer and should be allocated or cleared.
S+= indent + 'AllocateOrClear(' +CODE_LVAR +')\n'
S+=gatherFieldCode
#print "ASSIGN_CODE", S
# if debugTmp: exit(2)
return S
def fetchOrWriteTerminalParseRule(modelName, field, logLvl):
global nextParseNameID
#print "FIELD_IN:", modelName, field
fieldName='N/A'
fieldValue=''
if 'value' in field: fieldValue =field['value']
typeSpec = field['typeSpec']
fieldType = progSpec.getFieldType(typeSpec)
fieldOwner = typeSpec['owner']
if 'fieldName' in field: fieldName =field['fieldName']
cdlog(logLvl, "WRITING PARSE RULE for: {}.{}".format(modelName, fieldName))
#print "WRITE PARSE RULE:", modelName, fieldName
nameIn=None
nameOut=None
if fieldOwner=='const':
if fieldType=='string':
if fieldValue in definedRules: nameOut=definedRules[fieldValue]
else: nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='uint': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:3]=='int': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:6]=='double': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='char': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='bool': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
else:
print("Unusable const type in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
elif fieldOwner=='me' or fieldOwner=='their' or fieldOwner=='our':
if fieldType=='string': nameOut='quotedStr'
elif fieldType[0:4]=='uint': nameOut='uintSeq'
elif fieldType[0:3]=='int': nameOut='intSeq'
elif fieldType[0:6]=='double': nameOut='RdxSeq'
elif fieldType[0:4]=='char': nameOut=appendRule(nameIn, "term", "parseSEQ", None)
elif fieldType[0:4]=='bool': nameOut=appendRule(nameIn, "term", "parseSEQ", None)
elif progSpec.isStruct(fieldType):
objName=fieldType[0]
if (objName=='ws' or objName=='wsc' or objName=='quotedStr' or objName=='quotedStr1' or objName=='quotedStr2'
or objName=='CID' or objName=='UniID' or objName=='printables' or objName=='toEOL' or objName=='alphaNumSeq'
or progSpec.typeIsInteger(objName)):
nameOut=objName
else:
if objName=='[' or objName=='{': # This is an ALT or SEQ sub structure
print("ERROR: These should be handled in writeNonTermParseRule().\n")
exit(1)
else: nameOut=objName+'_str'
elif progSpec.isAlt(fieldType):
pass
elif progSpec.isCofactual(fieldType):
pass
else:
print("Unusable type in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
else: print("Pointer types not yet handled in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
if progSpec.isAContainer(typeSpec):
global rules
containerSpec = progSpec.getContainerSpec(typeSpec)
idxType=''
if 'indexType' in containerSpec:
idxType=containerSpec['indexType']
if(isinstance(containerSpec['datastructID'], str)):
datastructID = containerSpec['datastructID']
else: # it's a parseResult
datastructID = containerSpec['datastructID'][0]
if idxType[0:4]=='uint': pass
if(datastructID=='list'):
nameOut=appendRule(nameOut+'_REP', "nonterm", "parseREP", [nameOut, 0, 0])
elif datastructID=='opt':
nameOut=appendRule(nameOut+'_OPT', "nonterm", "parseREP", [nameOut, 0, 1])
#print("NAMEOUT:", nameOut)
field['parseRule']=nameOut
return nameOut
def getDashDeclAndUpdateCode(self, owner, fieldLabel, fieldRef, fieldName,
field, skipFlags, indent):
global classesToProcess
global classesEncoded
[
structText, updateFuncText, setPosFuncText, drawFuncText,
handleClicksFuncText
] = ['', '', '', '', '']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
if fldCat == 'func': return ['', '', '', '', '']
if progSpec.typeIsPointer(
typeSpec) and skipFlags != 'skipPtr': # Header for a POINTER
fieldName += 'Ptr'
if fieldRef == 'data.itmItr':
innerUpdateFuncStr = '"ItmItr"' # TODO: unhard code this reference to itmItr
else:
innerUpdateFuncStr = fieldRef + '.mySymbol(' + fieldRef + ')'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '))\n'
structText += " " + owner + " ptrToItem: " + fieldName + "\n"
elif progSpec.isAContainer(
typeSpec
) and skipFlags != 'skipLists': # Header and items for LIST
dispStructTypeName = "display_" + progSpec.getFieldType(
field['typeSpec'])[0]
innerUpdateFuncStr = '"Size:"+toString(data.' + fieldName + '.size())'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + "our dash[our list]: oldElements <- " + fieldName + ".elements\n"
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '), true)\n'
## Now push each item
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
if fieldRef == 'data.itmItr' or fieldRef == 'data.items':
newFieldRef = '_item' # TODO: unhard code this reference to itmItr
else:
newFieldRef = 'data.' + fieldName + '[_item_key]'
newFieldLabel = '"["+toString(_item_key)+"] "+ _item.mySymbol(_item)'
updateFuncText += "\n " + "me int64: dash_key <- 0"
updateFuncText += "\n withEach _item in data." + fieldName + "{\n"
[
innerStructText, innerUpdateFuncText, innerDrawFuncText,
innerSetPosFuncText, innerHandleClicksFuncText
] = self.getDashDeclAndUpdateCode('our', newFieldLabel,
newFieldRef, 'newItem', field,
'skipLists', ' ')
updateFuncText += " " + innerStructText
updateFuncText += " " + "if(oldElements==NULL or (oldElements!=NULL and !(asClass(" + dispStructTypeName + ", oldElements[dash_key]).data === _item))){\n"
updateFuncText += ' Allocate(newItem)\n'
updateFuncText += ' newItem.dashParent <- self\n'
updateFuncText += ' ' + 'addDependent(_item.mySymbol(_item), newItem)'
updateFuncText += '\n } else {\n newItem <- asClass(' + dispStructTypeName + ', oldElements[dash_key])\n dash_key <- dash_key + 1'
updateFuncText += '\n }'
updateFuncText += '\n ' + innerUpdateFuncText
updateFuncText += ' ' + fieldName + '.updatePush(newItem)'
updateFuncText += '\n }\n'
structText += " " + owner + " listOfItems: " + fieldName + "\n"
elif (fldCat == 'struct'): # Header for a STRUCT
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ">", ' + fieldRef + ')\n'
if 'fieldType' in typeSpec and not (isinstance(
typeSpec['fieldType'], basestring
)) and typeSpec['fieldType'][0] == 'DblLinkedList':
structTypeName = 'infon'
else:
structTypeName = progSpec.getFieldType(typeSpec)[0]
structText += " " + owner + " display_" + structTypeName + ': ' + fieldName + "\n"
# Add new classname to a list so it can be encoded.
if not (structTypeName in classesToProcess):
classesToProcess.append(structTypeName)
else: # Display field for a BASIC TYPES
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(data.' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = '"\'"+' + 'data.' + fieldName + '+"\'"'
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'dispBool((data.' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = fieldRef + 'Strings[data.' + fieldName + '] '
updateFuncText = " " + fieldName + '.update(100, 180, ' + fieldLabel + ', ' + valStr + ', isNull(' + valStr + '))\n'
structText += " " + owner + " dataField: " + fieldName + "\n"
drawFuncText = " " + fieldName + '.draw(cr)\n'
setPosFuncText += ''' if(!<fieldName>.isNullLike or displayMode==fullDisplay){
<fieldName>.setPos(x,y,extC)
extC <- <fieldName>.extC
y <- y + <fieldName>.height
extX <- max(extX, <fieldName>.extX)
extY <- max(extY, <fieldName>.extY)
width<- max(width, <fieldName>.width)
<fieldName>.isHidden<-false
} else {<fieldName>.isHidden<-true}
'''.replace('<fieldName>', fieldName)
# updateFuncText+=' if(crntWidth<'+fieldName+'.width){crntWidth <- '+fieldName+'.width}'
handleClicksFuncText = ' ' + fieldName + '.primaryClick(event)'
return [
structText, updateFuncText, drawFuncText, setPosFuncText,
handleClicksFuncText
]
