Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Licensed to the Apache Software Foundation (ASF) under one or more
3
    * contributor license agreements.  See the NOTICE file distributed with
4
    * this work for additional information regarding copyright ownership.
5
    * The ASF licenses this file to You under the Apache License, Version 2.0
6
    * (the "License"); you may not use this file except in compliance with
7
    * the License.  You may obtain a copy of the License at
8
    *
9
    *      http://www.apache.org/licenses/LICENSE-2.0
10
   *
11
   * Unless required by applicable law or agreed to in writing, software
12
   * distributed under the License is distributed on an "AS IS" BASIS,
13
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
   * See the License for the specific language governing permissions and
15
   * limitations under the License.
16
   */
17
  package org.apache.wicket;
18
  
21
  import java.util.Arrays;
25
  import java.util.List;
26
  
41
  import org.slf4j.Logger;
A MarkupContainer holds a map of child components.
  • Children - Children can be added by calling the add() method, and they can be looked up using a dotted path. For example, if a container called "a" held a nested container "b" which held a nested component "c", then a.get("b.c") would return the Component with id "c". The number of children in a MarkupContainer can be determined by calling size(), and the whole hierarchy of children held by a MarkupContainer can be traversed by calling visitChildren(), passing in an implementation of Component.IVisitor.
  • Markup Rendering - A MarkupContainer also holds/references associated markup which is used to render the container. As the markup stream for a container is rendered, component references in the markup are resolved by using the container to look up Components in the container's component map by id. Each component referenced by the markup stream is given an opportunity to render itself using the markup stream.

    Components may alter their referring tag, replace the tag's body or insert markup after the tag. But components cannot remove tags from the markup stream. This is an important guarantee because graphic designers may be setting attributes on component tags that affect visual presentation.

    The type of markup held in a given container subclass can be determined by calling getMarkupType(). Markup is accessed via a MarkupStream object which allows a component to traverse ComponentTag and RawMarkup MarkupElements while rendering a response. Markup in the stream may be HTML or some other kind of markup, such as VXML, as determined by the specific container subclass.

    A markup stream may be directly associated with a container via setMarkupStream. However, a container which does not have a markup stream (its getMarkupStream() returns null) may inherit a markup stream from a container above it in the component hierarchy. The findMarkupStream() method will locate the first container at or above this container which has a markup stream.

    All Page containers set a markup stream before rendering by calling the method getAssociatedMarkupStream() to load the markup associated with the page. Since Page is at the top of the container hierarchy, it is guaranteed that findMarkupStream will always return a valid markup stream.

    Author(s):
    Jonathan Locke
    See also:
    org.apache.wicket.markup.MarkupStream
83
  
84
  public abstract class MarkupContainer extends Component
85
  {
86
  	private static final long serialVersionUID = 1L;
Log for reporting.
88
  
89
  	private static final Logger log = LoggerFactory.getLogger(MarkupContainer.class);
List of children or single child
91
  
92
  	private Object children;
The markup stream for this container. This variable is used only during the render phase to provide access to the current element within the stream. 
97
  
98
  	private transient MarkupStream markupStream;

See also:
org.apache.wicket.Component.Component.(java.lang.String)
102
 
103
 	public MarkupContainer(final String id)
104
 	{
105
 		super(id);
106
 	}

See also:
org.apache.wicket.Component.Component.(java.lang.String,org.apache.wicket.model.IModel)
110
 
111
 	public MarkupContainer(final String id, IModel model)
112
 	{
113
 		super(id, model);
114
 	}
Adds a child component to this container.

Parameters:
child The child
Returns:
This
Throws:
java.lang.IllegalArgumentException Thrown if a child with the same id is replaced by the add operation.
124
 
125
 	public final MarkupContainer add(final Component child)
126
 	{
128
 
129
 		if (child == null)
130
 		{
131
 			throw new IllegalArgumentException("argument child may not be null");
132
 		}
133
 
135
 		{
136
 			.debug("Add " + child.getId() + " to " + this);
137
 		}
138
 
139
 		// Add to map
141
 		if (put(child) != null)
142
 		{
143
 			throw new IllegalArgumentException(exceptionMessage("A child with id '" +
144
 				child.getId() + "' already exists"));
145
 		}
146
 
147
 		return this;
148
 	}
Replaces a child component of this container with another or just adds it in case no child with the same id existed yet.

Parameters:
child The child
Returns:
This
157
 
158
 	public final MarkupContainer addOrReplace(final Component child)
159
 	{
161
 
162
 		if (child == null)
163
 		{
164
 			throw new IllegalArgumentException("argument child must be not null");
165
 		}
166
 
167
 		if (get(child.getId()) == null)
168
 		{
169
 			add(child);
170
 		}
171
 		else
172
 		{
173
 			replace(child);
174
 		}
175
 
176
 		return this;
177
 	}
This method allows a component to be added by an auto-resolver such as AutoComponentResolver or AutoLinkResolver. While the component is being added, the component's FLAG_AUTO boolean is set. The isAuto() method of Component returns true if a component or any of its parents has this bit set. When a component is added via autoAdd(), the logic in Page that normally (a) checks for modifications during the rendering process, and (b) versions components, is bypassed if Component.isAuto() returns true.

The result of all this is that components added with autoAdd() are free from versioning and can add their own children without the usual exception that would normally be thrown when the component hierarchy is modified during rendering.

Parameters:
component The component to add
markupStream Null, if the parent container is able to provide the markup. Else the markup stream to be used to render the component.
Returns:
True, if component has been added
197
 
198
 	public final boolean autoAdd(final Component component, final MarkupStream markupStream)
199
 	{
200
 		if (component == null)
201
 		{
202
 			throw new IllegalArgumentException("argument component may not be null");
203
 		}
204
 
205
 		/* Replace strategy */
206
 		component.setAuto(true);
207
 
208
 		int index = children_indexOf(component);
209
 		if (index >= 0)
210
 		{
212
 		}
213
 		add(component);
214
 		component.prepareForRender();
215
 		try
216
 		{
217
 			if (markupStream == null)
218
 			{
219
 				component.render();
220
 			}
221
 			else
222
 			{
223
 				component.render(markupStream);
224
 			}
225
 		}
226
 		finally
227
 		{
228
 			component.afterRender();
229
 		}
230
 		return true;
231
 	}

Deprecated:
since 1.3 Please use autoAdd(org.apache.wicket.Component,org.apache.wicket.markup.MarkupStream) instead
Parameters:
component The component to add
Returns:
True, if component has been added
240
 
241
 	public final boolean autoAdd(final Component component)
242
 	{
243
 		return autoAdd(component, null);
244
 	}

Parameters:
component The component to check
recurse True if all descendents should be considered
Returns:
True if the component is contained in this container
252
 
253
 	public final boolean contains(final Component component, final boolean recurse)
254
 	{
255
 		if (component == null)
256
 		{
257
 			throw new IllegalArgumentException("argument component may not be null");
258
 		}
259
 
260
 		if (recurse)
261
 		{
262
 			// Start at component and continue while we're not out of parents
263
 			for (Component current = component; current != null;)
264
 			{
265
 				// Get parent
266
 				final MarkupContainer parent = current.getParent();
267
 
268
 				// If this container is the parent, then the component is
269
 				// recursively contained by this container
270
 				if (parent == this)
271
 				{
272
 					// Found it!
273
 					return true;
274
 				}
275
 
276
 				// Move up the chain to the next parent
277
 				current = parent;
278
 			}
279
 
280
 			// Failed to find this container in component's ancestry
281
 			return false;
282
 		}
283
 		else
284
 		{
285
 			// Is the component contained in this container?
286
 			return component.getParent() == this;
287
 		}
288
 	}
Get a child component by looking it up with the given path.

Parameters:
path Path to component
Returns:
The component at the path
296
 
297
 	public final Component get(final String path)
298
 	{
299
 		// Reference to this container
300
 		if (path == null || path.trim().equals(""))
301
 		{
302
 			return this;
303
 		}
304
 
305
 		// Get child's id, if any
306
 		final String id = Strings.firstPathComponent(path, .);
307
 
308
 		// Get child by id
309
 		Component child = children_get(id);
310
 
311
 		// If the container is transparent, than ask its parent.
312
 		// ParentResolver does something quite similar, but because of <head>,
313
 		// <body>, <wicket:panel> etc. it is quite common to have transparent
314
 		// components. Hence, this is little short cut for a tiny performance
315
 		// optimization.
316
 		if ((child == null) && isTransparentResolver() && (getParent() != null))
317
 		{
318
 			child = getParent().get(path);
319
 		}
320
 
321
 		// Found child?
322
 		if (child != null)
323
 		{
324
 			final String path2 = Strings.afterFirstPathComponent(path, .);
325
 			// Recurse on latter part of path
326
 			return child.get(path2);
327
 		}
328
 
329
 		return child;
330
 	}
Gets a fresh markup stream that contains the (immutable) markup resource for this class.

Parameters:
throwException If true, throw an exception, if markup could not be found
Returns:
A stream of MarkupElement elements
338
 
339
 	public MarkupStream getAssociatedMarkupStream(final boolean throwException)
340
 	{
341
 		try
342
 		{
344
 				false, throwException);
345
 		}
346
 		catch (MarkupException ex)
347
 		{
348
 			// re-throw it. The exception contains already all the information
349
 			// required.
350
 			throw ex;
351
 		}
353
 		{
354
 			// throw exception since there is no associated markup
356
 				exceptionMessage("Markup of type '" + getMarkupType() + "' for component '" +
357
 					getClass().getName() + "' not found." +
358
 					" Enable debug messages for org.apache.wicket.util.resource to get a list of all filenames tried"),
359
 				ex);
360
 		}
361
 	}
Get the markup stream set on this container.

Returns:
Returns the markup stream set on this container.
368
 
369
 	public final MarkupStream getMarkupStream()
370
 	{
371
 		return ;
372
 	}
Get the type of associated markup for this component.

Returns:
The type of associated markup for this component (for example, "html", "wml" or "vxml"). The markup type for a component is independent of whether or not the component actually has an associated markup resource file (which is determined at runtime). If there is no markup type for a component, null may be returned, but this means that no markup can be loaded for the class.
383
 
384
 	public String getMarkupType()
385
 	{
386
 		return getPage().getMarkupType();
387
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT. Adds a child component to this container.

Parameters:
child The child
Throws:
java.lang.IllegalArgumentException Thrown if a child with the same id is replaced by the add operation.
398
 
399
 	public void internalAdd(final Component child)
400
 	{
402
 		{
403
 			.debug("internalAdd " + child.getId() + " to " + this);
404
 		}
405
 
406
 		// Add to map
408
 		put(child);
409
 	}
Some MarkupContainers (e.g. HtmlHeaderContainer) have to be transparent with respect to their child components. A transparent container gets its children from its parent container.

Returns:
false. By default a MarkupContainer is not transparent.
See also:
org.apache.wicket.markup.resolver.ParentResolver
419
 
420
 	public boolean isTransparentResolver()
421
 	{
422
 		return false;
423
 	}

Returns:
Iterator that iterates through children in the order they were added
427
 
428
 	public final Iterator iterator()
429
 	{
430
 		return new Iterator()
431
 		{
432
 			int index = 0;
433
 
434
 			public boolean hasNext()
435
 			{
436
 				return  < children_size();
437
 			}
438
 
439
 			public Object next()
440
 			{
441
 				return children_get(++);
442
 			}
443
 
444
 			public void remove()
445
 			{
446
 				final Component removed = children_remove(--);
448
 				removedComponent(removed);
449
 			}
450
 		};
451
 	}

Parameters:
comparator The comparator
Returns:
Iterator that iterates over children in the order specified by comparator
457
 
458
 	public final Iterator iterator(Comparator comparator)
459
 	{
460
 		final List sorted;
461
 		if ( == null)
462
 		{
463
 			sorted = .;
464
 		}
465
 		else
466
 		{
467
 			if ( instanceof Component)
468
 			{
469
 				sorted = new ArrayList(1);
470
 				sorted.add();
471
 			}
472
 			else if ( instanceof ChildList)
473
 			{
474
 				sorted = new ArrayList((ChildList));
475
 			}
476
 			else
477
 			{
478
 				sorted = Arrays.asList((Component[]));
479
 			}
480
 		}
481
 		Collections.sort(sorted, comparator);
482
 		return sorted.iterator();
483
 	}
NOT USED ANYMORE; it's here for helping people migrate from Wicket 1.2 to Wicket 1.3

Parameters:
containerClass
Returns:
nothing
Throws:
java.lang.IllegalStateException throws an java.lang.IllegalStateException
492
 
493
 	// TODO remove after release 1.3.0
494
 	public final IResourceStream newMarkupResourceStream(Class containerClass)
495
 	{
496
 		throw new IllegalStateException(
497
 			"this method is not used any more (and shouldn't be called by clients anyway)");
498
 	}

Parameters:
component Component to remove from this container
503
 
504
 	public void remove(final Component component)
505
 	{
507
 
508
 		if (component == null)
509
 		{
510
 			throw new IllegalArgumentException("argument component may not be null");
511
 		}
512
 
513
 		children_remove(component);
514
 		removedComponent(component);
515
 	}
Removes the given component

Parameters:
id The id of the component to remove
522
 
523
 	public final void remove(final String id)
524
 	{
525
 		if (id == null)
526
 		{
527
 			throw new IllegalArgumentException("argument id may not be null");
528
 		}
529
 
530
 		final Component component = get(id);
531
 		if (component != null)
532
 		{
533
 			remove(component);
534
 		}
535
 		else
536
 		{
537
 			throw new WicketRuntimeException("Unable to find a component with id '" + id +
538
 				"' to remove");
539
 		}
540
 	}
Removes all children from this container.

Note: implementation does not call for each component. 

547
 
548
 	public final void removeAll()
549
 	{
550
 		if ( != null)
551
 		{
553
 			{
554
 				private static final long serialVersionUID = 1L;
555
 
557
 
558
 				public String toString()
559
 				{
560
 					return "RemoveAllChange[component: " + getPath() + ", removed Children: " +
561
 						 + "]";
562
 				}
563
 
564
 				public void undo()
565
 				{
567
 					int size = children_size();
568
 					for (int i = 0; i < size; i++)
569
 					{
570
 						// Get next child
571
 						final Component child = children_get(i);
573
 					}
574
 				}
575
 			});
576
 
577
 			// Loop through child components
578
 			int size = children_size();
579
 			for (int i = 0; i < size; i++)
580
 			{
581
 				Object childObject = children_get(i, false);
582
 				if (childObject instanceof Component)
583
 				{
584
 					// Get next child
585
 					final Component child = (Component)childObject;
586
 
587
 					// Do not call remove() because the state change would than be
588
 					// recorded twice.
589
 					child.detachModel();
590
 					child.setParent(null);
591
 				}
592
 			}
593
 
594
 			 = null;
595
 		}
596
 	}
Renders the entire associated markup stream for a container such as a Border or Panel. Any leading or trailing raw markup in the associated markup is skipped.

Parameters:
openTagName the tag to render the associated markup for
exceptionMessage message that will be used for exceptions
606
 
607
 	public final void renderAssociatedMarkup(final String openTagName, final String exceptionMessage)
608
 	{
609
 		// Get markup associated with Border or Panel component
610
 		final MarkupStream originalMarkupStream = getMarkupStream();
611
 		final MarkupStream associatedMarkupStream = getAssociatedMarkupStream(true);
612
 
613
 		// skip until the targetted tag is found
614
 		associatedMarkupStream.skipUntil(openTagName);
615
 		setMarkupStream(associatedMarkupStream);
616
 
617
 		// Get open tag in associated markup of border component
618
 		final ComponentTag associatedMarkupOpenTag = associatedMarkupStream.getTag();
619
 
620
 		// Check for required open tag name
621
 		if (!((associatedMarkupOpenTag != null) && associatedMarkupOpenTag.isOpen() && (associatedMarkupOpenTag instanceof WicketTag)))
622
 		{
623
 			associatedMarkupStream.throwMarkupException(exceptionMessage);
624
 		}
625
 
626
 		try
627
 		{
629
 			renderComponentTag(associatedMarkupOpenTag);
630
 			associatedMarkupStream.next();
631
 
633
 			{
634
 				getResponse().write("<!-- MARKUP FOR ");
636
 				getResponse().write(" BEGIN -->");
637
 			}
638
 
639
 			renderComponentTagBody(associatedMarkupStream, associatedMarkupOpenTag);
640
 
642
 			{
643
 				getResponse().write("<!-- MARKUP FOR ");
645
 				getResponse().write(" END -->");
646
 			}
647
 
648
 			renderClosingComponentTag(associatedMarkupStream, associatedMarkupOpenTag, false);
649
 			setMarkupStream(originalMarkupStream);
650
 		}
651
 		finally
652
 		{
654
 		}
655
 	}
Replaces a child component of this container with another

Parameters:
child The child
Returns:
This
Throws:
java.lang.IllegalArgumentException Thrown if there was no child with the same id.
665
 
666
 	public final MarkupContainer replace(final Component child)
667
 	{
669
 
670
 		if (child == null)
671
 		{
672
 			throw new IllegalArgumentException("argument child must be not null");
673
 		}
674
 
676
 		{
677
 			.debug("Replacing " + child.getId() + " in " + this);
678
 		}
679
 
680
 		if (child.getParent() != this)
681
 		{
682
 			// Add to map
683
 			final Component replaced = put(child);
684
 
685
 			// Look up to make sure it was already in the map
686
 			if (replaced == null)
687
 			{
689
 					exceptionMessage("Cannot replace a component which has not been added: id='" +
690
 						child.getId() + "', component=" + child));
691
 			}
692
 
693
 			// first remove the component.
694
 			removedComponent(replaced);
695
 
696
 			// then add the other one.
698
 
699
 			// The position of the associated markup remains the same
700
 			child.markupIndex = replaced.markupIndex;
701
 
702
 			// The generated markup id remains the same
703
 			child.setMarkupIdImpl(replaced.getMarkupIdImpl());
704
 		}
705
 
706
 		return this;
707
 	}

See also:
Component.setModel(org.apache.wicket.model.IModel)
711
 
712
 	public Component setModel(final IModel model)
713
 	{
714
 		final IModel previous = getModelImpl();
715
 		super.setModel(model);
716
 		if (previous instanceof IComponentInheritedModel)
717
 		{
719
 			{
720
 				public Object component(Component component)
721
 				{
722
 					IModel compModel = component.getModel();
723
 					if (compModel instanceof IWrapModel)
724
 					{
725
 						compModel = ((IWrapModel)compModel).getWrappedModel();
726
 					}
727
 					if (compModel == previous)
728
 					{
729
 						component.setModel(null);
730
 					}
731
 					else if (compModel == model)
732
 					{
733
 						component.modelChanged();
734
 					}
736
 				}
737
 
738
 			});
739
 		}
740
 		return this;
741
 	}
Get the number of children in this container.

Returns:
Number of children in this container
747
 
748
 	public final int size()
749
 	{
750
 		return children_size();
751
 	}

See also:
Component.toString()
755
 
756
 	public String toString()
757
 	{
758
 		return toString(false);
759
 	}

Parameters:
detailed True if a detailed string is desired
Returns:
String representation of this container
765
 
766
 	public String toString(final boolean detailed)
767
 	{
768
 		final StringBuffer buffer = new StringBuffer();
769
 		buffer.append("[MarkupContainer ");
770
 		buffer.append(super.toString(true));
771
 		if (detailed)
772
 		{
773
 			if (getMarkupStream() != null)
774
 			{
775
 				buffer.append(", markupStream = " + getMarkupStream());
776
 			}
777
 
778
 			if (children_size() != 0)
779
 			{
780
 				buffer.append(", children = ");
781
 
782
 				// Loop through child components
783
 				final int size = children_size();
784
 				for (int i = 0; i < size; i++)
785
 				{
786
 					// Get next child
787
 					final Component child = children_get(i);
788
 					if (i != 0)
789
 					{
790
 						buffer.append(' ');
791
 					}
792
 					buffer.append(child.toString());
793
 				}
794
 			}
795
 		}
796
 		buffer.append(']');
797
 		return buffer.toString();
798
 	}
Traverses all child components of the given class in this container, calling the visitor's visit method at each one.

Parameters:
clazz The class of child to visit, or null to visit all children
visitor The visitor to call back to
Returns:
The return value from a visitor which halted the traversal, or null if the entire traversal occurred
810
 
811
 	public final Object visitChildren(final Class clazz, final IVisitor visitor)
812
 	{
813
 		if (visitor == null)
814
 		{
815
 			throw new IllegalArgumentException("argument visitor may not be null");
816
 		}
817
 
818
 		// Iterate through children of this container
819
 		for (int i = 0; i < children_size(); i++)
820
 		{
821
 			// Get next child component
822
 			final Component child = children_get(i);
823
 			Object value = null;
824
 
825
 			// Is the child of the correct class (or was no class specified)?
826
 			if (clazz == null || clazz.isInstance(child))
827
 			{
828
 				// Call visitor
829
 				value = visitor.component(child);
830
 
831
 				// If visitor returns a non-null value, it halts the traversal
832
 				if ((value != .) &&
834
 				{
835
 					return value;
836
 				}
837
 			}
838
 
839
 			// If child is a container
840
 			if ((child instanceof MarkupContainer) &&
842
 			{
843
 				// visit the children in the container
844
 				value = ((MarkupContainer)child).visitChildren(clazz, visitor);
845
 
846
 				// If visitor returns a non-null value, it halts the traversal
847
 				if ((value != .) &&
849
 				{
850
 					return value;
851
 				}
852
 			}
853
 		}
854
 
855
 		return null;
856
 	}
Traverses all child components in this container, calling the visitor's visit method at each one.

Parameters:
visitor The visitor to call back to
Returns:
The return value from a visitor which halted the traversal, or null if the entire traversal occurred
866
 
867
 	public final Object visitChildren(final IVisitor visitor)
868
 	{
869
 		return visitChildren(null, visitor);
870
 	}

Parameters:
component Component being added
875
 
876
 	private final void addedComponent(final Component component)
877
 	{
878
 		// Check for degenerate case
879
 		if (component == this)
880
 		{
881
 			throw new IllegalArgumentException("Component can't be added to itself");
882
 		}
883
 
884
 		MarkupContainer parent = component.getParent();
885
 		if (parent != null)
886
 		{
887
 			parent.remove(component);
888
 		}
889
 
890
 		// Set child's parent
891
 		component.setParent(this);
892
 
893
 		final Page page = findPage();
894
 
895
 		final IDebugSettings debugSettings = Application.get().getDebugSettings();
897
 		{
898
 			component.setMetaData(, Strings.toString(component, new MarkupException(
899
 				"added")));
900
 		}
901
 
902
 		if (page != null)
903
 		{
904
 			page.componentAdded(component);
905
 		}
906
 
907
 		// if the PREPARED_FOR_RENDER flag is set, we have already called
908
 		// beforeRender on this
909
 		// component's children. So we need to initialize the newly added one
911
 		{
912
 			component.beforeRender();
913
 		}
914
 	}

Parameters:
child Child to add
919
 
920
 	private final void children_add(final Component child)
921
 	{
922
 		if ( == null)
923
 		{
924
 			 = child;
925
 		}
926
 		else
927
 		{
928
 			if (!( instanceof ChildList))
929
 			{
930
 				// Save new children
932
 			}
933
 			((ChildList)).add(child);
934
 		}
935
 	}
936
 
937
 	private final Component children_get(int index)
938
 	{
939
 		return (Component)children_get(index, true);
940
 	}
If the given object is a MarkupContainer.ComponentSourceEntry instance and reconstruct is true, it reconstructs the component and returns it. Otherwise it just returns the object passed as parameter

Parameters:
object
reconstruct
parent
index
Returns:
952
 
953
 	private final Object postprocess(Object object, boolean reconstruct, MarkupContainer parent,
954
 		int index)
955
 	{
956
 		if (reconstruct && object instanceof ComponentSourceEntry)
957
 		{
958
 			object = ((ComponentSourceEntry)object).reconstruct(parent, index);
959
 		}
960
 		return object;
961
 	}
962
 
963
 	private final Object children_get(int index, boolean reconstruct)
964
 	{
965
 		Object component = null;
966
 		if ( != null)
967
 		{
968
 			if ( instanceof Object[] == false &&  instanceof ChildList == false)
969
 			{
970
 				if (index != 0)
971
 					throw new ArrayIndexOutOfBoundsException("index " + index +
972
 						" is greater then 0");
973
 				component = postprocess(, reconstruct, this, 0);
974
 				if ( != component)
975
 				{
976
 					 = component;
977
 				}
978
 			}
979
 			else
980
 			{
981
 				Object[] children = null;
982
 				if (this. instanceof ChildList)
983
 				{
984
 					// we have a list
985
 					children = ((ChildList)this.).;
986
 				}
987
 				else
988
 				{
989
 					// we have a object array
990
 					children = (Object[])this.;
991
 				}
992
 				component = postprocess(children[index], reconstruct, this, index);
993
 				if (children[index] != component)
994
 				{
995
 					children[index] = component;
996
 				}
997
 			}
998
 		}
999
 		return component;
1000
	}
Returns the wicket:id of the given object, that can be either a Component or a MarkupContainer.ComponentSourceEntry

Parameters:
object
Returns:
1009
	private final String getId(Object object)
1011
		if (object instanceof Component)
1013
			return ((Component)object).getId();
1015
		else if (object instanceof ComponentSourceEntry)
1017
			return ((ComponentSourceEntry)object).;
1019
		else
1021
			throw new IllegalArgumentException("Unknown type of object " + object);
1025
	private final Component children_get(final String id)
1027
		if ( == null)
1029
			return null;
1031
		Component component = null;
1032
		if ( instanceof Object[] == false &&  instanceof List == false)
1036
				component = (Component)postprocess(, true, this, 0);
1037
				if ( != component)
1039
					 = component;
1043
		else
1045
			Object[] children = null;
1046
			int size = 0;
1047
			if (this. instanceof ChildList)
1049
				children = ((ChildList)this.).;
1050
				size = ((ChildList)this.).;
1052
			else
1054
				children = (Object[])this.;
1055
				size = children.length;
1057
			for (int i = 0; i < size; i++)
1059
				if (getId(children[i]).equals(id))
1061
					component = (Component)postprocess(children[i], true, this, i);
1062
					if (children[i] != component)
1064
						children[i] = component;
1066
					break;
1070
		return component;
1073
	private final int children_indexOf(Component child)
1075
		if ( == null)
1077
			return -1;
1079
		if ( instanceof Object[] == false &&  instanceof ChildList == false)
1081
			if (getId().equals(child.getId()))
1083
				return 0;
1086
		else
1088
			int size = 0;
1089
			Object[] children;
1090
			if (this. instanceof Object[])
1092
				children = (Object[])this.;
1093
				size = children.length;
1095
			else
1097
				children = ((ChildList)this.).;
1098
				size = ((ChildList)this.).;
1101
			for (int i = 0; i < size; i++)
1103
				if (getId(children[i]).equals(child.getId()))
1105
					return i;
1109
		return -1;
1112
	private final Component children_remove(Component component)
1114
		int index = children_indexOf(component);
1115
		if (index != -1)
1117
			return children_remove(index);
1119
		return null;
1122
	private final Component children_remove(int index)
1124
		if ( == null)
1125
			return null;
1127
		if ( instanceof Component ||  instanceof ComponentSourceEntry)
1129
			if (index == 0)
1131
				final Component removed = (Component)postprocess(, true, null, -1);
1132
				 = null;
1133
				return removed;
1135
			else
1140
		else
1142
			if ( instanceof Object[])
1144
				Object[] c = ((Object[]));
1145
				final Object removed = c[index];
1146
				if (c.length == 2)
1148
					if (index == 0)
1150
						 = c[1];
1152
					else if (index == 1)
1154
						 = c[0];
1156
					else
1160
					return (Component)postprocess(removed, true, null, -1);
1166
			Object removed = lst.remove(index);
1167
			if (lst.size == 1)
1169
				 = lst.get(0);
1171
			return (Component)postprocess(removed, true, null, -1);
1175
	private final Object children_set(int index, Object child, boolean reconstruct)
1177
		Object replaced;
1178
		if (index >= 0 && index < children_size())
1180
			if ( instanceof Component ||  instanceof ComponentSourceEntry)
1182
				replaced = ;
1183
				 = child;
1185
			else
1187
				if ( instanceof ChildList)
1189
					replaced = ((ChildList)).set(index, child);
1191
				else
1193
					final Object[] children = (Object[])this.;
1194
					replaced = children[index];
1195
					children[index] = child;
1199
		else
1203
		return postprocess(replaced, reconstruct, null, -1);
1206
	private final Component children_set(int index, Component child)
1208
		return (Component)children_set(index, child, true);
1211
	private final int children_size()
1213
		if ( == null)
1215
			return 0;
1217
		else
1219
			if ( instanceof Component ||  instanceof ComponentSourceEntry)
1221
				return 1;
1223
			else if ( instanceof ChildList)
1227
			return ((Object[])).length;
1229
	}
Ensure that there is space in childForId map for a new entry before adding it.

Parameters:
child The child to put into the map
Returns:
Any component that was replaced
1238
	private final Component put(final Component child)
1240
		int index = children_indexOf(child);
1241
		if (index == -1)
1244
			return null;
1246
		else
1248
			return children_set(index, child);
1250
	}

Parameters:
component Component being removed
1256
	private final void removedComponent(final Component component)
1258
		// Notify Page that component is being removed
1259
		final Page page = component.findPage();
1260
		if (page != null)
1262
			page.componentRemoved(component);
1265
		component.detach();
1267
		// Component is removed
1268
		component.setParent(null);
1269
	}
Renders the next element of markup in the given markup stream.

Parameters:
markupStream The markup stream
1277
	private final void renderNext(final MarkupStream markupStream)
1279
		// Get the current markup element
1280
		final MarkupElement element = markupStream.get();
1282
		// If it a tag like <wicket..> or <span wicket:id="..." >
1283
		if ((element instanceof ComponentTag) && !markupStream.atCloseTag())
1285
			// Get element as tag
1286
			final ComponentTag tag = (ComponentTag)element;
1288
			// Get component id
1289
			final String id = tag.getId();
1291
			// Get the component for the id from the given container
1292
			final Component component = get(id);
1294
			// Failed to find it?
1295
			if (component != null)
1297
				component.render(markupStream);
1299
			else
1301
				// 2rd try: Components like Border and Panel might implement
1302
				// the ComponentResolver interface as well.
1303
				MarkupContainer container = this;
1304
				while (container != null)
1306
					if (container instanceof IComponentResolver)
1308
						if (((IComponentResolver)container).resolve(this, markupStream, tag))
1310
							return;
1314
					container = container.findParent(MarkupContainer.class);
1317
				// 3rd try: Try application's component resolvers
1318
				final List componentResolvers = getApplication().getPageSettings()
1320
				final Iterator iterator = componentResolvers.iterator();
1321
				while (iterator.hasNext())
1323
					final IComponentResolver resolver = (IComponentResolver)iterator.next();
1324
					if (resolver.resolve(this, markupStream, tag))
1326
						return;
1330
				if (tag instanceof WicketTag)
1332
					if (((WicketTag)tag).isChildTag())
1334
						markupStream.throwMarkupException("Found " + tag.toString() +
1335
							" but no <wicket:extend>");
1337
					else
1339
						markupStream.throwMarkupException("Failed to handle: " + tag.toString());
1343
				// No one was able to handle the component id
1344
				markupStream.throwMarkupException("Unable to find component with id '" + id +
1345
					"' in " + this + ". This means that you declared wicket:id=" + id +
1346
					" in your markup, but that you either did not add the " +
1347
					"component to your page at all, or that the hierarchy does not match.");
1350
		else
1352
			// Render as raw markup
1355
				.debug("Rendering raw markup");
1358
			markupStream.next();
1360
	}
Get the markup stream for this component.

Returns:
The markup stream for this component, or if it doesn't have one, the markup stream for the nearest parent which does have one
1368
	protected final MarkupStream findMarkupStream()
1370
		// Start here
1371
		MarkupContainer c = this;
1373
		// Walk up hierarchy until markup found
1374
		while (c.getMarkupStream() == null)
1376
			// Check parent
1377
			c = c.getParent();
1379
			// Are we at the top of the hierarchy?
1380
			if (c == null)
1382
				// Failed to find markup stream
1383
				throw new WicketRuntimeException(exceptionMessage("No markup found"));
1387
		return c.getMarkupStream();
1388
	}
Handle the container's body. If your override of this method does not advance the markup stream to the close tag for the openTag, a runtime exception will be thrown by the framework.

Parameters:
markupStream The markup stream
openTag The open tag for the body
1399
	protected void onComponentTagBody(final MarkupStream markupStream, final ComponentTag openTag)
1401
		renderComponentTagBody(markupStream, openTag);
1402
	}
Renders this component. This implementation just calls renderComponent.

Parameters:
markupStream
1409
	protected void onRender(final MarkupStream markupStream)
1411
		renderComponent(markupStream);
1412
	}
Renders this component and all sub-components using the given markup stream.

Parameters:
markupStream The markup stream
1420
	protected void renderAll(final MarkupStream markupStream)
1422
		// Loop through the markup in this container
1423
		while (markupStream.hasMore())
1425
			// Element rendering is responsible for advancing markup stream!
1426
			final int index = markupStream.getCurrentIndex();
1427
			renderNext(markupStream);
1428
			if (index == markupStream.getCurrentIndex())
1430
				markupStream.throwMarkupException("Component at markup stream index " + index +
1431
					" failed to advance the markup stream");
1434
	}
Renders markup for the body of a ComponentTag from the current position in the given markup stream. If the open tag passed in does not require a close tag, nothing happens. Markup is rendered until the closing tag for openTag is reached.

Parameters:
markupStream The markup stream
openTag The open tag
1446
	protected final void renderComponentTagBody(final MarkupStream markupStream,
1447
		final ComponentTag openTag)
1449
		if ((markupStream != null) && (markupStream.getCurrentIndex() > 0))
1451
			// If the original tag has been changed from open-close to open-body-close,
1452
			// than historically renderComponentTagBody gets called, but actually
1453
			// it shouldn't do anything since there is no body for that tag.
1454
			ComponentTag origOpenTag = (ComponentTag)markupStream.get(markupStream.getCurrentIndex() - 1);
1455
			if (origOpenTag.isOpenClose())
1457
				return;
1461
		// If the open tag requires a close tag
1462
		boolean render = openTag.requiresCloseTag();
1463
		if (render == false)
1465
			// Tags like <p> do not require a close tag, but they may have.
1466
			render = !openTag.hasNoCloseTag();
1468
		if (render == true)
1470
			// Loop through the markup in this container
1471
			while (markupStream.hasMore() && !markupStream.get().closes(openTag))
1473
				// Render markup element. Doing so must advance the markup
1474
				// stream
1475
				final int index = markupStream.getCurrentIndex();
1476
				renderNext(markupStream);
1477
				if (index == markupStream.getCurrentIndex())
1479
					markupStream.throwMarkupException("Markup element at index " + index +
1480
						" failed to advance the markup stream");
1484
	}
Set markup stream for this container.

Parameters:
markupStream The markup stream
1492
	protected final void setMarkupStream(final MarkupStream markupStream)
1494
		this. = markupStream;
1499
		private ComponentSourceEntry(MarkupContainer container, Component component,
1500
			IComponentSource componentSource)
1502
			super(container, component, componentSource);
1505
		private static final long serialVersionUID = 1L;
1507
		protected void setChild(MarkupContainer parent, int index, Component child)
1509
			parent.children_set(index, child, false);
1517
		for (int i = children_size(); i-- > 0;)
1519
			Object child = children_get(i, false);
1520
			if (child instanceof Component)
1522
				Component component = (Component)child;
1523
				component.detach();
1525
				if (child instanceof IComponentSourceProvider)
1527
					ComponentSourceEntry entry = new ComponentSourceEntry(this, component,
1529
					children_set(i, entry, false);
1531
				else if (component.isAuto())
1537
		if ( instanceof ChildList)
1540
			Object[] tmp = new Object[lst.size];
1541
			System.arraycopy(lst.childs, 0, tmp, 0, lst.size);
1542
			 = tmp;
1549
		final int size = children_size();
1550
		for (int i = 0; i < size; i++)
1552
			final Component child = children_get(i);
1559
		int size = children_size();
1560
		Component result[] = new Component[size];
1561
		for (int i = 0; i < size; ++i)
1563
			result[i] = children_get(i);
1565
		return result;
1572
		// We need to copy the children list because the children components can
1573
		// modify the hierarchy in their onBeforeRender.
1574
		Component[] children = copyChildren();
1575
		try
1577
			// Loop through child components
1578
			for (int i = 0; i < children.length; i++)
1580
				// Get next child
1581
				final Component child = children[i];
1583
				// Call begin request on the child
1584
				// We need to check whether the child's wasn't removed from the
1585
				// component in the meanwhile (e.g. from another's child
1586
				// onBeforeRender)
1587
				if (child.getParent() == this)
1593
		catch (RuntimeException ex)
1595
			if (ex instanceof WicketRuntimeException)
1597
				throw ex;
1599
			else
1601
				throw new WicketRuntimeException("Error attaching this container for rendering: " +
1602
					this, ex);
1609
		// Loop through child components
1610
		final Iterator iter = iterator();
1611
		while (iter.hasNext())
1613
			// Get next child
1614
			final Component child = (Component)iter.next();
1616
			// Call end request on the child
1617
			child.afterRender();
1620
	}

Returns:
True if this markup container has associated markup
1625
	public boolean hasAssociatedMarkup()
1628
	}

See also:
Component.setRenderAllowed()
1639
			public Object component(final Component component)
1641
				// Find out if this component can be rendered
1642
				final boolean renderAllowed = component.isActionAuthorized();
1643
				// Authorize rendering
1644
				component.setRenderAllowed(renderAllowed);
1647
		});
1650
	private static class ChildList extends AbstractList implements IClusterable
1652
		private static final long serialVersionUID = -7861580911447631127L;
1653
		private int size;
1654
		private Object[] childs;
Construct.

Parameters:
children
1661
		public ChildList(Object children)
1663
			if (children instanceof Object[])
1665
				 = (Object[])children;
1668
			else
1670
				 = new Object[3];
1671
				add(children);
1675
		public Object get(int index)
1677
			return [index];
1680
		public int size()
1682
			return ;
1685
		public boolean add(Object o)
1688
			[++] = o;
1689
			return true;
1692
		public void add(int index, Object element)
1694
			if (index >  || index < 0)
1695
				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + );
1698
			System.arraycopy(, index, , index + 1,  - index);
1699
			[index] = element;
1703
		public Object set(int index, Object element)
1705
			if (index >= )
1706
				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + );
1708
			Object oldValue = [index];
1709
			[index] = element;
1710
			return oldValue;
1713
		public Object remove(int index)
1715
			if (index >= )
1716
				throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + );
1718
			Object oldValue = [index];
1720
			int numMoved =  - index - 1;
1721
			if (numMoved > 0)
1722
				System.arraycopy(, index + 1, , index, numMoved);
1723
			[--] = null; // Let gc do its work
1725
			return oldValue;
1726
		}

Parameters:
minCapacity
1731
		public void ensureCapacity(int minCapacity)
1733
			int oldCapacity = .;
1734
			if (minCapacity > oldCapacity)
1736
				Object oldData[] = ;
1737
				int newCapacity = oldCapacity * 2;
1738
				if (newCapacity < minCapacity)
1739
					newCapacity = minCapacity;
1740
				 = new Object[newCapacity];
1741
				System.arraycopy(oldData, 0, , 0, );
New to GrepCode? Check out our FAQ X