def __init__(self,
moduleName,
boneName,
readOnly,
verify=True,
*args,
**kwargs):
super(PasswordEditBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.readOnly = readOnly
self.primeinput = html5.Input()
self.primeinput["type"] = "password"
self.appendChild(self.primeinput)
if verify and not readOnly:
lbl = html5.Label(translate("reenter password"))
lbl["for"] = (moduleName or "") + "_" + boneName + "_reenterpwd"
self.appendChild(lbl)
self.secondinput = html5.Input()
self.secondinput["type"] = "password"
self.secondinput["name"] = lbl["for"]
self.appendChild(self.secondinput)
else:
self.secondinput = None
if self.readOnly:
self["disabled"] = True
def __init__(self, *args, **kwargs):
super(ImageEditor, self).__init__(*args, **kwargs)
self["class"].append("imageeditor")
self["style"]["display"] = "none"
self.widthInput = html5.Input()
self.widthInput["type"] = "number"
self.appendChild(self.widthInput)
l = html5.Label(translate("Width"), self.widthInput)
l["class"].append("widthlbl")
self.appendChild(l)
self.keepAspectRatio = html5.Input()
self.keepAspectRatio["type"] = "checkbox"
self.appendChild(self.keepAspectRatio)
l = html5.Label(translate("Keep aspect ratio"), self.keepAspectRatio)
l["class"].append("aspectlbl")
self.appendChild(l)
self.heightInput = html5.Input()
self.heightInput["type"] = "number"
self.appendChild(self.heightInput)
l = html5.Label(translate("Height"), self.heightInput)
l["class"].append("heightlbl")
self.appendChild(l)
self.titleInput = html5.Input()
self.titleInput["type"] = "text"
self.appendChild(self.titleInput)
l = html5.Label(translate("Title"), self.titleInput)
l["class"].append("titlelbl")
self.appendChild(l)
self.currentElem = None
self.sinkEvent("onChange")
def __init__(self, targetNode, *args, **kwargs):
super(CreateTablePopup, self).__init__(*args, **kwargs)
assert targetNode
while not "innerHTML" in dir(targetNode):
targetNode = targetNode.parentNode
self.targetNode = targetNode
self["class"].append("createtable")
self.rowInput = html5.Input()
self.rowInput["type"] = "number"
self.rowInput["value"] = 3
self.appendChild(self.rowInput)
l = html5.Label(translate("Rows"), forElem=self.rowInput)
l["class"].append("rowlbl")
self.appendChild(l)
self.colInput = html5.Input()
self.colInput["type"] = "number"
self.colInput["value"] = 4
self.appendChild(self.colInput)
l = html5.Label(translate("Cols"), forElem=self.colInput)
l["class"].append("collbl")
self.appendChild(l)
self.insertHeader = html5.Input()
self.insertHeader["type"] = "checkbox"
self.appendChild(self.insertHeader)
l = html5.Label(translate("Insert Table Header"),
forElem=self.insertHeader)
l["class"].append("headerlbl")
self.appendChild(l)
self.appendChild(html5.ext.Button("Cancel", callback=self.doClose))
self.appendChild(html5.ext.Button("Create", callback=self.createTable))
def __init__(self,
moduleName,
boneName,
readOnly,
_min=False,
_max=False,
precision=False,
currency=None,
*args,
**kwargs):
super(NumericEditBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.readOnly = readOnly
self.input = html5.Input()
self.appendChild(self.input)
if currency:
self.appendChild(html5.Span(currency))
self.input["type"] = "number"
if _min:
self.input["min"] = _min
if _max:
self.input["max"] = _max
if precision:
self.input["step"] = pow(10, -precision)
else: #Precision is zero, treat as integer input
self.input["step"] = 1
if self.readOnly:
self.input["readonly"] = True
def __init__(self,
parentBone,
tag,
isEditMode,
readonly=False,
multiLine=False,
*args,
**kwargs):
super(Tag, self).__init__(*args, **kwargs)
self["class"].append("tag")
self.parentBone = parentBone
if multiLine:
self.input = html5.Textarea()
else:
self.input = html5.Input()
self.input["type"] = "text"
self.input["value"] = tag
self.appendChild(self.input)
if readonly:
self.input["readonly"] = True
else:
self["draggable"] = True
self.sinkEvent("onDrop", "onDragOver", "onDragStart", "onDragEnd")
delBtn = html5.ext.Button(translate("Delete"), self.onDelBtnClick)
delBtn["class"].append("icon delete tag")
self.appendChild(delBtn)
def __init__(self,
text,
value="",
successHandler=None,
abortHandler=None,
successLbl="OK",
abortLbl="Cancel",
*args,
**kwargs):
super(InputDialog, self).__init__(*args, **kwargs)
self["class"].append("inputdialog")
self.successHandler = successHandler
self.abortHandler = abortHandler
span = html5.Span()
span.element.innerHTML = text
self.appendChild(span)
self.inputElem = html5.Input()
self.inputElem["type"] = "text"
self.inputElem["value"] = value
self.appendChild(self.inputElem)
okayBtn = Button(successLbl, self.onOkay)
okayBtn["class"].append("btn_okay")
self.appendChild(okayBtn)
cancelBtn = Button(abortLbl, self.onCancel)
cancelBtn["class"].append("btn_cancel")
self.appendChild(cancelBtn)
self.sinkEvent("onkeydown")
self.inputElem.focus()
def __init__(self, moduleName, boneName, readOnly, *args, **kwargs):
super(SpatialBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.readOnly = readOnly
self.latitude = html5.Input()
self.longitude = html5.Input()
self.latitude["type"] = "number"
self.longitude["type"] = "number"
self.appendChild(self.latitude)
lbl = html5.Label(translate("longitude"))
lbl["for"] == moduleName + "_" + boneName + "_longitude"
self.appendChild(lbl)
self.longitude["name"] = moduleName + "_" + boneName + "_longitude"
self.appendChild(self.longitude)
if self.readOnly:
self["disabled"] = True
def __init__(self, moduleName, boneName, readOnly, values, *args,
**kwargs):
super(SelectMultiEditBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.readOnly = readOnly
# Compatibility mode
if isinstance(values, dict):
self.values = [(k, v) for k, v in values.items()]
else:
self.values = values
# Perform valuesOrder list
for key, value in self.values:
alabel = html5.Label()
acheckbox = html5.Input()
acheckbox["type"] = "checkbox"
acheckbox["name"] = key
alabel.appendChild(acheckbox)
aspan = html5.Span()
aspan.element.innerHTML = value
alabel.appendChild(aspan)
self.appendChild(alabel)
if self.readOnly:
self["disabled"] = True
def __init__(self, *args, **kwargs):
super(LinkEditor, self).__init__(*args, **kwargs)
self["class"].append("linkeditor")
self["style"]["display"] = "none"
self.linkTxt = html5.Input()
self.linkTxt["type"] = "text"
self.appendChild(self.linkTxt)
l = html5.Label(translate("URL"), forElem=self.linkTxt)
l["class"].append("urllbl")
self.appendChild(l)
self.newTab = html5.Input()
self.newTab["type"] = "checkbox"
self.appendChild(self.newTab)
l = html5.Label(translate("New window"), forElem=self.newTab)
l["class"].append("newwindowlbl")
self.appendChild(l)
self.currentElem = None
def __init__(self,
moduleName,
boneName,
readOnly,
date=True,
time=True,
*args,
**kwargs):
super(DateEditBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.readOnly = readOnly
self.hasdate = date
self.hastime = time
if date:
self.dateinput = html5.Input()
#IE11
try:
self.dateinput["type"] = "date"
except:
pass
self.dateinput["style"]["float"] = "left"
self.appendChild(self.dateinput)
if self.readOnly:
self.dateinput["readonly"] = True
if time:
self.timeinput = html5.Input()
#IE11
try:
self.timeinput["type"] = "time"
except:
pass
self.timeinput["style"][
"float"] = "left" #fixme: Do this with css?
self.timeinput["style"][
"width"] = "70px" #fixme: Do this with css?
self.appendChild(self.timeinput)
if self.readOnly:
self.timeinput["readonly"] = True
def __init__(self, listWdg, *args, **kwargs):
if not listWdg._structure:
return
super( SelectFieldsPopup, self ).__init__( title=translate("Select fields"), *args, **kwargs )
self["class"].append("selectfields")
self.listWdg = listWdg
self.checkboxes = []
ul = html5.Ul()
self.appendChild( ul )
for key, bone in self.listWdg._structure:
li = html5.Li()
ul.appendChild( li )
chkBox = html5.Input()
chkBox["type"] = "checkbox"
chkBox["value"] = key
li.appendChild(chkBox)
self.checkboxes.append( chkBox )
if key in self.listWdg.getFields():
chkBox["checked"] = True
lbl = html5.Label(bone["descr"],forElem=chkBox)
li.appendChild(lbl)
# Functions for Selection
div = html5.Div()
div[ "class" ].append( "selectiontools" )
self.appendChild( div )
self.selectAllBtn = html5.ext.Button( translate( "Select all" ), callback=self.doSelectAll )
self.selectAllBtn[ "class" ].append( "icon" )
self.selectAllBtn[ "class" ].append( "selectall" )
self.unselectAllBtn = html5.ext.Button( translate( "Unselect all" ), callback=self.doUnselectAll )
self.unselectAllBtn[ "class" ].append( "icon" )
self.unselectAllBtn[ "class" ].append( "unselectall" )
self.invertSelectionBtn = html5.ext.Button( translate( "Invert selection" ), callback=self.doInvertSelection )
self.invertSelectionBtn[ "class" ].append( "icon" )
self.invertSelectionBtn[ "class" ].append( "selectinvert" )
div.appendChild(self.selectAllBtn)
div.appendChild(self.unselectAllBtn)
div.appendChild(self.invertSelectionBtn)
# Function for Commit
self.cancelBtn = html5.ext.Button( translate( "Cancel" ), callback=self.doCancel)
self.cancelBtn["class"].append("btn_no")
self.applyBtn = html5.ext.Button( translate( "Apply" ), callback=self.doApply)
self.applyBtn["class"].append("btn_yes")
self.appendChild(self.applyBtn)
self.appendChild(self.cancelBtn)
def __init__(self, extension, view, module, *args, **kwargs):
super(DateRangeFilterPlugin, self).__init__(*args, **kwargs)
self.view = view
self.extension = extension
self.module = module
self.mutualExclusiveGroupTarget = "daterange-filter"
self.mutualExclusiveGroupKey = extension["target"]
self.filterChangedEvent = EventDispatcher("filterChanged")
title = html5.H2()
title.appendChild(html5.TextNode(extension["name"]))
self.appendChild(title)
# from daterange value
self.beginDatepicker = html5.Input()
self.beginDatepicker["type"] = "date"
self.beginDatepicker["id"] = "begin-date-%s" % self.extension["target"]
self.beginDatepicker["class"] = "js-extended-date-range-filter"
beginLabel = html5.Label(translate("Begin date"))
beginLabel["for"] = "begin-date-%s" % self.extension["target"]
span = html5.Span()
span.appendChild(beginLabel)
span.appendChild(self.beginDatepicker)
self.appendChild(span)
# to daterange value
self.toDatepicker = html5.Input()
self.toDatepicker["type"] = "date"
self.toDatepicker["id"] = "to-date-%s" % self.extension["target"]
self.toDatepicker[
"class"] = "extended-date-range-filter %s" % self.extension[
"target"]
toLabel = html5.Label(translate("End date"))
toLabel["for"] = "to-date-%s" % self.extension["target"]
span2 = html5.Span()
span2.appendChild(toLabel)
span2.appendChild(self.toDatepicker)
self.appendChild(span2)
self.clearButton = html5.ext.Button(translate("Clear filter"),
self.clearFilter)
self.appendChild(self.clearButton)
self.sinkEvent("onChange")
def __init__(self, extension, view, module, *args, **kwargs):
super(ExtendedStringSearch, self).__init__(*args, **kwargs)
self.view = view
self.extension = extension
self.module = module
self.opMode = extension["mode"]
self.filterChangedEvent = EventDispatcher("filterChanged")
assert self.opMode in ["equals", "from", "to", "prefix", "range"]
self.appendChild(html5.TextNode(extension["name"]))
self.sinkEvent("onKeyDown")
if self.opMode in ["equals", "from", "to", "prefix"]:
self.input = html5.Input()
self.input["type"] = "text"
self.appendChild(self.input)
elif self.opMode == "range":
self.input1 = html5.Input()
self.input1["type"] = "text"
self.appendChild(self.input1)
self.appendChild(html5.TextNode("to"))
self.input2 = html5.Input()
self.input2["type"] = "text"
self.appendChild(self.input2)
def __init__(self, *args, **kwargs):
super(Search, self).__init__(*args, **kwargs)
self.startSearchEvent = EventDispatcher("startSearch")
self["class"].append("search")
lblSearch = html5.H2()
lblSearch.appendChild(html5.TextNode(translate("Fulltext search")))
self.appendChild(lblSearch)
self.searchInput = html5.Input()
self.searchInput["type"] = "text"
self.appendChild(self.searchInput)
self.btn = html5.ext.Button(translate("Search"),
callback=self.doSearch)
self.appendChild(self.btn)
self.sinkEvent("onKeyDown")
self.last_search = ""
def prepareCol(self, row, col):
"""
Lets hook up the original removeRow function to optionally
provide index and checkbox columns.
"""
super(SelectTable, self).prepareCol(row, col + self._extraCols() - 1)
if self.checkboxes:
checkbox = html5.Input()
checkbox["type"] = "checkbox"
checkbox["class"].append("check")
checkbox["checked"] = False
self["cell"][row][self.checkboxes_col] = checkbox
self._checkboxes[row] = checkbox
if self.indexes:
lbl = html5.Label(str(row + 1))
lbl["class"].append("index")
self["cell"][row][self.indexes_col] = lbl
self.tableChangedEvent.fire(self, self.getRowCount())
def __init__(self,
srcModule,
boneName,
readOnly,
destModule,
format="$(dest.name)",
required=False,
using=None,
usingDescr=None,
context=None,
*args,
**kwargs):
"""
:param srcModule: Name of the module from which is referenced
:type srcModule: string
:param boneName: Name of the bone thats referencing
:type boneName: str
:param readOnly: Prevents modifying its value if set to True
:type readOnly: bool
:param destModule: Name of the module which gets referenced
:type destModule: str
:param format: Specifies how entries should be displayed.
:type format: str
"""
super(RelationalSingleSelectionBone, self).__init__(*args, **kwargs)
self.srcModule = srcModule
self.boneName = boneName
self.readOnly = readOnly
self.destModule = destModule
self.format = format
self.using = using
self.usingDescr = usingDescr
self.selection = None
self.selectionTxt = html5.Input()
self.selectionTxt["readonly"] = True
self.selectionTxt["type"] = "text"
self.appendChild(self.selectionTxt)
self.ie = None
self.baseContext = context
self.context = self.baseContext.copy() if self.baseContext else None
self.changeEvent = EventDispatcher("boneChange")
# Selection button
if (destModule in conf["modules"].keys() and
("root" in conf["currentUser"]["access"]
or destModule + "-view" in conf["currentUser"]["access"])):
self.selectBtn = html5.ext.Button(translate("Select"),
self.onShowSelector)
self.selectBtn["class"].append("icon")
self.selectBtn["class"].append("select")
self.appendChild(self.selectBtn)
else:
self.selectBtn = None
# Edit button
if (destModule in conf["modules"].keys() and
("root" in conf["currentUser"]["access"]
or destModule + "-edit" in conf["currentUser"]["access"])):
self.editBtn = html5.ext.Button(translate("Edit"), self.onEdit)
self.editBtn["class"].append("icon")
self.editBtn["class"].append("edit")
self.appendChild(self.editBtn)
else:
self.editBtn = None
# Remove button
if (not required and not readOnly and
("root" in conf["currentUser"]["access"]
or destModule + "-view" in conf["currentUser"]["access"])):
# Yes, we check for "view" on the remove button, because removal of relations
# is only useful when viewing the destination module is still allowed.
self.remBtn = html5.ext.Button(translate("Remove"), self.onRemove)
self.remBtn["class"].append("icon")
self.remBtn["class"].append("cancel")
self.appendChild(self.remBtn)
else:
self.remBtn = None
if self.readOnly:
self["disabled"] = True
def __init__(self,
moduleName,
boneName,
readOnly,
multiple=False,
languages=None,
multiLine=False,
*args,
**kwargs):
super(StringEditBone, self).__init__(*args, **kwargs)
self.moduleName = moduleName
self.boneName = boneName
self.readOnly = readOnly
self.multiple = multiple
self.languages = languages
self.boneName = boneName
self.currentTagToDrag = None
self.currentLanguage = None
if self.languages and self.multiple:
self["class"].append("is_translated")
self["class"].append("is_multiple")
self.languagesContainer = html5.Div()
self.appendChild(self.languagesContainer)
self.buttonContainer = html5.Div()
self.buttonContainer["class"] = "languagebuttons"
self.appendChild(self.buttonContainer)
self.langEdits = {}
self.langBtns = {}
for lang in self.languages:
tagContainer = html5.Div()
tagContainer["class"].append("lang_%s" % lang)
tagContainer["class"].append("tagcontainer")
tagContainer["style"]["display"] = "none"
langBtn = html5.ext.Button(lang,
callback=self.onLangBtnClicked)
langBtn.lang = lang
self.buttonContainer.appendChild(langBtn)
if not self.readOnly:
addBtn = html5.ext.Button(translate("New"),
callback=self.onBtnGenTag)
addBtn["class"].append("icon new tag")
addBtn.lang = lang
tagContainer.appendChild(addBtn)
self.languagesContainer.appendChild(tagContainer)
self.langEdits[lang] = tagContainer
self.langBtns[lang] = langBtn
self.setLang(self.languages[0])
elif self.languages and not self.multiple:
self["class"].append("is_translated")
self.languagesContainer = html5.Div()
self.appendChild(self.languagesContainer)
self.buttonContainer = html5.Div()
self.buttonContainer["class"] = "languagebuttons"
self.appendChild(self.buttonContainer)
self.langEdits = {}
self.langBtns = {}
for lang in self.languages:
langBtn = html5.ext.Button(lang,
callback=self.onLangBtnClicked)
langBtn.lang = lang
self.buttonContainer.appendChild(langBtn)
if multiLine:
inputField = html5.Textarea()
else:
inputField = html5.Input()
inputField["type"] = "text"
inputField["style"]["display"] = "none"
inputField["class"].append("lang_%s" % lang)
if self.readOnly:
inputField["readonly"] = True
self.languagesContainer.appendChild(inputField)
self.langEdits[lang] = inputField
self.langBtns[lang] = langBtn
self.setLang(self.languages[0])
elif not self.languages and self.multiple:
self["class"].append("is_multiple")
self.tagContainer = html5.Div()
self.tagContainer["class"].append("tagcontainer")
self.appendChild(self.tagContainer)
if not self.readOnly:
addBtn = html5.ext.Button(translate("New"),
callback=self.onBtnGenTag)
addBtn.lang = None
addBtn["class"].append("icon new tag")
self.tagContainer.appendChild(addBtn)
else: # not languages and not multiple:
if multiLine:
self.input = html5.Textarea()
else:
self.input = html5.Input()
self.input["type"] = "text"
self.appendChild(self.input)
if self.readOnly:
self.input["readonly"] = True
def __init__(self, moduleName, boneName, readOnly, values, *args,
**kwargs):
super(AccessMultiSelectBone, self).__init__(*args, **kwargs)
self.boneName = boneName
self.moduleName = moduleName
self.readOnly = readOnly
print(values)
self.values = {k: v for k, v in values}
self.modules = {}
self.modulesbox = {}
self.flags = {}
self.sinkEvent("onClick")
for value in self.values:
module = self.parseskelaccess(value)
if not module:
self.flags[value] = None
elif not module[0] in self.modules.keys():
self.modules[module[0]] = {}
# Render static / singleton flags first
for flag in sorted(self.flags.keys()):
label = html5.Label()
checkbox = html5.Input()
checkbox["type"] = "checkbox"
checkbox["name"] = flag
label.appendChild(checkbox)
self.flags[flag] = checkbox
span = html5.Span()
span.appendChild(html5.TextNode(flag))
label.appendChild(span)
self.appendChild(label)
# Render module access flags then
for module in sorted(self.modules.keys()):
label = html5.Label()
span = html5.Span()
span.appendChild(html5.TextNode(module))
label.appendChild(span)
ul = html5.Ul()
checkbox = html5.Input()
checkbox["type"] = "checkbox"
checkbox["name"] = module
self.modulesbox[module] = checkbox
li = html5.Li()
li.appendChild(checkbox)
ul.appendChild(li)
for state in self.states:
li = html5.Li()
li["class"] = ["access-state", state]
# Some modules may not support all states
if ("%s-%s" % (module, state)) not in self.values:
li["class"].append("disabled")
ul.appendChild(li)
self.modules[module][state] = li
label.appendChild(ul)
self.appendChild(label)
def setData( self, request=None, data=None, ignoreMissing=False ):
"""
Rebuilds the UI according to the skeleton received from server
@param request: A finished NetworkService request
@type request: NetworkService
@type data: dict
@param data: The data received
"""
assert (request or data)
if request:
data = NetworkService.decode( request )
try:
skelStructure = {k: v for k, v in data["structure"]}
except AttributeError:
NetworkService.notifyChange(self.module)
conf["mainWindow"].removeWidget( self )
return
print
print("data", data)
print("action", data["action"])
if "action" in data and (data["action"] in ["addSuccess", "editSuccess"]):
NetworkService.notifyChange(self.module)
logDiv = html5.Div()
logDiv["class"].append("msg")
spanMsg = html5.Span()
spanMsg.appendChild( html5.TextNode( translate("Entry saved!") ))
spanMsg["class"].append("msgspan")
logDiv.appendChild(spanMsg)
if self.module in conf["modules"].keys():
spanMsg = html5.Span()
spanMsg.appendChild( html5.TextNode( conf["modules"][self.module]["name"] ))
spanMsg["class"].append("modulspan")
logDiv.appendChild(spanMsg)
if "values" in data.keys() and "name" in data["values"].keys():
spanMsg = html5.Span()
spanMsg.appendChild( html5.TextNode( str(data["values"]["name"]) ))
spanMsg["class"].append("namespan")
logDiv.appendChild(spanMsg)
conf["mainWindow"].log("success",logDiv)
if self.closeOnSuccess:
conf["mainWindow"].removeWidget( self )
return
self.clear()
# self.bones = {}
self.reloadData()
return
self.clear()
self.actionbar.resetLoadingState()
self.dataCache = data
fieldSets = {}
cat = "byweek"
fs = html5.Fieldset()
fs["class"] = cat
if cat=="byweek":
fs["class"].append("active")
fs["name"] = cat
legend = html5.Legend()
fshref = fieldset_A()
fshref.appendChild(html5.TextNode(cat) )
legend.appendChild( fshref )
fs.appendChild(legend)
section = html5.Section()
fs.appendChild(section)
fs._section = section
fieldSets[ cat ] = fs
self.dtstart = data["values"]["startdate"]
startdateLabel = html5.Label("Termin")
startdateLabel["class"].append("termin")
startdateLabel["class"].append("date")
startdate_id = "vi_%s_%s_edit_bn_%s" % ( self.editIdx, self.module, "repeatdate")
startdateLabel["for"] = startdate_id
startdate = date.DateViewBoneDelegate("termin", "startdate", skelStructure).render(data["values"], "startdate")
startdate["id"] = startdate_id
containerDiv = html5.Div()
containerDiv.appendChild(startdateLabel)
containerDiv.appendChild(startdate)
containerDiv["class"].append("bone")
containerDiv["class"].append("bone_startdate")
containerDiv["class"].append("date")
fieldSets[ cat ]._section.appendChild( containerDiv )
countLabel = html5.Label("Wiederholungen")
countLabel["class"].append("count")
countLabel["class"].append("numeric")
count_id = "vi_%s_%s_edit_bn_%s" % ( self.editIdx, self.module, "count")
countLabel["for"] = count_id
self.count = html5.Input()
self.count["id"] = count_id
containerDiv2 = html5.Div()
containerDiv2["class"].append("bone")
containerDiv2["class"].append("bone_count")
containerDiv2["class"].append("date")
containerDiv2.appendChild(countLabel)
containerDiv2.appendChild(self.count)
# containerDiv3 = html5.Div()
# self.byweekday = list()
# for key, value in [["MO", "Mo"], ["TU", "Di"], ["TH", "Mi"], ["WE", "Do"], ["FR", "Fr"], ["SA", "Sa"], ["SU", "So"]]:
# alabel=html5.Label()
# acheckbox=html5.Input()
# acheckbox["type"]="checkbox"
# acheckbox["name"]=key
# alabel.appendChild(acheckbox)
# aspan=html5.Span()
# aspan.element.innerHTML=value
# alabel.appendChild(aspan)
# containerDiv3.appendChild(alabel)
# containerDiv2["class"].append("bone")
# containerDiv2["class"].append("bone_count")
# containerDiv2["class"].append("byweekday")
# self.byweekday.append(acheckbox)
fieldSets[ cat ]._section.appendChild(containerDiv2)
# fieldSets[ cat ]._section.appendChild(containerDiv3)
for (k,v) in fieldSets.items():
if not "active" in v["class"]:
v["class"].append("active")
tmpList = [(k,v) for (k,v) in fieldSets.items()]
tmpList.sort( key=lambda x:x[0])
for k,v in tmpList:
self.form.appendChild( v )
v._section = None
