Enterprise Tookit for Acrobat Products > Mobile > (Android | iOS)

JavaScript for Acrobat Reader Mobile API Reference (Android)

File: Util.js

                        /*************************************************************************
                         *
                         * ADOBE CONFIDENTIAL
                         * ___________________
                         *
                         * Copyright 2012 Adobe Systems Incorporated
                         * All Rights Reserved.
                         *
                         * NOTICE: All information contained herein is, and remains
                         * the property of Adobe Systems Incorporated and its suppliers,
                         * if any. The intellectual and technical concepts contained
                         * herein are proprietary to Adobe Systems Incorporated and its
                         * suppliers and are protected by trade secret or copyright law.
                         * Dissemination of this information or reproduction of this material
                         * is strictly forbidden unless prior written permission is obtained
                         * from Adobe Systems Incorporated.
                         *
                         **************************************************************************/
                        
                        /**
                         *  A static JavaScript object that defines a number of utility methods and convenience 
                         *  functions for string and date formatting and parsing.
                         *
                         *  @class util
                         */
                        function util() { };
                            
                        /**
                         *  Formats one or more arguments as a string according to a format string. It is similar 
                         *  to the C function of the same name.
                         *
                         *  @method printf
                         *  @param cFormat {String} The format string to use.
                         *  @param [arguments] {Any} The optional arguments(s) that contain the data to be inserted
                         *  in place of the % tags specified in the first parameter, the format string. The number of 
                         *  optional arguments must be the same as the number of % tags.
                         *  @return {String} A result string formatted as specified.
                         */
                        util.printf = function()
                        {
                        	var ret = "";
                        	try 
                        	{
                                // limit number of argument to less than 50 for now
                                if (arguments.length < 50)
                                {
                                    ret = sprintf.apply(this, arguments);
                                }
                        	}
                        	catch(e) {}
                        	return ret;
                        };
                        
                        /**
                         *  Returns a date using a specified format.
                         *
                         *  @method printd
                         *  @param cFormat {String} A string that is a pattern of supported substrings that are place-holders 
                         *  for date and time data.
                         *  @param oDate {Object} A Date object to format.
                         *  @return {String} The formatted date string.
                         */
                        util.printd = function()
                        {
                            var formattedDate = "";
                            
                            if (validateInput.apply(this, arguments))
                            {
                                var cFormat = arguments[0].toString();
                                var date = arguments[1];
                                
                                if ((cFormat.length == 1) && isNumber(cFormat.charAt(0)))
                                {
                                    // Note: All the cases below behave different from what is specified in Acrobat JS Reference
                                    // but they are in sync with the behaviour on desktop Acrobat
                                    switch (cFormat.charAt(0))
                                    {
                                        case "0":
                                            formattedDate = util.printd("D:yyyymmddHHMMss", date);
                                            break;
                                            
                                        case "1":
                                            formattedDate = util.printd("yyyy.mm.dd HH:MM:ss", date);
                                            break;
                                            
                                        case "2":
                                            formattedDate = util.printd("m/d/yy h:MM:ss tt", date);
                                            break;
                                    }
                                }
                                else
                                {
                                    var pattern = /m+|d+|y+|H+|h+|M+|s+|t+|j+|\\./g;
                                    var matches = cFormat.match(pattern);
                                    
                                    if (matches)
                                    {
                                        formattedDate += cFormat.substring(0, search(cFormat, matches[0]));
                                        for (var i = 0; i < matches.length; i++) 
                                        {
                                            var count = matches[i].length;
                                            
                                            formattedDate += getFormattedComponentValue(date, matches[i]);
                                            if ((i + 1) < matches.length)
                                            {
                                                var separatorBeginIndex = search(cFormat, matches[i]) + count;
                                                var separatorEndIndex = search(cFormat.slice(separatorBeginIndex), matches[i+1]) + separatorBeginIndex;
                                                formattedDate += cFormat.substring(separatorBeginIndex, separatorEndIndex);
                                                cFormat = cFormat.slice(separatorEndIndex);
                                            }
                                            else
                                            {
                                                var separatorBeginIndex = search(cFormat, matches[i]) + count;
                                                formattedDate += cFormat.slice(separatorBeginIndex);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        formattedDate = cFormat;
                                    }
                                }
                            }
                            return formattedDate;
                            
                            /**
                             *  Returns formatted date component.
                             *
                             *  @private
                             *  @method getFormattedComponentValue
                             *  @param date {Object} The date object.
                             *  @param match {String} The component match found in the format string.
                             *  @return {String} Formatted date component.
                             */
                            function getFormattedComponentValue(date, match)
                            {
                                var component = match.charAt(0);
                                var count = match.length;
                                var formattedComponentValue = "";
                                
                                switch (component)
                                {
                                    case "m":
                                        if (count == 1)
                                        {
                                            formattedComponentValue = (date.getMonth() + 1).toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(date.getMonth() + 1, 2);
                                        }
                                        else if (count == 3)
                                        {
                                            formattedComponentValue = getMonthString((date.getMonth() + 1), true);
                                        }
                                        else if (count == 4)
                                        {
                                            formattedComponentValue = getMonthString((date.getMonth() + 1), false);
                                        }
                                        break;
                                        
                                    case "d":
                                        if (count == 1)
                                        {
                                            formattedComponentValue = date.getDate().toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(date.getDate(), 2);
                                        }
                                        else if (count == 3)
                                        {
                                            formattedComponentValue = getDayString((date.getDay() + 1), true);
                                        }
                                        else if (count == 4)
                                        {
                                            formattedComponentValue = getDayString((date.getDay() + 1), false);
                                        }
                                        break;
                                        
                                    case "y":
                                        if (count == 2)
                                        {
                                            var year = lpad(date.getFullYear(), 4);
                                            formattedComponentValue = year.charAt(2) + year.charAt(3);
                                        }
                                        else if (count == 4)
                                        {
                                            formattedComponentValue = lpad(date.getFullYear(), 4);
                                        }
                                        break;
                                        
                                    case "H":
                                        if (count == 1)
                                        {
                                            formattedComponentValue = date.getHours().toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(date.getHours(), 2);
                                        }
                                        break;
                                        
                                    case "h":
                                        var hours = date.getHours() % 12; // converting to 12 hour format
                                        if (hours == 0)
                                            hours = 12;
                                        
                                        if (count == 1)
                                        {
                                            formattedComponentValue = hours.toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(hours, 2);
                                        }
                                        break;
                                        
                                    case "M":
                                        if (count == 1)
                                        {
                                            formattedComponentValue = date.getMinutes().toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(date.getMinutes(), 2);
                                        }
                                        break;
                                        
                                    case "s":
                                        if (count == 1)
                                        {
                                            formattedComponentValue = date.getSeconds().toString();
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = lpad(date.getSeconds(), 2);
                                        }
                                        break;
                                        
                                    case "t":
                                        var tValue = "";
                                        
                                        if (date.getHours() < 12)
                                            tValue = EScriptString.get("IDS_AM");
                                        else
                                            tValue = EScriptString.get("IDS_PM");
                                        
                                        if (count == 1)
                                        {
                                            formattedComponentValue = tValue.chatAt(0);
                                        }
                                        else if (count == 2)
                                        {
                                            formattedComponentValue = tValue;
                                        }
                                        break;
                                        
                                    case "\\":
                                        formattedComponentValue = match[1];
                                        break;
                                }
                        
                                return formattedComponentValue;
                            }
                            
                            /**
                             *  Returns the day string for the given index.
                             *
                             *  @private
                             *  @method getDayString
                             *  @param index {Number} The index of the day. For e.g. 1 for Sunday.
                             *  @param abbreviated {Boolean} Specifies if the abbreviated string is to be returned or the entire string.
                             *  @return {String} The day string for the index.
                             */
                            function getDayString(index, abbreviated)
                            {	
                                // returns the string (abbreviated or full) corresponding to the given day or a string that
                                // is indicative of the fact that the index was invalid
                                
                                var IDS_DAY_INFO = EScriptString.get("IDS_DAY_INFO");
                                var IDS_INVALID_MONTH = EScriptString.get("IDS_INVALID_MONTH");
                                var result = "";
                                
                                var datre = new RegExp("(\\w+)\\[" + index + "\\]", "g");
                                var matches = IDS_DAY_INFO.match(monthre);
                                if (matches.length == 2)
                                {
                                    if (abbreviated)
                                        result = matches[1].slice(0, (matches[1].indexOf("[")));
                                    else
                                        result = matches[0].slice(0, (matches[1].indexOf("[")));
                                    
                                    return result;
                                }
                                
                                return IDS_INVALID_MONTH;
                            }
                            
                            /**
                             *  Returns the month string for the given index.
                             *
                             *  @private
                             *  @method getMonthString
                             *  @param index {Number} The index of the day. For e.g. 1 for January.
                             *  @param abbreviated {Boolean} Specifies if the abbreviated string is to be returned or the entire string.
                             *  @return {String} The month string for the index.
                             */
                            function getMonthString(index, abbreviated)
                            {	
                                // returns the string (abbreviated or full) corresponding to the given month or a string that
                                // is indicative of the fact that the index was invalid
                                
                                // TODO_READER_MOBILE<pvyas>: modify the IDS_MONTH_INFO string so that it includes abbreviated May.
                                // this will prevent special handling, and then getDateString and getMonthString can share code.
                                
                                if (abbreviated)
                                {
                                    var IDS_MONTH_INFO = EScriptString.get("IDS_MONTH_INFO");
                                    var IDS_INVALID_MONTH = EScriptString.get("IDS_INVALID_MONTH");
                                    
                                    var monthre = new RegExp("(\\w+)\\[" + index + "\\]", "g");
                                    var matches = IDS_MONTH_INFO.match(monthre);
                                    if (matches.length == 2)
                                        return matches[1].slice(0, (matches[1].indexOf("[")));
                                    return AFGetMonthString(index); // if 2 matches are not found we try and default to full name
                                }
                                else
                                {
                                    return AFGetMonthString(index);
                                }
                            }
                            
                            /**
                             *  Does input validation for printd method.
                             *
                             *  @private
                             *  @method validateInput
                             *  @return {Boolean} True if input is valid, otherwise false.
                             */
                            function validateInput()
                            {
                                var result = true;
                                
                                // check if number of arguments are valid
                                if (!((arguments.length > 1) && (arguments.length < 4)))
                                {
                                    result = false;
                                }
                                else 
                                {
                                    // check if argument 1 is valid
                                    if (!((typeof(arguments[0]) == "string") || (typeof(arguments[0]) == "number")))
                                    {
                                        result = false;
                                    }
                                    else
                                    {
                                        if (typeof(arguments[0]) == "number")
                                        {
                                            if (!((arguments[0] >= 0) && (arguments[0] <= 2)))
                                                result = false;
                                        }
                                    }
                                    
                                    // check if argument 2 is valid
                                    if (!(arguments[1] instanceof Date))
                                    {
                                        result = false;
                                    }
                                }
                                
                                return result;
                            }
                        };
                        
                        /**
                         *  Formats a source string, cSource, according to a formatting string, cFormat.
                         *
                         *  @method printx
                         *  @param cFormat {String} The formatting string to use.
                         *  @param cSource {String} The source string to use.
                         *  @return {String} The formatted string.
                         */
                        util.printx = function()
                        {
                            var formattedValue = "";
                            if (validateInput.apply(this, arguments))
                            {
                                var cFormat = arguments[0].toString();
                                var cSource = arguments[1].toString();
                                var sourceIndex = 0;
                                var currCase = "";
                                
                                var pattern = /\?+|X+|A+|9+|\*|\\.|>|<|\=/g;
                                var matches = cFormat.match(pattern);
                                
                                if (matches)
                                {
                                    formattedValue += cFormat.substring(0, search(cFormat, matches[0]));
                                    for (var i = 0; i < matches.length; i++) 
                                    {
                                        var count = matches[i].length;
                                        
                                        formattedValue += getFormattedComponentValue(cSource, matches[i]);
                                        if ((i + 1) < matches.length)
                                        {
                                            var separatorBeginIndex = search(cFormat, matches[i]) + count;
                                            var separatorEndIndex = search(cFormat.slice(separatorBeginIndex), matches[i+1]) + separatorBeginIndex;
                                            formattedValue += cFormat.substring(separatorBeginIndex, separatorEndIndex);
                                            cFormat = cFormat.slice(separatorEndIndex);
                                        }
                                        else
                                        {
                                            var separatorBeginIndex = search(cFormat, matches[i]) + count;
                                            formattedValue += cFormat.slice(separatorBeginIndex);
                                        }
                                    }
                                }
                                else
                                {
                                    formattedValue = cFormat;
                                }
                            }
                            return formattedValue;
                            
                            /**
                             *  Returns formatted component value.
                             *
                             *  @private
                             *  @method getFormattedComponentValue
                             *  @param cSource {String} The source string.
                             *  @param match {String} The component match found in the format string.
                             *  @return {String} Formatted component value.
                             */
                            function getFormattedComponentValue(cSource, match)
                            {
                                var component = match.charAt(0);
                                var count = match.length;
                                var formattedComponentValue = "";
                                
                                switch (component)
                                {
                                    case "?":
                                        for (var i = 0; (i < count) && (sourceIndex < cSource.length); i++)
                                        {
                                            if (currCase == "upper")
                                                formattedComponentValue += cSource.charAt(sourceIndex).toUpperCase();
                                            else if (currCase == "lower")
                                                formattedComponentValue += cSource.charAt(sourceIndex).toLowerCase();
                                            else
                                                formattedComponentValue += cSource.charAt(sourceIndex);
                                            sourceIndex++;
                                        }
                                        break;
                                        
                                    case "X":
                                        for (var i = 0; (i < count) && (sourceIndex < cSource.length);)
                                        {
                                            if (isAlphaNumeric(cSource.charAt(sourceIndex)))
                                            {
                                                formattedComponentValue += cSource.charAt(sourceIndex);
                                                i++;
                                            }
                                            sourceIndex++;
                                        }
                                        break;
                                        
                                    case "A":
                                        for (var i = 0; (i < count) && (sourceIndex < cSource.length);)
                                        {
                                            if (isAlphabetic(cSource.charAt(sourceIndex)))
                                            {
                                                formattedComponentValue += cSource.charAt(sourceIndex);
                                                i++;
                                            }
                                            sourceIndex++;
                                        }
                                        break;
                                        
                                    case "9":
                                        for (var i = 0; (i < count) && (sourceIndex < cSource.length);)
                                        {
                                            if (isNumber(cSource.charAt(sourceIndex)))
                                            {
                                                formattedComponentValue += cSource.charAt(sourceIndex);
                                                i++;
                                            }
                                            sourceIndex++;
                                        }
                                        break;
                                        
                                    case "*":
                                        formattedComponentValue = cSource.slice(sourceIndex);
                                        break;
                                        
                                    case "\\":
                                        formattedComponentValue = match[1];
                                        break;
                                        
                                    case ">":
                                        currCase = "upper";
                                        break;
                                        
                                    case "<":
                                        currCase = "lower";
                                        break;
                                        
                                    case "=":
                                        currCase = "";
                                        break;
                                }
                                
                                return formattedComponentValue;
                            }
                            
                            /**
                             *  Does input validation for printx method.
                             *
                             *  @private
                             *  @method validateInput
                             *  @return {Boolean} True if input is valid, otherwise false.
                             */
                            function validateInput()
                            {
                                var result = true;
                                
                                // check if number of arguments are valid
                                if (!(arguments.length == 2))
                                {
                                    result = false;
                                }
                                else 
                                {
                                    // check if argument 1 is valid
                                    if (isNullOrUndefined(arguments[0]))
                                    {
                                        result = false;
                                    }
                                    
                                    // check if argument 2 is valid
                                    if (isNullOrUndefined(arguments[1]))
                                    {
                                        result = false;
                                    }
                                }
                                
                                return result;
                            }
                        }
                        
                        /**
                         *  Adds left pad to value.
                         *
                         *  @private
                         *  @method lpad
                         *  @param value {Number} The value to be left padded.
                         *  @param width {Number} The width in characters of the final string.
                         *  @return {String} Left padded value.
                         */
                        function lpad(value, width)
                        {
                        	result = value.toString();
                        	while (result.length < width)
                        		result = "0" + result;
                            
                            return result;
                        }
                        
                        /**
                         *  Searches for a string in another string.
                         *
                         *  @private
                         *  @method search
                         *  @param string {String} The string in which the searchString is to be found.
                         *  @param searchString {String} The search string.
                         *  @return {Number} The index of where the searchString was found in the string.
                         */
                        function search(string, searchString)
                        {
                            return string.search(searchString.replace(/\\/g,"\\\\").replace(/\?/g,"\\?").replace(/\*/g,"\\*"));
                        }
                        
                        /**
                         *  Checks if the value is either null or undefined.
                         *
                         *  @private
                         *  @method isNullOrUndefined
                         *  @param value {Any} The value which is to be tested.
                         *  @return {Boolean} True if value is null or undefined, otherwise false.
                         */
                        function isNullOrUndefined(value)
                        {
                            if ((value == null) || (value == undefined))
                                return true;
                            
                            return false;
                        }
                            

© 2013-15 Adobe Systems, Inc. All rights reserved. Use of these APIs including, the download of software, submission of comments, ideas, feature requests and techniques, and Adobe's rights to use such submitted materials, is governed by the Adobe.com Terms of Use and the Adobe Privacy Policy.