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
  
20
  import java.util.Arrays;
24
  import java.util.List;
25
  
40
  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
82
  
83
  public abstract class MarkupContainer extends Component
84
  {
85
  	private static final long serialVersionUID = 1L;
Log for reporting.
87
  
88
  	private static final Logger log = LoggerFactory.getLogger(MarkupContainer.class);
List of children or single child
90
  
91
  	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. 
96
  
97
  	private transient MarkupStream markupStream;

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

See also:
org.apache.wicket.Component.Component.(java.lang.String,org.apache.wicket.model.IModel)
109
 
110
 	public MarkupContainer(final String id, IModel model)
111
 	{
112
 		super(id, model);
113
 	}
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.
123
 
124
 	public final MarkupContainer add(final Component child)
125
 	{
127
 
128
 		if (child == null)
129
 		{
130
 			throw new IllegalArgumentException("argument child may not be null");
131
 		}
132
 
134
 		{
135
 			.debug("Add " + child.getId() + " to " + this);
136
 		}
137
 
138
 		// Add to map
140
 		if (put(child) != null)
141
 		{
142
 			throw new IllegalArgumentException(exceptionMessage("A child with id '" +
143
 				child.getId() + "' already exists"));
144
 		}
145
 
146
 		return this;
147
 	}
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
156
 
157
 	public final MarkupContainer addOrReplace(final Component child)
158
 	{
160
 
161
 		if (child == null)
162
 		{
163
 			throw new IllegalArgumentException("argument child must be not null");
164
 		}
165
 
166
 		if (get(child.getId()) == null)
167
 		{
168
 			add(child);
169
 		}
170
 		else
171
 		{
172
 			replace(child);
173
 		}
174
 
175
 		return this;
176
 	}
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
196
 
197
 	public final boolean autoAdd(final Component component, final MarkupStream markupStream)
198
 	{
199
 		if (component == null)
200
 		{
201
 			throw new IllegalArgumentException("argument component may not be null");
202
 		}
203
 
204
 		/* Replace strategy */
205
 		component.setAuto(true);
206
 
207
 		int index = children_indexOf(component);
208
 		if (index >= 0)
209
 		{
211
 		}
212
 		add(component);
213
 		component.prepareForRender();
214
 		try
215
 		{
216
 			if (markupStream == null)
217
 			{
218
 				component.render();
219
 			}
220
 			else
221
 			{
222
 				component.render(markupStream);
223
 			}
224
 		}
225
 		finally
226
 		{
227
 			component.afterRender();
228
 		}
229
 		return true;
230
 	}

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
239
 
240
 	public final boolean autoAdd(final Component component)
241
 	{
242
 		return autoAdd(component, null);
243
 	}

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

Parameters:
path Path to component
Returns:
The component at the path
295
 
296
 	public final Component get(final String path)
297
 	{
298
 		// Reference to this container
299
 		if (path == null || path.trim().equals(""))
300
 		{
301
 			return this;
302
 		}
303
 
304
 		// Get child's id, if any
305
 		final String id = Strings.firstPathComponent(path, .);
306
 
307
 		// Get child by id
308
 		Component child = children_get(id);
309
 
310
 		// If the container is transparent, than ask its parent.
311
 		// ParentResolver does something quite similar, but because of <head>,
312
 		// <body>, <wicket:panel> etc. it is quite common to have transparent
313
 		// components. Hence, this is little short cut for a tiny performance
314
 		// optimization.
315
 		if ((child == null) && isTransparentResolver() && (getParent() != null))
316
 		{
317
 			child = getParent().get(path);
318
 		}
319
 
320
 		// Found child?
321
 		if (child != null)
322
 		{
323
 			final String path2 = Strings.afterFirstPathComponent(path, .);
324
 			// Recurse on latter part of path
325
 			return child.get(path2);
326
 		}
327
 
328
 		return child;
329
 	}
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
337
 
338
 	public MarkupStream getAssociatedMarkupStream(final boolean throwException)
339
 	{
340
 		try
341
 		{
343
 				false, throwException);
344
 		}
345
 		catch (MarkupException ex)
346
 		{
347
 			// re-throw it. The exception contains already all the information
348
 			// required.
349
 			throw ex;
350
 		}
352
 		{
353
 			// throw exception since there is no associated markup
355
 				exceptionMessage("Markup of type '" + getMarkupType() + "' for component '" +
356
 					getClass().getName() + "' not found." +
357
 					" Enable debug messages for org.apache.wicket.util.resource to get a list of all filenames tried"),
358
 				ex);
359
 		}
360
 	}
Get the markup stream set on this container.

Returns:
Returns the markup stream set on this container.
367
 
368
 	public final MarkupStream getMarkupStream()
369
 	{
370
 		return ;
371
 	}
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.
382
 
383
 	public String getMarkupType()
384
 	{
385
 		throw new IllegalStateException(
386
 			exceptionMessage("You cannot directly subclass Page or MarkupContainer.	 Instead, subclass a markup-specific class, such as WebPage or WebMarkupContainer"));
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
473
 			{
474
 				sorted = Arrays.asList((Component[]));
475
 			}
476
 		}
477
 		Collections.sort(sorted, comparator);
478
 		return sorted.iterator();
479
 	}
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
488
 
489
 	// TODO remove after release 1.3.0
490
 	public final IResourceStream newMarkupResourceStream(Class containerClass)
491
 	{
492
 		throw new IllegalStateException(
493
 			"this method is not used any more (and shouldn't be called by clients anyway)");
494
 	}

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

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

Note: implementation does not call for each component. 

543
 
544
 	public final void removeAll()
545
 	{
546
 		if ( != null)
547
 		{
549
 			{
550
 				private static final long serialVersionUID = 1L;
551
 
553
 
554
 				public String toString()
555
 				{
556
 					return "RemoveAllChange[component: " + getPath() + ", removed Children: " +
557
 						 + "]";
558
 				}
559
 
560
 				public void undo()
561
 				{
563
 					int size = children_size();
564
 					for (int i = 0; i < size; i++)
565
 					{
566
 						// Get next child
567
 						final Component child = children_get(i);
569
 					}
570
 				}
571
 			});
572
 
573
 			// Loop through child components
574
 			int size = children_size();
575
 			for (int i = 0; i < size; i++)
576
 			{
577
 				// Get next child
578
 				final Component child = children_get(i);
579
 
580
 				// Do not call remove() because the state change would than be
581
 				// recorded twice.
582
 				child.detachModel();
583
 				child.setParent(null);
584
 			}
585
 
586
 			 = null;
587
 		}
588
 	}
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
598
 
599
 	public final void renderAssociatedMarkup(final String openTagName, final String exceptionMessage)
600
 	{
601
 		// Get markup associated with Border or Panel component
602
 		final MarkupStream originalMarkupStream = getMarkupStream();
603
 		final MarkupStream associatedMarkupStream = getAssociatedMarkupStream(true);
604
 
605
 		// skip until the targetted tag is found
606
 		associatedMarkupStream.skipUntil(openTagName);
607
 		setMarkupStream(associatedMarkupStream);
608
 
609
 		// Get open tag in associated markup of border component
610
 		final ComponentTag associatedMarkupOpenTag = associatedMarkupStream.getTag();
611
 
612
 		// Check for required open tag name
613
 		if (!((associatedMarkupOpenTag != null) && associatedMarkupOpenTag.isOpen() && (associatedMarkupOpenTag instanceof WicketTag)))
614
 		{
615
 			associatedMarkupStream.throwMarkupException(exceptionMessage);
616
 		}
617
 
618
 		try
619
 		{
621
 			renderComponentTag(associatedMarkupOpenTag);
622
 			associatedMarkupStream.next();
623
 
625
 			{
626
 				getResponse().write("<!-- MARKUP FOR ");
628
 				getResponse().write(" BEGIN -->");
629
 			}
630
 
631
 			renderComponentTagBody(associatedMarkupStream, associatedMarkupOpenTag);
632
 
634
 			{
635
 				getResponse().write("<!-- MARKUP FOR ");
637
 				getResponse().write(" END -->");
638
 			}
639
 
640
 			renderClosingComponentTag(associatedMarkupStream, associatedMarkupOpenTag, false);
641
 			setMarkupStream(originalMarkupStream);
642
 		}
643
 		finally
644
 		{
646
 		}
647
 	}
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.
657
 
658
 	public final MarkupContainer replace(final Component child)
659
 	{
661
 
662
 		if (child == null)
663
 		{
664
 			throw new IllegalArgumentException("argument child must be not null");
665
 		}
666
 
668
 		{
669
 			.debug("Replacing " + child.getId() + " in " + this);
670
 		}
671
 
672
 		if (child.getParent() != this)
673
 		{
674
 			// Add to map
675
 			final Component replaced = put(child);
676
 
677
 			// Look up to make sure it was already in the map
678
 			if (replaced == null)
679
 			{
681
 					exceptionMessage("Cannot replace a component which has not been added: id='" +
682
 						child.getId() + "', component=" + child));
683
 			}
684
 
685
 			// first remove the component.
686
 			removedComponent(replaced);
687
 
688
 			// then add the other one.
690
 
691
 			// The position of the associated markup remains the same
692
 			child.markupIndex = replaced.markupIndex;
693
 
694
 			// The generated markup id remains the same
695
 			child.setMarkupIdImpl(replaced.getMarkupIdImpl());
696
 		}
697
 
698
 		return this;
699
 	}

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

Returns:
Number of children in this container
739
 
740
 	public final int size()
741
 	{
742
 		return children_size();
743
 	}

See also:
Component.toString()
747
 
748
 	public String toString()
749
 	{
750
 		return toString(false);
751
 	}

Parameters:
detailed True if a detailed string is desired
Returns:
String representation of this container
757
 
758
 	public String toString(final boolean detailed)
759
 	{
760
 		final StringBuffer buffer = new StringBuffer();
761
 		buffer.append("[MarkupContainer ");
762
 		buffer.append(super.toString(true));
763
 		if (detailed)
764
 		{
765
 			if (getMarkupStream() != null)
766
 			{
767
 				buffer.append(", markupStream = " + getMarkupStream());
768
 			}
769
 
770
 			if (children_size() != 0)
771
 			{
772
 				buffer.append(", children = ");
773
 
774
 				// Loop through child components
775
 				final int size = children_size();
776
 				for (int i = 0; i < size; i++)
777
 				{
778
 					// Get next child
779
 					final Component child = children_get(i);
780
 					if (i != 0)
781
 					{
782
 						buffer.append(' ');
783
 					}
784
 					buffer.append(child.toString());
785
 				}
786
 			}
787
 		}
788
 		buffer.append(']');
789
 		return buffer.toString();
790
 	}
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
802
 
803
 	public final Object visitChildren(final Class clazz, final IVisitor visitor)
804
 	{
805
 		if (visitor == null)
806
 		{
807
 			throw new IllegalArgumentException("argument visitor may not be null");
808
 		}
809
 
810
 		// Iterate through children of this container
811
 		for (int i = 0; i < children_size(); i++)
812
 		{
813
 			// Get next child component
814
 			final Component child = children_get(i);
815
 			Object value = null;
816
 
817
 			// Is the child of the correct class (or was no class specified)?
818
 			if (clazz == null || clazz.isInstance(child))
819
 			{
820
 				// Call visitor
821
 				value = visitor.component(child);
822
 
823
 				// If visitor returns a non-null value, it halts the traversal
824
 				if ((value != .) &&
826
 				{
827
 					return value;
828
 				}
829
 			}
830
 
831
 			// If child is a container
832
 			if ((child instanceof MarkupContainer) &&
834
 			{
835
 				// visit the children in the container
836
 				value = ((MarkupContainer)child).visitChildren(clazz, visitor);
837
 
838
 				// If visitor returns a non-null value, it halts the traversal
839
 				if ((value != .) &&
841
 				{
842
 					return value;
843
 				}
844
 			}
845
 		}
846
 
847
 		return null;
848
 	}
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
858
 
859
 	public final Object visitChildren(final IVisitor visitor)
860
 	{
861
 		return visitChildren(null, visitor);
862
 	}

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

Parameters:
child Child to add
911
 
912
 	private final void children_add(final Component child)
913
 	{
914
 		if ( == null)
915
 		{
916
 			 = child;
917
 		}
918
 		else
919
 		{
920
 			// Get current list size
921
 			final int size = children_size();
922
 
923
 			// Create array that holds size + 1 elements
924
 			final Object[] children = new Object[size + 1];
925
 
926
 			// Loop through existing children copying them
927
 			for (int i = 0; i < size; i++)
928
 			{
929
 				children[i] = children_get(i, false);
930
 			}
931
 
932
 			// Add new child to the end
933
 			children[size] = child;
934
 
935
 			// Save new children
936
 			this. = children;
937
 		}
938
 	}
939
 
940
 	private final Component children_get(int index)
941
 	{
942
 		return (Component)children_get(index, true);
943
 	}
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:
955
 
956
 	private final Object postprocess(Object object, boolean reconstruct, MarkupContainer parent,
957
 		int index)
958
 	{
959
 		if (reconstruct && object instanceof ComponentSourceEntry)
960
 		{
961
 			object = ((ComponentSourceEntry)object).reconstruct(parent, index);
962
 		}
963
 		return object;
964
 	}
965
 
966
 	private final Object children_get(int index, boolean reconstruct)
967
 	{
968
 		Object component = null;
969
 		if (index == 0 &&  != null &&  instanceof Object[] == false)
970
 		{
971
 			component = postprocess(, reconstruct, this, 0);
972
 			if ( != component)
973
 			{
974
 				 = component;
975
 			}
976
 		}
977
 		else
978
 		{
979
 			// we have a list
980
 			Object[] children = (Object[])this.;
981
 			component = postprocess(children[index], reconstruct, this, index);
982
 			if (children[index] != component)
983
 			{
984
 				children[index] = component;
985
 			}
986
 		}
987
 
988
 		return component;
989
 	}
Returns the wicket:id of the given object, that can be either a Component or a MarkupContainer.ComponentSourceEntry

Parameters:
object
Returns:
997
 
998
 	private final String getId(Object object)
999
 	{
1000
		if (object instanceof Component)
1002
			return ((Component)object).getId();
1004
		else if (object instanceof ComponentSourceEntry)
1006
			return ((ComponentSourceEntry)object).;
1008
		else
1010
			throw new IllegalArgumentException("Unknown type of object " + object);
1014
	private final Component children_get(final String id)
1016
		Component component = null;
1017
		if ( != null &&  instanceof Object[] == false && getId().equals(id))
1019
			component = (Component)postprocess(, true, this, 0);
1020
			if ( != component)
1022
				 = component;
1025
		else if ( instanceof Object[])
1027
			final Object[] children = (Object[])this.;
1029
				for (int i = 0; i < children.length; i++)
1031
					if (getId(children[i]).equals(id))
1033
						component = (Component)postprocess(children[i], true, this, i);
1034
						if (children[i] != component)
1036
							children[i] = component;
1038
						break;
1043
		return component;
1046
	private final int children_indexOf(Component child)
1048
		if ( != null &&  instanceof Object[] == false &&
1051
			return 0;
1053
		else if ( instanceof Object[])
1055
			final Object[] children = (Object[])this.;
1056
			for (int i = 0; i < children.length; i++)
1058
				if (getId(children[i]).equals(child.getId()))
1060
					return i;
1064
		return -1;
1067
	private final Component children_remove(Component component)
1069
		int index = children_indexOf(component);
1070
		if (index != -1)
1072
			return children_remove(index);
1074
		return null;
1077
	private final Component children_remove(int index)
1079
		if ( instanceof Component ||  instanceof ComponentSourceEntry)
1081
			if (index == 0)
1083
				final Component removed = (Component)postprocess(, true, null, -1);
1084
				 = null;
1085
				return removed;
1087
			else
1092
		else
1094
			Object[] c = ((Object[]));
1095
			final Object removed = c[index];
1096
			if (c.length == 2)
1098
				if (index == 0)
1100
					 = c[1];
1102
				else if (index == 1)
1104
					 = c[0];
1106
				else
1111
			else
1113
				Object[] newChildren = new Object[c.length - 1];
1114
				int j = 0;
1115
				for (int i = 0; i < c.length; i++)
1117
					if (i != index)
1119
						newChildren[j++] = c[i];
1122
				 = newChildren;
1124
			return (Component)postprocess(removed, true, null, -1);
1128
	private final Object children_set(int index, Object child, boolean reconstruct)
1130
		Object replaced;
1131
		if (index < children_size())
1133
			if ( == null ||  instanceof Component ||
1136
				replaced = ;
1137
				 = child;
1139
			else
1141
				final Object[] children = (Object[])this.;
1142
				replaced = children[index];
1143
				children[index] = child;
1146
		else
1150
		return postprocess(replaced, reconstruct, null, -1);
1153
	private final Component children_set(int index, Component child)
1155
		return (Component)children_set(index, child, true);
1158
	private final int children_size()
1160
		if ( == null)
1162
			return 0;
1164
		else
1166
			if ( instanceof Component ||  instanceof ComponentSourceEntry)
1168
				return 1;
1170
			return ((Object[])).length;
1172
	}
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
1181
	private final Component put(final Component child)
1183
		int index = children_indexOf(child);
1184
		if (index == -1)
1187
			return null;
1189
		else
1191
			return children_set(index, child);
1193
	}

Parameters:
component Component being removed
1199
	private final void removedComponent(final Component component)
1201
		// Notify Page that component is being removed
1202
		final Page page = component.findPage();
1203
		if (page != null)
1205
			page.componentRemoved(component);
1208
		component.detach();
1210
		// Component is removed
1211
		component.setParent(null);
1212
	}
Renders the next element of markup in the given markup stream.

Parameters:
markupStream The markup stream
1220
	private final void renderNext(final MarkupStream markupStream)
1222
		// Get the current markup element
1223
		final MarkupElement element = markupStream.get();
1225
		// If it a tag like <wicket..> or <span wicket:id="..." >
1226
		if ((element instanceof ComponentTag) && !markupStream.atCloseTag())
1228
			// Get element as tag
1229
			final ComponentTag tag = (ComponentTag)element;
1231
			// Get component id
1232
			final String id = tag.getId();
1234
			// Get the component for the id from the given container
1235
			final Component component = get(id);
1237
			// Failed to find it?
1238
			if (component != null)
1240
				component.render(markupStream);
1242
			else
1244
				// 2rd try: Components like Border and Panel might implement
1245
				// the ComponentResolver interface as well.
1246
				MarkupContainer container = this;
1247
				while (container != null)
1249
					if (container instanceof IComponentResolver)
1251
						if (((IComponentResolver)container).resolve(this, markupStream, tag))
1253
							return;
1257
					container = container.findParent(MarkupContainer.class);
1260
				// 3rd try: Try application's component resolvers
1261
				final List componentResolvers = getApplication().getPageSettings()
1263
				final Iterator iterator = componentResolvers.iterator();
1264
				while (iterator.hasNext())
1266
					final IComponentResolver resolver = (IComponentResolver)iterator.next();
1267
					if (resolver.resolve(this, markupStream, tag))
1269
						return;
1273
				if (tag instanceof WicketTag)
1275
					if (((WicketTag)tag).isChildTag())
1277
						markupStream.throwMarkupException("Found " + tag.toString() +
1278
							" but no <wicket:extend>");
1280
					else
1282
						markupStream.throwMarkupException("Failed to handle: " + tag.toString());
1286
				// No one was able to handle the component id
1287
				markupStream.throwMarkupException("Unable to find component with id '" + id +
1288
					"' in " + this + ". This means that you declared wicket:id=" + id +
1289
					" in your markup, but that you either did not add the " +
1290
					"component to your page at all, or that the hierarchy does not match.");
1293
		else
1295
			// Render as raw markup
1298
				.debug("Rendering raw markup");
1301
			markupStream.next();
1303
	}
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
1311
	protected final MarkupStream findMarkupStream()
1313
		// Start here
1314
		MarkupContainer c = this;
1316
		// Walk up hierarchy until markup found
1317
		while (c.getMarkupStream() == null)
1319
			// Check parent
1320
			c = c.getParent();
1322
			// Are we at the top of the hierarchy?
1323
			if (c == null)
1325
				// Failed to find markup stream
1326
				throw new WicketRuntimeException(exceptionMessage("No markup found"));
1330
		return c.getMarkupStream();
1331
	}
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
1342
	protected void onComponentTagBody(final MarkupStream markupStream, final ComponentTag openTag)
1344
		renderComponentTagBody(markupStream, openTag);
1345
	}
Renders this component. This implementation just calls renderComponent.

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

Parameters:
markupStream The markup stream
1363
	protected void renderAll(final MarkupStream markupStream)
1365
		// Loop through the markup in this container
1366
		while (markupStream.hasMore())
1368
			// Element rendering is responsible for advancing markup stream!
1369
			final int index = markupStream.getCurrentIndex();
1370
			renderNext(markupStream);
1371
			if (index == markupStream.getCurrentIndex())
1373
				markupStream.throwMarkupException("Component at markup stream index " + index +
1374
					" failed to advance the markup stream");
1377
	}
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
1389
	protected final void renderComponentTagBody(final MarkupStream markupStream,
1390
		final ComponentTag openTag)
1392
		// If the open tag requires a close tag
1393
		boolean render = openTag.requiresCloseTag();
1394
		if (render == false)
1396
			// Tags like <p> do not require a close tag, but they may have.
1397
			render = !openTag.hasNoCloseTag();
1399
		if (render == true)
1401
			// Loop through the markup in this container
1402
			while (markupStream.hasMore() && !markupStream.get().closes(openTag))
1404
				// Render markup element. Doing so must advance the markup
1405
				// stream
1406
				final int index = markupStream.getCurrentIndex();
1407
				renderNext(markupStream);
1408
				if (index == markupStream.getCurrentIndex())
1410
					markupStream.throwMarkupException("Markup element at index " + index +
1411
						" failed to advance the markup stream");
1415
	}
Set markup stream for this container.

Parameters:
markupStream The markup stream
1423
	protected final void setMarkupStream(final MarkupStream markupStream)
1425
		this. = markupStream;
1430
		private ComponentSourceEntry(MarkupContainer container, Component component,
1431
			IComponentSource componentSource)
1433
			super(container, component, componentSource);
1436
		private static final long serialVersionUID = 1L;
1438
		protected void setChild(MarkupContainer parent, int index, Component child)
1440
			parent.children_set(index, child, false);
1448
		for (int i = children_size(); i-- > 0;)
1450
			Object child = children_get(i, false);
1451
			if (child instanceof Component)
1453
				Component component = (Component)child;
1454
				component.detach();
1456
				if (child instanceof IComponentSourceProvider)
1458
					ComponentSourceEntry entry = new ComponentSourceEntry(this, component,
1460
					children_set(i, entry, false);
1462
				else if (component.isAuto())
1473
		final int size = children_size();
1474
		for (int i = 0; i < size; i++)
1476
			final Component child = children_get(i);
1483
		int size = children_size();
1484
		Component result[] = new Component[size];
1485
		for (int i = 0; i < size; ++i)
1487
			result[i] = children_get(i);
1489
		return result;
1496
		// We need to copy the children list because the children components can
1497
		// modify the hierarchy in their onBeforeRender.
1498
		Component[] children = copyChildren();
1499
		try
1501
			// Loop through child components
1502
			for (int i = 0; i < children.length; i++)
1504
				// Get next child
1505
				final Component child = children[i];
1507
				// Call begin request on the child
1508
				// We need to check whether the child's wasn't removed from the
1509
				// component in the meanwhile (e.g. from another's child
1510
				// onBeforeRender)
1511
				if (child.getParent() == this)
1517
		catch (RuntimeException ex)
1519
			if (ex instanceof WicketRuntimeException)
1521
				throw ex;
1523
			else
1525
				throw new WicketRuntimeException("Error attaching this container for rendering: " +
1526
					this, ex);
1533
		// Loop through child components
1534
		final Iterator iter = iterator();
1535
		while (iter.hasNext())
1537
			// Get next child
1538
			final Component child = (Component)iter.next();
1540
			// Call end request on the child
1541
			child.afterRender();
1544
	}

Returns:
True if this markup container has associated markup
1549
	public boolean hasAssociatedMarkup()
1552
	}

See also:
Component.setRenderAllowed()
1563
			public Object component(final Component component)
1565
				// Find out if this component can be rendered
1566
				final boolean renderAllowed = component.isActionAuthorized();
1567
				// Authorize rendering
1568
				component.setRenderAllowed(renderAllowed);
1571
		});
New to GrepCode? Check out our FAQ X