001    package railo.runtime.tag;
002    
003    import java.io.IOException;
004    
005    import javax.servlet.jsp.tagext.Tag;
006    
007    import railo.commons.lang.HTMLEntities;
008    import railo.commons.lang.StringUtil;
009    import railo.runtime.exp.ApplicationException;
010    import railo.runtime.exp.ExpressionException;
011    import railo.runtime.exp.PageException;
012    import railo.runtime.ext.tag.TagImpl;
013    import railo.runtime.op.Caster;
014    import railo.runtime.op.Decision;
015    import railo.runtime.type.Array;
016    import railo.runtime.type.KeyImpl;
017    import railo.runtime.type.List;
018    import railo.runtime.type.Struct;
019    import railo.runtime.type.StructImpl;
020    
021    // FUTURE tag input 
022    //attr validateAt impl tag atrr
023    //attr validate add support for submitOnce
024    // Added support for generating Flash and XML controls (specified in the cfform tag).
025    // Added support for preventing multiple submissions.
026    // attr mask impl. logik dahinter umsetzen
027    
028    /**
029     * 
030     */
031    public class Input extends TagImpl {
032        
033        public static final short TYPE_SELECT=-1;
034            public static final short TYPE_TEXT=0;
035        public static final short TYPE_RADIO=1;
036        public static final short TYPE_CHECKBOX=2;
037        public static final short TYPE_PASSWORD=3;
038        public static final short TYPE_BUTTON=4;
039        public static final short TYPE_FILE=5;
040        public static final short TYPE_HIDDEN=6;
041        public static final short TYPE_IMAGE=7;
042        public static final short TYPE_RESET=8;
043        public static final short TYPE_SUBMIT=9;
044        public static final short TYPE_DATEFIELD=10;
045            
046        public static final short VALIDATE_DATE=4;
047        public static final short VALIDATE_EURODATE=5;
048        public static final short VALIDATE_TIME=6;
049        public static final short VALIDATE_FLOAT=7;
050        public static final short VALIDATE_INTEGER=8;
051        public static final short VALIDATE_TELEPHONE=9;
052        public static final short VALIDATE_ZIPCODE=10;
053        public static final short VALIDATE_CREDITCARD=11;
054        public static final short VALIDATE_SOCIAL_SECURITY_NUMBER=12;
055        public static final short VALIDATE_REGULAR_EXPRESSION=13;
056        public static final short VALIDATE_NONE=14;
057    
058        public static final short VALIDATE_USDATE=15;
059        public static final short VALIDATE_RANGE=16;
060        public static final short VALIDATE_BOOLEAN=17;
061        public static final short VALIDATE_EMAIL=18;
062        public static final short VALIDATE_URL=19;
063        public static final short VALIDATE_UUID=20;
064        public static final short VALIDATE_GUID=21;
065        public static final short VALIDATE_MAXLENGTH=22;
066        public static final short VALIDATE_NOBLANKS=23;
067        // TODO SubmitOnce
068    
069        /**
070         * @param validate The validate to set.
071         * @throws ApplicationException
072         */
073        public void setValidate(String validate) throws ApplicationException {
074            validate=validate.toLowerCase().trim();
075            if(validate.equals("creditcard"))               input.setValidate(VALIDATE_CREDITCARD);
076            else if(validate.equals("date"))                input.setValidate(VALIDATE_DATE);
077            else if(validate.equals("usdate"))              input.setValidate(VALIDATE_USDATE);
078            else if(validate.equals("eurodate"))    input.setValidate(VALIDATE_EURODATE);
079            else if(validate.equals("float"))               input.setValidate(VALIDATE_FLOAT);
080            else if(validate.equals("numeric"))             input.setValidate(VALIDATE_FLOAT);
081            else if(validate.equals("integer"))             input.setValidate(VALIDATE_INTEGER);
082            else if(validate.equals("int"))                 input.setValidate(VALIDATE_INTEGER);
083            else if(validate.equals("regular_expression"))          input.setValidate(VALIDATE_REGULAR_EXPRESSION);
084            else if(validate.equals("regex"))               input.setValidate(VALIDATE_REGULAR_EXPRESSION);
085            else if(validate.equals("social_security_number"))input.setValidate(VALIDATE_SOCIAL_SECURITY_NUMBER);
086            else if(validate.equals("ssn"))                 input.setValidate(VALIDATE_SOCIAL_SECURITY_NUMBER);
087            else if(validate.equals("telephone"))   input.setValidate(VALIDATE_TELEPHONE);
088            else if(validate.equals("phone"))               input.setValidate(VALIDATE_TELEPHONE);
089            else if(validate.equals("time"))                input.setValidate(VALIDATE_TIME);
090            else if(validate.equals("zipcode"))             input.setValidate(VALIDATE_ZIPCODE);
091            else if(validate.equals("zip"))                 input.setValidate(VALIDATE_ZIPCODE);
092    
093            else if(validate.equals("range"))               input.setValidate(VALIDATE_RANGE);
094            else if(validate.equals("boolean"))             input.setValidate(VALIDATE_BOOLEAN);
095            else if(validate.equals("email"))               input.setValidate(VALIDATE_EMAIL);
096            else if(validate.equals("url"))                 input.setValidate(VALIDATE_URL);
097            else if(validate.equals("uuid"))                input.setValidate(VALIDATE_UUID);
098            else if(validate.equals("guid"))                input.setValidate(VALIDATE_GUID);
099            else if(validate.equals("maxlength"))   input.setValidate(VALIDATE_MAXLENGTH);
100            else if(validate.equals("noblanks"))    input.setValidate(VALIDATE_NOBLANKS);
101            
102            else throw new ApplicationException("attribute validate has a invalid value ["+validate+"]",
103                    "valid values for attribute validate are [creditcard, date, eurodate, float, integer, regular, social_security_number, telephone, time, zipcode]");
104            
105        }
106        
107        
108            public static final String[] DAYNAMES_DEFAULT = new String[]{"S", "M", "T", "W", "Th", "F", "S"};
109            public static final String[] MONTHNAMES_DEFAULT = new String[]{"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
110            
111    
112        Struct attributes=new StructImpl();
113        InputBean input=new InputBean();
114        String passthrough;
115            
116        String[] daynames=DAYNAMES_DEFAULT;
117        String[] monthnames=MONTHNAMES_DEFAULT;
118        
119        boolean enabled=true;
120        boolean visible=true;
121        String label;
122        String tooltip;
123        String validateAt;
124            double firstDayOfWeek=0;
125            String mask;
126            
127        
128        /**
129         * @see javax.servlet.jsp.tagext.Tag#release()
130         */
131        public void release() {
132            super.release();
133            input=new InputBean();
134            attributes.clear();
135            passthrough=null;
136    
137            daynames=DAYNAMES_DEFAULT;
138            monthnames=MONTHNAMES_DEFAULT;
139            enabled=true;
140            visible=true;
141            label=null;
142            tooltip=null;
143            validateAt=null;
144            firstDayOfWeek=0;
145            mask=null;    
146        }
147        
148        /**
149         * @param cssclass The cssclass to set.
150         */
151        public void setClass(String cssclass) {
152            attributes.setEL("class",cssclass);
153        }
154        /**
155         * @param cssstyle The cssstyle to set.
156         */
157        public void setStyle(String cssstyle) {
158            attributes.setEL("style",cssstyle);
159        }
160       /**
161         * @param id The id to set.
162         */
163        public void setId(String id) {
164            attributes.setEL("id",id);
165        }
166        
167        public void setAccept(String accept) {
168            attributes.setEL("accept",accept);
169        }
170        
171        public void setAccesskey(String accesskey) {
172            attributes.setEL("accesskey",accesskey);
173        }
174        
175        public void setAlign(String align) {
176            attributes.setEL("align",align);
177        }
178        
179        public void setAlt(String alt) {
180            attributes.setEL("alt",alt);
181        }
182    
183    
184        public void setAutocomplete(String autocomplete) {
185            attributes.setEL("autocomplete",autocomplete);
186        }
187        public void setAutofocus(String autofocus) {
188            attributes.setEL("autofocus",autofocus);
189        }
190        
191    
192            public void setBorder(String border) {
193            attributes.setEL("border",border);
194        }
195        
196        public void setDatafld(String datafld) {
197            attributes.setEL("datafld",datafld);
198        }
199        
200        public void setDatasrc(String datasrc) {
201            attributes.setEL("datasrc",datasrc);
202        }
203    
204        public void setForm(String form) {
205            attributes.setEL("form",form);
206        }
207        public void setFormaction(String formAction) {
208            attributes.setEL("formaction",formAction);
209        }
210        public void setFormenctype(String formenctype) {
211            attributes.setEL("formenctype",formenctype);
212        }
213        public void setFormmethod(String formmethod) {
214            attributes.setEL("formmethod",formmethod);
215        }
216        public void setFormnovalidate(String formnovalidate) {
217            attributes.setEL("formnovalidate",formnovalidate);
218        }
219        public void setFormtarget(String formtarget) {
220            attributes.setEL("formtarget",formtarget);
221        }
222        
223    
224        public void setLang(String lang) {
225            attributes.setEL("lang",lang);
226        }
227        public void setList(String list) {
228            attributes.setEL("list",list);
229        }
230        
231        public void setDir(String dir) {
232            //dir=dir.trim();
233            //String lcDir=dir.toLowerCase();
234            //if( "ltr".equals(lcDir) || "rtl".equals(lcDir)) 
235                    attributes.setEL("dir",dir);
236            
237            //else throw new ApplicationException("attribute dir for tag input has a invalid value ["+dir+"], valid values are [ltr, rtl]");
238        }
239        
240        public void setDataformatas(String dataformatas) {
241            dataformatas=dataformatas.trim();
242            //String lcDataformatas=dataformatas.toLowerCase();
243            //if( "plaintext".equals(lcDataformatas) || "html".equals(lcDataformatas)) 
244                    attributes.setEL("dataformatas",dataformatas);
245            
246            //else throw new ApplicationException("attribute dataformatas for tag input has a invalid value ["+dataformatas+"], valid values are [plaintext, html");
247        }
248    
249        public void setDisabled(String disabled) {
250            // alles ausser false ist true
251            //if(Caster.toBooleanValue(disabled,true)) 
252                    attributes.setEL("disabled",disabled);
253        }
254    
255        public void setEnabled(String enabled) {
256            // alles ausser false ist true
257            //setDisabled(Caster.toString(!Caster.toBooleanValue(enabled,true))); 
258                    attributes.setEL("enabled",enabled);
259        }
260        
261        
262        
263        
264        public void setIsmap(String ismap) {
265            // alles ausser false ist true
266            //if(Caster.toBooleanValue(ismap,true)) attributes.setEL("ismap","ismap");
267            attributes.setEL("ismap",ismap);
268        }
269        
270        public void setReadonly(String readonly) {
271            // alles ausser false ist true
272            //if(Caster.toBooleanValue(readonly,true)) attributes.setEL("readonly","readonly");
273            attributes.setEL("readonly",readonly);
274        }
275        
276        public void setUsemap(String usemap) {
277            attributes.setEL("usemap",usemap);
278        }
279    
280        /**
281         * @param onBlur The onBlur to set.
282         */
283        public void setOnblur(String onBlur) {
284            attributes.setEL("onblur",onBlur);
285        }
286        /**
287         * @param onChange The onChange to set.
288         */
289        public void setOnchange(String onChange) {
290            attributes.setEL("onchange",onChange);
291        }
292        /**
293         * @param onClick The onClick to set.
294         */
295        public void setOnclick(String onClick) {
296            attributes.setEL("onclick",onClick);
297        }
298        /**
299         * @param onDblclick The onDblclick to set.
300         */
301        public void setOndblclick(String onDblclick) {
302            attributes.setEL("ondblclick",onDblclick);
303        }
304        /**
305         * @param onFocus The onFocus to set.
306         */
307        public void setOnfocus(String onFocus) {
308            attributes.setEL("onfocus",onFocus);
309        }
310        /**
311         * @param onKeyDown The onKeyDown to set.
312         */
313        public void setOnkeydown(String onKeyDown) {
314            attributes.setEL("onkeydown",onKeyDown);
315        }
316        /**
317         * @param onKeyPress The onKeyPress to set.
318         */
319        public void setOnkeypress(String onKeyPress) {
320            attributes.setEL("onkeypress",onKeyPress);
321        }
322        /**
323         * @param onKeyUp The onKeyUp to set.
324         */
325        public void setOnkeyup(String onKeyUp) {
326            attributes.setEL("onKeyUp",onKeyUp);
327        }
328        /**
329         * @param onMouseDown The onMouseDown to set.
330         */
331        public void setOnmousedown(String onMouseDown) {
332            attributes.setEL("onMouseDown",onMouseDown);
333        }
334        /**
335         * @param onMouseMove The onMouseMove to set.
336         */
337        public void setOnmousemove(String onMouseMove) {
338            attributes.setEL("onMouseMove",onMouseMove);
339        }
340        /**
341         * @param onMouseUp The onMouseUp to set.
342         */
343        public void setOnmouseup(String onMouseUp) {
344            attributes.setEL("onMouseUp",onMouseUp);
345        }
346        /**
347         * @param onMouseUp The onMouseUp to set.
348         */
349        public void setOnselect(String onselect) {
350            attributes.setEL("onselect",onselect);
351        }
352        /**
353         * @param onMouseOut The onMouseOut to set.
354         */
355        public void setOnmouseout(String onMouseOut) {
356            attributes.setEL("onMouseOut",onMouseOut);
357        }
358        /**
359         * @param onMouseOver The onKeyPress to set.
360         */
361        public void setOnmouseover(String onMouseOver) {
362            attributes.setEL("onMouseOver",onMouseOver);
363        }
364        /**
365         * @param tabIndex The tabIndex to set.
366         */
367        public void setTabindex(String tabIndex) {
368            attributes.setEL("tabindex",tabIndex);
369        }
370        /**
371         * @param title The title to set.
372         */
373        public void setTitle(String title) {
374            attributes.setEL("title",title);
375        }
376        /**
377         * @param value The value to set.
378         */
379        public void setValue(String value) {
380            attributes.setEL("value",value);
381        }
382        /**
383         * @param size The size to set.
384         */
385        public void setSize(String size) {
386            attributes.setEL("size",size);
387        }
388        /**
389         * @param maxLength The maxLength to set.
390         */
391        public void setMaxlength(double maxLength) {
392            input.setMaxLength((int)maxLength);
393            attributes.setEL("maxLength",Caster.toString(maxLength));
394        }
395        /**
396         * @param checked The checked to set.
397         */
398        public void setChecked(String checked) {
399            // alles ausser false ist true
400            if(Caster.toBooleanValue(checked,true)) attributes.setEL("checked","checked");
401        } 
402        /**
403         * @param daynames The daynames to set.
404         * @throws ApplicationException 
405         */
406        public void setDaynames(String listDaynames) throws ApplicationException {
407            String[] arr = List.listToStringArray(listDaynames, ',');
408            if(arr.length==7)
409                    throw new ApplicationException("value of attribute [daynames] must contain a string list with 7 values, now there are "+arr.length+" values");
410            this.daynames=arr;
411        }
412        /**
413         * @param daynames The daynames to set.
414         * @throws ApplicationException 
415         */
416        public void setFirstdayofweek(double firstDayOfWeek) throws ApplicationException {
417            if(firstDayOfWeek<0 || firstDayOfWeek>6)
418                    throw new ApplicationException("value of attribute [firstDayOfWeek] must conatin a numeric value between 0-6");
419            this.firstDayOfWeek=firstDayOfWeek;
420        }
421        /**
422         * @param daynames The daynames to set.
423         * @throws ApplicationException 
424         */
425        public void setMonthnames(String listMonthNames) throws ApplicationException {
426            String[] arr = List.listToStringArray(listMonthNames, ',');
427            if(arr.length==12)
428                    throw new ApplicationException("value of attribute [MonthNames] must contain a string list with 12 values, now there are "+arr.length+" values");
429            this.monthnames=arr;
430        }
431        
432        /**
433         * @param daynames The daynames to set.
434         */
435        public void setLabel(String label) {
436            this.label=label;
437        }
438        /**
439         * @param daynames The daynames to set.
440         */
441        public void setMask(String mask) {
442            this.mask=mask;
443        }
444    
445        public void setMax(String max) {
446                    attributes.setEL("max",max);
447            }
448        public void setMin(String min) {
449                    attributes.setEL("min",min);
450            }
451        public void setMultiple(String multiple) {
452                    attributes.setEL("multiple",multiple);
453            }
454        public void setPlaceholder(String placeholder) {
455                    attributes.setEL("placeholder",placeholder);
456            }
457        
458        
459        
460        /**
461         * @param daynames The daynames to set.
462         */
463        public void setNotab(String notab) {
464            attributes.setEL("notab",notab);
465        }
466        /**
467         * @param daynames The daynames to set.
468         */
469        public void setHspace(String hspace) {
470            attributes.setEL("hspace",hspace);
471        }
472        
473        /**
474         * @param type The type to set.
475         * @throws ApplicationException
476         */
477        public void setType(String type) throws ApplicationException {      
478            type=type.toLowerCase().trim();
479            if(             "checkbox".equals(type))        input.setType(TYPE_CHECKBOX);
480            else if("password".equals(type))        input.setType(TYPE_PASSWORD);
481            else if("text".equals(type))            input.setType(TYPE_TEXT);
482            else if("radio".equals(type))           input.setType(TYPE_RADIO);
483            else if("button".equals(type))          input.setType(TYPE_BUTTON);
484            else if("file".equals(type))            input.setType(TYPE_FILE);
485            else if("hidden".equals(type))          input.setType(TYPE_HIDDEN);
486            else if("image".equals(type))           input.setType(TYPE_IMAGE);
487            else if("reset".equals(type))           input.setType(TYPE_RESET);
488            else if("submit".equals(type))          input.setType(TYPE_SUBMIT);
489            else if("datefield".equals(type))       input.setType(TYPE_DATEFIELD);
490            
491            else throw new ApplicationException("attribute type has a invalid value ["+type+"]","valid values for attribute type are " +
492                            "[checkbox, password, text, radio, button, file, hidden, image, reset, submit, datefield]");
493    
494            attributes.setEL("type",type);
495        }
496        
497        /**
498         * @param onError The onError to set.
499         */
500        public void setOnerror(String onError) {
501            input.setOnError(onError);
502        }
503        /**
504         * @param onValidate The onValidate to set.
505         */
506        public void setOnvalidate(String onValidate) {
507            input.setOnValidate(onValidate);
508        }
509        /**
510         * @param passthrough The passThrough to set.
511         * @throws PageException
512         */
513        public void setPassthrough(Object passthrough) throws PageException {
514            if(passthrough instanceof Struct) {
515                Struct sct = (Struct) passthrough;
516                railo.runtime.type.Collection.Key[] keys=sct.keys();
517                railo.runtime.type.Collection.Key key;
518                for(int i=0;i<keys.length;i++) {
519                    key=keys[i];
520                    attributes.setEL(key,sct.get(key,null));
521                }
522            }
523            else this.passthrough = Caster.toString(passthrough);
524            
525            //input.setPassThrough(passThrough);
526        }
527        /**
528         * @param pattern The pattern to set.
529         * @throws ExpressionException 
530         */
531        public void setPattern(String pattern) throws ExpressionException {
532            input.setPattern(pattern);
533        }
534        /**
535         * @param range The range to set.
536         * @throws PageException
537         */
538        public void setRange(String range) throws PageException {
539            String errMessage="attribute range has a invalid value ["+range+"], must be string list with numbers";
540            String errDetail="Example: [number_from,number_to], [number_from], [number_from,], [,number_to]";
541            
542            Array arr=List.listToArray(range,',');
543            
544            if(arr.size()==1) {
545                double from=Caster.toDoubleValue(arr.get(1,null),Double.NaN);
546                if(!Decision.isValid(from))throw new ApplicationException(errMessage,errDetail);
547                input.setRangeMin(from);
548                input.setRangeMax(Double.NaN);
549            }
550            else if(arr.size()==2) {
551                String strFrom=arr.get(1,"").toString().trim();
552                double from=Caster.toDoubleValue(strFrom,Double.NaN);
553                if(!Decision.isValid(from) && strFrom.length()>0) {
554                    throw new ApplicationException(errMessage,errDetail);
555                }
556                input.setRangeMin(from);
557                
558                String strTo=arr.get(2,"").toString().trim();
559                double to=Caster.toDoubleValue(strTo,Double.NaN);
560                if(!Decision.isValid(to) && strTo.length()>0) {
561                    throw new ApplicationException(errMessage,errDetail);
562                }
563                input.setRangeMax(to);
564                
565            }
566            else throw new ApplicationException(errMessage,errDetail);
567        }
568        /**
569         * @param required The required to set.
570         */
571        public void setRequired(boolean required) {
572            input.setRequired(required);
573        }
574        /**
575         * @param name The name to set.
576         */
577        public void setName(String name) {
578            attributes.setEL(KeyImpl.NAME,name);
579            input.setName(name);
580        }
581        /**
582         * @param message The message to set.
583         */
584        public void setMessage(String message) {
585            if(!StringUtil.isEmpty(message))input.setMessage(message);
586        }
587    
588        /**
589             *
590             * @see railo.runtime.ext.tag.TagImpl#doEndTag()
591             */
592            public int doEndTag() throws PageException {
593                    try {
594                _doEndTag();
595            }
596                    catch (IOException e) {
597               throw Caster.toPageException(e);
598            }
599            return EVAL_PAGE;
600            }
601    
602            private void _doEndTag() throws PageException, IOException {
603            // check attributes
604            if(input.getValidate()==VALIDATE_REGULAR_EXPRESSION && input.getPattern()==null) {
605                throw new ApplicationException("when validation type regular_expression is seleted, the pattern attribute is required");
606            }
607    
608            Tag parent = getParent();
609            while(parent!=null && !(parent instanceof Form)){
610                            parent=parent.getParent();
611                    }
612            if(parent instanceof Form) {
613                        Form form = (Form)parent;
614                        form.setInput(input);
615                        if(input.getType()==TYPE_DATEFIELD && form.getFormat()!=Form.FORMAT_FLASH)
616                            throw new ApplicationException("type [datefield] is only allowed if form format is flash");
617                    }
618                    else { 
619                        throw new ApplicationException("Tag must be inside a form tag");
620                    }
621            draw();
622        }
623    
624        void draw() throws IOException, PageException {
625    
626            // start output
627            pageContext.forceWrite("<input");
628            
629            railo.runtime.type.Collection.Key[] keys = attributes.keys();
630            railo.runtime.type.Collection.Key key;
631            for(int i=0;i<keys.length;i++) {
632                key = keys[i];
633                pageContext.forceWrite(" ");
634                pageContext.forceWrite(key.getString());
635                pageContext.forceWrite("=\"");
636                pageContext.forceWrite(enc(Caster.toString(attributes.get(key,null))));
637                pageContext.forceWrite("\"");
638               
639            }
640            
641            if(passthrough!=null) {
642                pageContext.forceWrite(" ");
643                pageContext.forceWrite(passthrough);
644            }
645            pageContext.forceWrite(">");
646            }
647    
648            /**
649         * html encode a string
650         * @param str string to encode
651         * @return encoded string
652         */
653        String enc(String str) {
654            return HTMLEntities.escapeHTML(str,HTMLEntities.HTMLV20);
655        }
656    
657            /**
658             * @return the monthnames
659             */
660            public String[] getMonthnames() {
661                    return monthnames;
662            }
663    
664            /**
665             * @param monthnames the monthnames to set
666             */
667            public void setMonthnames(String[] monthnames) {
668                    this.monthnames = monthnames;
669            }
670    
671            /**
672             * @param height the height to set
673             */
674            public void setHeight(String height) {
675                    attributes.setEL("height",height);
676            }
677    
678            /**
679             * @param input the input to set
680             */
681            public void setInput(InputBean input) {
682                    this.input = input;
683            }
684    
685            /**
686             * @param passthrough the passthrough to set
687             */
688            public void setPassthrough(String passthrough) {
689                    this.passthrough = passthrough;
690            }
691    
692            /**
693             * @param tooltip the tooltip to set
694             * @throws ApplicationException 
695             */
696            public void setTooltip(String tooltip) {
697                    this.tooltip = tooltip;
698            }
699    
700            /**
701             * @param validateAt the validateAt to set
702             * @throws ApplicationException 
703             */
704            public void setValidateat(String validateAt) throws ApplicationException {
705                    this.validateAt = validateAt;
706                    throw new ApplicationException("attribute validateAt is not supportrd for tag input ");
707    
708            }
709    
710            /**
711             * @param visible the visible to set
712             * @throws ApplicationException 
713             */
714            public void setVisible(boolean visible) {
715                    this.visible = visible;
716            }
717    
718            /**
719             * @param width the width to set
720             * @throws ApplicationException 
721             */
722            public void setWidth(String width) {
723                    attributes.setEL("width", width);
724            }
725            
726            
727        private ExpressionException notSupported(String label) {
728                    return new ExpressionException("attribute ["+label+"] is not supported");
729            }
730        
731        
732    
733    
734        public void setAutosuggest(String autosuggest) throws ExpressionException {
735            throw notSupported("autosuggest");
736            //attributes.setEL("bind",bind);
737        }
738        public void setAutosuggestbinddelay(double autosuggestBindDelay) throws ExpressionException {
739            throw notSupported("autosuggestBindDelay");
740            //attributes.setEL("bind",bind);
741        }
742        public void setAutosuggestminlength(double autosuggestMinLength) throws ExpressionException {
743            throw notSupported("autosuggestMinLength");
744            //attributes.setEL("bind",bind);
745        }
746    
747        public void setBind(String bind) throws ExpressionException {
748            throw notSupported("bind");
749            //attributes.setEL("bind",bind);
750        }
751        
752        public void setBindattribute(String bindAttribute) throws ExpressionException {
753            throw notSupported("bindAttribute");
754            //attributes.setEL("bind",bind);
755        }
756        
757        public void setBindonload(boolean bindOnLoad) throws ExpressionException {
758            throw notSupported("bindOnLoad");
759            //attributes.setEL("bind",bind);
760        }
761    
762        public void setDelimiter(String delimiter) throws ExpressionException {
763            throw notSupported("delimiter");
764            //attributes.setEL("bind",bind);
765        }
766        public void setMaxresultsdisplayed(double maxResultsDisplayed) throws ExpressionException {
767            throw notSupported("maxResultsDisplayed");
768            //attributes.setEL("bind",bind);
769        }
770        public void setOnbinderror(String onBindError) throws ExpressionException {
771            throw notSupported("onBindError");
772            //attributes.setEL("bind",bind);
773        }
774        public void setShowautosuggestloadingicon(boolean showAutosuggestLoadingIcon) throws ExpressionException {
775            throw notSupported("showAutosuggestLoadingIcon");
776            //attributes.setEL("bind",bind);
777        }
778        public void setSourcefortooltip(String sourceForTooltip) throws ExpressionException {
779            throw notSupported("sourceForTooltip");
780            //attributes.setEL("bind",bind);
781        }
782        
783        public void setSrc(String src) {
784            attributes.setEL("src",src);
785        }
786        public void setStep(String step) {
787            attributes.setEL("step",step);
788        }
789        public void setTypeahead(boolean typeahead) throws ExpressionException {
790            throw notSupported("typeahead");
791            //attributes.setEL("src",src);
792        }
793        
794        
795        
796    }