/* eslint no-unused-vars: "off", eqeqeq: "off", no-useless-assignment: "off",
          no-empty: "off", no-dupe-else-if: "off", no-use-before-define: "off",
          no-eval: "off",  no-alert: "off", no-global-assign: "off", no-self-assign: "off",
          no-useless-escape: "off", no-dupe-keys: "off", no-constant-condition: "off",
          no-unreachable: "off" */
/*global
    // ConsoleLogging.js
    ConsoleLogging


    // SharedFunctions.js
    htmlEncode


    // ShopSharedFunctions.js
    mjtElemData
    getObj
    setFocus
*/


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
var SZFocusUtils = function () {

    // TODO: Store prior value in the form-elem-data object, and most importantly, INITIALIZE IT!
    //       (Otherwise, when editing existing item, simply tabbing to the field will auto-advance it)

    var FOCUS_INFO_BUNDLE_PROPERTY_NAME_PREFIX = 'szFocusBundle_',
        m_nextFieldDataUniquifierId = 1;



    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvFocusInfoBundlePropertyName(uniquifierId_) {
        return FOCUS_INFO_BUNDLE_PROPERTY_NAME_PREFIX + uniquifierId_;
    }



    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvGetAndAdvanceUniquifierId() {
        return m_nextFieldDataUniquifierId++;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvNumDecimalPlaces(value_){
        var strValue = '' + value_,
            idxDecimal = strValue.indexOf('.'),
            tmpStrLen = strValue.length,
            rcDecimalCount =
                idxDecimal < 0 ?
                    0 :
                    tmpStrLen - idxDecimal - 1;

        return rcDecimalCount;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function ptTestForAutoAdvanceField(params_) {
        ConsoleLogging.logBlockOpen('SZFocusUtils.ptTestForAutoAdvanceField()');
        var strFormId = params_.formId,
            tmpUniquifierId = params_.uniquifierId,

            theForm = getObj(strFormId),
            objFormElemData = mjtElemData(theForm, 'formElemData'),
            strFocusInfoBundlePropertyName =
                pvFocusInfoBundlePropertyName(
                    tmpUniquifierId),
            objFocusInfoBundle =
                objFormElemData[strFocusInfoBundlePropertyName],

            strFieldName = objFocusInfoBundle.fieldName,
            fnActionOnAdvance = objFocusInfoBundle.fnActionOnAdvance,
            strFollowingFocusFieldName =
                objFocusInfoBundle.followingFocusFieldName,
            tmpAdvanceIfGreaterThanIntVal =
                objFocusInfoBundle.advanceIfGreaterThanIntVal,
            tmpMaxDecimalPlaces = objFocusInfoBundle.maxDecimalPlaces,
            strPriorValue = objFocusInfoBundle.priorValue,

            objField = theForm[strFieldName],
            strValue = objField.value,
            tmpFloatVal = parseFloat(strValue),
            tmpIsValidFloat = !isNaN(tmpFloatVal),
            tmpIntValue = parseInt(strValue, 10),
            tmpIsValidInt = !isNaN(tmpIntValue),
            objFollowingField =
                strFollowingFocusFieldName ?
                    theForm[strFollowingFocusFieldName] :
                    null,
            tmpNumDecimalPlaces = pvNumDecimalPlaces(strValue),

            tmpDoAdvance =
                (tmpIsValidInt &&
                    tmpAdvanceIfGreaterThanIntVal &&
                    tmpIntValue &&
                    tmpIntValue > tmpAdvanceIfGreaterThanIntVal) ||
                (tmpIsValidFloat &&
                    tmpMaxDecimalPlaces &&
                    tmpNumDecimalPlaces &&
                    tmpNumDecimalPlaces >= tmpMaxDecimalPlaces);

        ConsoleLogging.logObject({
            tmpIsValidInt: tmpIsValidInt,
            tmpIntValue: tmpIntValue,
            tmpAdvanceIfGreaterThanIntVal: tmpAdvanceIfGreaterThanIntVal,
            tmpDoAdvance: tmpDoAdvance,
            strFollowingFocusFieldName: strFollowingFocusFieldName,
            is_objFollowingField: !!objFollowingField,
            tmpIsValidFloat: tmpIsValidFloat,
            tmpMaxDecimalPlaces: tmpMaxDecimalPlaces,
            tmpNumDecimalPlaces: tmpNumDecimalPlaces,
            params_: params_,
            strFocusInfoBundlePropertyName: strFocusInfoBundlePropertyName,
            objFocusInfoBundle: objFocusInfoBundle
        });

        objFocusInfoBundle.priorValue = strValue;

        if (strPriorValue.length !== strValue.length) {
            if (tmpDoAdvance) {
                if (fnActionOnAdvance) {
                    fnActionOnAdvance();
                } else {
                    setFocus(objFollowingField);
                }
            }
        }


        ConsoleLogging.logBlockClose();
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBuildOnChangeAttrValue(params_) {
        var strFormId = params_.formId,
            objFormElemData = params_.formElemData,
            strFieldName = params_.fieldName,
            tmpMaxDecimalPlaces = params_.maxDecimalPlaces,
            tmpAdvanceIfGreaterThanIntVal =
                params_.advanceIfGreaterThanIntVal,
            fnActionOnAdvance = params_.fnActionOnAdvance,
            strFollowingFocusFieldName = params_.followingFocusFieldName,
            strInitialValue = params_.initialValue,

            tmpUniquifierId = pvGetAndAdvanceUniquifierId(),
            objParams =
            {
                formId: strFormId,
                uniquifierId: tmpUniquifierId
            },
            strEncodedParams =
                htmlEncode(JSON.stringify(objParams)),
            rcOnChangeAttrVal =
                "SZFocusUtils.PROTECTED.testForAutoAdvanceField(" +
                strEncodedParams + ")",

            strFocusInfoBundlePropertyName =
                pvFocusInfoBundlePropertyName(tmpUniquifierId),
            objFocusInfoBundle =
            {
                priorValue: strInitialValue || '',
                fieldName: strFieldName,
                maxDecimalPlaces: tmpMaxDecimalPlaces,
                advanceIfGreaterThanIntVal: tmpAdvanceIfGreaterThanIntVal,
                fnActionOnAdvance: fnActionOnAdvance,
                followingFocusFieldName: strFollowingFocusFieldName
            };

        // Save off info to be used in the handler.
        objFormElemData[strFocusInfoBundlePropertyName] = objFocusInfoBundle;

        return rcOnChangeAttrVal;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    return {
        buildOnChangeAttrValue: pbBuildOnChangeAttrValue,


        PROTECTED: {
            testForAutoAdvanceField: ptTestForAutoAdvanceField
        }
    };
}(); 
/*global
    cdBuildFontIconElem
    cdBuildMnemonicLabelHTML
    cdBuildOpenDialogLabelCell
    ClientDialogModule
    consoleLog
    consoleLogBlockClose
    consoleLogBlockOpen
    displayTimedMessage
    FontIconId_Enum
    g_dcCustomDialogConfirmerElement
    g_dcForcedDirtyClass
    g_dcForceScan
    g_imageVersion
    getDateForUrlParam
    getObj
    hideDialog
    hideSubdialog
    htmlEncode
    htmlMultilineEncode
    jsrsExecuteWithErrorP
    MJTDictionary
    MWDateTime
    mwShowGenericReorderDialog
    pageIncludeRoot
    posLeft
    posTop
    setFocus
    StringificationUtils
    trim
*/

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//function adjustAlphaIndexForScrollOrSize(adjustForAlphaIndexHeight_) {
//    var tmpWindow = $(window),
//        tmpWindowScrollTop = tmpWindow.scrollTop(),
//        tmpDivAlphaIndex = $("#divAlphaIndex"),
//        tmpAlphaIndexOffset = tmpDivAlphaIndex ? tmpDivAlphaIndex.offset() : 0,
//        tmpAlphaIndexOffsetTop = tmpAlphaIndexOffset ? tmpAlphaIndexOffset.top : 0,
//        objAlphaIndexTable = $('#tblAlphaIndex'),
//        tmpAlphaIndexTableHeight = objAlphaIndexTable ? objAlphaIndexTable.height() : 0,
//        objAlphaIndexCell = getObj('cellAlphaIndex'),
//        tmpWindowHeight = tmpWindow.height(),
//        tmpTblAlphaIndex = tmpDivAlphaIndex.closest("table"),
//        tmpTblOffset = tmpTblAlphaIndex.offset();


//    if (!tmpTblOffset) {
//        return;
//    }

//    var tmpRecipeListContentTop = tmpTblOffset.top,
//        tmpRecipeListContentHeight = tmpTblAlphaIndex.height();


//    if (adjustForAlphaIndexHeight_) {
//        if (objAlphaIndexCell && tmpRecipeListContentHeight < 1.5 * tmpWindow.height()) {
//            objAlphaIndexCell.style.display = 'none';
//        } else {
//            objAlphaIndexCell.style.display = '';
//        }
//    }

//    if (tmpAlphaIndexOffset) {
//        if (tmpWindowScrollTop + tmpWindowHeight > tmpRecipeListContentTop + tmpRecipeListContentHeight &&
//                tmpAlphaIndexTableHeight > tmpWindowHeight) {
//            //  The bottom has come on-screen and the index is larger than the screen, so stick
//            // it to the bottom.
//            getObj('tblAlphaIndex').style.position = 'fixed';
//            getObj('tblAlphaIndex').style.top = '';
//            getObj('tblAlphaIndex').style.bottom = '10px';
//        } else if (tmpWindowScrollTop > tmpAlphaIndexOffsetTop) {
//            //  We've scrolled down so that the area is up off the page, so stick the top of the index to the top of the page.
//            getObj('tblAlphaIndex').style.position = 'fixed';
//            getObj('tblAlphaIndex').style.bottom = '';
//            getObj('tblAlphaIndex').style.top = '0px';
//        } else if (tmpAlphaIndexOffsetTop > tmpWindowScrollTop) {
//            //  The top of the index section is below the top of the page, so stick it to the top of the parent...
//            getObj('tblAlphaIndex').style.position = 'relative';
//            getObj('tblAlphaIndex').style.top = '0px';
//            getObj('tblAlphaIndex').style.bottom = '';
//        }
//    }
//}


////------------------------------------------------------------------------------
////------------------------------------------------------------------------------
//function setupStandardAlphaIndexHandlers() {
//    //var tmpWindow = $(window);
//    window.onscroll =
//        function () {
//            adjustAlphaIndexForScrollOrSize(0/*adjustForAlphaIndexHeight_*/);
//        };

//    window.onresize =
//        function () {
//            adjustAlphaIndexForScrollOrSize(1/*adjustForAlphaIndexHeight_*/);
//        };

//    adjustAlphaIndexForScrollOrSize(1/*adjustForAlphaIndexHeight_*/);
//}



//------------------------------------------------------------------------------
//
//
//  arrCellIdsWithEditDoneColspans_:  This is the list of any cells (in
//                                    additional rows) that will need their
//                                    colSpan values adjusted.
//
//------------------------------------------------------------------------------
//function toggleColumnsForEdit(editButtonId_, deleteButtonId_, startingCellIndex_, mandatoryColumnPrefix_, rbIdPrefix_, arrOptionalColumnPrefixes_, arrCellIdsWithEditDoneColspans_) {
//    var objEditButton = getObj(editButtonId_),
//        objDeleteButton = getObj(deleteButtonId_),
//        tmpNowEditing = objEditButton.innerHTML === 'Edit',
//        i,
//        j,
//        objMandatoryCell,
//        objOptionalCell,
//        strId,
//        tmpEditingSpan,
//        tmpDoneSpan,
//        arrCellSpanInfo;
//    if(objDeleteButton) {
//        objDeleteButton.style.display = tmpNowEditing ? '' : 'none';
//    }
//    objEditButton.innerHTML = tmpNowEditing ? 'Done' : 'Edit';


//    if(arrCellIdsWithEditDoneColspans_) {
//        for(i = 0; i < arrCellIdsWithEditDoneColspans_.length; ++i) {
//            arrCellSpanInfo = arrCellIdsWithEditDoneColspans_[i];
//            strId = arrCellSpanInfo[0];
//            tmpEditingSpan = arrCellSpanInfo[1];
//            tmpDoneSpan = arrCellSpanInfo[2];

//            getObj(strId).colSpan = tmpNowEditing ? tmpEditingSpan : tmpDoneSpan;
//        }
//    }


//    i = startingCellIndex_;
//    while(true) {
//        strId = mandatoryColumnPrefix_ + i;
//        objMandatoryCell = getObj(strId);
//        if(!objMandatoryCell) {
//            break;
//        }

//        if(rbIdPrefix_ && !tmpNowEditing) {
//            setCBChecked(rbIdPrefix_ + i/*id_*/, 0/*checked_*/);
//        }
//        objMandatoryCell.style.display = tmpNowEditing ? '' : 'none';


//        if(arrOptionalColumnPrefixes_) {
//            for(j = 0; j < arrOptionalColumnPrefixes_.length; ++j) {
//                objOptionalCell = getObj(arrOptionalColumnPrefixes_[j] + i);
//                if(objOptionalCell) {
//                    objOptionalCell.style.display = tmpNowEditing ? '' : 'none';
//                }
//            }
//        }
//        ++i;
//    }
//}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//function isMobile() {
//    if(typeof g_isMobile === 'undefined') {
//        return false;
//    }
//    return !!g_isMobile;
//}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//function setDialogPositionForMediaAndOpen(dialogId_, forceTop_, complexCenterAdjustment_, forceLeft_) {
//    if (isMobile()) {
//        if (typeof forceTop_ == 'undefined') {
//            forceTop_ = true;
//        }
//        if (typeof forceLeft_ == 'undefined') {
//            forceLeft_ = true;
//        }
//    }
//    var tmpPosition,
//        objDialog = $("#" + dialogId_),
//        strLeft = (forceLeft_ || isNarrowScreen()) ? "left " : "";
//
//    if (forceTop_ || isNarrowScreen()) {
//        tmpPosition = { my: strLeft + "top", at: strLeft + "top", of: window };
//    } else {
//        //tmpPosition = null;//{ my: "center", at: "center", of: window };
//        tmpPosition = { my: strLeft + "center", at: strLeft + "center", of: window };
//    }
//
//    objDialog.dialog("open");
//    if (complexCenterAdjustment_) {
//        objDialog.dialog("option", { position: { my: "left top", at: "left top", of: window } });
//        setTimeout(function () { objDialog.dialog("option", { position: tmpPosition }); }, 10);
//    } else {
//        objDialog.dialog("option", { position: tmpPosition });
//    }
//}




//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//function adjustDialogLayouts(objDialog_, arrWideFields_) {
//    var tmpWindowWidth = $(window).width(),
//        tmpObserveAlternateWidth = tmpWindowWidth > 550,
//        tmpDlgWidth = tmpObserveAlternateWidth ? Math.min(tmpWindowWidth - 44, 750) : 350,
//        tmpFieldWidth = tmpDlgWidth - (tmpObserveAlternateWidth ? 44 : 24),
//        idx;
//
//    objDialog_.dialog({ width: tmpDlgWidth });
//    for (idx = 0; idx < arrWideFields_.length; ++idx) {
//        arrWideFields_[idx].width(tmpFieldWidth);
//    }
//}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//function isNarrowScreen() {
//    return window.matchMedia && window.matchMedia("(max-width: 550px)").matches;
//}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//function isShortScreen() {
//    return window.matchMedia && window.matchMedia("(max-height: 500px)").matches;
//}






//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
var XZCommonUtils = function() {
    var _arrKeyDownHandlerFunctions = [],
        _keyDownHandlerNameToIndexMap = new MJTDictionary(),
        _arrKeyUpHandlerFunctions = [],
        _keyUpHandlerNameToIndexMap = new MJTDictionary(),

        TextBoxPositionMeaning_Enum = {
            tbpmCenter: 1,
            tbpmBottomCenter: 2
        };


    //--------------------------------------------------------------------------
    //#region Dialog Confirmer class management
    //--------------------------------------------------------------------------
    function pvFlagElementWithClass(params_) {
        var objTargetElement = params_.targetElement,
            tmpClearFlag = params_.clearFlag,
            strClassName = params_.className;

        if(objTargetElement) {
            if(tmpClearFlag) {
                objTargetElement.classList.remove(strClassName);
            } else {
                objTargetElement.classList.add(strClassName);
            }
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvFlagElementWithDialogConfirmerClasses(params_) {
        var objTargetElement = params_.targetElement,
            arrClassToggleIndicators = params_.arrClassToggleIndicators;

        arrClassToggleIndicators.forEach(function(toggleIndicator_) {
            pvFlagElementWithClass({
                targetElement: objTargetElement,
                clearFlag: toggleIndicator_.clearFlag,
                className: toggleIndicator_.className
            });
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetCustomConfirmationClass() {
        // Class indicates that the associated non-standard element should
        // be scanned for dirty flag
        return g_dcCustomDialogConfirmerElement;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlagElementForCustomDialogConfirmation(params_) {
        pvFlagElementWithClass({
            targetElement: params_.targetElement,
            clearFlag: params_.clearFlag,

            // Class indicates that the associated non-standard element should
            // be scanned for dirty flag
            className: pbGetCustomConfirmationClass()
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetForcedDirtyClass() {
        // Consider dirty even if no record of changes
        return g_dcForcedDirtyClass;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlagElementForcedDirty(params_) {
        pvFlagElementWithClass({
            targetElement: params_.targetElement,
            clearFlag: params_.clearFlag,

            className: pbGetForcedDirtyClass()
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetForcedScanClass() {
        // Scan even if hidden element
        return g_dcForceScan;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlagElementForcedScan(params_) {
        pvFlagElementWithClass({
            targetElement: params_.targetElement,
            clearFlag: params_.clearFlag,

            // Scan even if hidden element
            className: pbGetForcedScanClass()
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFlagCustomElementForcedDirtyAndForcedScan(params_) {
        var objTargetElement = params_.targetElement,
            tmpClearForcedDirtyClass = params_.clearForcedDirtyClass;

        pvFlagElementWithDialogConfirmerClasses({
            targetElement: objTargetElement,
            arrClassToggleIndicators: [
                {
                    className: pbGetCustomConfirmationClass()
                },
                {
                    className: pbGetForcedScanClass()
                },
                {
                    className: pbGetForcedDirtyClass(),
                    clearFlag: tmpClearForcedDirtyClass
                }
            ]
        });
    }
    //--------------------------------------------------------------------------
    //#endregion Dialog Confirmer class management
    //--------------------------------------------------------------------------



    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbNoOp() { }


    //--------------------------------------------------------------------------
    // TODO: Add to FormValidator? ClientDialogModule?
    //--------------------------------------------------------------------------
    function pbOptionallyValidateRequiredField(params_) {
        var objField = params_.field,
            objResultValueHolder = params_.resultValueHolder,
            tmpSuppressErrorMessage = params_.suppressErrorMessage,
            strRawMessage = params_.rawMessage,

            strRawValue = (objField || {}).value,
            rcIsValid;

        if(!objField) {
            if(!tmpSuppressErrorMessage) {
                ClientDialogModule.showDialogWithConsequence({
                    formTitle: 'Missing Field',
                    simpleRowContentHtml:
                        '<div class="dlgErrorPanel">' +
                            htmlMultilineEncode(
                                'Missing field for required field validation!\n\n' +
                                strRawMessage) +
                        '</div>',
                    subdialogDismisalFocusFieldName: objField.name,
                    subdialogDismisalFocusFieldId: objField.id
                });
            }
        } else if(trim(strRawValue)) {
            rcIsValid = true;
        } else if(!tmpSuppressErrorMessage) {
            ClientDialogModule.showDialogWithConsequence({
                formTitle: 'Missing Value',
                simpleRowContentHtml:
                    '<div class="dlgErrorPanel">' +
                        htmlMultilineEncode(strRawMessage) +
                    '</div>',
                subdialogDismisalFocusFieldName: objField.name,
                subdialogDismisalFocusFieldId: objField.id
            });
        }

        objResultValueHolder.rawValue = strRawValue;
        objResultValueHolder.isValid;

        return rcIsValid;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbRefreshListContents() {
        displayTimedMessage('Reloading...');
        window.location.reload(true);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbHideDialogAndRefreshListContents() {
        hideDialog();
        pbRefreshListContents();
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbHideDialogAndRefreshPage() {
        hideDialog();
        displayTimedMessage('Refreshing Page...');
        window.location.reload(false); // force_
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbSelRBFocusField(rbId_, fieldId_) {
        var objRB = getObj(rbId_),
            objFld = getObj(fieldId_);
        if(objRB) {
            objRB.checked = true;
        }
        setFocus(objFld);
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pbGetDurationToNow(params_) {
        var theForm = params_.form,
            objResultsHolder = params_.durationResultsHolder || {},
            strRaw24HourStartTime = params_.raw24HourStartTime,
            strDateFieldName = params_.dateFieldName,
            tmpTruncToTheMinute = params_.truncateToTheMinute;

        objResultsHolder.rcDuration = 0;
        objResultsHolder.durationTruncatedToTheMinute = tmpTruncToTheMinute;

        var objDate = strDateFieldName ? theForm[strDateFieldName] : null,
            rc;


        if(strDateFieldName && !objDate) {
            alert('setStopTime() - Couldn\'t get date field (name="' + strDateFieldName + '")');
            return rc;
        }

        var strDate = objDate ? getDateForUrlParam(objDate.value) : '',
            objNow = new Date(),
            objEndTime =
                new Date(
                    objNow.getFullYear(),
                    objNow.getMonth(),
                    objNow.getDate(),
                    objNow.getHours(),
                    objNow.getMinutes(),
                    tmpTruncToTheMinute ? 0 : objNow.getSeconds(),
                    0),

            y = objEndTime.getFullYear(),
            mm = objEndTime.getMonth(),
            d = objEndTime.getDate();
        if(strDate) {
            var arrDate = strDate.split('-');
            y = parseInt(arrDate[0], 10);
            mm = parseInt(arrDate[1], 10) - 1;
            d = parseInt(arrDate[2], 10);
        }


        var arrStartTime = strRaw24HourStartTime.split(':'),
            tmpStartingHour = parseInt(arrStartTime[0], 10),
            tmpStartingMinute = parseInt(arrStartTime[1], 10),
            tmpStartingSecond =
                (arrStartTime.length > 2 && !tmpTruncToTheMinute) ?
                    arrStartTime[2] :
                    0,
            tmpStartingMS = 0,
            objStartTime =
                new Date(
                    y,
                    mm,
                    d,
                    tmpStartingHour,
                    tmpStartingMinute,
                    tmpStartingSecond,
                    tmpStartingMS);

        if(objStartTime > objEndTime) {
            alert('The start time is in the future!');
        } else {
            var tmpStartMS = objStartTime.getTime(),
                tmpEndMS = objEndTime.getTime(),

                tmpDeltaMS = tmpEndMS - tmpStartMS,
                tmpDeltaSeconds =
                    tmpTruncToTheMinute ?
                        0 :
                        ((tmpDeltaMS - (tmpDeltaMS % 1000)) / (1000)),

                tmpSeconds = tmpDeltaSeconds % 60,
                tmpMinutes = ((tmpDeltaSeconds - tmpSeconds) / 60) % 60,
                tmpHours = (tmpDeltaSeconds - 60 * tmpMinutes - tmpSeconds) / (60 * 60);

            if(tmpHours * 60 + tmpMinutes > 60 * 18) {
                alert(
                    "Can't have a duration > 18 hours!\n" +
                    "\n" +
                    "(Stopping now would result in a duration of " +
                    tmpHours + " hours" +
                    (tmpMinutes > 0 ? " and " + tmpMinutes + " minute" + (tmpMinutes > 1 ? "s" : "") : "") +
                    (tmpTruncToTheMinute ?
                        "" :
                        (tmpSeconds > 0 ? " and " + tmpSeconds + " second" + (tmpSeconds > 1 ? "s" : "") : "")) +
                    ".)");
            } else {
                if(tmpHours === 0 && tmpMinutes === 0 && tmpTruncToTheMinute) {
                    tmpMinutes = 1;
                }

                objResultsHolder.durationHours = tmpHours;
                objResultsHolder.durationMinutes = tmpMinutes;
                objResultsHolder.durationSeconds = tmpSeconds;

                rc = true;
            }
        }

        return rc;
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pvDecodeDurationFieldName(fieldName_) {
        var idxLastDot = fieldName_.lastIndexOf('.'),
            strFieldPrefix = fieldName_.substring(0, idxLastDot),
            strFieldSuffix = fieldName_.substring(idxLastDot + 1),
            tmpIsHour = strFieldSuffix === "h",
            tmpIsMinute =
                !tmpIsHour &&
                strFieldSuffix === 'm',
            tmpIsSecond = !(tmpIsMinute || tmpIsHour);

        return {
            durationFieldNameBase: strFieldPrefix,
            isHour: tmpIsHour ? 1 : undefined,
            isMinute: tmpIsMinute ? 1 : undefined,
            isSecond: tmpIsSecond ? 1 : undefined
        };
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pbDecodeDurationFields(params_) {
        var theForm = params_.form,
            strDurationFieldNameBase = params_.durationFieldNameBase,
            objHourElem = theForm[strDurationFieldNameBase + '.h'],
            objMinuteElem = theForm[strDurationFieldNameBase + '.m'],
            objSecondElem = theForm[strDurationFieldNameBase + '.s'],

            strRawHourValue = objHourElem ? objHourElem.value : '',
            strRawMinuteValue = objMinuteElem.value,
            strRawSecondValue = objSecondElem.value,

            tmpIsEmptyHours = trim(strRawHourValue) === '',
            tmpIsEmptyMinutes = trim(strRawMinuteValue) === '',
            tmpIsEmptySeconds = trim(strRawSecondValue) === '',

            tmpIsFullyEmpty =
                tmpIsEmptyHours && tmpIsEmptyMinutes && tmpIsEmptySeconds,

            tmpTotalSeconds =
                tmpIsFullyEmpty ?
                    null :
                    ((parseInt(strRawHourValue || '0', 10) || 0) * 60 * 60 +
                        (parseInt(strRawMinuteValue || '0', 10) || 0) * 60 +
                        (parseInt(strRawSecondValue || '0', 10) || 0)),

            rc = {
                hourElement: objHourElem,
                minuteElement: objMinuteElem,
                secondElement: objSecondElem,

                rawHourValue: strRawHourValue,
                rawMinuteValue: strRawMinuteValue,
                rawSecondValue: strRawSecondValue,

                totalSeconds: tmpTotalSeconds,

                combinedValue: ''
            };

        if(strRawHourValue && strRawHourValue !== '00' && strRawHourValue !== '0') {
            rc.combinedValue =
                strRawHourValue +
                ':' + (strRawMinuteValue || '00') +
                ':' + (strRawSecondValue || '00');
        } else if(strRawMinuteValue && strRawMinuteValue !== '00' && strRawMinuteValue !== '0') {
            rc.combinedValue =
                strRawMinuteValue +
                ':' + (strRawSecondValue || '00');
        } else if(strRawSecondValue && strRawSecondValue !== '00' && strRawSecondValue !== '0') {
            rc.combinedValue = strRawSecondValue;
        }

        return rc;
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function ptDurationChanged(field_, maxDigits_, followingFocusFieldName_) {
        maxDigits_ = maxDigits_ || 2;
        var objDecodedFieldName = pvDecodeDurationFieldName(field_.name),
            strDurationFieldNameBase = objDecodedFieldName.durationFieldNameBase,
            objDecodedDurationFields =
                pbDecodeDurationFields({
                    form: field_.form,
                    durationFieldNameBase: strDurationFieldNameBase
                }),
            objHourElem = objDecodedDurationFields.hourElement,
            objMinuteElem = objDecodedDurationFields.minuteElement,
            objSecondElem = objDecodedDurationFields.secondElement,

            tmpIsHour = objDecodedFieldName.isHour,
            tmpIsMinute = objDecodedFieldName.isMinute,
            tmpIsSecond = objDecodedFieldName.isSecond,

            objUpdatedElem =
                tmpIsHour ?
                    objHourElem :
                    tmpIsMinute ?
                        objMinuteElem :
                        objSecondElem,
            theForm = objUpdatedElem.form,
            objFollowingFocusField =
                followingFocusFieldName_ && theForm ?
                    theForm[followingFocusFieldName_] :
                    null,
            strValue = objUpdatedElem.value,
            strPriorValue = objUpdatedElem.getAttribute('data-priorDurVal') || '';

        objUpdatedElem.setAttribute('data-priorDurVal', strValue);
        if(strPriorValue.length !== strValue.length) {
            if(strValue.length > maxDigits_) {
                objUpdatedElem.value = strValue.substring(0, 2);
            }
            if(strValue.length === maxDigits_) {
                if(tmpIsHour) {
                    setFocus(objMinuteElem);
                } else if(tmpIsMinute) {
                    setFocus(objSecondElem);
                } else if(tmpIsSecond && objFollowingFocusField) {
                    setFocus(objFollowingFocusField);
                }
            } else if((tmpIsMinute || tmpIsSecond) && strValue.length === 1) {
                if('6789'.indexOf(strValue) > -1) {
                    // Can't possibly be a second digit, so move on...
                    if(tmpIsMinute) {
                        setFocus(objSecondElem);
                    } else if(objFollowingFocusField) {
                        setFocus(objFollowingFocusField);
                    }
                }
            }
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function ptDurationKeyup(field_, maxDigits_, followingFocusFieldName_) {
        ptDurationChanged(field_, maxDigits_, followingFocusFieldName_);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBuildDurationFields(params_) {
        var strDurationFieldNameBase = params_.durationFieldNameBase,
            strComposedFieldValue = params_.composedFieldValue,
            tmpOmitHours = params_.omitHours,
            strFollowingFocusFieldName = params_.followingFocusFieldName,


            strEncodedFollowingFocusFieldNameToUse =
                strFollowingFocusFieldName ?
                    "'" + strFollowingFocusFieldName + "'" :
                    'undefined',

            strHoursFieldName = strDurationFieldNameBase + '.h',
            strMinutesFieldName = strDurationFieldNameBase + '.m',
            strSecondsFieldName = strDurationFieldNameBase + '.s',

            arrSplitFieldValue = strComposedFieldValue.split(':'),
            tmpSplitFieldCount = arrSplitFieldValue.length,

            strSeconds = arrSplitFieldValue[tmpSplitFieldCount - 1],
            strMinutes =
                tmpSplitFieldCount > 1 ?
                    arrSplitFieldValue[tmpSplitFieldCount - 2] :
                    '',
            strHours =
                tmpSplitFieldCount > 2 ?
                    arrSplitFieldValue[tmpSplitFieldCount - 3] :
                    '',

            strClassAttr =
                " class='clsDurationSubfield'",

            strHoursFieldHtml =
                '<input' +
                        ' name="' + strHoursFieldName + '"' +
                        ' placeholder="H"' +
                        ' data-priorDurVal="' + htmlEncode(strHours) + '"' +
                        ' value="' + htmlEncode(strHours) + '"' +
                        ' onchange="XZCommonUtils.PROTECTED.durationChanged(this,1)"' +
                        ' onkeyup="XZCommonUtils.PROTECTED.durationKeyup(this,1)"' +
                        strClassAttr +
                        ' type="number"' +
                        //' inputmode="decimal"' +
                        ' />' +
                ' : ',
            rc;

        rc = (tmpOmitHours ? '' : strHoursFieldHtml) +
            '<input' +
                    ' name="' + strMinutesFieldName + '"' +
                    ' placeholder="MM"' +
                    ' data-priorDurVal="' + htmlEncode(strMinutes) + '"' +
                    ' value="' + htmlEncode(strMinutes) + '"' +
                    ' onchange="XZCommonUtils.PROTECTED.durationChanged(this)"' +
                    ' onkeyup="XZCommonUtils.PROTECTED.durationKeyup(this)"' +
                    strClassAttr +
                    ' type="number"' +
                    //' inputmode="decimal"' +
                    ' />' +
            ' : ' +
            '<input' +
                    ' name="' + strSecondsFieldName + '"' +
                    ' placeholder="SS"' +
                    ' data-priorDurVal="' + htmlEncode(strSeconds) + '"' +
                    ' value="' + htmlEncode(strSeconds) + '"' +
                    ' onchange="XZCommonUtils.PROTECTED.durationChanged(this,undefined,' + strEncodedFollowingFocusFieldNameToUse + ')"' +
                    ' onkeyup="XZCommonUtils.PROTECTED.durationChanged(this,undefined,' + strEncodedFollowingFocusFieldNameToUse + ')"' +
                    strClassAttr +
                    ' type="number"' +
                    //' inputmode="decimal"' +
                    ' />';


        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBuildDurationFieldsRow(params_) {
        if(!params_) {
            params_ = {};
        }

        var strRowId = params_.rowId,
            tmpHideRow = params_.hideRow,
            strAdditionalFieldRowClasses = params_.additionalFieldRowClasses,
            strAdditionalFieldCellClasses = params_.additionalFieldCellClasses,
            strAdditionalLabelCellClasses = params_.additionalLabelCellClasses,
            strFieldLabelId = params_.fieldLabelId,
            tmpSuppressLabelColon = params_.suppressLabelColon,
            strPreFieldsHtml = params_.preFieldsHtml || '',
            strPostFieldsHtml = params_.postFieldsHtml || '',

            strLabelHtml = cdBuildMnemonicLabelHTML(params_),

            strRowIdAttr =
                strRowId ?
                    ' id="' + strRowId + '"' :
                    '',
            strRowStyleAttr = tmpHideRow ? ' style="display:none"' : '',
            strFieldRowClassAttr =
                strAdditionalFieldRowClasses ?
                    ' class="' + strAdditionalFieldRowClasses + '" ' :
                    '',
            strFieldsCellClasses =
                trim('dialogFieldValue' +
                    (strAdditionalFieldCellClasses ?
                        ' ' + strAdditionalFieldCellClasses :
                        '')),
            strFieldClassAttr =
                strFieldsCellClasses ?
                    ' class="' + strFieldsCellClasses + '"' :
                    '';

        return '<tr' + strRowIdAttr + strRowStyleAttr + strFieldRowClassAttr + '>' +
                    cdBuildOpenDialogLabelCell(strFieldLabelId, strAdditionalLabelCellClasses) +
                    (strLabelHtml ?
                        strLabelHtml + (tmpSuppressLabelColon ? '' : ':') :
                        '') +
                    '</td>' +
                    '<td' + strFieldClassAttr + '>' +
                        strPreFieldsHtml +
                            pbBuildDurationFields(params_) +
                        strPostFieldsHtml +
                    '</td>' +
                '</tr>\n';
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbAddDurationFieldsRow(objCDBuilder_, params_) {
        objCDBuilder_.addDialogInteriorRows(
            pbBuildDurationFieldsRow(params_)
        );
    }


    //--------------------------------------------------------------------------
    //
    // Parameters:
    //
    //           isExpanded: True if the section should initially be presented
    //                       as expanded.
    //
    //     expandoTitleHtml: Html to be rendered to the right of the chevron
    //                       buttons.
    //
    // expandoElementIdBase: Optional base name to use for the elements that
    //                       comprise the expando section.
    //
    //      expandedRowInfo: Optionally defines the row id and html content of
    //                       the section to be displayed when expanded. If this
    //                       is omitted, no row should be rendered for the
    //                       "Expanded" state. Object has two optional
    //                       parameters:
    //
    //                                rowId: If given, will be used as the id of
    //                                       the row rendered when the expando
    //                                       is expanded. If not given, the id
    //                                       will be derived from the base, if
    //                                       given. If there's no base either,
    //                                       it will have a hard-coded id so
    //                                       there better be only one such
    //                                       expando visible at any given time
    //                                       or they won't work.
    //
    //                          contentHtml: Optional content for the row.
    //                                       Defaults to an empty string.
    //
    //
    //     collapsedRowInfo: Optionally defines the row id and html content of
    //                       the section to be displayed when collapsed. If this
    //                       is omitted, no row should be rendered for the
    //                       "Collapsed" state. Object has two optional
    //                       parameters: "rowId" and "contentHtml".
    //
    //           cdBuilder_: Optional ClientDialogBuilder. If given, the
    //                       section header row and whichever of the expanded/
    //                       collapsed rows were given are added directly to
    //                       it (via addSectionHeaderRow()/addFlexibleRow())
    //                       rather than being returned as html.
    //
    //--------------------------------------------------------------------------
    var EXPANDO_SECTION_PREFIX_EXPAND_BUTTON_ID = 'expBtn_',
        EXPANDO_SECTION_PREFIX_COLLAPSE_BUTTON_ID = 'clpsBtn_',

        EXPANDO_SECTION_PREFIX_EXPANDED_SECTION_ID = 'expSec_',
        EXPANDO_SECTION_PREFIX_COLLAPSE_SECTION_ID = 'clpsSec_';
    function pbBuildExpandoSection(params_) {
        var strExpandoElementIdBase = params_.expandoElementIdBase,
            tmpIsExpanded = params_.isExpanded,
            strExpandoTitleHtml = params_.expandoTitleHtml || '',
            objExpandedRowInfo = params_.expandedRowInfo,
            objCollapsedRowInfo = params_.collapsedRowInfo,
            objCdBuilder = params_.cdBuilder_,

            strDefaultedIdBase = strExpandoElementIdBase || '',

            strGivenExpandedRowId = (objExpandedRowInfo || {}).rowId,
            strExpandedRowContentHtml =
                (objExpandedRowInfo || {}).contentHtml || '',

            strGivenCollapsedRowId = (objCollapsedRowInfo || {}).rowId,
            strCollapsedRowContentHtml =
                (objCollapsedRowInfo || {}).contentHtml || '',

            strExpandedRowIdToUse =
                strGivenExpandedRowId ||
                (EXPANDO_SECTION_PREFIX_EXPANDED_SECTION_ID +
                    strDefaultedIdBase),
            strCollapsedRowIdToUse =
                strGivenCollapsedRowId ||
                (EXPANDO_SECTION_PREFIX_COLLAPSE_SECTION_ID +
                    strDefaultedIdBase),

            strExpandButtonIdToUse =
                (EXPANDO_SECTION_PREFIX_EXPAND_BUTTON_ID + strDefaultedIdBase),
            strCollapseButtonIdToUse =
                (EXPANDO_SECTION_PREFIX_COLLAPSE_BUTTON_ID + strDefaultedIdBase),

            // Plain icons rather than real buttons -- the entire header
            // (wrapped in the clickable span below) is what actually
            // triggers the toggle, so these are purely visual. Each is
            // wrapped in its own fixed-width "expandoIconHolder" (see
            // uiv2.scss) -- fiiRightChevron/fiiDownChevron don't render
            // at the same width, and hiding/showing an unwrapped icon
            // directly would shift expandoTitleHtml sideways when
            // toggled; the holder's ".collapsed" variant is narrower but
            // makes up the difference with a matching left margin, so
            // whichever single holder is actually in the layout (the
            // other has display:none, same as any hidden ClientDialog
            // row/element) always occupies the same total width.
            strExpandButtonHtml =
                '<span class="expandoIconHolder collapsed"' +
                        ' id="' + strExpandButtonIdToUse + '"' +
                        (tmpIsExpanded ? ' style="display:none"' : '') +
                    '>' +
                    cdBuildFontIconElem({
                        fontId: FontIconId_Enum.fiiRightChevron,
                        terseFontIcon: 1
                    }) +
                '</span>',
            strCollapseButtonHtml =
                '<span class="expandoIconHolder"' +
                        ' id="' + strCollapseButtonIdToUse + '"' +
                        (tmpIsExpanded ? '' : ' style="display:none"') +
                    '>' +
                    cdBuildFontIconElem({
                        fontId: FontIconId_Enum.fiiDownChevron,
                        terseFontIcon: 1
                    }) +
                '</span>',

            // The actual row ids (which may have been overridden via
            // expandedRowInfo.rowId/collapsedRowInfo.rowId, rather than
            // derived from the base) are stashed on the header itself --
            // ptToggleExpandoSection() reads them back from here rather
            // than re-deriving them from the base, since re-deriving
            // would miss any override.
            // tabindex/role make this a real tab stop with the expected
            // a11y semantics for a non-<button> toggle; the keydown
            // handler just re-fires this same element's own click (see
            // pbHandleClickableKeydown()) so Enter/Space reach the exact
            // same onclick rather than duplicating its logic.
            //
            // inline-flex + align-items:center (rather than leaving this
            // as a plain inline span) keeps the focus outline a single
            // clean rectangle -- the chevron icon holders render taller
            // than the plain title text, and a plain inline span draws
            // its outline per line fragment, so without this the
            // outline comes out visibly taller across just the icons'
            // portion than across the title text.
            strCombinedChevronsAndExpandoTitleHtml =
                '<span class="clickable"' +
                        ' style="display:inline-flex;align-items:center"' +
                        ' tabindex="0" role="button"' +
                        ' data-expanded-row-id="' +
                            strExpandedRowIdToUse + '"' +
                        ' data-collapsed-row-id="' +
                            strCollapsedRowIdToUse + '"' +
                        ' onclick="' +
                            'XZCommonUtils.PROTECTED.toggleExpandoSection(' +
                                'this,\'' + strDefaultedIdBase + '\')' +
                        '"' +
                        ' onkeydown="' +
                            'XZCommonUtils.handleClickableKeydown(' +
                                'event,this)' +
                        '">' +
                        strExpandButtonHtml +
                        strCollapseButtonHtml +
                        strExpandoTitleHtml +
                    '</span>',

            rcHtml;

        if(objCdBuilder) {
            objCdBuilder.addSectionHeaderRow({
                titleHTML: strCombinedChevronsAndExpandoTitleHtml
            });
            if(objExpandedRowInfo) {
                objCdBuilder.addFlexibleRow({
                    rowId: strExpandedRowIdToUse,
                    valueHTML: strExpandedRowContentHtml,
                    rowClasses: tmpIsExpanded ? '' : 'hideElement'
                });
            }
            if(objCollapsedRowInfo) {
                objCdBuilder.addFlexibleRow({
                    rowId: strCollapsedRowIdToUse,
                    valueHTML: strCollapsedRowContentHtml,
                    rowClasses: tmpIsExpanded ? 'hideElement' : ''
                });
            }
            rcHtml = '';
        } else {
            rcHtml =
                '<tr>' +
                    '<td colspan="2">' +
                        strCombinedChevronsAndExpandoTitleHtml +
                    '</td>' +
                '</tr>' +
                (objExpandedRowInfo ?
                    '<tr id="' + strExpandedRowIdToUse + '"' +
                            (tmpIsExpanded ? '' : ' class="hideElement"') +
                            '>' +
                        '<td colspan="2">' +
                            strExpandedRowContentHtml +
                        '</td>' +
                    '</tr>' :
                    '') +
                (objCollapsedRowInfo ?
                    '<tr id="' + strCollapsedRowIdToUse + '"' +
                            (tmpIsExpanded ? ' class="hideElement"' : '') +
                            '>' +
                        '<td colspan="2">' +
                            strCollapsedRowContentHtml +
                        '</td>' +
                    '</tr>' :
                    '');
        }

        return {
            html: rcHtml,
            expandedSectionRowId: strExpandedRowIdToUse,
            collapsedSectionRowId: strCollapsedRowIdToUse,
            expandoElementIdBase: strExpandoElementIdBase,
            isExpanded: tmpIsExpanded
        };
    }


    //--------------------------------------------------------------------------
    // Generic keydown handler for a tabindex="0" clickable span/div (a
    // stand-in for a real <button>, which doesn't get Enter/Space
    // activation for free) -- re-fires elem_'s own click rather than
    // duplicating whatever its onclick does, so this is reusable for any
    // such element, not just pbBuildExpandoSection()'s header -- hence
    // it's exported publicly rather than under PROTECTED. Space is also
    // prevented from scrolling the page, matching native button
    // behavior.
    //--------------------------------------------------------------------------
    function pbHandleClickableKeydown(event_, elem_) {
        if(event_.key === 'Enter' || event_.key === ' ') {
            event_.preventDefault();
            elem_.click();
        }
    }


    //--------------------------------------------------------------------------
    // Toggles a section built by pbBuildExpandoSection() -- swaps which of
    // the expand/collapse chevron buttons is shown and which of the
    // expanded/collapsed rows (whichever were actually given) is visible.
    //
    // headerElem_ is the clickable header span itself (pbBuildExpandoSection()
    // wires "this" through in its onclick) -- the expanded/collapsed row ids
    // are read back from its data attributes rather than re-derived from
    // expandoElementIdBase_, since a given row's id may have been overridden
    // (via expandedRowInfo.rowId/collapsedRowInfo.rowId) rather than derived
    // from the base; re-deriving here would miss that override and look up
    // the wrong (nonexistent) id.
    //--------------------------------------------------------------------------
    function ptToggleExpandoSection(headerElem_, expandoElementIdBase_) {
        var strDefaultedIdBase = expandoElementIdBase_ || '',

            strExpandButtonId =
                EXPANDO_SECTION_PREFIX_EXPAND_BUTTON_ID + strDefaultedIdBase,
            strCollapseButtonId =
                EXPANDO_SECTION_PREFIX_COLLAPSE_BUTTON_ID + strDefaultedIdBase,
            strExpandedRowId = headerElem_.dataset.expandedRowId,
            strCollapsedRowId = headerElem_.dataset.collapsedRowId,

            objExpandButton = getObj(strExpandButtonId),
            objCollapseButton = getObj(strCollapseButtonId),
            objExpandedRow = strExpandedRowId ? getObj(strExpandedRowId) : null,
            objCollapsedRow =
                strCollapsedRowId ? getObj(strCollapsedRowId) : null,

            // Currently expanded if the collapse (down-chevron) button is
            // the one currently being shown.
            tmpWasExpanded =
                !!objCollapseButton &&
                    objCollapseButton.style.display !== 'none';

        if(objExpandButton) {
            objExpandButton.style.display = tmpWasExpanded ? '' : 'none';
        }
        if(objCollapseButton) {
            objCollapseButton.style.display = tmpWasExpanded ? 'none' : '';
        }
        if(objExpandedRow) {
            objExpandedRow.classList.toggle('hideElement', tmpWasExpanded);
        }
        if(objCollapsedRow) {
            objCollapsedRow.classList.toggle('hideElement', !tmpWasExpanded);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbIsDialogWithIdShowing(id_) {
        return getObj(id_) ? true : false;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbIsTouchDevice() {
        return 'ontouchstart' in window ||     // works on most browsers 
            navigator.maxTouchPoints;       // works on IE10/11 and Surface
    }

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbIsIOS() {
        return /iPad|iPhone|iPod/.test(navigator.platform);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbSelectFieldContent(obj_) {
        if(obj_) {
            try {
                if(obj_.setSelectionRange) {
                    obj_.setSelectionRange(0, obj_.value.length);
                }
            } catch(e) {
                consoleLog('Error on setSelectionRange: e=' + e);

                try {
                    if(obj_.select) {
                        obj_.select();
                    }
                } catch(e2) {
                    consoleLog('Error on select(): e2=' + e2);
                }
            }
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbSelectAndSetFocus(obj_) {
        pbSelectFieldContent(obj_);
        setFocus(obj_);
    }


    //--------------------------------------------------------------------------
    // Wires field_'s native "input" event to the function resolved from
    // functionName_ (a fully-qualified string, e.g.
    // "CZReceiptParser.PROTECTED.changedReceiptContents"). Prefer this over
    // an inline onchange/onkeyup HTML attribute when a field needs to react
    // as its value is entered: "input" fires reliably for typing, pasting,
    // cutting, and drag-and-drop across both desktop and mobile, whereas
    // onchange alone only fires once the field loses focus, and a paste
    // gesture on most mobile browsers doesn't dispatch a keyup event at all.
    //--------------------------------------------------------------------------
    function pbAddOnInputHandler(params_) {
        var objField = params_.field,
            strFunctionName = params_.functionName,
            fnHandler =
                StringificationUtils.resolveFunctionFromName({
                    functionName: strFunctionName
                });

        if(!objField || 'function' !== typeof fnHandler) {
            return;
        }

        objField.oninput = fnHandler;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvFormatYMD(y_, m_, d_) {
        return y_ + '-' + (m_ < 10 ? '0' : '') + m_ + '-' + (d_ < 10 ? '0' : '') + d_;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbFormatDateObjectYMD(date_) {
        return pvFormatYMD(
            date_.getFullYear(),
            date_.getMonth() + 1,
            date_.getDate());
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetTodayAsYMD() {
        var tmpToday = new Date();

        return pbFormatDateObjectYMD(tmpToday);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetYesterdayAsYMD() {
        var tmpToday = new Date();

        return pbFormatDateObjectYMD(
            MWDateTime.getPreviousDay(
                tmpToday));
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbGetCBOValUsingSelIndex(cboElement_) {
        var tmpSelIndex = cboElement_.selectedIndex;

        return tmpSelIndex < 0 ? '' : cboElement_.options[tmpSelIndex].value;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbMultilineIndentEncodeJSONString(jsonString_) {
        var arrSplitLines = jsonString_.split(/\n/g),
            i;
        for(i = 0; i < arrSplitLines.length; ++i) {
            arrSplitLines[i] =
                htmlEncode(arrSplitLines[i]).replace(/^\s+/,
                    function(m) {
                        return m.replace(/\s/g, '&nbsp;');
                    });
        }
        return arrSplitLines.join('<br />');
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbHtmlEncodeWithColonBreaks(strRawText_) {
        var arrPieces = strRawText_.split(':');
        for(var i = 0; i < arrPieces.length; ++i) {
            arrPieces[i] = htmlEncode(arrPieces[i]);
        }
        return arrPieces.join('<wbr />:<wbr />');
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbScrollItemWithIdIntoView(strId_) {
        var obj = getObj(strId_);
        if(obj) {
            obj.scrollIntoView();
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvGetStyle(el_, style_) {
        var rc = '';
        if(el_.currentStyle) {
            rc = el_.currentStyle[style_];
        } else if(window.getComputedStyle) {
            rc = document.defaultView.getComputedStyle(el_, null).getPropertyValue(style_);
        }
        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbStartsWith(string_, prefix_) {
        var prefixLen = prefix_.length;
        return string_.length >= prefixLen && (string_.substring(0, prefixLen) === prefix_);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbEndsWith(string_, suffix_) {
        var suffixLen = suffix_.length,
            stringLen = string_.length;
        return stringLen >= suffixLen &&
            (string_.substring(stringLen - suffixLen) === suffix_);
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbClearGlass(glassId_) {
        var glass = getObj(glassId_ || 'cvsWeightGlass'),
            szGlass = [glass.clientWidth, glass.clientHeight],
            context = (glass && glass.getContext) ? glass.getContext('2d') : 0;

        if(context) {
            context.clearRect(0, 0, szGlass[0], szGlass[1]);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvSplitTriosWithCommas(string_) {
        string_ = '' + string_;
        var rc = '';
        while(string_.length) {
            if(rc) {
                rc = ',' + rc;
            }

            if(string_.length > 3) {
                rc = string_.substring(string_.length - 3) + rc;
                string_ = string_.substring(0, string_.length - 3);
            } else {
                rc = string_ + rc;
                string_ = '';
            }
        }
        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbAddCommasToDecimalNum(value_) {
        var arrDec = ('' + value_).split('.'),
            tmpPartCount = arrDec.length,
            strDecimalPiece =
                tmpPartCount === 2 ?
                    ('.' + arrDec[1]) :
                    '';

        if(tmpPartCount > 2) {
            // Multiple decimals, so just return it as-is
            return '' + value_;
        }

        return pvSplitTriosWithCommas(arrDec[0]) + strDecimalPiece;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbPadDollars(params_) {
        var tmpDollarValue = params_.dollarValue,
            tmpOmitDecimals = params_.omitDecimals,
            tmpForceDecimalsWhenNone = params_.forceDecimalsWhenNone,
            tmpIncludeCommas = params_.includeCommas;

        if(typeof tmpDollarValue !== 'string') {
            tmpDollarValue = '' + tmpDollarValue;
        }

        tmpDollarValue = trim(tmpDollarValue).replace(new RegExp(',', 'g'), '');

        var tmpLen = tmpDollarValue.length,
            tmpDecPos = tmpDollarValue.indexOf('.');

        if(tmpDecPos < 0) {
            if(!tmpForceDecimalsWhenNone) {
                //  Not forcing decimals when there aren't any...
                if(tmpIncludeCommas) {
                    return pvSplitTriosWithCommas(tmpDollarValue);
                }
                return tmpDollarValue;
            }

            //  No decimal point.  Add one at the end.
            tmpDecPos = tmpLen;
            tmpDollarValue += '.';
            ++tmpLen;
        }

        //  By this point there is definitely a decimal point.
        // Make sure it is followed by at least 2 digits.
        while(tmpDecPos + 3 > tmpLen) {
            tmpDollarValue += '0';
            ++tmpLen;
        }

        if(tmpOmitDecimals) {
            //  Strip from the decimal on...
            tmpDollarValue = tmpDollarValue.substring(0, tmpDecPos);

            if(tmpIncludeCommas) {
                tmpDollarValue = pvSplitTriosWithCommas(tmpDollarValue);
            }
        } else {
            //  Now remove any trailing zeros...
            var tmpNewLen = tmpLen;
            while((tmpDecPos + 3 < tmpNewLen) && tmpDollarValue[tmpNewLen - 1] === '0') {
                --tmpNewLen;
            }
            if(tmpNewLen !== tmpLen) {
                tmpDollarValue = tmpDollarValue.substring(0, tmpNewLen);
            }

            if(tmpIncludeCommas) {
                tmpDollarValue = pvSplitTriosWithCommas(tmpDollarValue.substring(0, tmpDecPos)) + tmpDollarValue.substring(tmpDecPos);
            }
        }

        return tmpDollarValue;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbPadDollarsX(dollarValue_, forceDecimalsWhenNone_, includeCommas_) {
        return pbPadDollars({
            dollarValue: dollarValue_,
            forceDecimalsWhenNone: forceDecimalsWhenNone_,
            includeCommas: includeCommas_
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbIsNegDollarValue(value_) {
        return pbStartsWith('' + value_, '-');
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbNegateDollarValue(value_) {
        var rc = '' + value_;
        if(pbIsNegDollarValue(rc)) {
            rc = rc.substring(1);
        } else if(rc) {
            rc = '-' + rc;
        }
        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvSetCBChecked(id_, checked_) {
        var objCheck = getObj(id_),
            tmpAlreadyChecked = '1' === objCheck.getAttribute('data-checked'),
            objImg = getObj(id_ + '.img'),
            strSrc = pageIncludeRoot + 'graphics/' + (objCheck.getAttribute('data-' + (checked_ ? 'filledSrc' : 'emptySrc'))),
            objRow,
            strOldClass,
            strCurrClass;

        if((!tmpAlreadyChecked) === (!checked_)) {
            //  No change.  Don't do anything...
            return;
        }

        objRow = objCheck.parentNode;
        while(objRow && objRow.tagName !== 'TR') {
            objRow = objRow.parentNode;
        }
        if(objRow) {
            strOldClass = objRow.getAttribute('data-oldClassValue');
            if(checked_) {
                strCurrClass = objRow.className;
                objRow.setAttribute('data-oldClassValue', strCurrClass);
                objRow.className = "highlight" + (strCurrClass ? ' ' + strCurrClass : '');
            } else {
                objRow.className = strOldClass ? strOldClass : '';
            }
        }

        objCheck.setAttribute('data-checked', checked_ ? '1' : '0');
        objImg.src = strSrc + '?v=' + g_imageVersion;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbToggleCB(id_, fnToggle_) {
        var objCheck = getObj(id_),
            //objImg = getObj(id_ + '.img'),
            tmpWasChecked = '1' === objCheck.getAttribute('data-checked');

        pvSetCBChecked(id_, !tmpWasChecked/*checked_*/);

        if(fnToggle_) {
            fnToggle_();
        }
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pbBuildArrayOfCBValues(startingIndex_, idPrefix_) {
        var i = startingIndex_,
            objCheck,
            strDataValue,
            rc = [];

        while(true) {
            objCheck = getObj(idPrefix_ + i);
            if(!objCheck) {
                break;
            }

            if('1' === objCheck.getAttribute('data-checked')) {
                strDataValue = objCheck.getAttribute('data-value');
                rc[rc.length] = strDataValue;
            }
            ++i;
        }

        return rc;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBuildWordBoundaryFilterFunction(searchText_, fnGetValue_) {
        var strEscapedSearchText = RegExp.quote(searchText_),
            regExp = new RegExp('(\\b|^)' + strEscapedSearchText + '.*', 'i');

        return function(value_) {
            if(value_) {
                var strCurrent = fnGetValue_(value_);
                return regExp.test(strCurrent);
            }
            return false;
        };
    }


    //--------------------------------------------------------------------------
    //
    //  Returns 1 if parses ok, 0 if not.
    //
    //  If objRc_ is an object, will set:
    //
    //      objRc_.parsedValue=parsed value as float
    //      objRc_.rawValue=original string value.
    //
    //--------------------------------------------------------------------------
    function pbParseMixedFraction(strValue_, objRc_) {
        if(objRc_) {
            objRc_.rawValue = strValue_;
        }

        strValue_ = trim(strValue_);

        //consoleLogBlockOpen('parseMixedFraction() - strValue_=' + strValue_);
        var patDecimal = new RegExp('^\\d+\\.?\\d*$'),
            rc = 0;


        if(patDecimal.test(strValue_)) {
            //        consoleLog('It\'s a straight-up decimal!');
            objRc_.parsedValue = parseFloat(strValue_);
            rc = 1;
        } else {
            //consoleLog('Not a straight-up decimal.');

            var patFraction = new RegExp('^\\d+\\s*/\\s*\\d+$'),
                tmpIsFraction = patFraction.test(strValue_),
                patMixedFraction = new RegExp('^\\d+\\s+\\d+\\s*/\\s*\\d+$'),
                tmpIsMixedFraction = (!tmpIsFraction) && patMixedFraction.test(strValue_),
                tmpSlashPos = strValue_.indexOf('/'),
                tmpSpacePos = strValue_.indexOf(' '),
                strPreSlash,
                tmpInteger = 0,
                tmpNumerator,
                tmpDenominator;

            if(tmpIsFraction || tmpIsMixedFraction) {
                tmpDenominator = parseInt(trim(strValue_.substring(tmpSlashPos + 1)), 10);

                strPreSlash = trim(strValue_.substring(0, tmpSlashPos));
                if(tmpIsMixedFraction) {
                    tmpNumerator = parseInt(trim(strPreSlash.substring(tmpSpacePos + 1)), 10);
                    tmpInteger = parseInt(trim(strPreSlash.substring(0, tmpSpacePos)), 10);
                } else {
                    tmpNumerator = parseInt(strPreSlash, 10);
                }

                objRc_.parsedValue = tmpInteger + tmpNumerator / tmpDenominator;
                rc = 1;
                //consoleLog('Fractional value=' + objRc_.parsedValue);
            } else {
                //consoleLog('No good!');
            }
        }



        //consoleLogBlockClose('parseMixedFraction()');

        return rc;
    }



    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pbDrawArc(params_) {
        var objGlassContext = params_.context,
            strFillStyle = params_.fillStyle,
            strStrokeStyle = params_.strokeStyle,
            objPtCenter = params_.ptCenter,
            tmpRadius = params_.radius,
            tmpCounterClockwise = params_.counterClockwise,
            tmpStartAngle = params_.startAngle || 0,
            tmpEndAngle = params_.endAngle || 0,

            strOldFillStyle,
            strOldStrokeStyle;

        objGlassContext.beginPath();

        if(strFillStyle) {
            strOldFillStyle = objGlassContext.fillStyle;
            objGlassContext.fillStyle = strFillStyle;
        }

        if(strStrokeStyle) {
            strOldStrokeStyle = strStrokeStyle;
            objGlassContext.strokeStyle = strStrokeStyle;
        }
        objGlassContext.arc(
            objPtCenter.x, objPtCenter.y,
            tmpRadius,
            tmpStartAngle,
            tmpEndAngle,
            tmpCounterClockwise);
        if(strFillStyle) {
            objGlassContext.fill();
        } else {
            objGlassContext.stroke();
        }

        if(strFillStyle) {
            objGlassContext.fillStyle = strOldFillStyle;
        }
        if(strStrokeStyle) {
            objGlassContext.strokeStyle = strOldStrokeStyle;
        }
    }


    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    function pbDrawCircle(params_) {
        var objContext = params_.context,
            strFillStyle = params_.fillStyle,
            strStrokeStyle = params_.strokeStyle,
            objPtCenter = params_.ptCenter,
            tmpRadius = params_.radius;

        pbDrawArc({
            context: objContext,
            fillStyle: strFillStyle,
            strokeStyle: strStrokeStyle,
            ptCenter: objPtCenter,
            radius: tmpRadius,
            endAngle: 2 * Math.PI
        });
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbDrawRectangle(params_) {
        var objContext = params_.context,
            objRcl = params_.rcl,
            strFillStyle = params_.fillStyle,
            tmpFill = params_.fill,
            tmpStroke = params_.stroke,
            strStrokeStyle = params_.strokeStyle,
            arrLineDash = params_.arrLineDash,

            arrOldLineDash = objContext.getLineDash();

        objContext.beginPath();
        if(undefined !== arrLineDash) {
            objContext.setLineDash(arrLineDash);
        }
        if(strFillStyle !== undefined) {
            objContext.fillStyle = strFillStyle;
        }
        if(strStrokeStyle !== undefined) {
            objContext.strokeStyle = strStrokeStyle;
        }
        if(tmpFill) {
            objContext.fillRect(
                objRcl.pt[0], // x
                objRcl.pt[1], // y
                objRcl.sz[0], // cx
                objRcl.sz[1]); // cy
        }
        if(tmpStroke) {
            objContext.strokeRect(
                objRcl.pt[0], // x
                objRcl.pt[1], // y
                objRcl.sz[0], // cx
                objRcl.sz[1]); // cy
        }
        objContext.stroke();
        if(undefined !== arrLineDash) {
            objContext.setLineDash(arrOldLineDash);
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvBuildCloseButtonRCL(params_) {
        var tmpCloseBoxTotalCY = params_.closeBoxTotalCY,
            tmpDY = params_.dy,
            tmpBoxTop = params_.boxTop,
            tmpBoxLeft = params_.boxLeft,
            tmpBoxWidth = params_.boxWidth,


            tmpCloseBoxHeight = tmpCloseBoxTotalCY - 2 * tmpDY,
            tmpCloseBoxWidth = tmpCloseBoxHeight,

            tmpCloseBoxLeft =
                tmpBoxLeft + tmpBoxWidth - tmpDY - tmpCloseBoxWidth,
            tmpCloseBoxTop = tmpBoxTop + tmpDY,

            objRCTextBoxInfo = {
                pt: [tmpCloseBoxLeft, tmpCloseBoxTop],
                sz: [tmpCloseBoxWidth, tmpCloseBoxHeight]
            };

        return objRCTextBoxInfo;
    }

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbDrawCloseButton(params_) {
        var objContext = params_.context,
            objCloseButtonRCL = params_.closeButtonRCL,
            tmpHighlight = params_.highlight,

            tmpCloseBoxLeft = objCloseButtonRCL.pt[0],
            tmpCloseBoxTop = objCloseButtonRCL.pt[1],

            tmpCloseBoxWidth = objCloseButtonRCL.sz[0],
            tmpCloseBoxHeight = objCloseButtonRCL.sz[1],

            strStrokeStyle =
                tmpHighlight ?
                    '#f4a' :
                    '#000';

        objContext.clearRect(
            tmpCloseBoxLeft - 1,
            tmpCloseBoxTop - 1,
            tmpCloseBoxWidth + 2,
            tmpCloseBoxHeight + 2);

        pbDrawRectangle({
            context: objContext,
            rcl: objCloseButtonRCL,
            fillStyle: 'white',
            fill: 1
        });

        pbDrawRectangle({
            context: objContext,
            rcl: objCloseButtonRCL,
            strokeStyle: strStrokeStyle,
            stroke: 1,
            arrLineDash: [2, 3]
        });

        objContext.beginPath();
        objContext.strokeStyle = strStrokeStyle;
        objContext.moveTo(tmpCloseBoxLeft + 2, tmpCloseBoxTop + 2);
        objContext.lineTo(tmpCloseBoxLeft + tmpCloseBoxWidth - 2, tmpCloseBoxTop + tmpCloseBoxHeight - 2);
        objContext.stroke();

        objContext.beginPath();
        objContext.strokeStyle = strStrokeStyle;
        objContext.moveTo(tmpCloseBoxLeft + tmpCloseBoxWidth - 2, tmpCloseBoxTop + 2);
        objContext.lineTo(tmpCloseBoxLeft + 2, tmpCloseBoxTop + tmpCloseBoxHeight - 2);
        objContext.stroke();
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvDrawCloseButtonForInfo(params_) {
        var objContext = params_.context,
            tmpCloseBoxTotalCY = params_.closeBoxTotalCY,
            tmpDY = params_.dy,
            tmpBoxTop = params_.boxTop,
            tmpBoxLeft = params_.boxLeft,
            tmpBoxWidth = params_.boxWidth,
            objCloseButtonInfo = params_.closeButtonInfo,

            objTextBoxInfo =
                pvBuildCloseButtonRCL({
                    closeBoxTotalCY: tmpCloseBoxTotalCY,
                    dy: tmpDY,
                    boxTop: tmpBoxTop,
                    boxLeft: tmpBoxLeft,
                    boxWidth: tmpBoxWidth
                });

        objTextBoxInfo.additionalDrawnTextHitTestInfo = objCloseButtonInfo;

        pbDrawCloseButton({
            context: objContext,
            closeButtonRCL: objTextBoxInfo
        });


        return objTextBoxInfo;
    }

    //------------------------------------------------------------------------------
    //
    //
    //  arrTextLines_:  List of strings to be rendered.
    //                  Each entry in this array can either be a string or an object
    //                  with a "string" property and an optional .
    //
    //  arrTextLines_: Array of strings, one for each piece
    //                                  // of rendered text.
    //                                  //
    //                                  // If this is not a string, it should be
    //                                  // an object of the form:
    //                                  //
    //                                  //      {
    //                                  //          string: "",
    //                                  //          alignment: "left|right"
    //                                  //      }
    //                                  //
    //
    //  "options_" is an object with the following optional properties:
    //
    //      leftBound:
    //      rightBound:     When specified, text will be held within these bounds.
    //      topBound:
    //      bottomBound:
    //
    //      boxPositionMeaning: Defaults to TextBoxPositionMeaning_Enum.tbpmCenter
    //
    //      boxVerticalOffset:  Indicates a pixel-distance from the mouse to
    //                          vertically position the box.
    //                          Doesn't apply when boxPositionMeaning indicates
    //                          that the box should be centered.
    //
    //
    //  Returns:
    //      {
    //                rclBox: { pt: [x,y], sz: [cx,cy] }
    //
    //                          Rectangle for the entire box
    //
    //
    //          arrTextBoxes:   List of boundary rectangles for each of the
    //                          rendered pieces of text.
    //          
    //      }
    //
    //--------------------------------------------------------------------------
    function pbDrawBoxedText(params_) {
        var objContext = params_.context,
            arrTextLines = params_.arrTextLines,
            ptPosition = params_.ptPosition,
            strDefaultFont = params_.defaultFont || '14pt Calibri bold',
            tmpBoxVerticalOffset = params_.boxVerticalOffset || 0,
            tmpBoxPositionMeaning = params_.boxPositionMeaning,
            tmpRightBound = params_.rightBound,
            tmpLeftBound = params_.leftBound,
            tmpBottomBound = params_.bottomBound,
            tmpTopBound = params_.topBound,
            objCloseButtonInfo = params_.closeButtonInfo,

            strCurrFont = strDefaultFont;
        objContext.font = strCurrFont;
        var tmpTextCount = arrTextLines.length,
            objText,
            strText,
            tmpAlignRight,
            tmpTextWidth,
            tmpDeltaX,
            tmpTextHeight = objContext.measureText('m').width,
            tmpDY = tmpTextHeight / 5, // Space between lines.

            tmpIsCloseBox = !!objCloseButtonInfo,
            tmpCloseBoxTotalCY =
                tmpIsCloseBox ?
                    2 * tmpDY + 1.25 * tmpTextHeight :
                    0,

            tmpMaxTextWidth = 0,
            i,
            tmpCurrTextWidth,
            tmpBoxWidth,
            tmpBoxLeft,
            tmpBoxTop,
            tmpTextLeft,
            tmpTextTop,
            tmpCurrTextY,
            objAdditionalDrawnTextHitTestInfo,
            tmpBoxHeight =
                (tmpTextCount + 1) * tmpTextHeight +
                (tmpTextCount - 1) * tmpDY +
                tmpCloseBoxTotalCY,
            arrTextBoxes = [],
            rclBox = {},
            objRC = {
                rclBox: rclBox,
                arrTextBoxes: arrTextBoxes
            };

        for(i = 0; i < tmpTextCount; ++i) {
            objText = arrTextLines[i];
            if(typeof objText === 'string') {
                strText = objText;
            } else {
                strText = objText.string;
            }
            strCurrFont = objText.font || strDefaultFont;
            if(objContext.font !== strCurrFont) {
                objContext.font = strCurrFont;
            }
            tmpCurrTextWidth = objContext.measureText(strText).width;
            tmpMaxTextWidth = Math.max(tmpCurrTextWidth, tmpMaxTextWidth);
        }

        tmpBoxWidth = tmpMaxTextWidth + tmpTextHeight;

        switch(tmpBoxPositionMeaning) {
            case TextBoxPositionMeaning_Enum.tbpmBottomCenter:
                tmpBoxLeft = ptPosition[0] - tmpMaxTextWidth / 2;
                tmpBoxTop = ptPosition[1] - tmpBoxHeight - tmpBoxVerticalOffset;
                break;

            case -1: // Dummy to allow a switch
            default: // TextBoxPositionMeaning_Enum.tbpmCenter:
                tmpBoxLeft = ptPosition[0] - tmpMaxTextWidth / 2;
                tmpBoxTop = ptPosition[1] - tmpBoxHeight / 2;

                break;
        }


        //  Make sure the box is within bounds (if bounds have been specified)
        if(undefined !== tmpRightBound) {
            tmpBoxLeft = Math.min(tmpBoxLeft, tmpRightBound - tmpBoxWidth);
        }
        if(undefined !== tmpLeftBound) {
            tmpBoxLeft = Math.max(tmpBoxLeft, tmpLeftBound);
        }

        if(undefined !== tmpBottomBound) {
            tmpBoxTop = Math.min(tmpBoxTop, tmpBottomBound - tmpBoxHeight);
        }
        if(undefined !== tmpTopBound) {
            tmpBoxTop = Math.max(tmpBoxTop, tmpTopBound);
        }


        //  Now calculate the text position given the box position...(margins are textHeight/2)
        tmpTextLeft = tmpBoxLeft + tmpTextHeight / 2;
        tmpTextTop = tmpBoxTop + tmpTextHeight / 2 + tmpTextHeight;
        tmpCurrTextY = tmpTextTop;


        rclBox.pt = [tmpBoxLeft, tmpBoxTop];
        rclBox.sz = [tmpBoxWidth, tmpBoxHeight];

        pbDrawRectangle({
            context: objContext,
            rcl: rclBox,
            fillStyle: '#ffffff',
            fill: 1
        });

        pbDrawRectangle({
            context: objContext,
            rcl: rclBox,
            strokeStyle: '#000',
            stroke: 1
        });


        // First, if the close box has been requested, add it...
        if(tmpIsCloseBox) {
            var tmpSeparatorY = tmpBoxTop + tmpCloseBoxTotalCY + tmpDY,
                objTextBoxInfo =
                    pvDrawCloseButtonForInfo({
                        closeButtonInfo: objCloseButtonInfo,
                        context: objContext,
                        closeBoxTotalCY: tmpCloseBoxTotalCY,
                        dy: tmpDY,
                        boxTop: tmpBoxTop,
                        boxLeft: tmpBoxLeft,
                        boxWidth: tmpBoxWidth
                    });
            arrTextBoxes.push(objTextBoxInfo);

            tmpCurrTextY += tmpCloseBoxTotalCY;

            objContext.beginPath();
            objContext.moveTo(
                tmpBoxLeft,
                tmpSeparatorY);
            objContext.lineTo(
                tmpBoxLeft + tmpBoxWidth,
                tmpSeparatorY);
            objContext.stroke();
        }



        objContext.fillStyle = '#000000';
        for(i = 0; i < tmpTextCount; ++i) {
            objAdditionalDrawnTextHitTestInfo = undefined;
            objText = arrTextLines[i];
            if(typeof objText === 'string') {
                strText = objText;
                tmpAlignRight = 0;
                strCurrFont = strDefaultFont;
            } else {
                strText = objText.string;
                tmpAlignRight = 'right' === objText.alignment;
                strCurrFont = objText.font || strDefaultFont;
                objAdditionalDrawnTextHitTestInfo =
                    objText.additionalDrawnTextHitTestInfo;
            }

            if(objContext.font !== strCurrFont) {
                objContext.font = strCurrFont;
            }

            tmpTextWidth = objContext.measureText(strText).width;
            if(tmpAlignRight) {
                tmpDeltaX = tmpMaxTextWidth - tmpTextWidth;
            } else {
                tmpDeltaX = 0;
            }

            if(objText.color) {
                objContext.fillStyle = objText.color;
            } else {
                objContext.fillStyle = '#000000';
            }
            objContext.beginPath();
            objContext.fillText(strText, tmpTextLeft + tmpDeltaX, tmpCurrTextY);
            objContext.stroke();

            arrTextBoxes.push({
                additionalDrawnTextHitTestInfo:
                    objAdditionalDrawnTextHitTestInfo,

                pt: [
                    tmpTextLeft + tmpDeltaX,
                    tmpCurrTextY - tmpTextHeight], // remove text offset
                sz: [
                    tmpTextWidth,
                    tmpTextHeight + tmpDY] // Add padding
            });

            tmpCurrTextY += tmpTextHeight + tmpDY;
        }

        return objRC;
    }




    //function removeHandler(arrHandlers_, nameToIndexMap_, name_) {
    //    var idxHandler = nameToIndexMap_.item(name_);
    //    if(idxHandler) {
    //        nameToIndexMap_.removeItemWithKey(name_);
    //        arrHandlers_[idxHandler] = 0;
    //    }
    //}


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbAddHandler(arrHandlers_, nameToIndexMap_, name_, fnHandler_) {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pbAddHandler()');
        //ConsoleLogging.logObject({
        //    what: 'Adding a handler',
        //    name_: ConsoleLogging.undefinedStringIfUndefined(name_)
        //});
        var idxExisting = nameToIndexMap_.item(name_);
        if(idxExisting) {
            arrHandlers_[idxExisting].fnHandler = fnHandler_;
        } else {
            arrHandlers_.push({ name: name_, fnHandler: fnHandler_ });
            nameToIndexMap_.add(name_, arrHandlers_.length - 1);
        }
        //ConsoleLogging.logBlockClose();
    }

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbAddKeyDownHandler(name_, fnHandler_) {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pbAddKeyDownHandler()');
        pbAddHandler(_arrKeyDownHandlerFunctions, _keyDownHandlerNameToIndexMap, name_, fnHandler_);
        //ConsoleLogging.logBlockClose();
    }

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbAddKeyUpHandler(name_, fnHandler_) {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pbAddKeyUpHandler()');
        pbAddHandler(_arrKeyUpHandlerFunctions, _keyUpHandlerNameToIndexMap, name_, fnHandler_);
        //ConsoleLogging.logBlockClose();
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvIterateHandlers(arrHandlers_, event, isEscape_, isTabKey_, keyCode_, isShiftDown_, isAltDown_, isCtrlDown_, objTarget_) {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pvIterateHandlers()');
        var rc = 0,
            i,
            objFn;

        for(i = 0; (i < arrHandlers_.length) && !rc; ++i) {
            objFn = arrHandlers_[i];
            if(objFn) {
                //ConsoleLogging.logObject({
                //    what: 'Executing handler',
                //    i: i,
                //    objFn__name: ConsoleLogging.undefinedStringIfUndefined(objFn.name)
                //});
                rc = objFn.fnHandler(event, isEscape_, isTabKey_, keyCode_, isShiftDown_, isAltDown_, isCtrlDown_, objTarget_);
            }
        }

        //ConsoleLogging.logBlockClose();
        return rc;
    }


    //------------------------------------------------------------------------------
    // TODO: Why is this here? When would/did we ever use it?
    //------------------------------------------------------------------------------
    function pbIsShiftOnEvent(event_) {
        consoleLogBlockOpen('isShiftOnEvent()');
        if(window.event) {
            consoleLog('Using window.event.shiftKey=' + window.event.shiftKey);
            consoleLogBlockClose();
            return window.event.shiftKey;
        } else if(event_) {
            consoleLog('Using event_.shiftKey=' + event_.shiftKey);
            consoleLogBlockClose();
            return event_.shiftKey;
        }
        consoleLog('neither');
        consoleLogBlockClose();
        return 0;
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvBaseDoKeyDown(event) {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pvBaseDoKeyDown()');
        var objTarget,
            isShiftDown,
            isAltDown,
            isCtrlDown,
            keyCode,
            isEscape,
            isTabKey;
        try {
            if(window.event) {
                objTarget = window.event.target;
                isShiftDown = window.event.shiftKey;
                isAltDown = window.event.altKey;
                isCtrlDown = window.event.ctrlKey;
                keyCode = window.event.keyCode;
            } else if(event) {
                objTarget = event.target;
                isShiftDown = event.shiftKey;
                isAltDown = event.altKey;
                isCtrlDown = event.ctrlKey;
                keyCode = event.which;
            }
            if(!isAltDown && !isCtrlDown) {
                isTabKey = keyCode === 9;
                isEscape = keyCode === 27;
            }
        // eslint-disable-next-line no-unused-vars
        } catch(e) {
            // ignore error
            //ConsoleLogging.logBlockClose('error');
            return;
        }

        if(pvIterateHandlers(_arrKeyDownHandlerFunctions, event, isEscape, isTabKey, keyCode, isShiftDown, isAltDown, isCtrlDown, objTarget)) {
            //ConsoleLogging.logBlockClose('iterate-true');
            return false;
        }
        //ConsoleLogging.logBlockClose();
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pvBaseDoKeyUp(event) {
        var objTarget,
            isShiftDown,
            isAltDown,
            isCtrlDown,
            isEscape,
            keyCode,
            isTabKey;

        try {
            if(window.event) {
                objTarget = window.event.target;
                isShiftDown = window.event.shiftKey;
                isAltDown = window.event.altKey;
                isCtrlDown = window.event.ctrlKey;
                keyCode = window.event.keyCode;
            } else if(event) {
                objTarget = event.target;
                isShiftDown = event.shiftKey;
                isAltDown = event.altKey;
                isCtrlDown = event.ctrlKey;
                keyCode = event.which;
            }

            if(!isAltDown && !isCtrlDown) {
                isTabKey = keyCode === 9;
                isEscape = keyCode === 27;
            }
        // eslint-disable-next-line no-unused-vars
        } catch(e) {
            // ignore error
            return;
        }

        if(pvIterateHandlers(_arrKeyUpHandlerFunctions, event, isEscape, isTabKey, keyCode, isShiftDown, isAltDown, isCtrlDown, objTarget)) {
            return false;
        }
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbBaseInitKeyboard() {
        //ConsoleLogging.logBlockOpen('XZCommonUtils::pbBaseInitKeyboard()');
        document.onkeydown = pvBaseDoKeyDown;
        document.onkeyup = pvBaseDoKeyUp;
        //ConsoleLogging.logBlockClose();
    }


    //--------------------------------------------------------------------------
    // Supports prompting to re-order a set of objects listed in an existing,
    // client-side set of elements (most likely table rows) that have been
    // tagged with the "clsReorderRow" style class.
    //
    // TODO: Single-parameterize this method.
    //
    //--------------------------------------------------------------------------
    function pbShowReorderObjectsDialog(objectId_, rawObjectName_, reorderCommandName_, fnOnReorder_, strDialogTitle_, objRSParams_, fnExtractHtmlNameFromRow_) {
        var arrReorderRows = document.querySelectorAll('.clsReorderRow'),
            objRow,
            idx,
            arrIdNames = [],
            strName;

        for(idx = 0; idx < arrReorderRows.length; ++idx) {
            objRow = arrReorderRows[idx];
            if(fnExtractHtmlNameFromRow_) {
                strName = fnExtractHtmlNameFromRow_(objRow);
            } else {
                strName = unescape(objRow.getAttribute('data-name'));
            }
            arrIdNames.push(
                {
                    id: objRow.getAttribute('data-id'),
                    name: strName
                });
        }

        objRSParams_ = objRSParams_ || {};

        mwShowGenericReorderDialog(
            arrIdNames,
            function(arrOrderedIds_) {
                objRSParams_.ids = arrOrderedIds_.join(',');
                jsrsExecuteWithErrorP(
                    reorderCommandName_, // commandString_
                    function() {
                        hideSubdialog();
                        fnOnReorder_();
                    }, // fnCallback_
                    'Re-Ordering ' + rawObjectName_, // doingWhat_
                    objRSParams_ || {}); // payloadDocument_
            }, // fnReOrder_,
            strDialogTitle_,
            {
                highlightedId: objectId_,
                isHtmlEncoded: fnExtractHtmlNameFromRow_ ? 1 : 0
            }); // params_
    }


    //--------------------------------------------------------------------------
    //
    //	Adds two vectors
    //
    //--------------------------------------------------------------------------
    function pvAddV(v1_, v2_) {
        return [v1_[0] + v2_[0], v1_[1] + v2_[1]];
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbHitTestRect(pt_, rect_) {
        var rc = 0,
            ptBottomRight = XZCommonUtils.addV(rect_.pt, rect_.sz);

        if (pt_[0] >= rect_.pt[0]) {
            if (pt_[1] >= rect_.pt[1]) {
                if (pt_[0] <= ptBottomRight[0]) {
                    if (pt_[1] <= ptBottomRight[1]) {
                        rc = 1;
                    }
                }
            }
        }

        return rc;
    }


    //--------------------------------------------------------------------------
    // omitFixedOffset_=true opts this out of posTop()/posLeft()'s body-
    // scroll-lock compensation (mjtGetBodyPosIfFixedElement()). That
    // compensation is correct for placing a position:absolute popup
    // appended to body (e.g. a typeahead/picker, whose own coordinate
    // space is body's local, pre-freeze space), but wrong here: this
    // canvas/glass element normally sits inside its own genuinely
    // position:fixed dialog wrapper (.uiv2dialogDiv), whose coordinate
    // space is already the true viewport -- the same space e_.pageX/pageY
    // resolve to once body is frozen (window.scrollY reads 0 then).
    // Applying body's own compensation on top of that double-counts the
    // scroll amount, so hit-testing ends up offset by exactly how far the
    // underlying page had been scrolled before the dialog opened.
    //--------------------------------------------------------------------------
    function pvUpdatePos(x, y, posRelativeElement) {
        var rc;

        y = y - posTop(posRelativeElement/*ob_*/, 1/*accountForScrollTop_*/,
            true/*omitFixedOffset_*/);
        x = x - posLeft(posRelativeElement/*ob_*/, 1/*accountForScrollLeft_*/,
            true/*omitFixedOffset_*/);

        while (posRelativeElement) {
            var strBorderLeftWidth = pvGetStyle(posRelativeElement, 'border-left-width'),
                strBorderTopWidth = pvGetStyle(posRelativeElement, 'border-top-width'),
                deltaBorderX = strBorderLeftWidth && pbEndsWith(strBorderLeftWidth, 'px') ? parseInt(strBorderLeftWidth.substring(0, strBorderLeftWidth.length - 2), 10) : 0,
                deltaBorderY = strBorderTopWidth && pbEndsWith(strBorderTopWidth, 'px') ? parseInt(strBorderTopWidth.substring(0, strBorderTopWidth.length - 2), 10) : 0;
            x -= deltaBorderX;
            y -= deltaBorderY;
            posRelativeElement = posRelativeElement.offsetParent;
        }

        rc = [x, y];

        return rc;	//	**** Account for the canvas border
    }


    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    function pbUpdateEventPos(e_, posRelativeElement) {
        var x, y;

        // Get the mouse position relative to the canvas element.
        if (e_.touches) {	//	iPad
            var targetItem = e_.touches.item(0);
            x = targetItem.pageX;// - e_.target.offsetLeft - e_.target.offsetParent.offsetLeft;
            y = targetItem.pageY;// - e_.target.offsetTop - e_.target.offsetParent.offsetTop;
        } else {
            x = e_.pageX;
            y = e_.pageY;
        }
        return pvUpdatePos(x, y, posRelativeElement);
    }


    //--------------------------------------------------------------------------
    // Same coordinate math as pbUpdateEventPos(), but for a specific touch
    // (by index into e_.touches) rather than always the first one -- needed
    // for multi-touch gestures (e.g. pinch-to-zoom) where more than one
    // touch's position matters at once. Falls back to pbUpdateEventPos()
    // for a non-touch (mouse) event, same as that function.
    //--------------------------------------------------------------------------
    function pbUpdateTouchEventPosAtIndex(e_, posRelativeElement, touchIndex_) {
        var x, y, targetItem;

        if (e_.touches && e_.touches.length > touchIndex_) {
            targetItem = e_.touches.item(touchIndex_);
            x = targetItem.pageX;
            y = targetItem.pageY;
        } else {
            x = e_.pageX;
            y = e_.pageY;
        }
        return pvUpdatePos(x, y, posRelativeElement);
    }


    //--------------------------------------------------------------------------
    //
    // date1_ and date2_ are javascript Date objects
    //
    //--------------------------------------------------------------------------
    function pvDateDiffInDays(date1_, date2_) {
        //consoleLog('dateDiffInDays() - date1_=' + date1_ + ', date2_=' + date2_);
        var MS_PER_DAY = 1000 * 60 * 60 * 24,

            // Discard the time and time-zone information.
            utc1 = Date.UTC(date1_.getFullYear(), date1_.getMonth(), date1_.getDate()),
            utc2 = Date.UTC(date2_.getFullYear(), date2_.getMonth(), date2_.getDate());

        return Math.floor((utc2 - utc1) / MS_PER_DAY);
    }


    //--------------------------------------------------------------------------
    // XZCommonUtils
    //--------------------------------------------------------------------------
    return {
        optionallyValidateRequiredField: pbOptionallyValidateRequiredField,
        refreshListContents: pbRefreshListContents,
        hideDialogAndRefreshListContents: pbHideDialogAndRefreshListContents,
        hideDialogAndRefreshPage: pbHideDialogAndRefreshPage,
        selRBFocusField: pbSelRBFocusField,
        getDurationToNow: pbGetDurationToNow,


        decodeDurationFields: pbDecodeDurationFields,
        buildDurationFieldsRow: pbBuildDurationFieldsRow,
        addDurationFieldsRow: pbAddDurationFieldsRow,
        buildDurationFields: pbBuildDurationFields,
        buildExpandoSection: pbBuildExpandoSection,
        handleClickableKeydown: pbHandleClickableKeydown,

        isDialogWithIdShowing: pbIsDialogWithIdShowing,
        isTouchDevice: pbIsTouchDevice,
        isIOS: pbIsIOS,
        selectFieldContent: pbSelectFieldContent,
        selectAndSetFocus: pbSelectAndSetFocus,
        addOnInputHandler: pbAddOnInputHandler,
        formatDateObjectYMD: pbFormatDateObjectYMD,
        getTodayAsYMD: pbGetTodayAsYMD,
        getYesterdayAsYMD: pbGetYesterdayAsYMD,
        getCBOValUsingSelIndex: pbGetCBOValUsingSelIndex,
        multilineIndentEncodeJSONString: pbMultilineIndentEncodeJSONString,
        htmlEncodeWithColonBreaks: pbHtmlEncodeWithColonBreaks,
        scrollItemWithIdIntoView: pbScrollItemWithIdIntoView,
        startsWith: pbStartsWith,
        endsWith: pbEndsWith,
        clearGlass: pbClearGlass,
        addCommasToDecimalNum: pbAddCommasToDecimalNum,
        padDollars: pbPadDollars,
        padDollarsX: pbPadDollarsX,
        noOp: pbNoOp,
        isNegDollarValue: pbIsNegDollarValue,
        negateDollarValue: pbNegateDollarValue,
        toggleCB: pbToggleCB,
        buildArrayOfCBValues: pbBuildArrayOfCBValues,
        buildWordBoundaryFilterFunction: pbBuildWordBoundaryFilterFunction,
        parseMixedFraction: pbParseMixedFraction,

        drawBoxedText: pbDrawBoxedText,
        drawArc: pbDrawArc,
        drawCircle: pbDrawCircle,
        drawRectangle: pbDrawRectangle,
        drawCloseButton: pbDrawCloseButton,
        TextBoxPositionMeaning_Enum: TextBoxPositionMeaning_Enum,


        addKeyDownHandler: pbAddKeyDownHandler,
        addKeyUpHandler: pbAddKeyUpHandler,
        isShiftOnEvent: pbIsShiftOnEvent,
        baseInitKeyboard: pbBaseInitKeyboard,
        showReorderObjectsDialog: pbShowReorderObjectsDialog,
        addV: pvAddV,
        hitTestRect: pbHitTestRect,
        //updatePos: pbUpdatePos,
        updateEventPos: pbUpdateEventPos,
        updateTouchEventPosAtIndex: pbUpdateTouchEventPosAtIndex,
        dateDiffInDays: pvDateDiffInDays,


        //--------------------------------------------------------------------------
        //#region Dialog Confirmer class management
        //--------------------------------------------------------------------------
        getCustomConfirmationClass: pbGetCustomConfirmationClass,
        flagElementForCustomDialogConfirmation:
            pbFlagElementForCustomDialogConfirmation,

        getForcedDirtyClass: pbGetForcedDirtyClass,
        flagElementForcedDirty: pbFlagElementForcedDirty,

        getForcedScanClass: pbGetForcedScanClass,
        flagElementForcedScan: pbFlagElementForcedScan,

        flagCustomElementForcedDirtyAndForcedScan:
            pbFlagCustomElementForcedDirtyAndForcedScan,
        //--------------------------------------------------------------------------
        //#endregion Dialog Confirmer class management
        //--------------------------------------------------------------------------


        PROTECTED: {
            durationChanged: ptDurationChanged,
            durationKeyup: ptDurationKeyup,
            toggleExpandoSection: ptToggleExpandoSection
        }
    };
}();