Changeset 2231


Ignore:
Timestamp:
07/19/2008 02:00:21 PM (6 years ago)
Author:
mosipov
Message:

Fixed JavaDoc typos

Location:
FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/FCKeditor.java

    r2227 r2231  
    3030 
    3131/** 
    32  * Java represantation of the FCKeditor. This class creates the html code for 
     32 * Java representation of the FCKeditor. This class creates the HTML code for 
    3333 * the FCKeditor based on the following things: 
    3434 * <ul> 
     
    4848 
    4949        // defaults 
    50         private String toolbarSet = PropertiesLoader.getProperty("fckeditor.toolbarSet"); 
     50        private String toolbarSet = PropertiesLoader 
     51                        .getProperty("fckeditor.toolbarSet"); 
    5152        private String width = PropertiesLoader.getProperty("fckeditor.width"); 
    5253        private String height = PropertiesLoader.getProperty("fckeditor.height"); 
    53         private String basePath = PropertiesLoader.getProperty("fckeditor.basePath"); 
     54        private String basePath = PropertiesLoader 
     55                        .getProperty("fckeditor.basePath"); 
    5456 
    5557        /** 
     
    7274         *             when instanceName is not valid HTML id 
    7375         */ 
    74         public FCKeditor(final HttpServletRequest request, final String instanceName, 
    75                 final String width, final String height, final String toolbarSet, final String value, 
    76                 final String basePath) { 
     76        public FCKeditor(final HttpServletRequest request, 
     77                        final String instanceName, final String width, final String height, 
     78                        final String toolbarSet, final String value, final String basePath) { 
    7779                this.request = request; 
    7880                if (Utils.isBlank(instanceName)) 
     
    9092                if (Utils.isNotEmpty(value)) 
    9193                        this.value = value; 
    92                         else 
    93                                 this.value = new String(); 
     94                else 
     95                        this.value = new String(); 
    9496                if (Utils.isNotBlank(basePath)) 
    9597                        this.basePath = request.getContextPath().concat(basePath); 
     
    185187                return config; 
    186188        } 
    187         /** 
    188          * Set the advanced configuation set. 
     189 
     190        /** 
     191         * Set the advanced configuration set. 
    189192         *  
    190193         * @param config 
     
    206209                if (Utils.isEmpty(str)) 
    207210                        return str; 
    208                  
     211 
    209212                /* 
    210                  * TODO Strings are inefficent. It should be done like in Commons Lang 
     213                 * TODO Strings are inefficient. It should be done like in Commons Lang 
    211214                 * 2.4 StringUtils#replaceEach(String, String[], String[]) 
    212215                 */ 
     
    218221                return str; 
    219222        } 
    220          
     223 
    221224        /* 
    222225         * (non-Javadoc) 
     
    226229        /** 
    227230         * This method simply wraps to {@link #createHtml()}. 
     231         *  
    228232         * @see #createHtml() 
    229233         */ 
     
    239243         * or a simple textarea otherwise. 
    240244         *  
    241          * @return FCKeditor html code 
     245         * @return FCKeditor HTML code 
    242246         */ 
    243247        public String createHtml() { 
     
    248252 
    249253                if (Compatibility.check(request.getHeader("user-agent"))) { 
    250                         strEditor.append(createInputForVariable(instanceName, instanceName, encodedValue)); 
    251  
    252                         // create config html 
     254                        strEditor.append(createInputForVariable(instanceName, instanceName, 
     255                                        encodedValue)); 
     256 
     257                        // create config HTML 
    253258                        String configStr = config.getUrlParams(); 
    254259                        if (Utils.isNotEmpty(configStr)) 
    255                                 strEditor.append(createInputForVariable(null, instanceName.concat("___Config"), 
    256                                         configStr)); 
     260                                strEditor.append(createInputForVariable(null, instanceName 
     261                                                .concat("___Config"), configStr)); 
    257262 
    258263                        // create IFrame 
    259                         String sLink = basePath.concat("/editor/fckeditor.html?InstanceName=").concat( 
    260                                 instanceName); 
     264                        String sLink = basePath.concat( 
     265                                        "/editor/fckeditor.html?InstanceName=") 
     266                                        .concat(instanceName); 
    261267                        if (Utils.isNotEmpty(toolbarSet)) 
    262268                                sLink += "&amp;Toolbar=".concat(toolbarSet); 
    263                         XHtmlTagTool iframeTag = new XHtmlTagTool("iframe", XHtmlTagTool.SPACE); 
     269                        XHtmlTagTool iframeTag = new XHtmlTagTool("iframe", 
     270                                        XHtmlTagTool.SPACE); 
    264271                        iframeTag.addAttribute("id", instanceName.concat("___Frame")); 
    265272                        iframeTag.addAttribute("src", sLink); 
     
    271278 
    272279                } else { 
    273                         XHtmlTagTool textareaTag = new XHtmlTagTool("textarea", encodedValue); 
     280                        XHtmlTagTool textareaTag = new XHtmlTagTool("textarea", 
     281                                        encodedValue); 
    274282                        textareaTag.addAttribute("name", instanceName); 
    275283                        textareaTag.addAttribute("rows", "4"); 
    276284                        textareaTag.addAttribute("cols", "40"); 
    277285                        textareaTag.addAttribute("wrap", "virtual"); 
    278                         textareaTag.addAttribute("style", "width: ".concat(width).concat("; height: ").concat( 
    279                                 height)); 
     286                        textareaTag.addAttribute("style", "width: ".concat(width).concat( 
     287                                        "; height: ").concat(height)); 
    280288                } 
    281289                strEditor.append("</div>"); 
     
    283291        } 
    284292 
    285         private String createInputForVariable(final String name, final String id, final String value) { 
     293        private String createInputForVariable(final String name, final String id, 
     294                        final String value) { 
    286295                XHtmlTagTool tag = new XHtmlTagTool("input"); 
    287296                if (Utils.isNotEmpty(id)) 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/FCKeditorConfig.java

    r2224 r2231  
    4242 
    4343        private static final long serialVersionUID = -4831190504944866644L; 
    44         private final Logger logger = LoggerFactory.getLogger(FCKeditorConfig.class); 
     44        private final Logger logger = LoggerFactory 
     45                        .getLogger(FCKeditorConfig.class); 
    4546 
    4647        /** 
    4748         * Initialize the configuration collection 
    4849         */ 
    49         public FCKeditorConfig( ) { 
     50        public FCKeditorConfig() { 
    5051                super(); 
    5152        } 
    5253 
    5354        /** 
    54          * Generates the url parameter sequence from this configuration which is 
     55         * Generates the URL parameter sequence from this configuration which is 
    5556         * passed to the editor. 
    5657         *  
    57          * @return html encoded sequence of configuration parameters 
     58         * @return HTML-encoded sequence of configuration parameters 
    5859         */ 
    5960        public String getUrlParams() { 
     
    6364                                if (Utils.isNotEmpty(entry.getValue())) { 
    6465                                        osParams.append("&amp;"); 
    65                                         osParams.append(URLEncoder.encode(entry.getKey(),"UTF-8")); 
     66                                        osParams.append(URLEncoder.encode(entry.getKey(), "UTF-8")); 
    6667                                        osParams.append("="); 
    67                                         osParams.append(URLEncoder.encode(entry.getValue(),"UTF-8")); 
     68                                        osParams.append(URLEncoder 
     69                                                        .encode(entry.getValue(), "UTF-8")); 
    6870                                } 
    6971                        } 
    70                          
     72 
    7173                } catch (UnsupportedEncodingException e) { 
    7274                        logger.error("Configuration parameters could not be encoded", e); 
    7375                } 
    74                  
     76 
    7577                if (osParams.length() > 0) 
    76                         osParams.delete(0,5); 
     78                        osParams.delete(0, 5); 
    7779                return osParams.toString(); 
    7880        } 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/connector/ConnectorServlet.java

    r2223 r2231  
    6060 * <li><code>GetFolders</code>: Retrieves a list of folders in the current 
    6161 * folder</li> 
    62  * <li><code>GetFoldersAndFiles</code>: Retrives a list of files and folders 
    63  * in the current folder</li> 
     62 * <li><code>GetFoldersAndFiles</code>: Retrieves a list of files and 
     63 * folders in the current folder</li> 
    6464 * <li><code>CreateFolder</code>: Creates a new folder in the current folder</li> 
    6565 * <li><code>FileUpload</code>: Stores an uploaded file into the current 
     
    7272 
    7373        private static final long serialVersionUID = -5742008970929377161L; 
    74         private static final Logger logger = LoggerFactory.getLogger(ConnectorServlet.class); 
     74        private static final Logger logger = LoggerFactory 
     75                        .getLogger(ConnectorServlet.class); 
    7576 
    7677        /** 
     
    7980        public void init() throws ServletException, IllegalArgumentException { 
    8081                String realDefaultUserFilesPath = getServletContext().getRealPath( 
    81                         ConnectorHandler.getDefaultUserFilesPath()); 
     82                                ConnectorHandler.getDefaultUserFilesPath()); 
    8283 
    8384                File defaultUserFilesDir = new File(realDefaultUserFilesPath); 
     
    99100         */ 
    100101        public void doGet(HttpServletRequest request, HttpServletResponse response) 
    101                 throws ServletException, IOException { 
     102                        throws ServletException, IOException { 
    102103                logger.debug("Entering ConnectorServlet#doGet"); 
    103104 
     
    119120 
    120121                if (!RequestCycleHandler.isEnabledForFileBrowsing(request)) 
    121                         xr = new XmlResponse(XmlResponse.EN_ERROR, lrh.getString("message.connector.fileBrowsing.disabled")); 
     122                        xr = new XmlResponse(XmlResponse.EN_ERROR, lrh 
     123                                        .getString("message.connector.fileBrowsing.disabled")); 
    122124                else if (!CommandHandler.isValidForGet(commandStr)) 
    123                         xr = new XmlResponse(XmlResponse.EN_ERROR, lrh.getString("message.connector.invalid_command_specified")); 
     125                        xr = new XmlResponse(XmlResponse.EN_ERROR, lrh 
     126                                        .getString("message.connector.invalid_command_specified")); 
    124127                else if (typeStr != null && !ResourceTypeHandler.isValid(typeStr)) 
    125                         xr = new XmlResponse(XmlResponse.EN_ERROR, lrh.getString("message.connector.invalid_type_specified")); 
     128                        xr = new XmlResponse(XmlResponse.EN_ERROR, lrh 
     129                                        .getString("message.connector.invalid_type_specified")); 
    126130                else if (!UtilsFile.isValidPath(currentFolderStr)) 
    127                         xr = new XmlResponse(XmlResponse.EN_ERROR, lrh.getString("message.connector.invalid_current_folder_speficied")); 
     131                        xr = new XmlResponse( 
     132                                        XmlResponse.EN_ERROR, 
     133                                        lrh 
     134                                                        .getString("message.connector.invalid_current_folder_speficied")); 
    128135                else { 
    129136                        CommandHandler command = CommandHandler.getCommand(commandStr); 
    130                         ResourceTypeHandler resourceType = ResourceTypeHandler.getDefaultResourceType(typeStr); 
    131  
    132                         String typePath = UtilsFile.constructServerSidePath(request, resourceType); 
     137                        ResourceTypeHandler resourceType = ResourceTypeHandler 
     138                                        .getDefaultResourceType(typeStr); 
     139 
     140                        String typePath = UtilsFile.constructServerSidePath(request, 
     141                                        resourceType); 
    133142                        String typeDirPath = getServletContext().getRealPath(typePath); 
    134143 
     
    142151                        else { 
    143152 
    144                                 xr = new XmlResponse(command, resourceType, currentFolderStr, UtilsResponse 
    145                                         .constructResponseUrl(request, resourceType, currentFolderStr, true, 
    146                                                 ConnectorHandler.isFullUrl())); 
     153                                xr = new XmlResponse(command, resourceType, currentFolderStr, 
     154                                                UtilsResponse.constructResponseUrl(request, 
     155                                                                resourceType, currentFolderStr, true, 
     156                                                                ConnectorHandler.isFullUrl())); 
    147157 
    148158                                if (command.equals(CommandHandler.GET_FOLDERS)) 
     
    152162                                else if (command.equals(CommandHandler.CREATE_FOLDER)) { 
    153163                                        String newFolderStr = UtilsFile.sanitizeFolderName(request 
    154                                                 .getParameter("NewFolderName")); 
     164                                                        .getParameter("NewFolderName")); 
    155165                                        logger.debug("Parameter NewFolderName: {}", newFolderStr); 
    156166 
     
    163173                                                try { 
    164174                                                        errorNumber = (newFolder.mkdir()) ? XmlResponse.EN_OK 
    165                                                                 : XmlResponse.EN_INVALID_FOLDER_NAME; 
     175                                                                        : XmlResponse.EN_INVALID_FOLDER_NAME; 
    166176                                                } catch (SecurityException e) { 
    167177                                                        errorNumber = XmlResponse.EN_SECURITY_ERROR; 
     
    191201        @SuppressWarnings("unchecked") 
    192202        public void doPost(HttpServletRequest request, HttpServletResponse response) 
    193                 throws ServletException, IOException { 
     203                        throws ServletException, IOException { 
    194204                logger.debug("Entering Connector#doPost"); 
    195205 
     
    218228 
    219229                if (!RequestCycleHandler.isEnabledForFileUpload(request)) 
    220                         ur = new UploadResponse(UploadResponse.SC_SECURITY_ERROR, null, null, 
    221                                 lrh.getString("message.connector.fileUpload.disabled")); 
     230                        ur = new UploadResponse(UploadResponse.SC_SECURITY_ERROR, null, 
     231                                        null, lrh 
     232                                                        .getString("message.connector.fileUpload.disabled")); 
    222233                else if (!CommandHandler.isValidForPost(commandStr)) 
    223                         ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, lrh.getString("message.connector.invalid_command_specified")); 
     234                        ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, lrh 
     235                                        .getString("message.connector.invalid_command_specified")); 
    224236                else if (typeStr != null && !ResourceTypeHandler.isValid(typeStr)) 
    225                         ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, lrh.getString("message.connector.invalid_type_specified")); 
     237                        ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, lrh 
     238                                        .getString("message.connector.invalid_type_specified")); 
    226239                else if (!UtilsFile.isValidPath(currentFolderStr)) 
    227                         ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, 
    228                                         lrh.getString("message.connector.invalid_current_folder_speficied")); 
     240                        ur = new UploadResponse( 
     241                                        UploadResponse.SC_ERROR, 
     242                                        null, 
     243                                        null, 
     244                                        lrh 
     245                                                        .getString("message.connector.invalid_current_folder_speficied")); 
    229246                else { 
    230                         ResourceTypeHandler resourceType = ResourceTypeHandler.getDefaultResourceType(typeStr); 
    231  
    232                         String typePath = UtilsFile.constructServerSidePath(request, resourceType); 
     247                        ResourceTypeHandler resourceType = ResourceTypeHandler 
     248                                        .getDefaultResourceType(typeStr); 
     249 
     250                        String typePath = UtilsFile.constructServerSidePath(request, 
     251                                        resourceType); 
    233252                        String typeDirPath = getServletContext().getRealPath(typePath); 
    234253 
     
    239258 
    240259                        if (!currentDir.exists()) 
    241                                 ur = new UploadResponse(UploadResponse.SC_ERROR, null, null, 
    242                                                 lrh.getString("message.connector.invalid_current_folder_speficied")); 
     260                                ur = new UploadResponse( 
     261                                                UploadResponse.SC_ERROR, 
     262                                                null, 
     263                                                null, 
     264                                                lrh 
     265                                                                .getString("message.connector.invalid_current_folder_speficied")); 
    243266                        else { 
    244267 
     
    253276                                        // We upload only one file at the same time 
    254277                                        FileItem uplFile = items.get(0); 
    255                                         String rawName = UtilsFile.sanitizeFileName(uplFile.getName()); 
     278                                        String rawName = UtilsFile.sanitizeFileName(uplFile 
     279                                                        .getName()); 
    256280                                        String filename = FilenameUtils.getName(rawName); 
    257281                                        String baseName = FilenameUtils.removeExtension(filename); 
     
    259283 
    260284                                        if (!ExtensionsHandler.isAllowed(resourceType, extension)) 
    261                                                 ur = new UploadResponse(UploadResponse.SC_INVALID_EXTENSION); 
     285                                                ur = new UploadResponse( 
     286                                                                UploadResponse.SC_INVALID_EXTENSION); 
    262287                                        else { 
    263288 
     
    266291                                                int counter = 1; 
    267292                                                while (pathToSave.exists()) { 
    268                                                         newFilename = baseName.concat("(").concat(String.valueOf(counter)) 
    269                                                                 .concat(")").concat(".").concat(extension); 
     293                                                        newFilename = baseName.concat("(").concat( 
     294                                                                        String.valueOf(counter)).concat(")") 
     295                                                                        .concat(".").concat(extension); 
    270296                                                        pathToSave = new File(currentDir, newFilename); 
    271297                                                        counter++; 
     
    273299 
    274300                                                if (Utils.isEmpty(newFilename)) 
    275                                                         ur = new UploadResponse(UploadResponse.SC_OK, UtilsResponse 
    276                                                                 .constructResponseUrl(request, resourceType, currentFolderStr, 
    277                                                                         true, ConnectorHandler.isFullUrl()).concat(filename)); 
     301                                                        ur = new UploadResponse(UploadResponse.SC_OK, 
     302                                                                        UtilsResponse.constructResponseUrl(request, 
     303                                                                                        resourceType, currentFolderStr, 
     304                                                                                        true, ConnectorHandler.isFullUrl()) 
     305                                                                                        .concat(filename)); 
    278306                                                else 
    279307                                                        ur = new UploadResponse(UploadResponse.SC_RENAMED, 
    280                                                                 UtilsResponse.constructResponseUrl(request, resourceType, 
    281                                                                         currentFolderStr, true, ConnectorHandler.isFullUrl()) 
    282                                                                         .concat(newFilename), newFilename); 
     308                                                                        UtilsResponse.constructResponseUrl(request, 
     309                                                                                        resourceType, currentFolderStr, 
     310                                                                                        true, ConnectorHandler.isFullUrl()) 
     311                                                                                        .concat(newFilename), newFilename); 
    283312 
    284313                                                // secure image check 
    285314                                                if (resourceType.equals(ResourceTypeHandler.IMAGE) 
    286                                                         && ConnectorHandler.isSecureImageUploads()) { 
     315                                                                && ConnectorHandler.isSecureImageUploads()) { 
    287316                                                        if (UtilsFile.isImage(uplFile.getInputStream())) 
    288317                                                                uplFile.write(pathToSave); 
    289318                                                        else { 
    290319                                                                uplFile.delete(); 
    291                                                                 ur = new UploadResponse(UploadResponse.SC_INVALID_EXTENSION); 
     320                                                                ur = new UploadResponse( 
     321                                                                                UploadResponse.SC_INVALID_EXTENSION); 
    292322                                                        } 
    293323                                                } else 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/handlers/CommandHandler.java

    r2151 r2231  
    8989 
    9090        /** 
    91          * Checks if a specfied string represents a valid <code>GET</code> 
     91         * Checks if a specified string represents a valid <code>GET</code> 
    9292         * command. 
    9393         *  
     
    102102 
    103103        /** 
    104          * Checks if a specfied string represents a valid <code>POST</code> 
     104         * Checks if a specified string represents a valid <code>POST</code> 
    105105         * command. 
    106106         *  
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/handlers/ResourceTypeHandler.java

    r2151 r2231  
    101101        /** 
    102102         *  
    103          * Checks if a specfied string represents a valid resource type. 
     103         * Checks if a specified string represents a valid resource type. 
    104104         *  
    105105         * @param name 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/response/UploadResponse.java

    r2223 r2231  
    2828 * <p> 
    2929 * The usage is quite easy but can be tricky since varargs are used in the class 
    30  * constructor.<br/> The requestor expects a JS method callback with variable 
     30 * constructor.<br/> The requester expects a JS method callback with variable 
    3131 * arguments size. 
    3232 * </p> 
     
    4747        private Object[] parameters; 
    4848 
    49         // Naming scheme according static status codes in javax.servlet.http.HttpServletResponse 
     49        // Naming scheme according static status codes in 
     50        // javax.servlet.http.HttpServletResponse 
    5051        /** Error number OK */ 
    5152        public static final int SC_OK = 0; 
     
    6263        /** Error number SECURITY ERROR */ 
    6364        public static final int SC_SECURITY_ERROR = 203; 
    64          
     65 
    6566        /** 
    6667         * Constructs the response with variable amount of parameters. 
     
    7374         * </p> 
    7475         * <p> 
    75          * Use, if possible, the pre-defined error numbers or upload responses. 
     76         * Use, if possible, the predefined error numbers or upload responses. 
    7677         * </p> 
    7778         * <p> 
     
    130131                StringBuffer sb = new StringBuffer(400); 
    131132                sb.append("<script type=\"text/javascript\">\n"); 
    132         // Minified version of the document.domain automatic fix script. 
    133                 // The original script can be found at [fckeditor dir]/_dev/domain_fix_template.js 
    134                 sb.append("(function(){var d=document.domain;while (true){try{var A=window.parent.document.domain;break;}catch(e) {};d=d.replace(/.*?(?:\\.|$)/,'');if (d.length==0) break;try{document.domain=d;}catch (e){break;}}})();\n"); 
     133                // Compressed version of the document.domain automatic fix script. 
     134                // The original script can be found at [fckeditor 
     135                // dir]/_dev/domain_fix_template.js 
     136                sb 
     137                                .append("(function(){var d=document.domain;while (true){try{var A=window.parent.document.domain;break;}catch(e) {};d=d.replace(/.*?(?:\\.|$)/,'');if (d.length==0) break;try{document.domain=d;}catch (e){break;}}})();\n"); 
    135138                sb.append("window.parent.OnUploadCompleted("); 
    136139 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/response/XmlResponse.java

    r2151 r2231  
    7777 
    7878        /** 
    79          * Use this contructor if want to respond a positive message. 
     79         * Use this constructor if want to respond a positive message. 
    8080         *  
    8181         * @param command 
     
    111111        /** 
    112112         *  
    113          * Use this contructor if want to respond a negative/error message with 
     113         * Use this constructor if want to respond a negative/error message with 
    114114         * custom text. 
    115115         *  
     
    133133         
    134134        /** 
    135          * Use this contructor if want to respond a negative/error message only. 
     135         * Use this constructor if want to respond a negative/error message only. 
    136136         *  
    137137         * @param number 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/tags/ConfigTag.java

    r2151 r2231  
    3131/** 
    3232 * This tag sets configuration options for the surrounding editor tag. Provide 
    33  * any configuraion options you want as described <a 
     33 * any configuration options you want as described <a 
    3434 * href="http://docs.fckeditor.net/FCKeditor_2.x/Developers_Guide/Configuration/Configuration_Options">here</a>. 
    3535 * This tag utilizes the dynamic attribute features provided by the 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/tags/EditorTag.java

    r2227 r2231  
    5656         *  
    5757         * @param instanceName 
    58          *            some name without whitespaces 
     58         *            some name without whitespace 
    5959         */ 
    6060        public void setInstanceName(String instanceName) { 
     
    143143                        out.println(fckEditor); 
    144144                } catch (IOException e) { 
    145                         throw new JspException("Tag response could not be written to the user!",e); 
     145                        throw new JspException( 
     146                                        "Tag response could not be written to the user!", e); 
    146147                } 
    147148 
  • FCKeditor.Java/trunk/java-core/src/main/java/net/fckeditor/tool/Utils.java

    r2227 r2231  
    3838         * @param delimiter 
    3939         *            The delimiter. 
    40          * @return An emtpy list if 'stringList' is empty else a lowercased set of 
     40         * @return An empty list if 'stringList' is empty else a lowercased set of 
    4141         *         strings. 
    4242         * @throws IllegalArgumentException 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy