forms-angular 0.12.0-beta.191 → 0.12.0-beta.193

package/dist/client/forms-angular.js

@@ -5,21 +5,52 @@ var fng;
     (function (directives) {
         /*@ngInject*/
         function modelControllerDropdown() {
+            var menuVisibilityStr;
+            var menuDisabledStr;
+            var itemVisibilityStr = "isHidden($index)";
+            var itemClassStr = "ng-class=\"dropdownClass($index)\"";
+            if (fng.formsAngular.elemSecurityFuncBinding) {
+                // without a more fundamental re-write, we cannot support "instant" binding here, so we'll fall-back to using
+                // the next-best alternative, which is one-time binding
+                var oneTimeBinding = fng.formsAngular.elemSecurityFuncBinding !== "normal";
+                var bindingStr = oneTimeBinding ? "::" : "";
+                // as ng-class is already being used, we'll add the .disabled class if the menu item is securely disabled using
+                // class="{{ }}".  note that we "prevent" a disabled menu item from being clicked by checking for the DISABLED
+                // attribute in the doClick(...) function, and aborting if this is found.
+                // note that the 'normal' class introduced here might not actually do anything, but for one-time binding to work
+                // properly, we need a truthy value
+                itemClassStr += " class=\"{{ ".concat(bindingStr, "isSecurelyDisabled(choice.id) ? 'disabled' : 'normal' }}\"");
+                if (oneTimeBinding) {
+                    // because the isHidden(...) logic is highly likely to be model dependent, that cannot be one-time bound.  to
+                    // be able to combine one-time and regular binding, we'll use ng-if for the one-time bound stuff and ng-hide for the rest
+                    itemVisibilityStr = "ng-if=\"::!isSecurelyHidden(choice.id)\" ng-hide=\"".concat(itemVisibilityStr, "\"");
+                }
+                else if (fng.formsAngular.elemSecurityFuncBinding === "normal") {
+                    itemVisibilityStr = "ng-hide=\"isSecurelyHidden(choice.id) || ".concat(itemVisibilityStr, "\"");
+                }
+                menuVisibilityStr = "ng-if=\"!contextMenuHidden\"";
+                menuDisabledStr = "disableable-link ng-disabled=\"contextMenuDisabled\"";
+            }
+            else {
+                menuVisibilityStr = "";
+                menuDisabledStr = "";
+                itemVisibilityStr = "ng-hide=\"".concat(itemVisibilityStr, "\"");
+            }
             return {
-                restrict: 'AE',
+                restrict: "AE",
                 replace: true,
-                template: '<li ng-show="items.length > 0" class="mcdd" uib-dropdown>' +
+                template: "<li id=\"{{ contextMenuId }}\" ng-show=\"items.length > 0\" class=\"mcdd\" uib-dropdown ".concat(menuVisibilityStr, " ").concat(menuDisabledStr, ">") +
                     ' <a href="#" uib-dropdown-toggle>' +
                     '  {{contextMenu}} <b class="caret"></b>' +
-                    ' </a>' +
+                    " </a>" +
                     ' <ul class="uib-dropdown-menu dropdown-menu">' +
-                    '  <li ng-repeat="choice in items" ng-hide="isHidden($index)" ng-class="dropdownClass($index)">' +
+                    "  <li ng-repeat=\"choice in items\" ng-attr-id=\"{{choice.id}}\" ".concat(itemVisibilityStr, " ").concat(itemClassStr, ">") +
                     '   <a ng-show="choice.text || choice.textFunc" class="dropdown-option" ng-href="{{choice.url || choice.urlFunc()}}" ng-click="doClick($index, $event)">' +
-                    '    {{ choice.text || choice.textFunc() }}' +
-                    '   </a>' +
-                    '  </li>' +
-                    ' </ul>' +
-                    '</li>'
+                    "    {{ choice.text || choice.textFunc() }}" +
+                    "   </a>" +
+                    "  </li>" +
+                    " </ul>" +
+                    "</li>",
             };
         }
         directives.modelControllerDropdown = modelControllerDropdown;
@@ -288,7 +319,7 @@ var fng;
                     //                <input type="text" class="input-small" placeholder="Email">
                     var subkeys = [];
                     var tabsSetup = tabsSetupState.N;
-                    var generateInput = function (fieldInfo, modelString, isRequired, idString, options) {
+                    var generateInput = function (fieldInfo, modelString, isRequired, options) {
                         function generateEnumInstructions() {
                             var enumInstruction;
                             if (angular.isArray(scope[fieldInfo.options])) {
@@ -314,6 +345,10 @@ var fng;
                             }
                             return enumInstruction;
                         }
+                        var idString = fieldInfo.id;
+                        if (fieldInfo.array || options.subschema) {
+                            idString = formMarkupHelper.generateArrayElementIdString(idString, fieldInfo, options);
+                        }
                         var nameString;
                         if (!modelString) {
                             var modelBase = (options.model || 'record') + '.';
@@ -335,7 +370,6 @@ var fng;
                                     }
                                     else {
                                         modelString += '[$index].' + lastPart;
-                                        idString = null;
                                         nameString = compoundName.replace(/\./g, '-');
                                     }
                                 }
@@ -350,28 +384,13 @@ var fng;
                         isRequired = isRequired || fieldInfo.required;
                         var requiredStr = isRequired ? ' required ' : '';
                         var enumInstruction;
-                        function handleReadOnlyDisabled(readonly) {
-                            var retVal = '';
-                            if (readonly) {
-                                // despite the option being "readonly", we should use disabled and ng-disabled rather than their readonly
-                                // equivalents (which give controls the appearance of being read-only, but don't actually prevent user
-                                // interaction)
-                                if (typeof readonly === "boolean") {
-                                    retVal = " disabled ";
-                                }
-                                else {
-                                    retVal = " ng-disabled=\"".concat(readonly, "\" ");
-                                }
-                            }
-                            return retVal;
-                        }
                         switch (fieldInfo.type) {
                             case 'select':
                                 if (fieldInfo.select2) {
                                     value = '<input placeholder="fng-select2 has been removed" readonly>';
                                 }
                                 else {
-                                    common += handleReadOnlyDisabled(fieldInfo.readonly);
+                                    common += formMarkupHelper.handleReadOnlyDisabled(fieldInfo);
                                     common += fieldInfo.add ? (' ' + fieldInfo.add + ' ') : '';
                                     common += " aria-label=\"".concat(fieldInfo.label && fieldInfo.label !== "" ? fieldInfo.label : fieldInfo.name, "\" ");
                                     value = '<select ' + common + 'class="' + allInputsVars.formControl.trim() + allInputsVars.compactClass + allInputsVars.sizeClassBS2 + '" ' + requiredStr + '>';
@@ -425,7 +444,7 @@ var fng;
                             case 'radio':
                                 value = '';
                                 common += requiredStr;
-                                common += handleReadOnlyDisabled(fieldInfo.readonly);
+                                common += formMarkupHelper.handleReadOnlyDisabled(fieldInfo);
                                 common += fieldInfo.add ? (' ' + fieldInfo.add + ' ') : '';
                                 var separateLines = options.formstyle === 'vertical' || (options.formstyle !== 'inline' && !fieldInfo.inlineRadio);
                                 if (angular.isArray(fieldInfo.options)) {
@@ -456,7 +475,7 @@ var fng;
                                 break;
                             case 'checkbox':
                                 common += requiredStr;
-                                common += handleReadOnlyDisabled(fieldInfo.readonly);
+                                common += formMarkupHelper.handleReadOnlyDisabled(fieldInfo);
                                 common += fieldInfo.add ? (' ' + fieldInfo.add + ' ') : '';
                                 value = formMarkupHelper.generateSimpleInput(common, fieldInfo, options);
                                 if (cssFrameworkService.framework() === 'bs3') {
@@ -465,6 +484,7 @@ var fng;
                                 break;
                             default:
                                 common += formMarkupHelper.addTextInputMarkup(allInputsVars, fieldInfo, requiredStr);
+                                common += formMarkupHelper.handleReadOnlyDisabled(fieldInfo);
                                 if (fieldInfo.type === 'textarea') {
                                     if (fieldInfo.rows) {
                                         if (fieldInfo.rows === 'auto') {
@@ -629,6 +649,9 @@ var fng;
                     };
                     var handleField = function (info, options) {
                         var fieldChrome = formMarkupHelper.fieldChrome(scope, info, options);
+                        if (fieldChrome.omit) {
+                            return "";
+                        }
                         var template = fieldChrome.template;
                         if (info.schema) {
                             var niceName = info.name.replace(/\./g, '_');
@@ -685,12 +708,24 @@ var fng;
                                         if (info.formStyle === "inline" && info.inlineHeaders) {
                                             template += generateInlineHeaders(info.schema, options, model, info.inlineHeaders === "always");
                                         }
-                                        template += '<ol class="sub-doc"' + (info.sortable ? " ui-sortable=\"sortableOptions\" ng-model=\"".concat(model, "\"") : '') + '>';
-                                        template += '<li ng-form class="' + (cssFrameworkService.framework() === 'bs2' ? 'row-fluid ' : '') +
-                                            (info.inlineHeaders ? 'width-controlled ' : '') +
-                                            convertFormStyleToClass(info.formStyle) + ' ' + (info.ngClass ? "ng-class:" + info.ngClass : "") + '" name="form_' + niceName + '{{$index}}" class="sub-doc well" id="' + info.id + 'List_{{$index}}" ' +
-                                            ' ng-repeat="subDoc in ' + model + ' track by $index"' +
-                                            (info.filterable ? ' data-ng-hide="subDoc._hidden"' : "") + '>';
+                                        var disableCond = formMarkupHelper.handleReadOnlyDisabled(info);
+                                        // if we already know that the field is disabled (only possible when formsAngular.elemSecurityFuncBinding === "instant")
+                                        // then we don't need to add the sortable attribute at all
+                                        // otherwise, we need to include the ng-disabled on the <ol> so this can be referenced by the ui-sortable directive
+                                        // (see sortableOptions)
+                                        var sortableStr = info.sortable && disableCond.trim().toLowerCase() !== "disabled"
+                                            ? "".concat(disableCond, " ui-sortable=\"sortableOptions\" ng-model=\"").concat(model, "\"")
+                                            : "";
+                                        template += "<ol class=\"sub-doc\" ".concat(sortableStr, ">");
+                                        template +=
+                                            "<li ng-form id=\"".concat(info.id, "List_{{$index}}\" name=\"form_").concat(niceName, "{{$index}}\" ") +
+                                                "  class=\"".concat(convertFormStyleToClass(info.formStyle)) +
+                                                "  ".concat(cssFrameworkService.framework() === 'bs2' ? 'row-fluid' : '') +
+                                                "  ".concat(info.inlineHeaders ? 'width-controlled' : '') +
+                                                "  ".concat(info.ngClass ? "ng-class:" + info.ngClass : '', "\"") +
+                                                "  ng-repeat=\"subDoc in ".concat(model, " track by $index\"") +
+                                                "  ".concat(info.filterable ? 'data-ng-hide="subDoc._hidden"' : '') +
+                                                ">";
                                         if (cssFrameworkService.framework() === 'bs2') {
                                             template += '<div class="row-fluid sub-doc">';
                                         }
@@ -700,7 +735,7 @@ var fng;
                                                 template += info.customSubDoc;
                                             }
                                             if (info.noRemove !== true) {
-                                                template += "<button ".concat(info.noRemove ? 'ng-hide="' + info.noRemove + '"' : '', " name=\"remove_").concat(info.id, "_btn\" ng-click=\"remove('").concat(info.name, "', $index, $event)\"");
+                                                template += "<button ".concat(disableCond, " ").concat(info.noRemove ? 'ng-hide="' + info.noRemove + '"' : '', " name=\"remove_").concat(info.id, "_btn\" ng-click=\"remove('").concat(info.name, "', $index, $event)\"");
                                                 if (info.remove) {
                                                     template += ' class="remove-btn btn btn-mini btn-default btn-xs form-btn"><i class="' + formMarkupHelper.glyphClass() + '-minus"></i> Remove';
                                                 }
@@ -755,7 +790,11 @@ var fng;
                                             else {
                                                 hideCond = info.noAdd ? "ng-hide=\"".concat(info.noAdd, "\"") : '';
                                                 indicatorShowCond = info.noAdd ? "ng-show=\"".concat(info.noAdd, " && ").concat(indicatorShowCond, "\"") : '';
-                                                footer += "<button ".concat(hideCond, " id=\"add_").concat(info.id, "_btn\" class=\"add-btn btn btn-default btn-xs btn-mini\" ng-click=\"add('").concat(info.name, "',$event)\">\n                                   <i class=\"' + formMarkupHelper.glyphClass() + '-plus\"></i> \n                                   Add\n                                 </button>");
+                                                var disableCond_1 = formMarkupHelper.handleReadOnlyDisabled(info);
+                                                footer +=
+                                                    "<button ".concat(hideCond, " ").concat(disableCond_1, " id=\"add_").concat(info.id, "_btn\" class=\"add-btn btn btn-default btn-xs btn-mini\" ng-click=\"add('").concat(info.name, "',$event)\">") +
+                                                        " <i class=\"".concat(formMarkupHelper.glyphClass(), "-plus\"></i> Add ") +
+                                                        "</button>";
                                             }
                                             if (info.noneIndicator) {
                                                 footer += "<span ".concat(indicatorShowCond, " class=\"none_indicator\" id=\"no_").concat(info.id, "_indicator\">None</span>");
@@ -790,12 +829,16 @@ var fng;
                                     throw new Error('Cannot use arrays in an inline or stacked form');
                                 }
                                 template += formMarkupHelper.label(scope, info, info.type !== 'link', options);
-                                template += formMarkupHelper.handleArrayInputAndControlDiv(generateInput(info, info.type === 'link' ? null : 'arrayItem.x', true, info.id + '_{{$index}}', options), controlDivClasses, info, options);
+                                var stashedHelp = info.help;
+                                delete info.help;
+                                var inputHtml = generateInput(info, info.type === 'link' ? null : 'arrayItem.x', true, options);
+                                info.help = stashedHelp;
+                                template += formMarkupHelper.handleArrayInputAndControlDiv(inputHtml, controlDivClasses, info, options);
                             }
                             else {
                                 // Single fields here
                                 template += formMarkupHelper.label(scope, info, null, options);
-                                template += formMarkupHelper.handleInputAndControlDiv(generateInput(info, null, options.required, info.id, options), controlDivClasses);
+                                template += formMarkupHelper.handleInputAndControlDiv(generateInput(info, null, options.required, options), controlDivClasses);
                             }
                         }
                         template += fieldChrome.closeTag;
@@ -1950,7 +1993,7 @@ var fng;
                         angular.extend(formInstructions, mongooseType.options.form);
                     }
                 }
-                if (mongooseType.instance === 'String') {
+                if (mongooseType.instance === 'String' || (mongooseType.instance === 'ObjectID' && formInstructions.asText)) {
                     if (mongooseOptions.enum) {
                         formInstructions.type = formInstructions.type || 'select';
                         if (formInstructions.select2) {
@@ -2261,14 +2304,19 @@ var fng;
                     return forceNextTime;
                 },
                 add: function add(fieldName, $event, $scope, modelOverride) {
-                    var _a;
+                    var _a, _b;
+                    // for buttons, the click event won't fire if the disabled attribute exists, but the same is not true of
+                    // icons, so we need to check this for simple array item addition
+                    if (((_a = $event === null || $event === void 0 ? void 0 : $event.target) === null || _a === void 0 ? void 0 : _a.hasAttribute) && $event.target.hasAttribute("disabled")) {
+                        return $event.preventDefault();
+                    }
                     // check that target element is visible.  May not be reliable - see https://stackoverflow.com/questions/19669786/check-if-element-is-visible-in-dom
                     if ($event.target.offsetParent) {
                         var arrayField = getArrayFieldToExtend(fieldName, $scope, modelOverride);
                         var schemaElement = $scope.formSchema.find(function (f) { return f.name === fieldName; }); // In case someone is using the formSchema directly
                         var subSchema = schemaElement ? schemaElement.schema : null;
                         var obj = subSchema ? $scope.setDefaults(subSchema, fieldName + '.') : {};
-                        if (typeof ((_a = $scope.dataEventFunctions) === null || _a === void 0 ? void 0 : _a.onInitialiseNewSubDoc) === "function") {
+                        if (typeof ((_b = $scope.dataEventFunctions) === null || _b === void 0 ? void 0 : _b.onInitialiseNewSubDoc) === "function") {
                             $scope.dataEventFunctions.onInitialiseNewSubDoc(fieldName, subSchema, obj);
                         }
                         arrayField.push(obj);
@@ -2281,6 +2329,12 @@ var fng;
                     $scope.setFormDirty($event);
                 },
                 remove: function remove(fieldName, value, $event, $scope, modelOverride) {
+                    var _a;
+                    // for buttons, the click event won't fire if the disabled attribute exists, but the same is not true of
+                    // icons, so we need to check this for simple array item removal
+                    if (((_a = $event === null || $event === void 0 ? void 0 : $event.target) === null || _a === void 0 ? void 0 : _a.hasAttribute) && $event.target.hasAttribute("disabled")) {
+                        return $event.preventDefault();
+                    }
                     // Remove an element from an array
                     var arrayField = getArrayFieldToExtend(fieldName, $scope, modelOverride);
                     var err;
@@ -2415,8 +2469,8 @@ var fng;
     var services;
     (function (services) {
         /*@ngInject*/
-        formMarkupHelper.$inject = ["cssFrameworkService", "inputSizeHelper", "addAllService", "$filter"];
-        function formMarkupHelper(cssFrameworkService, inputSizeHelper, addAllService, $filter) {
+        formMarkupHelper.$inject = ["cssFrameworkService", "inputSizeHelper", "addAllService", "$filter", "$rootScope"];
+        function formMarkupHelper(cssFrameworkService, inputSizeHelper, addAllService, $filter, $rootScope) {
             function generateNgShow(showWhen, model) {
                 function evaluateSide(side) {
                     var result = side;
@@ -2454,25 +2508,108 @@ var fng;
             function glyphClass() {
                 return (cssFrameworkService.framework() === 'bs2' ? 'icon' : 'glyphicon glyphicon');
             }
+            function handleReadOnlyDisabled(fieldInfo) {
+                if (fieldInfo.readonly && typeof fieldInfo.readonly === "boolean") {
+                    // if we have a true-valued readonly property then this trumps whatever security rule might apply to this field
+                    return " disabled ";
+                }
+                function wrapReadOnly() {
+                    return fieldInfo.readonly ? " ng-disabled=\"".concat(fieldInfo.readonly, "\" ") : "";
+                }
+                if (!fieldInfo.id || !fng.formsAngular.elemSecurityFuncBinding || !fng.formsAngular.elemSecurityFuncName || !$rootScope[fng.formsAngular.elemSecurityFuncName]) {
+                    // no security, so we're just concerned about what value fieldInfo.readonly has
+                    return wrapReadOnly();
+                }
+                if (fng.formsAngular.elemSecurityFuncBinding === "instant") {
+                    // "instant" security is evaluated now, and a positive result trumps whatever fieldInfo.readonly might be set to
+                    if ($rootScope.isSecurelyDisabled(fieldInfo.id)) {
+                        return " disabled ";
+                    }
+                    else {
+                        return wrapReadOnly();
+                    }
+                }
+                var securityFuncStr = "".concat(fng.formsAngular.elemSecurityFuncName, "('").concat(fieldInfo.id, "', 'disabled')");
+                var oneTimeBinding = fng.formsAngular.elemSecurityFuncBinding === "one-time";
+                if (fieldInfo.readonly) {
+                    // we have both security and a read-only attribute to deal with
+                    if (oneTimeBinding) {
+                        // if our field has a string-typed readonly attribute *and* one-time binding is required by our securityFunc, we
+                        // cannot simply combine these into a single ng-disabled expression, because the readonly property is highly
+                        // likely to be model-dependent and therefore cannot use one-time-binding.  the best we can do in this case is
+                        // to use ng-disabled for the field's readonly property, and a one-time-bound ng-readonly for the securityFunc.
+                        // this is not perfect, because in the case of selects, ng-readonly doesn't actually prevent the user from
+                        // making a selection.  however, the select will be styled as if it is disabled (including the not-allowed
+                        // cursor), which should deter the user in most cases.  
+                        return wrapReadOnly() + "ng-readonly=\"::".concat(securityFuncStr, "\" ");
+                    }
+                    else {
+                        // if we have both things and we are *NOT* required to use one-time binding for the securityFunc, then they can
+                        // simply be combined into a single ng-disabled expression
+                        return " ng-disabled=\"".concat(securityFuncStr, " || ").concat(fieldInfo.readonly, "\" ");
+                    }
+                }
+                else {
+                    // we have security only
+                    return " ng-disabled=\"".concat(oneTimeBinding ? "::" : "").concat(securityFuncStr, "\" ");
+                }
+            }
+            function generateArrayElementIdString(idString, info, options) {
+                if (options.subschema && options.model) {
+                    // for subschemas, it is possible that our model will begin with $parent., or $parent.$parent. (etc).  though a bit of 
+                    // a hack where this does occur (probably where a directive used by a sub-schema is using a nested <form-input>
+                    // directive), we need to look for the $index in the same place as our model is looking for data.
+                    var model = options.model;
+                    var nestedSteps = 0;
+                    var stepIndicator = "$parent.";
+                    while (model.startsWith(stepIndicator)) {
+                        nestedSteps++;
+                        model = model.substring(stepIndicator.length);
+                    }
+                    return "".concat(idString, "_{{").concat(stepIndicator.repeat(nestedSteps), "$index}}");
+                }
+                else {
+                    return "".concat(idString, "_{{$index}}");
+                }
+            }
+            function isArrayElement(scope, info, options) {
+                return scope["$index"] !== undefined || !!options.subschema;
+            }
             return {
                 isHorizontalStyle: isHorizontalStyle,
+                isArrayElement: isArrayElement,
                 fieldChrome: function fieldChrome(scope, info, options) {
+                    var insert = '';
+                    if (info.id && typeof info.id.replace === "function") {
+                        var idStr = "cg_".concat(info.id.replace(/\./g, '-'));
+                        insert += "id=\"".concat(isArrayElement(scope, info, options) ? generateArrayElementIdString(idStr, info, options) : idStr, "\"");
+                        if (fng.formsAngular.elemSecurityFuncBinding && fng.formsAngular.elemSecurityFuncName && $rootScope[fng.formsAngular.elemSecurityFuncName]) {
+                            if (fng.formsAngular.elemSecurityFuncBinding === "instant") {
+                                if ($rootScope.isSecurelyHidden(idStr)) {
+                                    // if our securityFunc supports instant binding and evaluates to true, then nothing needs to be 
+                                    // added to the dom for this field, which we indicate to our caller as follows...
+                                    return { omit: true };
+                                }
+                                ;
+                            }
+                            else {
+                                var bindingStr = fng.formsAngular.elemSecurityFuncBinding === "one-time" ? "::" : "";
+                                insert += " data-ng-if=\"".concat(bindingStr, "!").concat(fng.formsAngular.elemSecurityFuncName, "('").concat(idStr, "', 'hidden')\"");
+                            }
+                        }
+                    }
                     var classes = info.classes || '';
                     var template = '';
                     var closeTag = '';
-                    var insert = '';
                     info.showWhen = info.showWhen || info.showwhen; //  deal with use within a directive
                     if (info.showWhen) {
                         if (typeof info.showWhen === 'string') {
-                            insert += 'ng-show="' + info.showWhen + '"';
+                            insert += ' ng-show="' + info.showWhen + '"';
                         }
                         else {
-                            insert += 'ng-show="' + generateNgShow(info.showWhen, options.model) + '"';
+                            insert += ' ng-show="' + generateNgShow(info.showWhen, options.model) + '"';
                         }
                     }
-                    if (info.id && typeof info.id.replace === "function") {
-                        insert += ' id="cg_' + info.id.replace(/\./g, '-') + '"';
-                    }
                     if (cssFrameworkService.framework() === 'bs3') {
                         classes += ' form-group';
                         if (options.formstyle === 'vertical' && info.size !== 'block-level') {
@@ -2532,7 +2669,8 @@ var fng;
                         }
                         labelHTML += addAllService.addAll(scope, 'Label', null, options) + ' class="' + classes + '">' + fieldInfo.label;
                         if (addButtonMarkup) {
-                            labelHTML += ' <i id="add_' + fieldInfo.id + '" ng-click="add(\'' + fieldInfo.name + '\',$event)" class="' + glyphClass() + '-plus-sign"></i>';
+                            var disableCond = handleReadOnlyDisabled(fieldInfo);
+                            labelHTML += " <i ".concat(disableCond, " id=\"add_").concat(fieldInfo.id, "\" ng-click=\"add('").concat(fieldInfo.name, "', $event)\" class=\"").concat(glyphClass(), "-plus-sign\"></i>");
                         }
                         labelHTML += '</label>';
                         if (fieldInfo.linklabel) {
@@ -2568,13 +2706,24 @@ var fng;
                     if (['inline', 'stacked'].includes(options.formstyle)) {
                         placeHolder = placeHolder || fieldInfo.label;
                     }
-                    common = 'data-ng-model="' + modelString + '"' + (idString ? ' id="' + idString + '" name="' + idString + '" ' : ' name="' + nameString + '" ');
-                    common += (placeHolder ? ('placeholder="' + placeHolder + '" ') : '');
+                    common = 'data-ng-model="' + modelString + '"';
+                    if (idString) {
+                        common += " id=\"".concat(idString, "\"");
+                    }
+                    if (nameString) {
+                        common += " name=\"".concat(nameString, "\"");
+                    }
+                    else if (idString) {
+                        common += " name=\"".concat(idString, "\"");
+                    }
+                    if (placeHolder) {
+                        common += " placeholder=\"".concat(placeHolder, "\"");
+                    }
                     if (fieldInfo.popup) {
-                        common += 'title="' + fieldInfo.popup + '" ';
+                        common += " title=\"".concat(fieldInfo.popup, "\"");
                     }
                     if (fieldInfo.ariaLabel) {
-                        common += 'aria-label="' + fieldInfo.ariaLabel + '" ';
+                        common += " aria-label=\"".concat(fieldInfo.ariaLabel, "\"");
                     }
                     common += addAllService.addAll(scope, 'Field', null, options);
                     return {
@@ -2595,6 +2744,9 @@ var fng;
                         var helpMarkup = cssFrameworkService.framework() === 'bs2' ? { el: 'span', cl: 'help-inline' } : { el: 'div', cl: 'help-block' };
                         value += "<".concat(helpMarkup.el, " class=\"").concat(helpMarkup.cl, "\">").concat(inlineHelp, "</").concat(helpMarkup.el, ">");
                     }
+                    // this is a dummy tag identifying where the input ends and the messages block (that is only visible when the form field is $dirty)
+                    // begins.  our caller could replace this tag with anything it needs to insert between these two things.
+                    value += "<dms/>";
                     if (!options.noid) {
                         value += "<div ng-if=\"".concat((options.name || 'myForm'), "['").concat(fieldInfo.id, "'].$dirty\" class=\"help-block\">") +
                             " <div ng-messages=\"".concat((options.name || 'myForm'), "['").concat(fieldInfo.id, "'].$error\">") +
@@ -2636,17 +2788,20 @@ var fng;
                     return inputMarkup;
                 },
                 handleArrayInputAndControlDiv: function handleArrayInputAndControlDiv(inputMarkup, controlDivClasses, info, options) {
-                    var result = '<div ';
-                    if (cssFrameworkService.framework() === 'bs3') {
-                        result += 'ng-class="skipCols($index)" ';
-                    }
-                    result += 'class="' + controlDivClasses.join(' ') + '" id="' + info.id + 'List" ';
-                    result += 'ng-repeat="arrayItem in ' + (options.model || 'record') + '.' + info.name + ' track by $index">';
-                    result += inputMarkup;
-                    if (info.type !== 'link') {
-                        result += '<i ng-click="remove(\'' + info.name + '\',$index,$event)" id="remove_' + info.id + '_{{$index}}" class="' + glyphClass() + '-minus-sign"></i>';
-                    }
+                    var indentStr = cssFrameworkService.framework() === 'bs3' ? 'ng-class="skipCols($index)" ' : "";
+                    var arrayStr = (options.model || 'record') + '.' + info.name;
+                    var result = "";
+                    result += '<div id="' + info.id + 'List" class="' + controlDivClasses.join(' ') + '" ' + indentStr + ' ng-repeat="arrayItem in ' + arrayStr + ' track by $index">';
+                    var disableCond = handleReadOnlyDisabled(info);
+                    var removeBtn = info.type !== 'link'
+                        ? "<i ".concat(disableCond, " ng-click=\"remove('").concat(info.name, "', $index, $event)\" id=\"remove_").concat(info.id, "_{{$index}}\" class=\"").concat(glyphClass(), "-minus-sign\"></i>")
+                        : "";
+                    result += inputMarkup.replace("<dms/>", removeBtn);
                     result += '</div>';
+                    indentStr = cssFrameworkService.framework() === 'bs3' ? 'ng-class="skipCols(' + arrayStr + '.length)" ' : "";
+                    if (info.help) {
+                        result += '<div class="array-help-block ' + controlDivClasses.join(' ') + '" ' + indentStr + ' id="empty' + info.id + 'ListHelpBlock">' + info.help + '</div>';
+                    }
                     return result;
                 },
                 addTextInputMarkup: function addTextInputMarkup(allInputsVars, fieldInfo, requiredStr) {
@@ -2659,14 +2814,10 @@ var fng;
                         result += ' ' + fieldInfo.add + ' ';
                     }
                     result += requiredStr;
-                    if (fieldInfo.readonly) {
-                        result += " ".concat(typeof fieldInfo.readOnly === 'boolean' ? 'readonly' : 'ng-readonly="' + fieldInfo.readonly + '"', " ");
-                    }
-                    else {
-                        result += ' ';
-                    }
                     return result;
-                }
+                },
+                handleReadOnlyDisabled: handleReadOnlyDisabled,
+                generateArrayElementIdString: generateArrayElementIdString
             };
         }
         services.formMarkupHelper = formMarkupHelper;
@@ -2705,106 +2856,187 @@ var fng;
         /*@ngInject*/
         pluginHelper.$inject = ["formMarkupHelper"];
         function pluginHelper(formMarkupHelper) {
-            return {
-                extractFromAttr: function extractFromAttr(attr, directiveName) {
-                    function deserialize(str) {
-                        var retVal = str.replace(/&quot;/g, '"');
-                        if (retVal === 'true') {
-                            retVal = true;
+            function internalGenDisabledStr(id, processedAttrs, forceNg) {
+                var result = formMarkupHelper.handleReadOnlyDisabled({ id: id, readonly: processedAttrs.info.readonly }).trim();
+                // some types of control (such as ui-select) don't deal correctly with a DISABLED attribute and
+                // need ng-disabled, even when the expression is simply "true"
+                if (forceNg && result.toLowerCase() === "disabled") {
+                    return 'ng-disabled="true"';
+                }
+                else {
+                    return result;
+                }
+            }
+            function makeIdStringUniqueForArrayElements(scope, processedAttrs, idString) {
+                if (formMarkupHelper.isArrayElement(scope, processedAttrs.info, processedAttrs.options)) {
+                    return formMarkupHelper.generateArrayElementIdString(idString, processedAttrs.info, processedAttrs.options);
+                }
+                else {
+                    return idString;
+                }
+            }
+            function internalGenIdString(scope, processedAttrs, suffix, makeUniqueForArrayElements) {
+                var result = processedAttrs.info.id;
+                if (suffix) {
+                    if (!suffix.startsWith("_")) {
+                        result += "_";
+                    }
+                    result += suffix;
+                }
+                if (makeUniqueForArrayElements) {
+                    result = makeIdStringUniqueForArrayElements(scope, processedAttrs, result);
+                }
+                return result;
+            }
+            function internalGenDateTimePickerDisabledStr(processedAttrs, idString) {
+                var rawDisabledStr = internalGenDisabledStr(idString, processedAttrs, true);
+                var disabledStr = "";
+                // disabledStr might now include an ng-disabled attribute.  To disable both the date and time inputs, we need to
+                // take the value of that attribute and wrap it up as two new attributes: "disabledDate" and "readonlyTime"
+                // (which is what the datetimepicker directive is expecting to receive)
+                if (rawDisabledStr) {
+                    // disabledStr should contain either 'ng-disabled="xxxx"' or 'ng-readonly="yyyy"', or both.
+                    // the values of xxxx and yyyy could be more-or-less anything, and certainly they could include = or ", which
+                    // makes parsing hard
+                    // our strategy will be to re-format disabledStr as if it was the string representation of an object, and
+                    // then parse it.  we can then refer to the ng-disabled and ng-readonly attributes of the parsed object.
+                    // in the future, perhaps ng-disabled and ng-readonly will be changed to data-ng-disabled and data-ng-readonly
+                    rawDisabledStr = rawDisabledStr.replace("data-ng-disabled", "ng-disabled");
+                    rawDisabledStr = rawDisabledStr.replace("data-ng-readonly", "ng-readonly");
+                    rawDisabledStr = rawDisabledStr.replace("ng-disabled=", '"ng-disabled":');
+                    rawDisabledStr = rawDisabledStr.replace("ng-readonly=", '"ng-readonly":');
+                    try {
+                        rawDisabledStr = "{ ".concat(rawDisabledStr, " }");
+                        var disabledObj = JSON.parse(rawDisabledStr);
+                        rawDisabledStr = disabledObj["ng-disabled"];
+                        // cannot see a way to sensibly deal with both ng-disabled and ng-readonly.  Let's just ignore the ng-readonly
+                        // for now - with the way handleReadOnlyDisabled is currently written, this means we'll be unable to fully
+                        // support a datetime field with a string-typed "readonly" attribute and where fngAngular's elemSecurityFuncBinding
+                        // option is set up to "one-time" or "normal".
+                        if (rawDisabledStr) {
+                            disabledStr = "disabledDate=\"".concat(rawDisabledStr, "\" readonlyTime=\"").concat(rawDisabledStr, "\"");
                         }
-                        else if (retVal === 'false') {
-                            retVal = false;
+                    }
+                    catch (e) {
+                        // give up
+                    }
+                }
+                return disabledStr;
+            }
+            function extractFromAttr(attr, directiveName) {
+                function deserialize(str) {
+                    var retVal = str.replace(/&quot;/g, '"');
+                    if (retVal === "true") {
+                        return true;
+                    }
+                    else if (retVal === "false") {
+                        return false;
+                    }
+                    else {
+                        var num = parseFloat(retVal);
+                        if (!isNaN(num) && isFinite(num)) {
+                            return num;
                         }
-                        else if (!isNaN(parseFloat(retVal)) && isFinite(retVal)) {
-                            retVal = parseFloat(retVal);
+                        else {
+                            return retVal;
                         }
-                        return retVal;
                     }
-                    var info = {};
-                    var options = { formStyle: attr.formstyle };
-                    var directiveOptions = {};
-                    var directiveNameLength = directiveName ? directiveName.length : 0;
-                    var lcDirectiveName = directiveName === null || directiveName === void 0 ? void 0 : directiveName.toLowerCase();
-                    for (var prop in attr) {
-                        if (attr.hasOwnProperty(prop)) {
-                            var lcProp = prop.toLowerCase();
-                            if (lcProp.slice(0, 6) === 'fngfld') {
-                                info[lcProp.slice(6)] = deserialize(attr[prop]);
-                            }
-                            else if (lcProp.slice(0, 6) === 'fngopt') {
-                                options[lcProp.slice(6)] = deserialize(attr[prop]);
-                            }
-                            else if (directiveName && lcProp.slice(0, directiveNameLength) === lcDirectiveName) {
-                                directiveOptions[_.kebabCase(prop.slice(directiveNameLength))] = deserialize(attr[prop]);
-                            }
+                }
+                var info = {};
+                var options = { formStyle: attr.formstyle };
+                var directiveOptions = {};
+                var directiveNameLength = directiveName ? directiveName.length : 0;
+                var lcDirectiveName = directiveName === null || directiveName === void 0 ? void 0 : directiveName.toLowerCase();
+                for (var prop in attr) {
+                    if (attr.hasOwnProperty(prop)) {
+                        var lcProp = prop.toLowerCase();
+                        if (lcProp.slice(0, 6) === "fngfld") {
+                            info[lcProp.slice(6)] = deserialize(attr[prop]);
+                        }
+                        else if (lcProp.slice(0, 6) === "fngopt") {
+                            options[lcProp.slice(6)] = deserialize(attr[prop]);
+                        }
+                        else if (directiveName && lcProp.slice(0, directiveNameLength) === lcDirectiveName) {
+                            directiveOptions[_.kebabCase(prop.slice(directiveNameLength))] = deserialize(attr[prop]);
                         }
                     }
-                    return { info: info, options: options, directiveOptions: directiveOptions };
-                },
-                buildInputMarkup: function buildInputMarkup(scope, model, info, options, addButtons, needsX, generateInputControl) {
-                    var fieldChrome = formMarkupHelper.fieldChrome(scope, info, options, ' id="cg_' + info.id + '"');
-                    var controlDivClasses = formMarkupHelper.controlDivClasses(options);
-                    var elementHtml = fieldChrome.template + formMarkupHelper.label(scope, info, addButtons, options);
-                    var modelString, idString, nameString;
-                    if (addButtons) {
-                        modelString = 'arrayItem' + (needsX ? '.x' : '');
-                        idString = info.id + '_{{$index}}';
-                        nameString = info.name + '_{{$index}}';
+                }
+                return { info: info, options: options, directiveOptions: directiveOptions };
+            }
+            return {
+                extractFromAttr: extractFromAttr,
+                buildInputMarkup: function buildInputMarkup(scope, attrs, params, generateInputControl) {
+                    var processedAttrs = params.processedAttrs || extractFromAttr(attrs, "");
+                    var info = {};
+                    if (!params.ignoreFieldInfoFromAttrs) {
+                        Object.assign(info, processedAttrs.info);
                     }
-                    else {
-                        modelString = model + '.' + info.name;
-                        idString = info.id;
-                        nameString = info.name;
+                    if (params.fieldInfoOverrides) {
+                        Object.assign(info, params.fieldInfoOverrides);
                     }
-                    if (options.subschema && info.name.indexOf('.') !== -1) {
+                    var options = Object.assign({}, processedAttrs.options, params.optionOverrides);
+                    var fieldChrome = formMarkupHelper.fieldChrome(scope, info, options);
+                    if (fieldChrome.omit) {
+                        return "";
+                    }
+                    var controlDivClasses = formMarkupHelper.controlDivClasses(options);
+                    var elementHtml = fieldChrome.template + formMarkupHelper.label(scope, info, params.addButtons, options);
+                    var idString = info.id;
+                    if (info.array || options.subschema) {
+                        idString = formMarkupHelper.generateArrayElementIdString(idString, info, options);
+                    }
+                    var modelString = params.addButtons
+                        ? "arrayItem" + (params.needsX ? ".x" : "")
+                        : attrs.model + "." + info.name;
+                    var nameString = info.name;
+                    if (options.subschema && info.name.indexOf(".") !== -1) {
                         // Schema handling - need to massage the ngModel and the id
-                        var modelBase = model + '.';
-                        var compoundName = info.name;
+                        var modelBase = attrs.model + ".";
                         var root = options.subschemaroot;
-                        var lastPart = compoundName.slice(root.length + 1);
-                        modelString = modelBase;
-                        if (options.index) {
-                            modelString += root + '[' + options.index + '].' + lastPart;
-                            idString = 'f_' + modelString.slice(modelBase.length).replace(/(\.|\[|\]\.)/g, '-');
+                        var lastPart = info.name.slice(root.length + 1);
+                        modelString = modelBase + root;
+                        if (options.subkey) {
+                            idString = modelString.slice(modelBase.length).replace(/\./g, "-") + "-subkey" + options.subkeyno + "-" + lastPart;
+                            modelString += "[" + "$_arrayOffset_" + root.replace(/\./g, "_") + "_" + options.subkeyno + "]." + lastPart;
                         }
                         else {
-                            modelString += root;
-                            if (options.subkey) {
-                                idString = modelString.slice(modelBase.length).replace(/\./g, '-') + '-subkey' + options.subkeyno + '-' + lastPart;
-                                modelString += '[' + '$_arrayOffset_' + root.replace(/\./g, '_') + '_' + options.subkeyno + '].' + lastPart;
-                            }
-                            else {
-                                modelString += '[$index].' + lastPart;
-                                idString = null;
-                                nameString = compoundName.replace(/\./g, '-');
-                            }
+                            modelString += "[$index]." + lastPart;
+                            nameString = info.name.replace(/\./g, "-");
                         }
                     }
                     var buildingBlocks = formMarkupHelper.allInputsVars(scope, info, options, modelString, idString, nameString);
                     buildingBlocks.modelString = modelString;
-                    elementHtml += formMarkupHelper['handle' + (addButtons ? 'Array' : '') + 'InputAndControlDiv'](formMarkupHelper.inputChrome(generateInputControl(buildingBlocks), info, options, buildingBlocks), controlDivClasses, info, options);
+                    // defer to the calling directive to generate the markup for the input(s)
+                    var inputHtml = generateInputControl(buildingBlocks);
+                    // wrap this in a div that puts it into the correct bootstrap 'column' and adds validation messages and help text
+                    var wrappedInputHtml = formMarkupHelper.inputChrome(inputHtml, info, options, buildingBlocks);
+                    // further wrap this to add the control div classes, and in the case of an array, the button that allows array elements to be removed
+                    var inputAndControlDivGenerator = params.addButtons
+                        ? formMarkupHelper.handleArrayInputAndControlDiv
+                        : formMarkupHelper.handleInputAndControlDiv;
+                    elementHtml += inputAndControlDivGenerator(wrappedInputHtml, controlDivClasses, info, options);
                     elementHtml += fieldChrome.closeTag;
                     return elementHtml;
                 },
-                findIdInSchemaAndFlagNeedX: function findIdInSchemaAndFlagNeedX(scope, id) {
-                    // Find the entry in the schema of scope for id and add a needsX property so string arrays are properly handled
-                    var foundIt = false;
-                    for (var i = 0; i < scope.length; i++) {
-                        var element = scope[i];
-                        if (element.id === id) {
-                            element.needsX = true;
-                            foundIt = true;
-                            break;
-                        }
-                        else if (element.schema) {
-                            if (findIdInSchemaAndFlagNeedX(element.schema, id)) {
-                                foundIt = true;
-                                break;
-                            }
-                        }
-                    }
-                    return foundIt;
-                }
+                genIdString: function genIdString(scope, processedAttrs, idSuffix) {
+                    return internalGenIdString(scope, processedAttrs, idSuffix, true);
+                },
+                genDisabledStr: function genDisabledStr(scope, processedAttrs, idSuffix, forceNg) {
+                    var idString = internalGenIdString(scope, processedAttrs, idSuffix, false);
+                    return internalGenDisabledStr(idString, processedAttrs, forceNg);
+                },
+                genIdAndDisabledStr: function genIdAndDisabledStr(scope, processedAttrs, idSuffix, forceNg) {
+                    var idString = internalGenIdString(scope, processedAttrs, idSuffix, false);
+                    return "id=\"".concat(makeIdStringUniqueForArrayElements(scope, processedAttrs, idString), "\" ") + internalGenDisabledStr(idString, processedAttrs, forceNg);
+                },
+                genDateTimePickerDisabledStr: function genDateTimePickerDisabledStr(scope, processedAttrs, idSuffix) {
+                    var idString = internalGenIdString(scope, processedAttrs, idSuffix, false);
+                    return internalGenDateTimePickerDisabledStr(processedAttrs, idString);
+                },
+                genDateTimePickerIdAndDisabledStr: function genDateTimePickerIdAndDisabledStr(scope, processedAttrs, idSuffix) {
+                    var idString = internalGenIdString(scope, processedAttrs, idSuffix, false);
+                    return "id=\"".concat(makeIdStringUniqueForArrayElements(scope, processedAttrs, idString), "\" ") + internalGenDateTimePickerDisabledStr(processedAttrs, idString);
+                },
             };
         }
         services.pluginHelper = pluginHelper;
@@ -3076,18 +3308,12 @@ var fng;
                         var idList = $scope[suffixCleanId(schemaEntry, "_ids")];
                         var thisConversion = void 0;
                         if (fieldValue && idList && idList.length > 0) {
-                            if (fieldName.indexOf(".") !== -1) {
-                                throw new Error("Trying to directly assign to a nested field 332");
-                            } // Not sure that this can happen, but put in a runtime test
                             if (
-                            /*
-                             Check we are starting with an ObjectId (ie not being called because of $watch on conversion, with a
-                             converted value, which would cause an exception)
-                             */
-                            fieldValue.toString().match(/^[a-f0-9]{24}$/) &&
-                                /*
-                                  We are not suppressing conversions
-                                 */
+                            // it's not a nested field
+                            !fieldName.includes(".") &&
+                                // Check we are starting with an ObjectId (ie not being called because of $watch on conversion, with a converted value, which would cause an exception)
+                                fieldValue.toString().match(/^[a-f0-9]{24}$/) &&
+                                // We are not suppressing conversions
                                 (!schemaEntry.internalRef || !schemaEntry.internalRef.noConvert)) {
                                 anObject[fieldName] = convertForeignKeys(schemaEntry, fieldValue, $scope[suffixCleanId(schemaEntry, "Options")], idList);
                             }
@@ -3438,18 +3664,20 @@ var fng;
                 return function (response) {
                     if ([200, 400].indexOf(response.status) !== -1) {
                         var errorMessage = "";
-                        for (var errorField in response.data.errors) {
-                            if (response.data.errors.hasOwnProperty(errorField)) {
-                                errorMessage += "<li><b>" + $filter("titleCase")(errorField) + ": </b> ";
-                                switch (response.data.errors[errorField].type) {
-                                    case "enum":
-                                        errorMessage += "You need to select from the list of values";
-                                        break;
-                                    default:
-                                        errorMessage += response.data.errors[errorField].message;
-                                        break;
+                        if (response.data && response.data.errors) {
+                            for (var errorField in response.data.errors) {
+                                if (response.data.errors.hasOwnProperty(errorField)) {
+                                    errorMessage += "<li><b>" + $filter("titleCase")(errorField) + ": </b> ";
+                                    switch (response.data.errors[errorField].type) {
+                                        case "enum":
+                                            errorMessage += "You need to select from the list of values";
+                                            break;
+                                        default:
+                                            errorMessage += response.data.errors[errorField].message;
+                                            break;
+                                    }
+                                    errorMessage += "</li>";
                                 }
-                                errorMessage += "</li>";
                             }
                         }
                         if (errorMessage.length > 0) {
@@ -4088,11 +4316,25 @@ var fng;
                         //}
                     };
                     $scope.sortableOptions = {
-                        update: function () {
-                            if ($scope.topLevelFormName) {
+                        update: function (e, ui) {
+                            if (e.target.hasAttribute("disabled")) {
+                                // where formsAngular.elemSecurityFuncBinding is set to "one-time" or "normal", the <ol> that the
+                                // ui-sortable directive has been used with will have an ng-disabled that may or may not have caused
+                                // a disabled attribute to be added to that element.  in the case where this attribute has been
+                                // added, sorting should be prevented.
+                                // allowing the user to begin the drag, and then preventing it only once they release the mouse button,
+                                // doesn't seem like the best solution, but I've yet to find something that works better.  the
+                                // cancel property (see commented-out code below) looks like it should work (and kind of does), but this
+                                // screws up mouse events on input fields hosted within the draggable <li> items, so you're
+                                // basically prevented from updating any form element in the nested schema
+                                ui.item.sortable.cancel();
+                            }
+                            else if ($scope.topLevelFormName) {
                                 $scope[$scope.topLevelFormName].$setDirty();
                             }
-                        }
+                        },
+                        // don't do this (see comment above)
+                        //cancel: "ol[disabled]>li"
                     };
                     $scope.setUpCustomLookupOptions = function (schemaElement, ids, options, baseScope) {
                         for (var _i = 0, _a = [$scope, baseScope]; _i < _a.length; _i++) {
@@ -4412,8 +4654,17 @@ var fng;
             function clearContextMenu() {
                 $scope.items = [];
                 $scope.contextMenu = undefined;
+                $scope.contextMenuId = undefined;
+                $scope.contextMenuHidden = undefined;
+                $scope.contextMenuDisabled = undefined;
             }
             $rootScope.navScope = $scope; // Lets plugins access menus
+            $rootScope.isSecurelyHidden = function (elemId) {
+                return fng.formsAngular.elemSecurityFuncName && $rootScope[fng.formsAngular.elemSecurityFuncName](elemId, "hidden");
+            };
+            $rootScope.isSecurelyDisabled = function (elemId) {
+                return fng.formsAngular.elemSecurityFuncName && $rootScope[fng.formsAngular.elemSecurityFuncName](elemId, "disabled");
+            };
             clearContextMenu();
             $scope.toggleCollapsed = function () {
                 $scope.collapsed = !$scope.collapsed;
@@ -4489,11 +4740,21 @@ var fng;
                 }
                 return result;
             };
+            $scope.secureContextMenu = function () {
+                $scope.contextMenuHidden = $rootScope.isSecurelyHidden($scope.contextMenuId);
+                $scope.contextMenuDisabled = $rootScope.isSecurelyDisabled($scope.contextMenuId);
+            };
+            function initialiseContextMenu(menuCaption) {
+                $scope.contextMenu = menuCaption;
+                var menuId = "".concat(_.camelCase(menuCaption), "ContextMenu");
+                $scope.contextMenuId = menuId;
+                $scope.secureContextMenu();
+            }
             $scope.$on('fngControllersLoaded', function (evt, sharedData, modelName) {
-                $scope.contextMenu = sharedData.dropDownDisplay || sharedData.modelNameDisplay || $filter('titleCase')(modelName, false);
+                initialiseContextMenu(sharedData.dropDownDisplay || sharedData.modelNameDisplay || $filter('titleCase')(modelName, false));
                 if (sharedData.dropDownDisplayPromise) {
                     sharedData.dropDownDisplayPromise.then(function (value) {
-                        $scope.contextMenu = value;
+                        initialiseContextMenu(value);
                     });
                 }
             });
@@ -4542,8 +4803,9 @@ var fng;
                     return item.isHidden ? item.isHidden() : false;
                 }
                 var dividerHide = false;
+                var item = $scope.items[index];
                 // Hide a divider if it appears under another
-                if ($scope.items[index].divider) {
+                if (item.divider) {
                     if (index === 0) {
                         dividerHide = true;
                     }
@@ -4563,7 +4825,7 @@ var fng;
                         }
                     }
                 }
-                return dividerHide || explicitlyHidden($scope.items[index]);
+                return dividerHide || explicitlyHidden(item);
             };
             $scope.isDisabled = function (index) {
                 return $scope.items[index].isDisabled ? $scope.items[index].isDisabled() : false;