1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package javax.faces.component;
20
21 import java.io.IOException;
22 import java.sql.ResultSet;
23 import java.util.*;
24 import javax.el.ValueExpression;
25 import javax.faces.FacesException;
26 import javax.faces.application.FacesMessage;
27 import javax.faces.context.FacesContext;
28 import javax.faces.event.AbortProcessingException;
29 import javax.faces.event.FacesEvent;
30 import javax.faces.event.FacesListener;
31 import javax.faces.event.PhaseId;
32 import javax.faces.model.*;
33 import javax.servlet.jsp.jstl.sql.Result;
34 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;
35 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFFacet;
36 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFProperty;
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103 @JSFComponent(defaultRendererType = "javax.faces.Table")
104 public class UIData extends UIComponentBase
105 implements NamingContainer
106 {
107 public static final String COMPONENT_FAMILY = "javax.faces.Data";
108 public static final String COMPONENT_TYPE = "javax.faces.Data";
109
110 private static final String FOOTER_FACET_NAME = "footer";
111 private static final String HEADER_FACET_NAME = "header";
112 private static final Class OBJECT_ARRAY_CLASS = (new Object[0]).getClass();
113 private static final int PROCESS_DECODES = 1;
114 private static final int PROCESS_VALIDATORS = 2;
115 private static final int PROCESS_UPDATES = 3;
116
117 private static final Object[] LEAF_NO_STATE = new Object[]{null,null};
118
119 private int _rowIndex = -1;
120 private String _var;
121
122
123
124
125 private Map _rowStates = new HashMap();
126
127
128
129
130
131
132
133
134 private Map _dataModelMap = new HashMap();
135
136
137 private boolean _isValidChilds = true;
138
139 private Object _initialDescendantComponentState = null;
140
141 private int _first;
142 private boolean _firstSet;
143 private int _rows;
144 private boolean _rowsSet;
145 private Object _value;
146
147 private static class FacesEventWrapper extends FacesEvent
148 {
149 private static final long serialVersionUID = 6648047974065628773L;
150 private FacesEvent _wrappedFacesEvent;
151 private int _rowIndex;
152
153 public FacesEventWrapper(FacesEvent facesEvent, int rowIndex,
154 UIData redirectComponent)
155 {
156 super(redirectComponent);
157 _wrappedFacesEvent = facesEvent;
158 _rowIndex = rowIndex;
159 }
160
161 @Override
162 public PhaseId getPhaseId()
163 {
164 return _wrappedFacesEvent.getPhaseId();
165 }
166
167 @Override
168 public void setPhaseId(PhaseId phaseId)
169 {
170 _wrappedFacesEvent.setPhaseId(phaseId);
171 }
172
173 @Override
174 public void queue()
175 {
176 _wrappedFacesEvent.queue();
177 }
178
179 @Override
180 public String toString()
181 {
182 return _wrappedFacesEvent.toString();
183 }
184
185 @Override
186 public boolean isAppropriateListener(FacesListener faceslistener)
187 {
188 return _wrappedFacesEvent.isAppropriateListener(faceslistener);
189 }
190
191 @Override
192 public void processListener(FacesListener faceslistener)
193 {
194 _wrappedFacesEvent.processListener(faceslistener);
195 }
196
197 public FacesEvent getWrappedFacesEvent()
198 {
199 return _wrappedFacesEvent;
200 }
201
202 public int getRowIndex()
203 {
204 return _rowIndex;
205 }
206 }
207
208
209 private static final DataModel EMPTY_DATA_MODEL = new DataModel()
210 {
211 @Override
212 public boolean isRowAvailable()
213 {
214 return false;
215 }
216
217 @Override
218 public int getRowCount()
219 {
220 return 0;
221 }
222
223 @Override
224 public Object getRowData()
225 {
226 throw new IllegalArgumentException();
227 }
228
229 @Override
230 public int getRowIndex()
231 {
232 return -1;
233 }
234
235 @Override
236 public void setRowIndex(int i)
237 {
238 if (i < -1)
239 throw new IllegalArgumentException();
240 }
241
242 @Override
243 public Object getWrappedData()
244 {
245 return null;
246 }
247
248 @Override
249 public void setWrappedData(Object obj)
250 {
251 if (obj == null)
252 {
253 return;
254 }
255 throw new UnsupportedOperationException(this.getClass().getName()
256 + " UnsupportedOperationException");
257 }
258 };
259
260 private class EditableValueHolderState
261 {
262 private final Object _value;
263 private final boolean _localValueSet;
264 private final boolean _valid;
265 private final Object _submittedValue;
266
267 public EditableValueHolderState(EditableValueHolder evh)
268 {
269 _value = evh.getLocalValue();
270 _localValueSet = evh.isLocalValueSet();
271 _valid = evh.isValid();
272 _submittedValue = evh.getSubmittedValue();
273 }
274
275 public void restoreState(EditableValueHolder evh)
276 {
277 evh.setValue(_value);
278 evh.setLocalValueSet(_localValueSet);
279 evh.setValid(_valid);
280 evh.setSubmittedValue(_submittedValue);
281 }
282 }
283
284
285
286
287 public UIData()
288 {
289 setRendererType("javax.faces.Table");
290 }
291
292 @Override
293 public boolean invokeOnComponent(FacesContext context, String clientId, ContextCallback callback) throws FacesException {
294 if (context == null || clientId == null || callback == null)
295 {
296 throw new NullPointerException();
297 }
298
299
300 boolean returnValue = this.getClientId(context).equals(clientId);
301
302 boolean isCachedFacesContext = isCachedFacesContext();
303 if (!isCachedFacesContext)
304 {
305 setCachedFacesContext(context);
306 }
307
308 try
309 {
310 if (returnValue)
311 {
312 try
313 {
314 callback.invokeContextCallback(context, this);
315 }
316 catch (Exception e)
317 {
318 throw new FacesException(e);
319 }
320 return returnValue;
321 }
322
323
324 for (Iterator<UIComponent> it = this.getFacets().values().iterator(); !returnValue && it.hasNext();)
325 {
326 returnValue = it.next().invokeOnComponent(context, clientId, callback);
327 }
328
329 if (returnValue == true)
330 {
331 return returnValue;
332 }
333
334
335 String baseClientId = super.getClientId(context);
336
337
338 if (clientId.startsWith(baseClientId))
339 {
340
341
342 String subId = clientId.substring(baseClientId.length() + 1);
343
344
345 if (clientId.charAt(baseClientId.length()) == NamingContainer.SEPARATOR_CHAR &&
346 subId.matches("[0-9]+"+NamingContainer.SEPARATOR_CHAR+".*"))
347 {
348 String clientRow = subId.substring(0, subId.indexOf(NamingContainer.SEPARATOR_CHAR));
349
350
351 int oldRow = this.getRowIndex();
352
353
354 try
355 {
356
357
358 this.setRowIndex(Integer.parseInt(clientRow));
359
360
361 if (!isRowAvailable())
362 {
363 return false;
364 }
365
366 for (Iterator<UIComponent> it1 = getChildren().iterator();
367 !returnValue && it1.hasNext();)
368 {
369
370 returnValue = it1.next().invokeOnComponent(context, clientId, callback);
371 }
372 }
373 finally
374 {
375
376
377 this.setRowIndex(oldRow);
378 }
379 }
380 else
381 {
382
383
384
385
386
387 for (Iterator<UIComponent> itChildren = this.getChildren().iterator();
388 !returnValue && itChildren.hasNext();)
389 {
390 UIComponent child = itChildren.next();
391 if (child instanceof UIColumn && clientId.equals(child.getClientId(context)))
392 {
393 try {
394 callback.invokeContextCallback(context, child);
395 } catch (Exception e) {
396 throw new FacesException(e);
397 }
398 returnValue = true;
399 }
400
401 for (Iterator<UIComponent> itChildFacets = child.getFacets().values().iterator();
402 !returnValue && itChildFacets.hasNext();)
403 {
404
405 returnValue = itChildFacets.next().invokeOnComponent(context, clientId, callback);
406 }
407 }
408 }
409 }
410 }
411 finally
412 {
413 if (!isCachedFacesContext)
414 {
415 setCachedFacesContext(null);
416 }
417 }
418
419 return returnValue;
420 }
421
422 public void setFooter(UIComponent footer)
423 {
424 getFacets().put(FOOTER_FACET_NAME, footer);
425 }
426
427 @JSFFacet
428 public UIComponent getFooter()
429 {
430 return (UIComponent) getFacets().get(FOOTER_FACET_NAME);
431 }
432
433 public void setHeader(UIComponent header)
434 {
435 getFacets().put(HEADER_FACET_NAME, header);
436 }
437
438 @JSFFacet
439 public UIComponent getHeader()
440 {
441 return (UIComponent) getFacets().get(HEADER_FACET_NAME);
442 }
443
444 public boolean isRowAvailable()
445 {
446 return getDataModel().isRowAvailable();
447 }
448
449 public int getRowCount()
450 {
451 return getDataModel().getRowCount();
452 }
453
454 public Object getRowData()
455 {
456 return getDataModel().getRowData();
457 }
458
459 public int getRowIndex()
460 {
461 return _rowIndex;
462 }
463
464
465
466
467
468
469
470
471
472 public void setRowIndex(int rowIndex)
473 {
474 if (rowIndex < -1)
475 {
476 throw new IllegalArgumentException("rowIndex is less than -1");
477 }
478
479 if (_rowIndex == rowIndex)
480 {
481 return;
482 }
483
484 FacesContext facesContext = getFacesContext();
485
486 if (_rowIndex == -1)
487 {
488 if (_initialDescendantComponentState == null)
489 {
490
491
492
493
494 _initialDescendantComponentState = saveDescendantComponentStates(this, false, false);
495 }
496 }
497 else
498 {
499
500
501
502 if (_initialDescendantComponentState != null)
503 {
504
505
506
507
508 Collection<Object[]> savedRowState = saveDescendantComponentStates(this, false, false);
509 if (savedRowState != null)
510 {
511 _rowStates.put(getClientId(facesContext), savedRowState);
512 }
513 }
514 }
515
516 _rowIndex = rowIndex;
517
518 DataModel dataModel = getDataModel();
519 dataModel.setRowIndex(rowIndex);
520
521 String var = _var;
522 if (rowIndex == -1)
523 {
524 if (var != null)
525 {
526 facesContext.getExternalContext().getRequestMap().remove(var);
527 }
528 }
529 else
530 {
531 if (var != null)
532 {
533 if (isRowAvailable())
534 {
535 Object rowData = dataModel.getRowData();
536 facesContext.getExternalContext().getRequestMap().put(var,
537 rowData);
538 }
539 else
540 {
541 facesContext.getExternalContext().getRequestMap().remove(
542 var);
543 }
544 }
545 }
546
547 if (_rowIndex == -1)
548 {
549
550
551 if (_initialDescendantComponentState != null)
552 {
553 restoreDescendantComponentStates(this, false, _initialDescendantComponentState, false);
554 }
555 else
556 {
557 restoreDescendantComponentWithoutRestoreState(this, false, false);
558 }
559 }
560 else
561 {
562 Object rowState = _rowStates.get(getClientId(facesContext));
563 if (rowState == null)
564 {
565
566
567
568
569 if (_initialDescendantComponentState != null)
570 {
571 restoreDescendantComponentStates(this, false, _initialDescendantComponentState, false);
572 }
573 else
574 {
575 restoreDescendantComponentWithoutRestoreState(this, false, false);
576 }
577 }
578 else
579 {
580
581
582
583
584 restoreDescendantComponentStates(this, false, rowState, false);
585 }
586 }
587 }
588
589
590
591
592
593
594
595
596 @SuppressWarnings("unchecked")
597 private void restoreDescendantComponentStates(UIComponent parent, boolean iterateFacets, Object state,
598 boolean restoreChildFacets)
599 {
600 int descendantStateIndex = -1;
601 List<? extends Object[]> stateCollection = null;
602
603 if (iterateFacets && parent.getFacetCount() > 0)
604 {
605 Iterator<UIComponent> childIterator = parent.getFacets().values().iterator();
606
607 while (childIterator.hasNext())
608 {
609 UIComponent component = childIterator.next();
610
611
612 component.setId(component.getId());
613 if (!component.isTransient())
614 {
615 if (descendantStateIndex == -1)
616 {
617 stateCollection = ((List<? extends Object[]>) state);
618 descendantStateIndex = stateCollection.isEmpty() ? -1 : 0;
619 }
620
621 if (descendantStateIndex != -1 && descendantStateIndex < stateCollection.size())
622 {
623 Object[] object = stateCollection.get(descendantStateIndex);
624 if (object[0] != null && component instanceof EditableValueHolder)
625 {
626 ((EditableValueHolderState) object[0]).restoreState((EditableValueHolder) component);
627 }
628
629
630 if (object[1] != null)
631 {
632 restoreDescendantComponentStates(component, restoreChildFacets, object[1], true);
633 }
634 else
635 {
636 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
637 }
638 }
639 else
640 {
641 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
642 }
643 descendantStateIndex++;
644 }
645 }
646 }
647
648 if (parent.getChildCount() > 0)
649 {
650 for (int i = 0; i < parent.getChildCount(); i++)
651 {
652 UIComponent component = parent.getChildren().get(i);
653
654
655 component.setId(component.getId());
656 if (!component.isTransient())
657 {
658 if (descendantStateIndex == -1)
659 {
660 stateCollection = ((List<? extends Object[]>) state);
661 descendantStateIndex = stateCollection.isEmpty() ? -1 : 0;
662 }
663
664 if (descendantStateIndex != -1 && descendantStateIndex < stateCollection.size())
665 {
666 Object[] object = stateCollection.get(descendantStateIndex);
667 if (object[0] != null && component instanceof EditableValueHolder)
668 {
669 ((EditableValueHolderState) object[0]).restoreState((EditableValueHolder) component);
670 }
671
672
673 if (object[1] != null)
674 {
675 restoreDescendantComponentStates(component, restoreChildFacets, object[1], true);
676 }
677 else
678 {
679 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
680 }
681 }
682 else
683 {
684 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
685 }
686 descendantStateIndex++;
687 }
688 }
689 }
690 }
691
692
693
694
695
696
697
698
699
700
701 private void restoreDescendantComponentWithoutRestoreState(UIComponent parent, boolean iterateFacets, boolean restoreChildFacets)
702 {
703 if (iterateFacets && parent.getFacetCount() > 0)
704 {
705 Iterator<UIComponent> childIterator = parent.getFacets().values().iterator();
706
707 while (childIterator.hasNext())
708 {
709 UIComponent component = childIterator.next();
710
711
712 component.setId(component.getId());
713 if (!component.isTransient())
714 {
715 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
716 }
717 }
718 }
719
720 if (parent.getChildCount() > 0)
721 {
722 for (int i = 0; i < parent.getChildCount(); i++)
723 {
724 UIComponent component = parent.getChildren().get(i);
725
726
727 component.setId(component.getId());
728 if (!component.isTransient())
729 {
730 restoreDescendantComponentWithoutRestoreState(component, restoreChildFacets, true);
731 }
732 }
733 }
734 }
735
736
737
738
739
740
741
742
743
744
745
746
747
748 private Collection<Object[]> saveDescendantComponentStates(UIComponent parent, boolean iterateFacets,
749 boolean saveChildFacets)
750 {
751 Collection<Object[]> childStates = null;
752
753 int childEmptyIndex = 0;
754 int totalChildCount = 0;
755
756 if (iterateFacets && parent.getFacetCount() > 0)
757 {
758 Iterator<UIComponent> childIterator = parent.getFacets().values().iterator();
759
760 while (childIterator.hasNext())
761 {
762 UIComponent child = childIterator.next();
763 if (!child.isTransient())
764 {
765
766
767
768
769
770 if (child instanceof EditableValueHolder)
771 {
772 if (childStates == null)
773 {
774 childStates = new ArrayList<Object[]>(
775 parent.getFacetCount()
776 + parent.getChildCount()
777 - totalChildCount
778 + childEmptyIndex);
779 for (int ci = 0; ci < childEmptyIndex; ci++)
780 {
781 childStates.add(LEAF_NO_STATE);
782 }
783 }
784
785 childStates.add(child.getChildCount() > 0 ?
786 new Object[]{new EditableValueHolderState((EditableValueHolder) child),
787 saveDescendantComponentStates(child, saveChildFacets, true)} :
788 new Object[]{new EditableValueHolderState((EditableValueHolder) child),
789 null});
790 }
791 else if (child.getChildCount() > 0 || (saveChildFacets && child.getFacetCount() > 0))
792 {
793 Object descendantSavedState = saveDescendantComponentStates(child, saveChildFacets, true);
794
795 if (descendantSavedState == null)
796 {
797 if (childStates == null)
798 {
799 childEmptyIndex++;
800 }
801 else
802 {
803 childStates.add(LEAF_NO_STATE);
804 }
805 }
806 else
807 {
808 if (childStates == null)
809 {
810 childStates = new ArrayList<Object[]>(
811 parent.getFacetCount()
812 + parent.getChildCount()
813 - totalChildCount
814 + childEmptyIndex);
815 for (int ci = 0; ci < childEmptyIndex; ci++)
816 {
817 childStates.add(LEAF_NO_STATE);
818 }
819 }
820 childStates.add(new Object[]{null, descendantSavedState});
821 }
822 }
823 else
824 {
825 if (childStates == null)
826 {
827 childEmptyIndex++;
828 }
829 else
830 {
831 childStates.add(LEAF_NO_STATE);
832 }
833 }
834 }
835 totalChildCount++;
836 }
837 }
838
839 if (parent.getChildCount() > 0)
840 {
841 for (int i = 0; i < parent.getChildCount(); i++)
842 {
843 UIComponent child = parent.getChildren().get(i);
844 if (!child.isTransient())
845 {
846
847
848
849
850
851 if (child instanceof EditableValueHolder)
852 {
853 if (childStates == null)
854 {
855 childStates = new ArrayList<Object[]>(
856 parent.getFacetCount()
857 + parent.getChildCount()
858 - totalChildCount
859 + childEmptyIndex);
860 for (int ci = 0; ci < childEmptyIndex; ci++)
861 {
862 childStates.add(LEAF_NO_STATE);
863 }
864 }
865
866 childStates.add(child.getChildCount() > 0 ?
867 new Object[]{new EditableValueHolderState((EditableValueHolder) child),
868 saveDescendantComponentStates(child, saveChildFacets, true)} :
869 new Object[]{new EditableValueHolderState((EditableValueHolder) child),
870 null});
871 }
872 else if (child.getChildCount() > 0 || (saveChildFacets && child.getFacetCount() > 0))
873 {
874 Object descendantSavedState = saveDescendantComponentStates(child, saveChildFacets, true);
875
876 if (descendantSavedState == null)
877 {
878 if (childStates == null)
879 {
880 childEmptyIndex++;
881 }
882 else
883 {
884 childStates.add(LEAF_NO_STATE);
885 }
886 }
887 else
888 {
889 if (childStates == null)
890 {
891 childStates = new ArrayList<Object[]>(
892 parent.getFacetCount()
893 + parent.getChildCount()
894 - totalChildCount
895 + childEmptyIndex);
896 for (int ci = 0; ci < childEmptyIndex; ci++)
897 {
898 childStates.add(LEAF_NO_STATE);
899 }
900 }
901 childStates.add(new Object[]{null, descendantSavedState});
902 }
903 }
904 else
905 {
906 if (childStates == null)
907 {
908 childEmptyIndex++;
909 }
910 else
911 {
912 childStates.add(LEAF_NO_STATE);
913 }
914 }
915 }
916 totalChildCount++;
917 }
918 }
919
920 return childStates;
921 }
922
923 @Override
924 public void setValueExpression(String name, ValueExpression binding) {
925 if (name == null)
926 {
927 throw new NullPointerException("name");
928 }
929 else if (name.equals("value"))
930 {
931 _dataModelMap.clear();
932 }
933 else if (name.equals("rowIndex"))
934 {
935 throw new IllegalArgumentException("name " + name);
936 }
937 super.setValueExpression(name, binding);
938 }
939
940 @Override
941 public String getClientId(FacesContext context)
942 {
943 String clientId = super.getClientId(context);
944 int rowIndex = getRowIndex();
945 if (rowIndex == -1)
946 {
947 return clientId;
948 }
949
950 StringBuilder bld = __getSharedStringBuilder();
951 return bld.append(clientId).append(NamingContainer.SEPARATOR_CHAR).append(rowIndex).toString();
952 }
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973 @Override
974 public void queueEvent(FacesEvent event)
975 {
976 super.queueEvent(new FacesEventWrapper(event, getRowIndex(), this));
977 }
978
979
980
981
982
983
984
985 @Override
986 public void broadcast(FacesEvent event) throws AbortProcessingException
987 {
988 if (event instanceof FacesEventWrapper)
989 {
990 FacesEvent originalEvent = ((FacesEventWrapper) event)
991 .getWrappedFacesEvent();
992 int eventRowIndex = ((FacesEventWrapper) event).getRowIndex();
993 int currentRowIndex = getRowIndex();
994 setRowIndex(eventRowIndex);
995 try
996 {
997 originalEvent.getComponent().broadcast(originalEvent);
998 }
999 finally
1000 {
1001 setRowIndex(currentRowIndex);
1002 }
1003 }
1004 else
1005 {
1006 super.broadcast(event);
1007 }
1008 }
1009
1010
1011
1012
1013
1014
1015 @Override
1016 public void encodeBegin(FacesContext context) throws IOException
1017 {
1018 _initialDescendantComponentState = null;
1019 if (_isValidChilds && !hasErrorMessages(context))
1020 {
1021
1022
1023
1024 _dataModelMap.clear();
1025
1026
1027
1028
1029
1030 _rowStates.clear();
1031 }
1032 super.encodeBegin(context);
1033 }
1034
1035 private boolean hasErrorMessages(FacesContext context)
1036 {
1037 for(Iterator iter = context.getMessages(); iter.hasNext();)
1038 {
1039 FacesMessage message = (FacesMessage) iter.next();
1040 if(FacesMessage.SEVERITY_ERROR.compareTo(message.getSeverity()) <= 0)
1041 {
1042 return true;
1043 }
1044 }
1045 return false;
1046 }
1047
1048
1049
1050
1051 @Override
1052 public void encodeEnd(FacesContext context) throws IOException
1053 {
1054 try
1055 {
1056 setCachedFacesContext(context);
1057 setRowIndex(-1);
1058 }
1059 finally
1060 {
1061 setCachedFacesContext(null);
1062 }
1063 super.encodeEnd(context);
1064 }
1065
1066 @Override
1067 public void processDecodes(FacesContext context)
1068 {
1069 if (context == null)
1070 {
1071 throw new NullPointerException("context");
1072 }
1073 try
1074 {
1075 setCachedFacesContext(context);
1076 if (!isRendered())
1077 {
1078 return;
1079 }
1080 setRowIndex(-1);
1081 processFacets(context, PROCESS_DECODES);
1082 processColumnFacets(context, PROCESS_DECODES);
1083 processColumnChildren(context, PROCESS_DECODES);
1084 setRowIndex(-1);
1085 try
1086 {
1087 decode(context);
1088 }
1089 catch (RuntimeException e)
1090 {
1091 context.renderResponse();
1092 throw e;
1093 }
1094 }
1095 finally
1096 {
1097 setCachedFacesContext(null);
1098 }
1099 }
1100
1101 @Override
1102 public void processValidators(FacesContext context)
1103 {
1104 if (context == null)
1105 {
1106 throw new NullPointerException("context");
1107 }
1108
1109 try
1110 {
1111 setCachedFacesContext(context);
1112 if (!isRendered())
1113 {
1114 return;
1115 }
1116
1117 setRowIndex(-1);
1118 processFacets(context, PROCESS_VALIDATORS);
1119 processColumnFacets(context, PROCESS_VALIDATORS);
1120 processColumnChildren(context, PROCESS_VALIDATORS);
1121 setRowIndex(-1);
1122
1123
1124 if (context.getRenderResponse())
1125 {
1126 _isValidChilds = false;
1127 }
1128 }
1129 finally
1130 {
1131 setCachedFacesContext(null);
1132 }
1133 }
1134
1135 @Override
1136 public void processUpdates(FacesContext context)
1137 {
1138 if (context == null)
1139 {
1140 throw new NullPointerException("context");
1141 }
1142 try
1143 {
1144 setCachedFacesContext(context);
1145 if (!isRendered())
1146 {
1147 return;
1148 }
1149 setRowIndex(-1);
1150 processFacets(context, PROCESS_UPDATES);
1151 processColumnFacets(context, PROCESS_UPDATES);
1152 processColumnChildren(context, PROCESS_UPDATES);
1153 setRowIndex(-1);
1154
1155 if (context.getRenderResponse())
1156 {
1157 _isValidChilds = false;
1158 }
1159 }
1160 finally
1161 {
1162 setCachedFacesContext(null);
1163 }
1164 }
1165
1166 private void processFacets(FacesContext context, int processAction)
1167 {
1168 for (Iterator it = getFacets().values().iterator(); it.hasNext();)
1169 {
1170 UIComponent facet = (UIComponent) it.next();
1171 process(context, facet, processAction);
1172 }
1173 }
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183 private void processColumnFacets(FacesContext context, int processAction)
1184 {
1185 for (Iterator childIter = getChildren().iterator(); childIter.hasNext();)
1186 {
1187 UIComponent child = (UIComponent) childIter.next();
1188 if (child instanceof UIColumn)
1189 {
1190 if (!child.isRendered())
1191 {
1192
1193 continue;
1194 }
1195 for (Iterator facetsIter = child.getFacets().values()
1196 .iterator(); facetsIter.hasNext();)
1197 {
1198 UIComponent facet = (UIComponent) facetsIter.next();
1199 process(context, facet, processAction);
1200 }
1201 }
1202 }
1203 }
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213 private void processColumnChildren(FacesContext context, int processAction)
1214 {
1215 int first = getFirst();
1216 int rows = getRows();
1217 int last;
1218 if (rows == 0)
1219 {
1220 last = getRowCount();
1221 }
1222 else
1223 {
1224 last = first + rows;
1225 }
1226 for (int rowIndex = first; last==-1 || rowIndex < last; rowIndex++)
1227 {
1228 setRowIndex(rowIndex);
1229
1230
1231 if (!isRowAvailable())
1232 {
1233 break;
1234 }
1235
1236 for (Iterator it = getChildren().iterator(); it.hasNext();)
1237 {
1238 UIComponent child = (UIComponent) it.next();
1239 if (child instanceof UIColumn)
1240 {
1241 if (!child.isRendered())
1242 {
1243
1244 continue;
1245 }
1246 for (Iterator columnChildIter = child.getChildren()
1247 .iterator(); columnChildIter.hasNext();)
1248 {
1249 UIComponent columnChild = (UIComponent) columnChildIter
1250 .next();
1251 process(context, columnChild, processAction);
1252 }
1253 }
1254 }
1255 }
1256 }
1257
1258 private void process(FacesContext context, UIComponent component,
1259 int processAction)
1260 {
1261 switch (processAction)
1262 {
1263 case PROCESS_DECODES:
1264 component.processDecodes(context);
1265 break;
1266 case PROCESS_VALIDATORS:
1267 component.processValidators(context);
1268 break;
1269 case PROCESS_UPDATES:
1270 component.processUpdates(context);
1271 break;
1272 }
1273 }
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290 protected DataModel getDataModel()
1291 {
1292 DataModel dataModel;
1293 String clientID = "";
1294
1295 UIComponent parent = getParent();
1296 if (parent != null)
1297 {
1298 clientID = parent.getClientId(getFacesContext());
1299 }
1300 dataModel = (DataModel) _dataModelMap.get(clientID);
1301 if (dataModel == null)
1302 {
1303 dataModel = createDataModel();
1304 _dataModelMap.put(clientID, dataModel);
1305 }
1306 return dataModel;
1307 }
1308
1309 protected void setDataModel(DataModel dataModel)
1310 {
1311 throw new UnsupportedOperationException(
1312 "this method is here only to maintain binary compatibility w/ the RI");
1313 }
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327 private DataModel createDataModel()
1328 {
1329 Object value = getValue();
1330
1331 if (value == null)
1332 {
1333 return EMPTY_DATA_MODEL;
1334 }
1335 else if (value instanceof DataModel)
1336 {
1337 return (DataModel) value;
1338 }
1339 else if (value instanceof List)
1340 {
1341 return new ListDataModel((List) value);
1342 }
1343 else if (OBJECT_ARRAY_CLASS.isAssignableFrom(value.getClass()))
1344 {
1345 return new ArrayDataModel((Object[]) value);
1346 }
1347 else if (value instanceof ResultSet)
1348 {
1349 return new ResultSetDataModel((ResultSet) value);
1350 }
1351 else if (value instanceof Result)
1352 {
1353 return new ResultDataModel((Result) value);
1354 }
1355 else
1356 {
1357 return new ScalarDataModel(value);
1358 }
1359 }
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379 @JSFProperty
1380 public Object getValue()
1381 {
1382 if (_value != null)
1383 {
1384 return _value;
1385 }
1386 ValueExpression expression = getValueExpression("value");
1387 if (expression != null)
1388 {
1389 return expression.getValue(getFacesContext().getELContext());
1390 }
1391 return null;
1392 }
1393
1394 public void setValue(Object value)
1395 {
1396 _value = value;
1397 _dataModelMap.clear();
1398 _rowStates.clear();
1399 _isValidChilds = true;
1400 }
1401
1402
1403
1404
1405 @JSFProperty
1406 public int getFirst()
1407 {
1408 if (_firstSet)
1409 {
1410 return _first;
1411 }
1412 ValueExpression expression = getValueExpression("first");
1413 if (expression != null)
1414 {
1415 return (Integer)expression.getValue(getFacesContext().getELContext());
1416 }
1417 return 0;
1418 }
1419
1420 public void setFirst(int first)
1421 {
1422 if (first < 0)
1423 {
1424 throw new IllegalArgumentException("Illegal value for first row: " + first);
1425 }
1426 _first = first;
1427 _firstSet=true;
1428 }
1429
1430
1431
1432
1433
1434
1435
1436
1437 @JSFProperty
1438 public int getRows()
1439 {
1440 if (_rowsSet)
1441 {
1442 return _rows;
1443 }
1444 ValueExpression expression = getValueExpression("rows");
1445 if (expression != null)
1446 {
1447 return (Integer)expression.getValue(getFacesContext().getELContext());
1448 }
1449 return 0;
1450 }
1451
1452
1453
1454
1455 public void setRows(int rows)
1456 {
1457 if (rows < 0)
1458 {
1459 throw new IllegalArgumentException("rows: " + rows);
1460 }
1461 _rows = rows;
1462 _rowsSet = true;
1463 }
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475 @JSFProperty(literalOnly = true)
1476 public String getVar()
1477 {
1478 return _var;
1479 }
1480
1481 public void setVar(String var)
1482 {
1483 this._var = var;
1484 }
1485
1486
1487 @Override
1488 public Object saveState(FacesContext facesContext)
1489 {
1490 Object[] values = new Object[7];
1491 values[0] = super.saveState(facesContext);
1492 values[1] = _value;
1493 values[2] = _var;
1494 values[3] = _rows;
1495 values[4] = _rowsSet;
1496 values[5] = _first;
1497 values[6] = _firstSet;
1498
1499 return values;
1500 }
1501
1502 @Override
1503 public void restoreState(FacesContext facesContext, Object state)
1504 {
1505 Object[] values = (Object[])state;
1506 super.restoreState(facesContext,values[0]);
1507 _value = values[1];
1508 _var = (String)values[2];
1509 _rows = (Integer)values[3];
1510 _rowsSet = (Boolean)values[4];
1511 _first = (Integer)values[5];
1512 _firstSet = (Boolean)values[6];
1513 }
1514
1515 @Override
1516 public String getFamily()
1517 {
1518 return COMPONENT_FAMILY;
1519 }
1520 }