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
  
24
  import java.util.HashSet;
26
  import java.util.List;
27
  import java.util.Set;
28
  
49
  import org.slf4j.Logger;
Abstract base class for pages. As a MarkupContainer subclass, a Page can contain a component hierarchy and markup in some markup language such as HTML. Users of the framework should not attempt to subclass Page directly. Instead they should subclass a subclass of Page that is appropriate to the markup type they are using, such as WebPage (for HTML markup).
  • Construction - When a page is constructed, it is automatically added to the current PageMap in the Session. When a Page is added to the Session's PageMap, the PageMap assigns the Page an id. A PageMap is roughly equivalent to a browser window and encapsulates a set of pages accessible through that window. When a popup window is created, a new PageMap is created for the popup.
  • Identity - The Session that a Page is contained in can be retrieved by calling Page.getSession(). Page identifiers start at 0 for each PageMap in the Session and increment as new pages are added to the map. The PageMap-(and Session)-unique identifier assigned to a given Page can be retrieved by calling getId(). So, the first Page added to a new user Session will always be named "0".
  • LifeCycle - Subclasses of Page which are interested in lifecycle events can override onBeginRequest, onEndRequest() and onModelChanged(). The onBeginRequest() method is inherited from Component. A call to onBeginRequest() is made for every Component on a Page before page rendering begins. At the end of a request (when rendering has completed) to a Page, the onEndRequest() method is called for every Component on the Page.
  • Nested Component Hierarchy - The Page class is a subclass of MarkupContainer. All MarkupContainers can have "associated markup", which resides alongside the Java code by default. All MarkupContainers are also Component containers. Through nesting, of containers, a Page can contain any arbitrary tree of Components. For more details on MarkupContainers, see MarkupContainer.
  • Bookmarkable Pages - Pages can be constructed with any constructor when they are being used in a Wicket session, but if you wish to link to a Page using a URL that is "bookmarkable" (which implies that the URL will not have any session information encoded in it, and that you can call this page directly without having a session first directly from your browser), you need to implement your Page with a no-arg constructor or with a constructor that accepts a PageParameters argument (which wraps any query string parameters for a request). In case the page has both constructors, the constructor with PageParameters will be used.
  • Models - Pages, like other Components, can have models (see org.apache.wicket.model.IModel). A Page can be assigned a model by passing one to the Page's constructor, by overriding initModel() or with an explicit invocation of setModel(). If the model is a org.apache.wicket.model.CompoundPropertyModel, Components on the Page can use the Page's model implicitly via container inheritance. If a Component is not assigned a model, the initModel() override in Component will cause that Component to use the nearest CompoundModel in the parent chain, in this case, the Page's model. For basic CompoundModels, the name of the Component determines which property of the implicit page model the component is bound to. If more control is desired over the binding of Components to the page model (for example, if you want to specify some property expression other than the component's name for retrieving the model object), BoundCompoundPropertyModel can be used.
  • Back Button - Pages can support the back button by enabling versioning with a call to setVersioned(boolean). If a Page is versioned and changes occur to it which need to be tracked, a version manager will be installed using the org.apache.wicket.session.ISessionStore's factory method newVersionManager().
  • Security - See org.apache.wicket.authorization.IAuthorizationStrategy, org.apache.wicket.authorization.strategies.page.SimplePageAuthorizationStrategy

    Author(s):
    Jonathan Locke
    Chris Turner
    Eelco Hillenius
    Johan Compagner
    See also:
    org.apache.wicket.markup.html.WebPage
    MarkupContainer
    org.apache.wicket.model.CompoundPropertyModel
    org.apache.wicket.model.BoundCompoundPropertyModel
    Component
    org.apache.wicket.version.IPageVersionManager
    org.apache.wicket.version.undo.UndoPageVersionManager
122
 
123
 public abstract class Page extends MarkupContainer implements IRedirectListener, IPageMapEntry
124
 {
You can set implementation of the interface in the Page.serializer then that implementation will handle the serialization of this page. The serializePage method is called from the writeObject method then the implementation override the default serialization.

Author(s):
jcompagner
131
 
132
 	public static interface IPageSerializer
133
 	{
Called when page is being deserialized

Parameters:
id TODO
name TODO
page
stream
Throws:
java.io.IOException
java.lang.ClassNotFoundException
146
 
147
 		public void deserializePage(int id, String name, Page page, ObjectInputStream stream)
Called from the Component.writeObject(java.io.ObjectOutputStream) method.

Parameters:
page The page that must be serialized.
stream ObjectOutputStream
Throws:
java.io.IOException
158
 
159
 
160
 		public void serializePage(Page page, ObjectOutputStream stream) throws IOException;
Returns object to be serialized instead of given page (called from writeReplace).

Parameters:
serializedPage
Returns:
object to be serialized instead of page (or the page instance itself)
167
 
168
 		public Object getPageReplacementObject(Page serializedPage);
169
 	}
When passed to getVersion(int) the latest page version is returned. 
173
 
174
 	public static final int LATEST_VERSION = -1;
This is a thread local that is used for serializing page references in this page.It stores a Page.IPageSerializer which can be set by the outside world to do the serialization of this page. 
180
 
181
 	public static final ThreadLocal serializer = new ThreadLocal();
True if a new version was created for this request.
183
 
184
 	private static final short FLAG_NEW_VERSION = ;
True if the page should try to be stateless
186
 
187
 	private static final int FLAG_STATELESS_HINT = ;
True if component changes are being tracked.
189
 
190
 	private static final short FLAG_TRACK_CHANGES = ;
Log.
192
 
193
 	private static final Logger log = LoggerFactory.getLogger(Page.class);
isBookmarkable() is expensive, we cache the result here 
197
 
199
 
200
 	private static final long serialVersionUID = 1L;
Used to create page-unique numbers
202
 
203
 	private short autoIndex;
Numeric version of this page's id
205
 
206
 	private int numericId;
The PageMap within the session that this page is stored in
208
 
209
 	private transient IPageMap pageMap;
Name of PageMap that this page is stored in
211
 
212
 	private String pageMapName;
Set of components that rendered if component use checking is enabled
214
 
215
 	private transient Set renderedComponents;
Boolean if the page is stateless, so it doesn't have to be in the page map, will be set in urlFor 
220
 
221
 	private transient Boolean stateless = null;
Version manager for this page
223
 
The page parameters object hat constructed this page
226
 
Constructor. 
231
 
232
 	protected Page()
233
 	{
234
 		// A Page's id is not determined until setId is called when the Page is
235
 		// added to a PageMap in the Session.
236
 		super(null);
237
 		init();
238
 	}
Constructor.

Parameters:
model See Component
See also:
Component.Component.(java.lang.String,org.apache.wicket.model.IModel)
246
 
247
 	protected Page(final IModel model)
248
 	{
249
 		// A Page's id is not determined until setId is called when the Page is
250
 		// added to a PageMap in the Session.
251
 		super(null, model);
252
 		init();
253
 	}
Constructor.

Parameters:
pageMap The page map to put this page in
260
 
261
 	protected Page(final IPageMap pageMap)
262
 	{
263
 		// A Page's id is not determined until setId is called when the Page is
264
 		// added to a PageMap in the Session.
265
 		super(null);
266
 		init(pageMap);
267
 	}
Constructor.

Parameters:
pageMap the page map to put this page in
model See Component
See also:
Component.Component.(java.lang.String,org.apache.wicket.model.IModel)
277
 
278
 	protected Page(final IPageMap pageMap, final IModel model)
279
 	{
280
 		// A Page's id is not determined until setId is called when the Page is
281
 		// added to a PageMap in the Session.
282
 		super(null, model);
283
 		init(pageMap);
284
 	}
The PageParameters parameter will be stored in this page and then those parameters will be used to create stateless links to this bookmarkable page.

Parameters:
parameters externally passed parameters
See also:
PageParameters
293
 
294
 	protected Page(final PageParameters parameters)
295
 	{
296
 		super(null);
297
 		this. = parameters;
298
 		init();
299
 	}
The PageParameters parameter will be stored in this page and then those parameters will be used to create stateless links to this bookmarkable page.

Parameters:
pageMap the page map to put this page in
parameters externally passed parameters
See also:
PageParameters
310
 
311
 	protected Page(final IPageMap pageMap, final PageParameters parameters)
312
 	{
313
 		super(null);
314
 		this. = parameters;
315
 		init(pageMap);
316
 	}
The PageParameters object that was used to construct this page. This will be used in creating stateless/bookmarkable links to this page

Returns:
PageParameters The construction page parameter
323
 
325
 	{
326
 		return ;
327
 	}
Called right after a component's listener method (the provided method argument) was called. This method may be used to clean up dependencies, do logging, etc. NOTE: this method will also be called when beforeCallComponent(org.apache.wicket.Component,org.apache.wicket.RequestListenerInterface) or the method invocation itself failed.

Parameters:
component the component that is to be called
listener the listener of that component that is to be called
339
 
340
 	// TODO Post-1.3: We should create a listener on Application like
341
 	// IComponentInstantiationListener
342
 	// that forwards to IAuthorizationStrategy for RequestListenerInterface
343
 	// invocations.
344
 	public void afterCallComponent(final Component component,
345
 		final RequestListenerInterface listener)
346
 	{
347
 	}
Called just before a component's listener method (the provided method argument) is called. This method may be used to set up dependencies, enforce authorization, etc. NOTE: if this method fails, the method will not be executed. Method afterCallComponent(org.apache.wicket.Component,org.apache.wicket.RequestListenerInterface) will always be called.

Parameters:
component the component that is to be called
listener the listener of that component that is to be called
360
 
361
 	// TODO Post-1.3: We should create a listener on Application like
362
 	// IComponentInstantiationListener
363
 	// that forwards to IAuthorizationStrategy for RequestListenerInterface
364
 	// invocations.
365
 	public void beforeCallComponent(final Component component,
366
 		final RequestListenerInterface listener)
367
 	{
368
 	}
Adds a component to the set of rendered components.

Parameters:
component The component that was rendered
375
 
376
 	public final void componentRendered(final Component component)
377
 	{
378
 		// Inform the page that this component rendered
379
 		if (Application.get().getDebugSettings().getComponentUseCheck())
380
 		{
381
 			if ( == null)
382
 			{
384
 			}
385
 			if (.add(component) == false)
386
 			{
387
 				throw new MarkupException("The component " + component +
388
 					" has the same wicket:id as another component already added at the same level");
389
 			}
391
 			{
392
 				.debug("Rendered " + component);
393
 			}
394
 		}
395
 	}
Detaches any attached models referenced by this page. 
399
 
400
 	public void detachModels()
401
 	{
402
 		// // visit all this page's children to detach the models
403
 		// visitChildren(new IVisitor()
404
 		// {
405
 		// public Object component(Component component)
406
 		// {
407
 		// try
408
 		// {
409
 		// // detach any models of the component
410
 		// component.detachModels();
411
 		// }
412
 		// catch (Exception e) // catch anything; we MUST detach all models
413
 		// {
414
 		// log.error("detaching models of component " + component + " failed:",
415
 		// e);
416
 		// }
417
 		// return IVisitor.CONTINUE_TRAVERSAL;
418
 		// }
419
 		// });
420
 
421
 		super.detachModels();
422
 	}
Mark this page as dirty in the session 
427
 
428
 	public final void dirty()
429
 	{
430
 		Session.get().dirtyPage(this);
431
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL. This method is called when a component was rendered standalone. If it is a MarkupContainer then the rendering for that container is checked.

Parameters:
component
442
 
443
 	public final void endComponentRender(Component component)
444
 	{
445
 		if (component instanceof MarkupContainer)
446
 		{
448
 		}
449
 		else
450
 		{
452
 		}
453
 	}
Expire the oldest version of this page 
457
 
458
 	public final void expireOldestVersion()
459
 	{
460
 		if ( != null)
461
 		{
463
 		}
464
 	}

Returns:
The current ajax version number of this page.
468
 
469
 	public final int getAjaxVersionNumber()
470
 	{
471
 		return  == null ? 0 : .getAjaxVersionNumber();
472
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT. Get a page unique number, which will be increased with each call.

Returns:
A page unique number
480
 
481
 	public final short getAutoIndex()
482
 	{
483
 		return ++;
484
 	}

Returns:
The current version number of this page. If the page has been changed once, the return value will be 1. If the page has not yet been revised, the version returned will be 0, indicating that the page is still in its original state.
490
 
491
 	public final int getCurrentVersionNumber()
492
 	{
493
 		return  == null ? 0 : .getCurrentVersionNumber();
494
 	}

See also:
Component.getId()
498
 
499
 	public final String getId()
500
 	{
501
 		return Integer.toString();
502
 	}

See also:
org.apache.wicket.session.pagemap.IPageMapEntry.getNumericId()
506
 
507
 	public int getNumericId()
508
 	{
509
 		return ;
510
 	}

See also:
org.apache.wicket.session.pagemap.IPageMapEntry.getPageClass()
514
 
515
 	public final Class getPageClass()
516
 	{
517
 		return getClass();
518
 	}

Returns:
Returns the PageMap that this Page is stored in.
522
 
523
 	public final IPageMap getPageMap()
524
 	{
525
 		// If the transient needs to be restored
526
 		if ( == null)
527
 		{
528
 			// Look the page map up in the session
529
 			 = PageMap.forName();
530
 		}
531
 		return ;
532
 	}

Returns:
Get a page map entry for this page. By default, this is the page itself. But if you know of some way to compress the state for the page, you can return a custom implementation that produces the page on-the-fly.
538
 
540
 	{
541
 		return this;
542
 	}

Returns:
String The PageMap name
546
 
547
 	public final String getPageMapName()
548
 	{
549
 		return ;
550
 	}

Returns:
Size of this page in bytes
554
 
555
 	public final long getSizeInBytes()
556
 	{
557
 		 = null;
558
 		return Objects.sizeof(this);
559
 	}
Returns whether the page should try to be stateless. To be stateless, getStatelessHint() of every component on page (and it's behavior) must return true and the page must be bookmarkable.

See also:
Component.getStatelessHint()
567
 
568
 	public final boolean getStatelessHint()
569
 	{
571
 	}
Override this method to implement a custom way of producing a version of a Page when it cannot be found in the Session.

Parameters:
versionNumber The version desired
Returns:
A Page object with the component/model hierarchy that was attached to this page at the time represented by the requested version.
581
 
582
 	public Page getVersion(final int versionNumber)
583
 	{
584
 		// If we're still the original Page and that's what's desired
585
 		if ( == null)
586
 		{
587
 			if (versionNumber == 0 || versionNumber == )
588
 			{
589
 				return this;
590
 			}
591
 			else
592
 			{
593
 				.info("No version manager available to retrieve requested versionNumber " +
594
 					versionNumber);
595
 				return null;
596
 			}
597
 		}
598
 		else
599
 		{
600
 			// Save original change tracking state
601
 			final boolean originalTrackChanges = getFlag();
602
 
603
 			try
604
 			{
605
 				// While the version manager is potentially playing around with
606
 				// the Page, it may change the page in order to undo changes and
607
 				// we don't want change tracking going on while its doing this.
609
 
610
 				// Get page of desired version
611
 				final Page page;
612
 				if (versionNumber != )
613
 				{
614
 					page = .getVersion(versionNumber);
615
 				}
616
 				else
617
 				{
619
 				}
620
 
621
 				// If we went all the way back to the original page
622
 				if (page != null && page.getCurrentVersionNumber() == 0 &&
623
 					page.getAjaxVersionNumber() == 0)
624
 				{
625
 					// remove version info
626
 					page.versionManager = null;
627
 				}
628
 
629
 				return page;
630
 			}
631
 			finally
632
 			{
633
 				// Restore change tracking state
634
 				setFlag(, originalTrackChanges);
635
 			}
636
 		}
637
 	}

Returns:
Number of versions of this page
641
 
642
 	public final int getVersions()
643
 	{
644
 		return  == null ? 1 : .getVersions() + 1;
645
 	}

Returns:
This page's component hierarchy as a string
649
 
650
 	public final String hierarchyAsString()
651
 	{
652
 		final StringBuffer buffer = new StringBuffer();
653
 		buffer.append("Page " + getId() + " (version " + getCurrentVersionNumber() + ")");
655
 		{
656
 			public Object component(Component component)
657
 			{
658
 				int levels = 0;
659
 				for (Component current = component; current != null; current = current.getParent())
660
 				{
661
 					levels++;
662
 				}
663
 				buffer.append(StringValue.repeat(levels, "	") + component.getPageRelativePath() +
664
 					":" + Classes.simpleName(component.getClass()));
665
 				return null;
666
 			}
667
 		});
668
 		return buffer.toString();
669
 	}
Call this method when the current (ajax) request shouldn't merge the changes that are happening to the page with the previous version. This is for example needed when you want to redirect to this page in an ajax request and then you do want to version normally.. This method doesn't do anything if the getRequest().mergeVersion doesn't return true. 
679
 
680
 	public final void ignoreVersionMerge()
681
 	{
683
 		{
684
 			mayTrackChangesFor(this, null);
685
 			if ( != null)
686
 			{
688
 			}
689
 		}
690
 	}
Bookmarkable page can be instantiated using a bookmarkable URL.

Returns:
Returns true if the page is bookmarkable.
696
 
697
 	public boolean isBookmarkable()
698
 	{
700
 		if (bookmarkable == null)
701
 		{
702
 			try
703
 			{
704
 
705
 				if (getClass().getConstructor(new Class[] {}) != null)
706
 				{
707
 					bookmarkable = .;
708
 				}
709
 
710
 			}
711
 			catch (Exception ignore)
712
 			{
713
 				try
714
 				{
715
 					if (getClass().getConstructor(new Class[] { PageParameters.class }) != null)
716
 					{
717
 						bookmarkable = .;
718
 					}
719
 				}
720
 				catch (Exception ignore2)
721
 				{
722
 				}
723
 			}
724
 			if (bookmarkable == null)
725
 			{
726
 				bookmarkable = .;
727
 			}
729
 		}
730
 		return bookmarkable.booleanValue();
731
 
732
 	}
Override this method and return true if your page is used to display Wicket errors. This can help the framework prevent infinite failure loops.

Returns:
True if this page is intended to display an error to the end user.
739
 
740
 	public boolean isErrorPage()
741
 	{
742
 		return false;
743
 	}
Gets whether the page is stateless. Components on stateless page must not render any statefull urls, and components on statefull page must not render any stateless urls. Statefull urls are urls, which refer to a certain (current) page instance.

Returns:
Whether this page is stateless
751
 
752
 	public final boolean isPageStateless()
753
 	{
754
 		if (isBookmarkable() == false)
755
 		{
758
 			{
759
 				.warn("Page '" + this + "' is not stateless because it is not bookmarkable, " +
760
 					"but the stateless hint is set to true!");
761
 			}
762
 		}
763
 
764
 		if (getStatelessHint() == false)
765
 		{
766
 			return false;
767
 		}
768
 
769
 		if ( == null)
770
 		{
771
 			if (isStateless() == false)
772
 			{
774
 			}
775
 		}
776
 
777
 		if ( == null)
778
 		{
779
 			final Object[] returnArray = new Object[1];
780
 			Object returnValue = visitChildren(Component.class, new IVisitor()
781
 			{
782
 				public Object component(Component component)
783
 				{
784
 					if (!component.isStateless())
785
 					{
786
 						returnArray[0] = component;
787
 						return .;
788
 					}
789
 
791
 				}
792
 			});
793
 			if (returnValue == null)
794
 			{
796
 			}
797
 			else if (returnValue instanceof Boolean)
798
 			{
799
 				 = (Boolean)returnValue;
800
 			}
801
 
802
 			// TODO (matej_k): The stateless hint semantics has been changed, this warning doesn't
803
 			// work anymore. but we don't really have
804
 			// alternative to this
805
 			/*
806
 			 * if (!stateless.booleanValue() && getStatelessHint()) { log.warn("Page '" + this + "'
807
 			 * is not stateless because of '" + returnArray[0] + "' but the stateless hint is set to
808
 			 * true!"); }
809
 			 */
810
 		}
811
 
813
 	}
Redirect to this page.

See also:
IRedirectListener.onRedirect()
819
 
820
 	public final void onRedirect()
821
 	{
822
 	}
Convenience method. Search for children of type fromClass and invoke their respective removePersistedFormData() methods.

Parameters:
formClass Form to be selected. Pages may have more than one Form.
disablePersistence if true, disable persistence for all FormComponents on that page. If false, it will remain unchanged.
See also:
org.apache.wicket.markup.html.form.Form.removePersistentFormComponentValues(boolean)
835
 
836
 	public final void removePersistedFormData(final Class formClass,
837
 		final boolean disablePersistence)
838
 	{
839
 		// Check that formClass is an instanceof Form
840
 		if (!Form.class.isAssignableFrom(formClass))
841
 		{
842
 			throw new WicketRuntimeException("Form class " + formClass.getName() +
843
 				" is not a subclass of Form");
844
 		}
845
 
846
 		// Visit all children which are an instance of formClass
847
 		visitChildren(formClass, new IVisitor()
848
 		{
849
 			public Object component(final Component component)
850
 			{
851
 				// They must be of type Form as well
852
 				if (component instanceof Form)
853
 				{
854
 					// Delete persistent FormComponent data and disable
855
 					// persistence
856
 					((Form)component).removePersistentFormComponentValues(disablePersistence);
857
 				}
859
 			}
860
 		});
861
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT. 
865
 
866
 	public final void renderPage()
867
 	{
868
 		// first try to check if the page can be rendered:
870
 		{
872
 			{
873
 				.debug("Page not allowed to render: " + this);
874
 			}
876
 		}
877
 
878
 		// Make sure it is really empty
880
 
881
 		// if the page is stateless, reset the flag so that it is tested again
883
 		{
884
 			 = null;
885
 		}
886
 
887
 		// Set form component values from cookies
889
 
890
 		try
891
 		{
893
 		}
894
 		catch (RuntimeException e)
895
 		{
896
 			// if an exception is thrown then we have to call after render
897
 			// else the components could be in a wrong state (rendering)
898
 			try
899
 			{
901
 			}
902
 			catch (RuntimeException e2)
903
 			{
904
 				// ignore this one could be a result off.
905
 			}
906
 			throw e;
907
 		}
908
 
909
 
910
 		// Handle request by rendering page
911
 		try
912
 		{
913
 			render(null);
914
 		}
915
 		finally
916
 		{
918
 		}
919
 
920
 		// Check rendering if it happened fully
922
 
923
 		// clean up debug meta data if component check is on
924
 		if (Application.get().getDebugSettings().getComponentUseCheck())
925
 		{
927
 			{
928
 				public Object component(Component component)
929
 				{
931
 					component.setMetaData(., null);
933
 				}
934
 			});
935
 		}
936
 
937
 		if (!isPageStateless())
938
 		{
939
 			// trigger creation of the actual session in case it was deferred
940
 			Session.get().getSessionStore().getSessionId(RequestCycle.get().getRequest(), true);
941
 			// Add/touch the response page in the session (its pagemap).
942
 			getSession().touch(this);
943
 		}
944
 	}
This returns a page instance that is rollbacked the number of versions that is specified compared to the current page. This is a rollback including ajax versions.

Parameters:
numberOfVersions to rollback
Returns:
rollbacked page instance
955
 
956
 	public final Page rollbackPage(int numberOfVersions)
957
 	{
958
 		Page page =  == null ? this : .rollbackPage(numberOfVersions);
959
 		getSession().touch(page);
960
 		return page;
961
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL. Set the id for this Page. This method is called by PageMap when a Page is added because the id, which is assigned by PageMap, is not known until this time.

Parameters:
id The id
971
 
972
 	public final void setNumericId(final int id)
973
 	{
974
 		 = id;
975
 	}
Sets whether the page should try to be stateless. To be stateless, getStatelessHint() of every component on page (and it's behavior) must return true and the page must be bookmarkable.

Parameters:
value whether the page should try to be stateless
984
 
985
 	public final void setStatelessHint(boolean value)
986
 	{
987
 		if (value && !isBookmarkable())
988
 		{
990
 				"Can't set stateless hint to true on a page when the page is not bookmarkable, page: " +
991
 					this);
992
 		}
994
 	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL. This method is called when a component will be rendered standalone.

Parameters:
component
1004
	public final void startComponentRender(Component component)
1007
	}
Get the string representation of this container.

Returns:
String representation of this container
1014
	public String toString()
1016
		if ( != null)
1018
			return "[Page class = " + getClass().getName() + ", id = " + getId() + ", version = " +
1022
		else
1024
			return "[Page class = " + getClass().getName() + ", id = " + getId() + ", version = " +
1025
				0 + "]";
1027
	}
Throw an exception if not all components rendered.

Parameters:
renderedContainer The page itself if it was a full page render or the container that was rendered standalone
1036
	private final void checkRendering(final MarkupContainer renderedContainer)
1038
		// If the application wants component uses checked and
1039
		// the response is not a redirect
1040
		final IDebugSettings debugSettings = Application.get().getDebugSettings();
1041
		if (debugSettings.getComponentUseCheck() && !getResponse().isRedirect())
1043
			final List unrenderedComponents = new ArrayList();
1044
			final StringBuffer buffer = new StringBuffer();
1045
			renderedContainer.visitChildren(new IVisitor()
1047
				public Object component(final Component component)
1049
					// If component never rendered
1050
					if ( == null || !.contains(component))
1052
						// If auto component ...
1053
						if (!component.isAuto() && component.isVisibleInHierarchy())
1055
							// Increase number of unrendered components
1056
							unrenderedComponents.add(component);
1058
							// Add to explanatory string to buffer
1059
							buffer.append(Integer.toString(unrenderedComponents.size()) + ". " +
1060
								component + "\n");
1062
							if (metadata != null)
1064
								buffer.append(metadata);
1066
							metadata = (String)component.getMetaData(.);
1067
							if (metadata != null)
1069
								buffer.append(metadata);
1072
						else
1074
							// if the component is not visible in hierarchy we
1075
							// should not visit its children since they are also
1076
							// not visible
1082
			});
1084
			// Throw exception if any errors were found
1085
			if (unrenderedComponents.size() > 0)
1087
				// Get rid of set
1090
				Iterator iterator = unrenderedComponents.iterator();
1092
				while (iterator.hasNext())
1094
					Component component = (Component)iterator.next();
1095
					// Now first test if the component has a sibling that is a transparent resolver.
1097
					Iterator iterator2 = component.getParent().iterator();
1098
					while (iterator2.hasNext())
1100
						Component sibling = (Component)iterator2.next();
1101
						if (!sibling.isVisible())
1103
							boolean isTransparentMarkupContainer = sibling instanceof MarkupContainer &&
1105
							boolean isComponentResolver = sibling instanceof IComponentResolver;
1106
							if (isTransparentMarkupContainer || isComponentResolver)
1108
								// we found a transparent container that isn't visible
1109
								// then ignore this component and only do a debug statement here.
1111
									"Component {} wasn't rendered but most likely it has a transparent parent: {}",
1112
									component, sibling);
1113
								iterator.remove();
1114
								break;
1119
					// Check if this component is a child of a border whose body is invisible and if
1120
					// so ignore it
1121
					Border border = (Border)component.findParent(Border.class);
1122
					if (border != null && !border.getBodyContainer().isVisibleInHierarchy())
1125
						// Suppose:
1126
						//						  
1127
						// <div wicket:id="border"><div wicket:id="label"></div> suppose
1128
						// border->label and border's body is hidden.
1129
						//						  
1130
						// The label is added to border not to its hidden body so as far as wicket
1131
						// is concerned label is visible in hierarchy, but when rendering label wont
1132
						// be rendered because in the markup it is inside the border's hidden body.
1133
						// Thus component use check will fail even though it shouldnt - make sure it
1134
						// doesnt.
1135
						//						 
1137
						// TODO it would be more accurate to determine that this component is inside
1138
						// the border parent's markup not the border's itself
1139
						iterator.remove();
1142
				// if still > 0
1143
				if (unrenderedComponents.size() > 0)
1145
					// Throw exception
1147
						"The component(s) below failed to render. A common problem is that you have added a component in code but forgot to reference it in the markup (thus the component will never be rendered).\n\n" +
1148
							buffer.toString());
1153
		// Get rid of set
1155
	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL OR OVERRIDE. 
1161
	private final void endVersion()
1163
		// Any changes to the page after this point will be tracked by the
1164
		// page's version manager. Since trackChanges is never set to false,
1165
		// this effectively means that change tracking begins after the
1166
		// first request to a page completes.
1169
		// If a new version was created
1172
			// Reset boolean for next request
1175
			// We're done with this version
1176
			if ( != null)
1181
			// Evict any page version(s) as need be
1184
	}
Initializes Page by adding it to the Session and initializing it. 
1189
	private final void init()
1191
		final RequestCycle cycle = getRequestCycle();
1192
		String pageMapName = null;
1193
		if (cycle != null)
1196
			pageMapName = parameters.getPageMapName();
1199
		final IPageMap pageMap = PageMap.forName(pageMapName);
1200
		init(pageMap);
1201
	}
Initializes Page by adding it to the Session and initializing it.

Parameters:
pageMap The page map to put this page in.
1209
	private final void init(final IPageMap pageMap)
1214
		// Set the page map
1215
		if (pageMap != null)
1217
			setPageMap(pageMap);
1219
		else
1221
			throw new IllegalStateException("PageMap cannot be null");
1226
		// Set versioning of page based on default
1229
		// All Pages are born dirty so they get clustered right away
1233
	private void setNextAvailableId()
1239
		else
1241
			// Set the numeric id on this page
1244
	}
For the given component, whether we may record changes.

Parameters:
component The component which is affected
parent
Returns:
True if the change is okay to report
1254
	private final boolean mayTrackChangesFor(final Component component, MarkupContainer parent)
1256
		// first call the method so that people can track dirty components
1257
		componentChanged(component, parent);
1258
		// Auto components do not participate in versioning since they are
1259
		// added during the rendering phase (which is normally illegal).
1260
		if (component.isAuto() || (parent == null && !component.isVersioned()) ||
1261
			(parent != null && !parent.isVersioned()))
1263
			return false;
1265
		else
1267
			// the component is versioned... are we tracking changes at all?
1270
				// we are tracking changes... do we need to start new version?
1273
					// if we have no version manager
1274
					if ( == null)
1276
						// then install a new version manager
1280
					// start a new version
1285
				// return true as we are ready for versioning
1286
				return true;
1289
			// we are not tracking changes or the component not versioned
1290
			return false;
1292
	}
This method will be called for all components that are changed on the page So also auto components or components that are not versioned. If the parent is given that it was a remove or add from that parent of the given component. else it was just a internal property change of that component.

Parameters:
component
parent
1304
	protected void componentChanged(Component component, MarkupContainer parent)
1310
		int id = s.readShort();
1311
		String name = (String)s.readObject();
1314
		if (ps != null)
1316
			ps.deserializePage(id, name, this, s);
1318
		else
1329
		if (ps != null)
1331
			return ps.getPageReplacementObject(this);
1333
		else
1335
			return this;
1346
		if (ps != null)
1348
			ps.serializePage(this, s);
1350
		else
1354
	}
Set-up response with appropriate content type, locale and encoding. The locale is set equal to the session's locale. The content type header contains information about the markup type (@see #getMarkupType()) and the encoding. The response (and request) encoding is determined by an application setting (@see ApplicationSettings#getResponseRequestEncoding()). In addition, if the page's markup contains a xml declaration like &lt?xml ... ?> an xml declaration with proper encoding information is written to the output as well, provided it is not disabled by an application setting (@see ApplicationSettings#getStripXmlDeclarationFromOutput()).

Note: Prior to Wicket 1.1 the output encoding was determined by the page's markup encoding. Because this caused uncertainties about the /request/ encoding, it has been changed in favor of the new, much safer, approach. Please see the Wiki for more details. 

1371
	protected void configureResponse()
1373
		// Get the response and application
1374
		final RequestCycle cycle = getRequestCycle();
1375
		final Application application = cycle.getApplication();
1376
		final Response response = cycle.getResponse();
1378
		// Determine encoding
1379
		final String encoding = application.getRequestCycleSettings().getResponseRequestEncoding();
1381
		// Set content type based on markup type for page
1382
		response.setContentType("text/" + getMarkupType() + "; charset=" + encoding);
1384
		// Write out an xml declaration if the markup stream and settings allow
1385
		final MarkupStream markupStream = findMarkupStream();
1386
		if ((markupStream != null) && (markupStream.getXmlDeclaration() != null) &&
1389
			// Gwyn - Wed, 21 May 2008 12:23:41
1390
			// If the xml declaration in the markup used double-quotes, use them in the output too
1391
			// Whether it should be or not, sometimes it's significant...
1392
			final String quoteChar = (markupStream.getXmlDeclaration().indexOf('\"') == -1) ? "'"
1393
				: "\"";
1395
			response.write("<?xml version=");
1396
			response.write(quoteChar);
1397
			response.write("1.0");
1398
			response.write(quoteChar);
1399
			response.write(" encoding=");
1400
			response.write(quoteChar);
1401
			response.write(encoding);
1402
			response.write(quoteChar);
1403
			response.write("?>");
1406
		// Set response locale from session locale
1408
	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL OR OVERRIDE.

See also:
Component.internalOnModelChanged()
1415
	protected final void internalOnModelChanged()
1419
			public Object component(final Component component)
1421
				// If form component is using form model
1422
				if (component.sameInnermostModel(Page.this))
1424
					component.modelChanged();
1428
		});
1429
	}
THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL OR OVERRIDE.

Parameters:
map
1436
	protected final void moveToPageMap(IPageMap map)
1438
		// TODO post 1.2 shouldn't we remove this page from the pagemap/session
1439
		// if it would be in there?
1440
		// This should be done if the page was not cloned first, but shouldn't
1441
		// be done if it was cloned..
1445
	}

Deprecated:
TODO Remove in 1.4
Returns:
Factory method that creates a version manager for this Page
1453
		return null;
1456
	protected void onBeforeRender()
1459
		// If any of the components on page is not stateless, we need to bind the session
1460
		// before we start rendering components, as then jsessionid won't be appended
1461
		// for links rendered before first stateful component
1466
	}

See also:
Component.onDetach()
1471
	protected void onDetach()
1475
			.debug("ending request for page " + this + ", request " + getRequest());
1482
		super.onDetach();
1484
	}
Renders this container to the given response object.

Parameters:
markupStream
1492
	protected void onRender(final MarkupStream markupStream)
1494
		// Set page's associated markup stream
1495
		final MarkupStream associatedMarkupStream = getAssociatedMarkupStream(true);
1496
		setMarkupStream(associatedMarkupStream);
1498
		// Configure response object with locale and content type
1501
		// Render markup
1502
		renderAll(associatedMarkupStream);
1503
	}
A component was added.

Parameters:
component The component that was added
1511
	final void componentAdded(final Component component)
1514
		if (mayTrackChangesFor(component, component.getParent()))
1518
	}
A component's model changed.

Parameters:
component The component whose model is about to change
1526
	final void componentModelChanging(final Component component)
1529
		if (mayTrackChangesFor(component, null))
1531
			// If it is an inhertiable model then don't call model changing
1532
			// on the version manager.
1538
	}
A component was removed.

Parameters:
component The component that was removed
1546
	final void componentRemoved(final Component component)
1549
		if (mayTrackChangesFor(component, component.getParent()))
1555
	final void componentStateChanging(final Component component, Change change)
1558
		if (mayTrackChangesFor(component, null))
1562
	}
Sets values for form components based on cookie values in the request. 
1570
		// Visit all Forms contained in the page
1573
			// For each FormComponent found on the Page (not Form)
1574
			public Object component(final Component component)
1579
		});
1580
	}

Parameters:
pageMap Sets this page into the page map with the given name. If the page map does not yet exist, it is automatically created.
1587
	final void setPageMap(final IPageMap pageMap)
1589
		// Save transient reference to pagemap
1590
		this. = pageMap;
1592
		// Save name for restoring transient
1593
		 = pageMap.getName();
1594
	}
Set page stateless

Parameters:
stateless
1601
	void setPageStateless(Boolean stateless)
1603
		this. = stateless;
1604
	}
Called when the page is retrieved from Session. 
1609
	public void onPageAttached()
1617
			"Page does not support markup. This error can happen if you have extended Page directly, instead extend WebPage");
New to GrepCode? Check out our FAQ X