The Unified and Autonomous Development Platform
chore: Refactoring component context
Robin Shencfc94c05d0c6
diff --git a/server-core/src/main/java/org/apache/wicket/Component.java b/server-core/src/main/java/org/apache/wicket/Component.javanew file mode 100644index 0000000000..febd3200db--- /dev/null+++ b/server-core/src/main/java/org/apache/wicket/Component.java@@ -0,0 +1,4688 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You under the Apache License, Version 2.0+ * (the "License"); you may not use this file except in compliance with+ * the License. You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.apache.wicket;++import java.io.Serializable;+import java.lang.reflect.Method;+import java.util.ArrayList;+import java.util.Arrays;+import java.util.Iterator;+import java.util.List;+import java.util.Locale;++import org.apache.wicket.ajax.IAjaxRegionMarkupIdProvider;+import org.apache.wicket.application.IComponentInstantiationListener;+import org.apache.wicket.authorization.Action;+import org.apache.wicket.authorization.AuthorizationException;+import org.apache.wicket.authorization.IAuthorizationStrategy;+import org.apache.wicket.authorization.UnauthorizedActionException;+import org.apache.wicket.authorization.strategies.page.SimplePageAuthorizationStrategy;+import org.apache.wicket.behavior.Behavior;+import org.apache.wicket.core.request.handler.BookmarkableListenerInterfaceRequestHandler;+import org.apache.wicket.core.request.handler.ListenerInterfaceRequestHandler;+import org.apache.wicket.core.request.handler.PageAndComponentProvider;+import org.apache.wicket.core.util.lang.WicketObjects;+import org.apache.wicket.core.util.string.ComponentStrings;+import org.apache.wicket.event.Broadcast;+import org.apache.wicket.event.IEvent;+import org.apache.wicket.event.IEventSink;+import org.apache.wicket.event.IEventSource;+import org.apache.wicket.feedback.FeedbackMessage;+import org.apache.wicket.feedback.FeedbackMessages;+import org.apache.wicket.feedback.IFeedback;+import org.apache.wicket.markup.ComponentTag;+import org.apache.wicket.markup.IMarkupFragment;+import org.apache.wicket.markup.Markup;+import org.apache.wicket.markup.MarkupCache;+import org.apache.wicket.markup.MarkupElement;+import org.apache.wicket.markup.MarkupException;+import org.apache.wicket.markup.MarkupNotFoundException;+import org.apache.wicket.markup.MarkupStream;+import org.apache.wicket.markup.WicketTag;+import org.apache.wicket.markup.head.IHeaderResponse;+import org.apache.wicket.markup.head.StringHeaderItem;+import org.apache.wicket.markup.html.IHeaderContributor;+import org.apache.wicket.markup.html.form.Form;+import org.apache.wicket.markup.html.form.FormComponent;+import org.apache.wicket.markup.html.form.IFormSubmitListener;+import org.apache.wicket.markup.html.internal.HtmlHeaderContainer;+import org.apache.wicket.markup.html.panel.DefaultMarkupSourcingStrategy;+import org.apache.wicket.markup.html.panel.IMarkupSourcingStrategy;+import org.apache.wicket.model.CompoundPropertyModel;+import org.apache.wicket.model.IComponentAssignedModel;+import org.apache.wicket.model.IComponentInheritedModel;+import org.apache.wicket.model.IModel;+import org.apache.wicket.model.IModelComparator;+import org.apache.wicket.model.IWrapModel;+import org.apache.wicket.protocol.http.WicketFilter;+import org.apache.wicket.request.IRequestHandler;+import org.apache.wicket.request.Request;+import org.apache.wicket.request.Response;+import org.apache.wicket.request.component.IRequestableComponent;+import org.apache.wicket.request.component.IRequestablePage;+import org.apache.wicket.request.cycle.RequestCycle;+import org.apache.wicket.request.mapper.parameter.PageParameters;+import org.apache.wicket.request.resource.ResourceReference;+import org.apache.wicket.response.StringResponse;+import org.apache.wicket.settings.DebugSettings;+import org.apache.wicket.settings.ExceptionSettings;+import org.apache.wicket.util.IHierarchical;+import org.apache.wicket.util.convert.IConverter;+import org.apache.wicket.util.io.IClusterable;+import org.apache.wicket.util.lang.Args;+import org.apache.wicket.util.lang.Classes;+import org.apache.wicket.util.string.PrependingStringBuffer;+import org.apache.wicket.util.string.Strings;+import org.apache.wicket.util.value.ValueMap;+import org.apache.wicket.util.visit.IVisit;+import org.apache.wicket.util.visit.IVisitFilter;+import org.apache.wicket.util.visit.IVisitor;+import org.apache.wicket.util.visit.Visit;+import org.slf4j.Logger;+import org.slf4j.LoggerFactory;++import io.onedev.server.util.ComponentContext;+++/**+ * Component serves as the highest level abstract base class for all components.+ *+ * <ul>+ * <li><b>Identity </b>- All Components must have a non-null id which is retrieved by calling+ * getId(). The id must be unique within the {@link MarkupContainer} that holds the Component, but+ * does not have to be globally unique or unique within a Page's component hierarchy.</li>+ * <li><b>Hierarchy </b>- A component has a parent which can be retrieved with {@link #getParent()}.+ * If a component is an instance of MarkupContainer, it may have children. In this way it has a+ * place in the hierarchy of components contained on a given page.+ * <p>+ * The path from the Page at the root of the component hierarchy to a given Component is simply the+ * concatenation with colon separators of each id along the way. For example, the path "a:b:c" would+ * refer to the component named "c" inside the MarkupContainer named "b" inside the container named+ * "a". The path to a component can be retrieved by calling {@link #getPath()}. To get a Component+ * path relative to the page that contains it, you can call {@link #getPageRelativePath()}.</li>+ * <li><b>LifeCycle </b>- Components participate in the following lifecycle phases:+ * <ul>+ * <li><b>Construction </b>- A Component is constructed with the Java language new operator.+ * Children may be added during construction if the Component is a MarkupContainer.+ * {@link IComponentInstantiationListener}s are notified of component instantiation.+ * <p>+ * {@link #onInitialize()} is called on the component as soon as the component is part of a page's+ * component tree. At this state the component is able to access its markup.</li>+ * <li><b>Request Handling </b>- An incoming request is processed by a protocol request handler such+ * as {@link WicketFilter}. An associated Application object creates {@link Session},+ * {@link Request} and {@link Response} objects for use by a given Component in updating its model+ * and rendering a response. These objects are stored inside a container called {@link RequestCycle}+ * which is accessible via {@link Component#getRequestCycle()}. The convenience methods+ * {@link Component#getRequest()}, {@link Component#getResponse()} and+ * {@link Component#getSession()} provide easy access to the contents of this container.</li>+ * <li><b>Listener Invocation </b>- If the request references an {@link IRequestListener} on an+ * existing Component (or one of its {@link Behavior}s, see below), that listener is notified,+ * allowing arbitrary user code to handle events such as link clicks or form submits. Although+ * arbitrary listeners are supported in Wicket, the need to implement a new class of listener is+ * unlikely for a web application and even the need to implement a listener interface directly is+ * highly discouraged. Instead, calls to listeners are routed through logic specific to the event,+ * resulting in calls to user code through other overridable methods. See {@link Form} for an+ * example of a component which listens for events via {@link IFormSubmitListener}.</li>+ * <li><b>Rendering </b>- Before a page or part of a page (in case of Ajax updates) is rendered, all+ * containing components are able to prepare for rendering via two hook methods:+ * {@link #onConfigure()} (regardless whether they are visible or not) and {@link #onBeforeRender()}+ * (if visible only) . <br>+ * A markup response is generated by the Component via {@link Component#render()}, which calls+ * subclass implementation code contained in {@link Component#onRender()}. Once this phase begins, a+ * Component becomes immutable. Attempts to alter the Component will result in a+ * WicketRuntimeException.</li>+ * <li><b>Detachment </b>- Each request cycle finishes by detaching all touched components.+ * Subclasses should clean up their state by overriding {@link #onDetach()} or more specifically+ * {@link #detachModels()} if they keep references to models beside the default model.</li>+ * </ul>+ * </li>+ * <li><b>Visibility </b>- If a component is not visible (see {@link #setVisible(boolean)}) it will+ * not render a response (nor will their children).</li>+ * <li><b>Enabling </b>- Component subclasses take into account their enabled state (see+ * {@link #setEnabled(boolean)} when rendering, and in case of a {@link FormComponent} will not not+ * update its model while the request is handled.</li>+ * <li><b>Models </b>- The primary responsibility of a component is to use its model (an object that+ * implements {@link IModel}) to render a response in an appropriate markup language, such as HTML.+ * In addition, {@link FormComponent}s know how to update their models based on request information,+ * see {@link FormComponent#updateModel()}. Since the IModel interface is a wrapper around another+ * object, a convenience method {@link Component#getDefaultModelObject()} is provided to retrieve+ * the object from its IModel wrapper. A further convenience method,+ * {@link Component#getDefaultModelObjectAsString()}, is provided for the very common operation of+ * converting the wrapped object to a String. <br>+ * The component's model can be passed in the constructor or set via+ * {@link Component#setDefaultModel(IModel)}. In neither case a model can be created on demand with+ * {@link #initModel()}.<br>+ * Note that a component can have more models besides its default model.</li>+ * <li><b>Behaviors </b>- You can add multiple {@link Behavior}s to any component if you need to+ * dynamically alter the behavior of components, e.g. manipulate attributes of the markup tag to+ * which a Component is attached. Behaviors take part in the component's lifecycle through various+ * callback methods.</li>+ * <li><b>Locale </b>- The Locale for a Component is available through {@link #getLocale()}, which+ * delegates to its parent's locale, finally consulting the {@link Session}'s locale.</li>+ * <li><b>Style </b>- The Session's style ("skin") is available through+ * {@link org.apache.wicket.Component#getStyle()}. Styles are intended to give a particular look to+ * all components or resources in a session that is independent of its Locale. For example, a style+ * might be a set of resources, including images and markup files, which gives the design look of+ * "ocean" to the user. If the Session's style is set to "ocean" and these resources are given names+ * suffixed with "_ocean", Wicket's resource management logic will prefer these resources to other+ * resources, such as default resources, which are not as good of a match.</li>+ * <li><b>Variation </b>- Whereas styles are Session (user) specific, variations are component+ * specific. E.g. if the Style is "ocean" and {@link #getVariation()} returnss "NorthSea", than the+ * resources are given the names suffixed with "_ocean_NorthSea".</li>+ * <li><b>String Resources </b>- Components can have associated String resources via the+ * Application's Localizer, which is available through the method {@link Component#getLocalizer()}.+ * The convenience methods {@link Component#getString(String key)} and+ * {@link Component#getString(String key, IModel model)} wrap the identical methods on the+ * Application Localizer for easy access in Components.</li>+ * <li><b>Feedback Messages </b>- The {@link Component#debug(Serializable)},+ * {@link Component#info(Serializable)}, {@link Component#warn(Serializable)},+ * {@link Component#error(java.io.Serializable)} and {@link Component#fatal(Serializable)} methods+ * associate feedback messages with a Component. It is generally not necessary to use these methods+ * directly since Wicket validators automatically register feedback messages on Components. Feedback+ * message for a given Component can be retrieved with {@link Component#getFeedbackMessages}.</li>+ * <li><b>Versioning </b>- Pages are the unit of versioning in Wicket, but fine-grained control of+ * which Components should participate in versioning is possible via the+ * {@link Component#setVersioned(boolean)} method. The versioning participation of a given Component+ * can be retrieved with {@link Component#isVersioned()}.</li>+ * <li><b>Page </b>- The Page containing any given Component can be retrieved by calling+ * {@link Component#getPage()}. If the Component is not attached to a Page, an IllegalStateException+ * will be thrown. An equivalent method, {@link Component#findPage()} is available for special+ * circumstances where it might be desirable to get a null reference back instead.</li>+ * <li><b>Application </b>- The {@link #getApplication()} method provides convenient access to the+ * {@link Application} for a Component.</li>+ * <li><b>AJAX support</b>- Components can be re-rendered after the whole Page has been rendered at+ * least once by calling doRender().</li>+ * <li><b>Security </b>- All components are subject to an {@link IAuthorizationStrategy} which+ * controls instantiation, visibility and enabling. See {@link SimplePageAuthorizationStrategy} for+ * a simple implementation.</li>+ *+ * @author Jonathan Locke+ * @author Chris Turner+ * @author Eelco Hillenius+ * @author Johan Compagner+ * @author Juergen Donnerstag+ * @author Igor Vaynberg (ivaynberg)+ */+@SuppressWarnings("unused")+public abstract class Component+ implements+ IClusterable,+ IConverterLocator,+ IRequestableComponent,+ IHeaderContributor,+ IHierarchical<Component>,+ IEventSink,+ IEventSource+{+ /** Log. */+ private static final Logger log = LoggerFactory.getLogger(Component.class);++ private static final long serialVersionUID = 1L;++ /**+ * Action used with IAuthorizationStrategy to determine whether a component is allowed to be+ * enabled.+ * <p>+ * If enabling is authorized, a component may decide by itself (typically using it's enabled+ * property) whether it is enabled or not. If enabling is not authorized, the given component is+ * marked disabled, regardless its enabled property.+ * <p>+ * When a component is not allowed to be enabled (in effect disabled through the implementation+ * of this interface), Wicket will try to prevent model updates too. This is not completely fail+ * safe, as constructs like:+ *+ * <pre>+ *+ * User u = (User)getModelObject();+ * u.setName("got you there!");+ *+ * </pre>+ *+ * can't be prevented. Indeed it can be argued that any model protection is best dealt with in+ * your model objects to be completely secured. Wicket will catch all normal framework-directed+ * use though.+ */+ public static final Action ENABLE = new Action(Action.ENABLE);++ /** Separator for component paths */+ public static final char PATH_SEPARATOR = ':';+ /** Path segment that represents this component's parent */+ public static final String PARENT_PATH = "..";++ /**+ * Action used with IAuthorizationStrategy to determine whether a component and its children are+ * allowed to be rendered.+ * <p>+ * There are two uses for this method:+ * <ul>+ * <li>The 'normal' use is for controlling whether a component is rendered without having any+ * effect on the rest of the processing. If a strategy lets this method return 'false', then the+ * target component and its children will not be rendered, in the same fashion as if that+ * component had visibility property 'false'.</li>+ * <li>The other use is when a component should block the rendering of the whole page. So+ * instead of 'hiding' a component, what we generally want to achieve here is that we force the+ * user to logon/give-credentials for a higher level of authorization. For this functionality,+ * the strategy implementation should throw a {@link AuthorizationException}, which will then be+ * handled further by the framework.</li>+ * </ul>+ * </p>+ */+ public static final Action RENDER = new Action(Action.RENDER);++ /** meta data for user specified markup id */+ private static final MetaDataKey<String> MARKUP_ID_KEY = new MetaDataKey<String>()+ {+ private static final long serialVersionUID = 1L;+ };++ /** meta data for user specified markup id */+ private static final MetaDataKey<FeedbackMessages> FEEDBACK_KEY = new MetaDataKey<FeedbackMessages>()+ {+ private static final long serialVersionUID = 1L;+ };+++ /** Basic model IModelComparator implementation for normal object models */+ private static final IModelComparator defaultModelComparator = new IModelComparator()+ {+ private static final long serialVersionUID = 1L;++ @Override+ public boolean compare(Component component, Object b)+ {+ final Object a = component.getDefaultModelObject();+ if (a == null && b == null)+ {+ return true;+ }+ if (a == null || b == null)+ {+ return false;+ }+ return a.equals(b);+ }+ };++ /** an unused flag */+ private static final int FLAG_UNUSED0 = 0x20000000;+ private static final int FLAG_UNUSED1 = 0x800000;+ private static final int FLAG_UNUSED2 = 0x1000000;+ private static final int FLAG_UNUSED3 = 0x10000000;++ /** True when a component is being auto-added */+ private static final int FLAG_AUTO = 0x0001;++ /** Flag for escaping HTML in model strings */+ private static final int FLAG_ESCAPE_MODEL_STRINGS = 0x0002;++ /** Boolean whether this component's model is inheritable. */+ static final int FLAG_INHERITABLE_MODEL = 0x0004;++ /** Versioning boolean */+ private static final int FLAG_VERSIONED = 0x0008;++ /** Visibility boolean */+ private static final int FLAG_VISIBLE = 0x0010;++ /** Render tag boolean */+ private static final int FLAG_RENDER_BODY_ONLY = 0x0020;++ /** Ignore attribute modifiers */+ private static final int FLAG_IGNORE_ATTRIBUTE_MODIFIER = 0x0040;++ /** True when a component is enabled for model updates and is reachable. */+ private static final int FLAG_ENABLED = 0x0080;++ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED1 = 0x0100;+ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED2 = 0x0200;+ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED3 = 0x0400;+ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED4 = 0x0800;++ /** Boolean whether this component was rendered at least once for tracking changes. */+ private static final int FLAG_HAS_BEEN_RENDERED = 0x1000;++ /**+ * Internal indicator of whether this component may be rendered given the current context's+ * authorization. It overrides the visible flag in case this is false. Authorization is done+ * before trying to render any component (otherwise we would end up with a half rendered page in+ * the buffer)+ */+ private static final int FLAG_IS_RENDER_ALLOWED = 0x2000;++ /** Whether or not the component should print out its markup id into the id attribute */+ private static final int FLAG_OUTPUT_MARKUP_ID = 0x4000;++ /**+ * Output a placeholder tag if the component is not visible. This is useful in ajax mode to go+ * to visible(false) to visible(true) without the overhead of repainting a visible parent+ * container+ */+ private static final int FLAG_PLACEHOLDER = 0x8000;++ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED5 = 0x10000;+ /** onInitialize called */+ protected static final int FLAG_INITIALIZED = 0x20000;+ /** Set when a component is removed from the hierarchy */+ private static final int FLAG_REMOVED = 0x40000;+ /** Reserved subclass-definable flag bit */+ protected static final int FLAG_RESERVED8 = 0x80000;++ /**+ * Flag that determines whether the model is set. This is necessary because of the way we+ * represent component state ({@link #data}). We can't distinguish between model and behavior+ * using instanceof, because one object can implement both interfaces. Thus we need this flag -+ * when the flag is set, first object in {@link #data} is always model.+ */+ private static final int FLAG_MODEL_SET = 0x100000;++ /** True when a component is being removed from the hierarchy */+ protected static final int FLAG_REMOVING_FROM_HIERARCHY = 0x200000;++ /**+ * Flag that makes we are in before-render callback phase Set after component.onBeforeRender is+ * invoked (right before invoking beforeRender on children)+ */+ protected static final int FLAG_RENDERING = 0x2000000;+ protected static final int FLAG_PREPARED_FOR_RENDER = 0x4000000;+ protected static final int FLAG_AFTER_RENDERING = 0x8000000;++ /**+ * Flag that restricts visibility of a component when set to true. This is usually used when a+ * component wants to restrict visibility of another component. Calling+ * {@link #setVisible(boolean)} on a component does not always have the desired effect because+ * isVisible() can be overwritten thus this flag offers an alternative that should always work.+ */+ private static final int FLAG_VISIBILITY_ALLOWED = 0x40000000;++ private static final int FLAG_DETACHING = 0x80000000;++ /**+ * The name of attribute that will hold markup id+ */+ private static final String MARKUP_ID_ATTR_NAME = "id";++ /**+ * Meta data key for line precise error logging for the moment of addition. Made package private+ * for access in {@link MarkupContainer} and {@link Page}+ */+ static final MetaDataKey<String> ADDED_AT_KEY = new MetaDataKey<String>()+ {+ private static final long serialVersionUID = 1L;+ };++ /**+ * meta data key for line precise error logging for the moment of construction. Made package+ * private for access in {@link Page}+ */+ static final MetaDataKey<String> CONSTRUCTED_AT_KEY = new MetaDataKey<String>()+ {+ private static final long serialVersionUID = 1L;+ };++ /** Component flags. See FLAG_* for possible non-exclusive flag values. */+ private int flags = FLAG_VISIBLE | FLAG_ESCAPE_MODEL_STRINGS | FLAG_VERSIONED | FLAG_ENABLED |+ FLAG_IS_RENDER_ALLOWED | FLAG_VISIBILITY_ALLOWED | FLAG_RESERVED5 /* page's stateless hint */;++ private static final short RFLAG_ENABLED_IN_HIERARCHY_VALUE = 0x1;+ private static final short RFLAG_ENABLED_IN_HIERARCHY_SET = 0x2;+ private static final short RFLAG_VISIBLE_IN_HIEARARCHY_VALUE = 0x4;+ private static final short RFLAG_VISIBLE_IN_HIERARCHY_SET = 0x8;+ /** onconfigure has been called */+ private static final short RFLAG_CONFIGURED = 0x10;+ private static final short RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED = 0x20;+ private static final short RFLAG_INITIALIZE_SUPER_CALL_VERIFIED = 0x40;+ protected static final short RFLAG_CONTAINER_DEQUEING = 0x80;+ private static final short RFLAG_ON_RE_ADD_SUPER_CALL_VERIFIED = 0x100;++ /**+ * Flags that only keep their value during the request. Useful for cache markers, etc. At the+ * end of the request the value of this variable is reset to 0+ */+ private transient short requestFlags = 0;++ /** Component id. */+ private String id;++ /** Any parent container. */+ private MarkupContainer parent;++ /**+ * Instead of remembering the whole markupId, we just remember the number for this component so+ * we can "reconstruct" the markupId on demand. While this could be part of {@link #data},+ * profiling showed that having it as separate property consumes less memory.+ */+ int generatedMarkupId = -1;++ /** Must only be used by auto components */+ private transient IMarkupFragment markup;++ /**+ * Will be re-created instead of persisted when session is replicated. Markup sourcing strategy+ * are typically stateless (but don't have to).+ */+ private transient IMarkupSourcingStrategy markupSourcingStrategy;++ /**+ * The object that holds the component state.+ * <p>+ * What's stored here depends on what attributes are set on component. Data can contains+ * combination of following attributes:+ * <ul>+ * <li>Model (indicated by {@link #FLAG_MODEL_SET})+ * <li>MetaDataEntry (optionally {@link MetaDataEntry}[] if more metadata entries are present) *+ * <li>{@link Behavior}(s) added to component. The behaviors are not stored in separate array,+ * they are part of the {@link #data} array (this is in order to save the space of the pointer+ * to an empty array as most components have no behaviours). - FIXME - explain why - is this+ * correct?+ * </ul>+ * If there is only one attribute set (i.e. model or MetaDataEntry([]) or one behavior), the+ * #data object points directly to value of that attribute. Otherwise the data is of type+ * Object[] where the attributes are ordered as specified above.+ * <p>+ */+ Object data = null;++ final int data_start()+ {+ return getFlag(FLAG_MODEL_SET) ? 1 : 0;+ }++ final int data_length()+ {+ if (data == null)+ {+ return 0;+ }+ else if (data instanceof Object[] && !(data instanceof MetaDataEntry<?>[]))+ {+ return ((Object[])data).length;+ }+ else+ {+ return 1;+ }+ }++ final Object data_get(int index)+ {+ if (data == null)+ {+ return null;+ }+ else if (data instanceof Object[] && !(data instanceof MetaDataEntry<?>[]))+ {+ Object[] array = (Object[])data;+ return index < array.length ? array[index] : null;+ }+ else if (index == 0)+ {+ return data;+ }+ else+ {+ return null;+ }+ }++ final void data_set(int index, Object object)+ {+ if (index > data_length() - 1)+ {+ throw new IndexOutOfBoundsException("can not set data at " + index ++ " when data_length() is " + data_length());+ }+ else if (index == 0 && !(data instanceof Object[] && !(data instanceof MetaDataEntry<?>[])))+ {+ data = object;+ }+ else+ {+ Object[] array = (Object[])data;+ array[index] = object;+ }+ }++ final void data_add(Object object)+ {+ data_insert(-1, object);+ }++ final void data_insert(int position, Object object)+ {+ int currentLength = data_length();+ if (position == -1)+ {+ position = currentLength;+ }+ if (position > currentLength)+ {+ throw new IndexOutOfBoundsException("can not insert data at " + position ++ " when data_length() is " + currentLength);+ }+ if (currentLength == 0)+ {+ data = object;+ }+ else if (currentLength == 1)+ {+ Object[] array = new Object[2];+ if (position == 0)+ {+ array[0] = object;+ array[1] = data;+ }+ else+ {+ array[0] = data;+ array[1] = object;+ }+ data = array;+ }+ else+ {+ Object[] array = new Object[currentLength + 1];+ Object[] current = (Object[])data;+ int after = currentLength - position;+ if (position > 0)+ {+ System.arraycopy(current, 0, array, 0, position);+ }+ array[position] = object;+ if (after > 0)+ {+ System.arraycopy(current, position, array, position + 1, after);+ }+ data = array;+ }+ }++ final void data_remove(int position)+ {+ int currentLength = data_length();++ if (position > currentLength - 1)+ {+ throw new IndexOutOfBoundsException();+ }+ else if (currentLength == 1)+ {+ data = null;+ }+ else if (currentLength == 2)+ {+ Object[] current = (Object[])data;+ if (position == 0)+ {+ data = current[1];+ }+ else+ {+ data = current[0];+ }+ }+ else+ {+ Object[] current = (Object[])data;+ data = new Object[currentLength - 1];++ if (position > 0)+ {+ System.arraycopy(current, 0, data, 0, position);+ }+ if (position != currentLength - 1)+ {+ final int left = currentLength - position - 1;+ System.arraycopy(current, position + 1, data, position, left);+ }+ }+ }++ /**+ * Constructor. All components have names. A component's id cannot be null. This is the minimal+ * constructor of component. It does not register a model.+ *+ * @param id+ * The non-null id of this component+ * @throws WicketRuntimeException+ * Thrown if the component has been given a null id.+ */+ public Component(final String id)+ {+ this(id, null);+ }++ /**+ * Constructor. All components have names. A component's id cannot be null. This constructor+ * includes a model.+ *+ * @param id+ * The non-null id of this component+ * @param model+ * The component's model+ *+ * @throws WicketRuntimeException+ * Thrown if the component has been given a null id.+ */+ public Component(final String id, final IModel<?> model)+ {+ setId(id);++ init();++ getApplication().getComponentInstantiationListeners().onInstantiation(this);++ final DebugSettings debugSettings = getApplication().getDebugSettings();+ if (debugSettings.isLinePreciseReportingOnNewComponentEnabled() && debugSettings.getComponentUseCheck())+ {+ setMetaData(CONSTRUCTED_AT_KEY,+ ComponentStrings.toString(this, new MarkupException("constructed")));+ }++ if (model != null)+ {+ setModelImpl(wrap(model));+ }+ }++ /**+ * Let subclasses initialize this instance, before constructors are executed. <br>+ * This method is intentionally <b>not</b> declared protected, to limit overriding to classes in+ * this package.+ */+ void init()+ {+ }++ /**+ * Get the Markup associated with the Component. If not subclassed, the parent container is+ * asked to return the markup of this child component.+ * <p/>+ * Components like Panel and Border should return the "calling" markup fragment, e.g.+ * <code><span wicket:id="myPanel">body</span></code>. You may use+ * Panel/Border/Enclosure.getMarkup(null) to return the associated markup file. And+ * Panel/Border/Enclosure.getMarkup(child) will search the child in the appropriate markup+ * fragment.+ *+ * @see MarkupContainer#getMarkup(Component)+ *+ * @return The markup fragment+ */+ public IMarkupFragment getMarkup()+ {+ // Markup already determined or preset?+ if (markup != null)+ {+ return markup;+ }++ // No parent, than check associated markup files+ if (parent == null)+ {+ // Must be a MarkupContainer to have associated markup file+ if (this instanceof MarkupContainer)+ {+ MarkupContainer container = (MarkupContainer)this;+ Markup associatedMarkup = container.getAssociatedMarkup();+ if (associatedMarkup != null)+ {+ markup = associatedMarkup;+ return markup;+ }+ }++ // Don't know how to find the markup+ throw new MarkupNotFoundException(+ "Can not determine Markup. Component is not yet connected to a parent. " ++ toString());+ }++ // Ask the parent for find the markup for me+ markup = parent.getMarkup(this);+ return markup;+ }++ /**+ * @return The 'id' attribute from the associated markup tag+ */+ public final String getMarkupIdFromMarkup()+ {+ ComponentTag tag = getMarkupTag();+ if (tag != null)+ {+ String id = tag.getAttribute("id");+ if (Strings.isEmpty(id) == false)+ {+ return id.trim();+ }+ }++ return null;+ }++ /**+ * Set the markup for the component. Note that the component's markup variable is transient and+ * thus must only be used for one render cycle. E.g. auto-component are using it. You may also+ * it if you subclassed getMarkup().+ *+ * @param markup+ */+ public final Component setMarkup(final IMarkupFragment markup)+ {+ this.markup = markup;+ return this;+ }++ /**+ * Called once per request on components before they are about to be rendered. This method+ * should be used to configure such things as visibility and enabled flags.+ * <p>+ * Overrides must call {@code super.onConfigure()}, usually before any other code+ * <p>+ * NOTE: Component hierarchy should not be modified inside this method, instead it should be+ * done in {@link #onBeforeRender()}+ * <p>+ * NOTE: Why this method is preferrable to directly overriding {@link #isVisible()} and+ * {@link #isEnabled()}? Because those methods are called multiple times even for processing of+ * a single request. If they contain expensive logic they can slow down the response time of the+ * entire page. Further, overriding those methods directly on form components may lead to+ * inconsistent or unexpected state depending on when those methods are called in the form+ * processing workflow. It is a better practice to push changes to state rather than pull.+ * <p>+ * NOTE: If component's visibility or another property depends on another component you may call+ * {@code other.configure()} followed by {@code other.isVisible()} as mentioned in+ * {@link #configure()} javadoc.+ * <p>+ * NOTE: Why should {@link #onBeforeRender()} not be used for this? Because if a component's+ * visibility is controlled inside {@link #onBeforeRender()}, once invisible the component will+ * never become visible again.+ */+ protected void onConfigure()+ {+ }++ /**+ * This method is meant to be used as an alternative to initialize components. Usually the+ * component's constructor is used for this task, but sometimes a component cannot be+ * initialized in isolation, it may need to access its parent component or its markup in order+ * to fully initialize. This method is invoked once per component's lifecycle when a path exists+ * from this component to the {@link Page} thus providing the component with an atomic callback+ * when the component's environment is built out.+ * <p>+ * Overrides must call super#{@link #onInitialize()}. Usually this should be the first thing an+ * override does, much like a constructor.+ * </p>+ * <p>+ * Parent containers are guaranteed to be initialized before their children+ * </p>+ *+ * <p>+ * It is safe to use {@link #getPage()} in this method+ * </p>+ *+ * <p>+ * NOTE:The timing of this call is not precise, the contract is that it is called sometime+ * before {@link Component#onBeforeRender()}.+ * </p>+ *+ */+ protected void onInitialize()+ {+ setRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED, true);+ }++ /**+ * Checks if the component has been initialized - {@link #onInitialize()} has been called+ *+ * @return {@code true} if component has been initialized+ */+ final boolean isInitialized()+ {+ return getFlag(FLAG_INITIALIZED);+ }++ /**+ * THIS METHOD IS NOT PART OF THE PUBLIC API, DO NOT CALL IT+ *+ * Used to call {@link #onInitialize()}+ */+ public void internalInitialize()+ {+ fireInitialize();+ }++ /**+ * Used to call {@link #onInitialize()}+ */+ final void fireInitialize()+ {+ ComponentContext.push(new ComponentContext(this));+ try {+ if (!getFlag(FLAG_INITIALIZED))+ {+ setFlag(FLAG_INITIALIZED, true);+ setRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED, false);+ onInitialize();+ if (!getRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly initialized. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onInitialize() in the override of onInitialize() method");+ }+ setRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED, false);++ getApplication().getComponentInitializationListeners().onInitialize(this);+ }+ else if (getFlag(FLAG_REMOVED))+ {+ setFlag(FLAG_REMOVED, false);+ setRequestFlag(RFLAG_ON_RE_ADD_SUPER_CALL_VERIFIED, false);+ onReAdd();+ if (!getRequestFlag(RFLAG_ON_RE_ADD_SUPER_CALL_VERIFIED))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly added. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onReAdd() in the override of onReAdd() method");+ }+ }+ } finally {+ ComponentContext.pop();+ }+ }++ /**+ * Called on every component after the page is rendered. It will call onAfterRender for it self+ * and its children.+ */+ public final void afterRender()+ {+ try+ {+ setFlag(FLAG_AFTER_RENDERING, true);++ // always detach children because components can be attached+ // independently of their parents+ onAfterRenderChildren();++ onAfterRender();+ getApplication().getComponentOnAfterRenderListeners().onAfterRender(this);+ if (getFlag(FLAG_AFTER_RENDERING))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly detached. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onAfterRender() in the override of onAfterRender() method");+ }+ }+ finally+ {+ // this flag must always be set to false.+ markRendering(false);+ }+ }++ /**+ *+ */+ private void internalBeforeRender()+ {+ configure();++ if ((determineVisibility()) && !getFlag(FLAG_RENDERING) &&+ !getFlag(FLAG_PREPARED_FOR_RENDER))+ {+ setRequestFlag(RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED, false);++ getApplication().getComponentPreOnBeforeRenderListeners().onBeforeRender(this);++ onBeforeRender();+ getApplication().getComponentPostOnBeforeRenderListeners().onBeforeRender(this);++ if (!getRequestFlag(RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly rendered. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onBeforeRender() in the override of onBeforeRender() method");+ }+ }+ }++ /**+ * We need to postpone calling beforeRender() on components that implement {@link IFeedback}, to+ * be sure that all other component's beforeRender() has been already called, so that IFeedbacks+ * can collect all feedback messages. This is the key under list of postponed {@link IFeedback}+ * is stored to request cycle metadata. The List is then iterated over in+ * {@link #prepareForRender()} after calling {@link #beforeRender()}, to initialize postponed+ * components.+ */+ private static final MetaDataKey<List<Component>> FEEDBACK_LIST = new MetaDataKey<List<Component>>()+ {+ private static final long serialVersionUID = 1L;+ };++ /**+ * Called for every component when the page is getting to be rendered. it will call+ * {@link #configure()} and {@link #onBeforeRender()} for this component and all the child+ * components+ */+ public final void beforeRender()+ {+ ComponentContext.push(new ComponentContext(this));+ try {+ if (this instanceof IFeedback)+ {+ // this component is a feedback. Feedback must be initialized last, so that+ // they can collect messages from other components+ List<Component> feedbacks = getRequestCycle().getMetaData(FEEDBACK_LIST);+ if (feedbacks == null)+ {+ feedbacks = new ArrayList<Component>();+ getRequestCycle().setMetaData(FEEDBACK_LIST, feedbacks);+ }++ if (this instanceof MarkupContainer)+ {+ ((MarkupContainer)this).visitChildren(IFeedback.class,+ new IVisitor<Component, Void>()+ {+ @Override+ public void component(Component feedback, IVisit<Void> visit)+ {+ feedback.beforeRender();++ // don't need to go deeper,+ // as the feedback will visit its children on its own+ visit.dontGoDeeper();+ }+ });+ }++ if (!feedbacks.contains(this))+ {+ feedbacks.add(this);+ }+ }+ else+ {+ internalBeforeRender();+ }+ } finally {+ ComponentContext.pop();+ }+ }++ /**+ * Triggers {@link #onConfigure()} to be invoked on this component if it has not already during+ * this request.+ * <p>+ * This method should be invoked before any calls to {@link #isVisible()} or+ * {@link #isEnabled()}. Usually this method will be called by the framework before the+ * component is rendered and so users should not need to call it; however, in cases where+ * visibility or enabled or other state of one component depends on the state of another this+ * method should be manually invoked on the other component by the user. EG to link visiliby of+ * two markup containers the following should be done:+ *+ * <pre>+ * final WebMarkupContainer source=new WebMarkupContainer("a") {+ * protected void onConfigure() {+ * setVisible(Math.rand()>0.5f);+ * }+ * };+ *+ * WebMarkupContainer linked=new WebMarkupContainer("b") {+ * protected void onConfigure() {+ * source.configure(); // make sure source is configured+ * setVisible(source.isVisible());+ * }+ * }+ * </pre>+ *+ * </p>+ */+ public final void configure()+ {+ if (!getRequestFlag(RFLAG_CONFIGURED))+ {+ clearEnabledInHierarchyCache();+ clearVisibleInHierarchyCache();+ onConfigure();+ for (Behavior behavior : getBehaviors())+ {+ if (isBehaviorAccepted(behavior))+ {+ behavior.onConfigure(this);+ }+ }++ // check authorization+ setRenderAllowed();++ internalOnAfterConfigure();++ getApplication().getComponentOnConfigureListeners().onConfigure(this);++ setRequestFlag(RFLAG_CONFIGURED, true);+ }+ }++ /**+ *+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * Called after the {@link #onConfigure()}, but before {@link #onBeforeRender()}+ */+ void internalOnAfterConfigure()+ {+ }++ /**+ * Redirects to any intercept page previously specified by a call to {@link #redirectToInterceptPage(Page)}.+ * The redirect is done by throwing an exception. If there is no intercept page no exception+ * will be thrown and the program flow will continue uninterrupted.+ *+ * Example:+ *+ * <pre>+ * add(new Link("login")+ * {+ * protected void onClick()+ * {+ * if (authenticate())+ * {+ * continueToOriginalDestination();+ * // if we reach this line there was no intercept page, so go to home page+ * setResponsePage(WelcomePage.class);+ * }+ * }+ * });+ *+ * @see Component#redirectToInterceptPage(Page)+ */+ public final void continueToOriginalDestination()+ {+ RestartResponseAtInterceptPageException.continueToOriginalDestination();+ }++ /**+ * Clears any data about previously intercepted page.+ */+ public final void clearOriginalDestination()+ {+ RestartResponseAtInterceptPageException.clearOriginalDestination();+ }++ /**+ * Registers a debug feedback message for this component+ *+ * @param message+ * The feedback message+ */+ public final void debug(final Serializable message)+ {+ getFeedbackMessages().debug(this, message);+ addStateChange();+ }++ /**+ * Signals this Component that it is removed from the Component hierarchy.+ */+ final void internalOnRemove()+ {+ setFlag(FLAG_REMOVING_FROM_HIERARCHY, true);+ onRemove();+ setFlag(FLAG_REMOVED, true);+ if (getFlag(FLAG_REMOVING_FROM_HIERARCHY))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly removed from hierachy. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onRemove() in the override of onRemove() method");+ }+ new Behaviors(this).onRemove(this);+ removeChildren();+ }++ /**+ * Detaches the component. This is called at the end of the request for all the pages that are+ * touched in that request.+ */+ @Override+ public final void detach()+ {+ try+ {+ setFlag(FLAG_DETACHING, true);+ onDetach();+ if (getFlag(FLAG_DETACHING))+ {+ throw new IllegalStateException(Component.class.getName() ++ " has not been properly detached. Something in the hierarchy of " ++ getClass().getName() ++ " has not called super.onDetach() in the override of onDetach() method");+ }++ // always detach models because they can be attached without the+ // component. eg component has a compoundpropertymodel and one of its+ // children component's getmodelobject is called+ detachModels();++ // detach any behaviors+ new Behaviors(this).detach();+ }+ catch (Exception x)+ {+ throw new WicketRuntimeException("An error occurred while detaching component: " + toString(true), x);+ }++ // always detach children because components can be attached+ // independently of their parents+ detachChildren();++ // reset the model to null when the current model is a IWrapModel and+ // the model that created it/wrapped in it is a IComponentInheritedModel+ // The model will be created next time.+ if (getFlag(FLAG_INHERITABLE_MODEL))+ {+ setModelImpl(null);+ setFlag(FLAG_INHERITABLE_MODEL, false);+ }++ clearEnabledInHierarchyCache();+ clearVisibleInHierarchyCache();++ boolean beforeRenderSuperCallVerified = getRequestFlag(RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED);+ boolean initializeSuperCallVerified = getRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED);++ requestFlags = 0;++ // preserve the super_call_verified flags if they were set. WICKET-5417+ if (beforeRenderSuperCallVerified)+ {+ setRequestFlag(RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED, true);+ }+ if (initializeSuperCallVerified)+ {+ setRequestFlag(RFLAG_INITIALIZE_SUPER_CALL_VERIFIED, true);+ }++ detachFeedback();++ internalDetach();++ // notify any detach listener+ IDetachListener detachListener = getApplication().getFrameworkSettings()+ .getDetachListener();+ if (detachListener != null)+ {+ detachListener.onDetach(this);+ }+ }++ private void detachFeedback()+ {+ FeedbackMessages feedback = getMetaData(FEEDBACK_KEY);+ if (feedback != null)+ {+ feedback.clear(getApplication().getApplicationSettings()+ .getFeedbackMessageCleanupFilter());++ if (feedback.isEmpty())+ {+ setMetaData(FEEDBACK_KEY, null);+ }+ else+ {+ feedback.detach();+ }+ }+ }++ /**+ * Removes the cached markup at the end of the request. For the next request it will be get+ * either from the parent's markup or from {@link MarkupCache}.+ */+ private void internalDetach()+ {+ markup = null;+ }++ /**+ * Detaches all models+ */+ public void detachModels()+ {+ // Detach any detachable model from this component+ detachModel();+ }++ /**+ * Registers an error feedback message for this component+ *+ * @param message+ * The feedback message+ */+ public final void error(final Serializable message)+ {+ getFeedbackMessages().error(this, message);+ addStateChange();+ }++ /**+ * Registers a fatal feedback message for this component+ *+ * @param message+ * The feedback message+ */+ public final void fatal(final Serializable message)+ {+ getFeedbackMessages().fatal(this, message);+ addStateChange();+ }++ /**+ * Finds the first container parent of this component of the given class.+ *+ * @param <Z>+ * type of parent+ *+ *+ * @param c+ * MarkupContainer class to search for+ * @return First container parent that is an instance of the given class, or null if none can be+ * found+ */+ public final <Z> Z findParent(final Class<Z> c)+ {+ // Start with immediate parent+ MarkupContainer current = parent;++ // Walk up containment hierarchy+ while (current != null)+ {+ // Is current an instance of this class?+ if (c.isInstance(current))+ {+ return c.cast(current);+ }++ // Check parent+ current = current.getParent();+ }++ // Failed to find component+ return null;+ }++ /**+ * @return The nearest markup container with associated markup+ */+ public final MarkupContainer findParentWithAssociatedMarkup()+ {+ MarkupContainer container = parent;+ while (container != null)+ {+ if (container.getAssociatedMarkup() != null)+ {+ return container;+ }+ container = container.getParent();+ }++ // This should never happen since Page always has associated markup+ throw new WicketRuntimeException("Unable to find parent with associated markup");+ }++ /**+ * Gets interface to application that this component is a part of.+ *+ * @return The application associated with the session that this component is in.+ * @see Application+ */+ public final Application getApplication()+ {+ return Application.get();+ }++ /**+ * @return A path of the form [page-class-name]:[page-relative-path]+ * @see Component#getPageRelativePath()+ */+ public final String getClassRelativePath()+ {+ return getClass().getName() + PATH_SEPARATOR + getPageRelativePath();+ }++ /**+ * Get the converter that should be used by this component, delegates to+ * {@link #createConverter(Class)} and then to the application's+ * {@link IConverterLocator}.+ *+ * @param type+ * The type to convert to+ *+ * @return The converter that should be used by this component+ */+ @SuppressWarnings("unchecked")+ @Override+ public <C> IConverter<C> getConverter(Class<C> type) {+ IConverter<?> converter = createConverter(type);+ if (converter != null) {+ return (IConverter<C>) converter;+ }+ return getApplication().getConverterLocator().getConverter(type);+ }++ /**+ * Factory method for converters to be used by this component,+ * returns {@code null} by default.+ *+ * @param type+ * The type to convert to+ *+ * @return a converter to be used by this component+ */+ protected IConverter<?> createConverter(Class<?> type) {+ return null;+ }++ /**+ * Gets whether model strings should be escaped.+ *+ * @return Returns whether model strings should be escaped+ */+ public final boolean getEscapeModelStrings()+ {+ return getFlag(FLAG_ESCAPE_MODEL_STRINGS);+ }++ /**+ * Gets the id of this component.+ *+ * @return The id of this component+ */+ @Override+ public String getId()+ {+ return id;+ }++ /**+ * @return Innermost model for this component+ */+ public final IModel<?> getInnermostModel()+ {+ return getInnermostModel(getDefaultModel());+ }++ /**+ * Gets the locale for this component. By default, it searches its parents for a locale. If no+ * parents (it's a recursive search) returns a locale, it gets one from the session.+ *+ * @return The locale to be used for this component+ * @see Session#getLocale()+ */+ public Locale getLocale()+ {+ if (parent != null)+ {+ return parent.getLocale();+ }+ return getSession().getLocale();+ }++ /**+ * Convenience method to provide easy access to the localizer object within any component.+ *+ * @return The localizer object+ */+ public final Localizer getLocalizer()+ {+ return getApplication().getResourceSettings().getLocalizer();+ }++ /**+ * Get the first component tag in the associated markup+ *+ * @return first component tag+ */+ private ComponentTag getMarkupTag()+ {+ IMarkupFragment markup = getMarkup();+ if (markup != null)+ {+ for (int i = 0; i < markup.size(); i++)+ {+ MarkupElement elem = markup.get(i);+ if (elem instanceof ComponentTag)+ {+ return (ComponentTag)elem;+ }+ }+ }+ return null;+ }++ /**+ * THIS IS WICKET INTERNAL ONLY. DO NOT USE IT.+ *+ * Get a copy of the markup's attributes which are associated with the component.+ * <p>+ * Modifications to the map returned don't change the tags attributes. It is just a copy.+ * <p>+ * Note: The component must have been added (directly or indirectly) to a container with an+ * associated markup file (Page, Panel or Border).+ *+ * @return markup attributes+ */+ public final ValueMap getMarkupAttributes()+ {+ ComponentTag tag = getMarkupTag();+ if (tag != null)+ {+ ValueMap attrs = new ValueMap(tag.getAttributes());+ attrs.makeImmutable();+ return attrs;+ }+ return ValueMap.EMPTY_MAP;+ }++ /**+ * Get the markupId+ *+ * @return MarkupId+ */+ public final Object getMarkupIdImpl()+ {+ if (generatedMarkupId != -1)+ {+ return generatedMarkupId;+ }++ String id = getMetaData(MARKUP_ID_KEY);++ // if still no markup id is found, and the component has been attached to a page, try to+ // retrieve the id from the markup file.+ if (id == null && findPage() != null)+ {+ id = getMarkupIdFromMarkup();+ }+ return id;+ }++ /**+ * Retrieves id by which this component is represented within the markup. This is either the id+ * attribute set explicitly via a call to {@link #setMarkupId(String)}, id attribute defined in+ * the markup, or an automatically generated id - in that order.+ * <p>+ * If no id is set and <code>createIfDoesNotExist</code> is false, this method will return null.+ * Otherwise it will generate an id value which by default will be unique in the page. This is+ * the preferred way as there is no chance of id collision. This will also enable+ * {@link #setOutputMarkupId(boolean)}.+ * <p>+ *+ * <p>+ * Note: This method should only be called after the component or its parent have been added to+ * the page.+ *+ * @param createIfDoesNotExist+ * When there is no existing markup id, determines whether it should be generated or+ * whether <code>null</code> should be returned.+ *+ * @return markup id of the component+ */+ public String getMarkupId(boolean createIfDoesNotExist)+ {+ IMarkupIdGenerator markupIdGenerator = getApplication().getMarkupSettings().getMarkupIdGenerator();+ String markupId = markupIdGenerator.generateMarkupId(this, createIfDoesNotExist);+ return markupId;+ }++ /**+ * Retrieves id by which this component is represented within the markup. This is either the id+ * attribute set explicitly via a call to {@link #setMarkupId(String)}, id attribute defined in+ * the markup, or an automatically generated id - in that order.+ * <p>+ * If no explicit id is set this function will generate an id value that will be unique in the+ * page. This is the preferred way as there is no chance of id collision. This will also enable+ * {@link #setOutputMarkupId(boolean)}.+ * <p>+ * Note: This method should only be called after the component or its parent have been added to+ * the page.+ *+ * @return markup id of the component+ */+ public String getMarkupId()+ {+ return getMarkupId(true);+ }++ /**+ * Gets metadata for this component using the given key.+ *+ * @param <M>+ * The type of the metadata.+ *+ * @param key+ * The key for the data+ * @return The metadata or null of no metadata was found for the given key+ * @see MetaDataKey+ */+ public final <M extends Serializable> M getMetaData(final MetaDataKey<M> key)+ {+ return key.get(getMetaData());+ }++ /**+ * Gets the meta data entries for this component as an array of {@link MetaDataEntry} objects.+ *+ * @return the meta data entries for this component+ */+ private MetaDataEntry<?>[] getMetaData()+ {+ MetaDataEntry<?>[] metaData = null;++ // index where we should expect the entry+ int index = getFlag(FLAG_MODEL_SET) ? 1 : 0;++ int length = data_length();++ if (index < length)+ {+ Object object = data_get(index);+ if (object instanceof MetaDataEntry<?>[])+ {+ metaData = (MetaDataEntry<?>[])object;+ }+ else if (object instanceof MetaDataEntry)+ {+ metaData = new MetaDataEntry[] { (MetaDataEntry<?>)object };+ }+ }++ return metaData;+ }++ /**+ * Gets the model. It returns the object that wraps the backing model.+ *+ * @return The model+ */+ public final IModel<?> getDefaultModel()+ {+ IModel<?> model = getModelImpl();+ // If model is null+ if (model == null)+ {+ // give subclass a chance to lazy-init model+ model = initModel();+ setModelImpl(model);+ }++ return model;+ }++ /**+ * Gets the backing model object. Unlike getDefaultModel().getObject(), this method returns null+ * for a null model.+ *+ * @return The backing model object+ */+ public final Object getDefaultModelObject()+ {+ final IModel<?> model = getDefaultModel();+ if (model != null)+ {+ try+ {+ // Get model value for this component.+ return model.getObject();+ }+ catch (Exception ex)+ {+ // wrap the exception so that it brings info about the component+ WicketRuntimeException rex = new WicketRuntimeException(+ "An error occurred while getting the model object for Component: " ++ this.toString(true), ex);+ throw rex;+ }+ }+ return null;+ }++ /**+ * Gets a model object as a string. Depending on the "escape model strings" flag of the+ * component, the string is either HTML escaped or not. "HTML escaped" meaning that only HTML+ * sensitive chars are escaped but not all none-ascii chars. Proper HTML encoding should be used+ * instead. In case you really need a fully escaped model string you may call+ * {@link Strings#escapeMarkup(CharSequence, boolean, boolean)} on the model string returned.+ *+ * @see Strings#escapeMarkup(CharSequence, boolean, boolean)+ * @see #getEscapeModelStrings()+ *+ * @return Model object for this component as a string+ */+ public final String getDefaultModelObjectAsString()+ {+ return getDefaultModelObjectAsString(getDefaultModelObject());+ }++ /**+ * Gets a model object as a string. Depending on the "escape model strings" flag of the+ * component, the string is either HTML escaped or not. "HTML escaped" meaning that only HTML+ * sensitive chars are escaped but not all none-ascii chars. Proper HTML encoding should be used+ * instead. In case you really need a fully escaped model string you may call+ * {@link Strings#escapeMarkup(CharSequence, boolean, boolean)} on the model string returned.+ *+ * @see Strings#escapeMarkup(CharSequence, boolean, boolean)+ * @see #getEscapeModelStrings()+ *+ * @param modelObject+ * Model object to convert to string+ * @return The string+ */+ @SuppressWarnings({ "rawtypes", "unchecked" })+ public final String getDefaultModelObjectAsString(final Object modelObject)+ {+ if (modelObject != null)+ {+ // Get converter+ final Class<?> objectClass = modelObject.getClass();++ final IConverter converter = getConverter(objectClass);++ // Model string from property+ final String modelString = converter.convertToString(modelObject, getLocale());++ if (modelString != null)+ {+ // If we should escape the markup+ if (getFlag(FLAG_ESCAPE_MODEL_STRINGS))+ {+ // Escape HTML sensitive characters only. Not all none-ascii chars+ return Strings.escapeMarkup(modelString, false, false).toString();+ }+ return modelString;+ }+ }+ return "";+ }++ /**+ * Gets whether or not component will output id attribute into the markup. id attribute will be+ * set to the value returned from {@link Component#getMarkupId()}.+ *+ * @return whether or not component will output id attribute into the markup+ */+ public final boolean getOutputMarkupId()+ {+ return getFlag(FLAG_OUTPUT_MARKUP_ID);+ }++ /**+ * Gets whether or not an invisible component will render a placeholder tag.+ *+ * @return true if a placeholder tag should be rendered+ */+ public final boolean getOutputMarkupPlaceholderTag()+ {+ return getFlag(FLAG_PLACEHOLDER);+ }++ /**+ * Gets the page holding this component.+ *+ * @return The page holding this component+ * @throws WicketRuntimeException+ * Thrown if component is not yet attached to a Page.+ * @see #findPage()+ */+ @Override+ public final Page getPage()+ {+ // Search for nearest Page+ final Page page = findPage();++ // If no Page was found+ if (page == null)+ {+ // Give up with a nice exception+ throw new WicketRuntimeException("No Page found for component " + this);+ }++ return page;+ }++ /**+ * Gets the path to this component relative to its containing page, i.e. without leading page+ * id.+ *+ * @return The path to this component relative to the page it is in+ */+ @Override+ public final String getPageRelativePath()+ {+ return Strings.afterFirstPathComponent(getPath(), PATH_SEPARATOR);+ }++ /**+ * Gets any parent container, or null if there is none.+ *+ * @return Any parent container, or null if there is none+ */+ @Override+ public final MarkupContainer getParent()+ {+ return parent;+ }++ /**+ * Gets this component's path.+ *+ * @return Colon separated path to this component in the component hierarchy+ */+ public final String getPath()+ {+ final PrependingStringBuffer buffer = new PrependingStringBuffer(32);+ for (Component c = this; c != null; c = c.getParent())+ {+ if (buffer.length() > 0)+ {+ buffer.prepend(PATH_SEPARATOR);+ }+ buffer.prepend(c.getId());+ }+ return buffer.toString();+ }++ /**+ * If false the component's tag will be printed as well as its body (which is default). If true+ * only the body will be printed, but not the component's tag.+ *+ * @return If true, the component tag will not be printed+ */+ public final boolean getRenderBodyOnly()+ {+ return getFlag(FLAG_RENDER_BODY_ONLY);+ }++ /**+ * @return The request for this component's active request cycle+ */+ public final Request getRequest()+ {+ RequestCycle requestCycle = getRequestCycle();+ if (requestCycle == null)+ {+ // Happens often with WicketTester when one forgets to call+ // createRequestCycle()+ throw new WicketRuntimeException("No RequestCycle is currently set!");+ }+ return requestCycle.getRequest();+ }++ /**+ * Gets the active request cycle for this component+ *+ * @return The request cycle+ */+ public final RequestCycle getRequestCycle()+ {+ return RequestCycle.get();+ }++ /**+ * @return The response for this component's active request cycle+ */+ public final Response getResponse()+ {+ return getRequestCycle().getResponse();+ }++ /**+ * Gets the current Session object.+ *+ * @return The Session that this component is in+ */+ public Session getSession()+ {+ return Session.get();+ }++ /**+ * @return Size of this Component in bytes. Returns {@code 0} - if the size cannot be calculated for some reason+ */+ public long getSizeInBytes()+ {+ final MarkupContainer originalParent = parent;+ parent = null;+ long size = 0;+ try+ {+ size = WicketObjects.sizeof(this);+ }+ catch (Exception e)+ {+ log.error("Exception getting size for component " + this, e);+ }+ parent = originalParent;+ return size;+ }++ /**+ * @param key+ * Key of string resource in property file+ * @return The String+ * @see Localizer+ */+ public final String getString(final String key)+ {+ return getString(key, null);+ }++ /**+ * @param key+ * The resource key+ * @param model+ * The model+ * @return The formatted string+ * @see Localizer+ */+ public final String getString(final String key, final IModel<?> model)+ {+ return getLocalizer().getString(key, this, model);+ }++ /**+ * @param key+ * The resource key+ * @param model+ * The model+ * @param defaultValue+ * A default value if the string cannot be found+ * @return The formatted string+ * @see Localizer+ */+ public final String getString(final String key, final IModel<?> model, final String defaultValue)+ {+ return getLocalizer().getString(key, this, model, defaultValue);+ }++ /**+ * A convenience method to access the Sessions's style.+ *+ * @return The style of this component respectively the style of the Session.+ *+ * @see org.apache.wicket.Session#getStyle()+ */+ public final String getStyle()+ {+ Session session = getSession();+ if (session == null)+ {+ throw new WicketRuntimeException("Wicket Session object not available");+ }+ return session.getStyle();+ }++ /**+ * Gets the variation string of this component that will be used to look up markup for this+ * component. Subclasses can override this method to define by an instance what markup variation+ * should be picked up. By default it will return null or the value of a parent.+ *+ * @return The variation of this component.+ */+ public String getVariation()+ {+ if (parent != null)+ {+ return parent.getVariation();+ }+ return null;+ }++ /**+ * Gets whether this component was rendered at least once.+ *+ * @return true if the component has been rendered before, false if it is merely constructed+ */+ public final boolean hasBeenRendered()+ {+ return getFlag(FLAG_HAS_BEEN_RENDERED);+ }++ /**+ * Gets feedback messages for this component. This method will instantiate a+ * {@link FeedbackMessages} instance and add it to the component metadata, even when called on a+ * component that has no feedback messages, to avoid the overhead use+ * {@link #hasFeedbackMessage()}+ *+ * @return feedback messages instance+ */+ public FeedbackMessages getFeedbackMessages()+ {+ FeedbackMessages messages = getMetaData(FEEDBACK_KEY);+ if (messages == null)+ {+ messages = new FeedbackMessages();+ setMetaData(FEEDBACK_KEY, messages);+ }+ return messages;+ }++ /**+ * @return True if this component has an error message+ */+ public final boolean hasErrorMessage()+ {+ FeedbackMessages messages = getMetaData(FEEDBACK_KEY);+ if (messages == null)+ {+ return false;+ }+ return messages.hasMessage(FeedbackMessage.ERROR);+ }++ /**+ * @return True if this component has some kind of feedback message+ *+ */+ public final boolean hasFeedbackMessage()+ {+ FeedbackMessages messages = getMetaData(FEEDBACK_KEY);+ if (messages == null)+ {+ return false;+ }+ return messages.size() > 0;+ }++ /**+ * Registers an informational feedback message for this component+ *+ * @param message+ * The feedback message+ */+ public final void info(final Serializable message)+ {+ getFeedbackMessages().info(this, message);+ addStateChange();+ }++ /**+ * Registers an success feedback message for this component+ *+ * @param message+ * The feedback message+ */+ public final void success(final Serializable message)+ {+ getFeedbackMessages().success(this, message);+ addStateChange();+ }++ /**+ * Authorizes an action for a component.+ *+ * @param action+ * The action to authorize+ * @return True if the action is allowed+ * @throws AuthorizationException+ * Can be thrown by implementation if action is unauthorized+ */+ public final boolean isActionAuthorized(Action action)+ {+ IAuthorizationStrategy authorizationStrategy = getSession().getAuthorizationStrategy();+ if (authorizationStrategy != null)+ {+ return authorizationStrategy.isActionAuthorized(this, action);+ }+ return true;+ }++ /**+ * @return true if this component is authorized to be enabled, false otherwise+ */+ public final boolean isEnableAllowed()+ {+ return isActionAuthorized(ENABLE);+ }++ /**+ * Gets whether this component is enabled. Specific components may decide to implement special+ * behavior that uses this property, like web form components that add a disabled='disabled'+ * attribute when enabled is false.+ *+ * @return Whether this component is enabled.+ */+ public boolean isEnabled()+ {+ return getFlag(FLAG_ENABLED);+ }++ /**+ * Checks the security strategy if the {@link Component#RENDER} action is allowed on this+ * component+ *+ * @return ture if {@link Component#RENDER} action is allowed, false otherwise+ */+ public final boolean isRenderAllowed()+ {+ return getFlag(FLAG_IS_RENDER_ALLOWED);+ }++ /**+ * Returns if the component is stateless or not. It checks the stateless hint if that is false+ * it returns directly false. If that is still true it checks all its behaviors if they can be+ * stateless.+ *+ * @return whether the component is stateless.+ */+ public final boolean isStateless()+ {+ if (+ // the component is either invisible or disabled+ (isVisibleInHierarchy() && isEnabledInHierarchy()) == false &&++ // and it can't call listener interfaces+ canCallListenerInterface(null) == false)+ {+ // then pretend the component is stateless+ return true;+ }++ if (!getStatelessHint())+ {+ return false;+ }++ for (Behavior behavior : getBehaviors())+ {+ if (!behavior.getStatelessHint(this))+ {+ return false;+ }+ }+ return true;+ }++ /**+ * @return {@code true} if this component should notify its holding page about changes in its+ * state. If a {@link Page} is not versioned then it wont track changes in its+ * components and will use the same {@link Page#getPageId()} during its lifetime+ */+ public boolean isVersioned()+ {+ // Is the component itself versioned?+ if (!getFlag(FLAG_VERSIONED))+ {+ return false;+ }+ else+ {+ // If there's a parent and this component is versioned+ if (parent != null)+ {+ // Check if the parent is unversioned. If any parent+ // (recursively) is unversioned, then this component is too+ if (!parent.isVersioned())+ {+ return false;+ }+ }+ return true;+ }+ }++ /**+ * Gets whether this component and any children are visible.+ * <p>+ * WARNING: this method can be called multiple times during a request. If you override this+ * method, it is a good idea to keep it cheap in terms of processing. Alternatively, you can+ * call {@link #setVisible(boolean)}.+ * <p>+ *+ * @return True if component and any children are visible+ */+ public boolean isVisible()+ {+ return getFlag(FLAG_VISIBLE);+ }++ /**+ * Checks if the component itself and all its parents are visible.+ *+ * @return true if the component and all its parents are visible.+ */+ public final boolean isVisibleInHierarchy()+ {+ Component parent = getParent();+ if (parent != null && !parent.isVisibleInHierarchy())+ {+ return false;+ }+ else+ {+ return determineVisibility();+ }+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * Sets the RENDERING flag and removes the PREPARED_FOR_RENDER flag on component and it's+ * children.+ *+ * @param setRenderingFlag+ * if this is false only the PREPARED_FOR_RENDER flag is removed from component, the+ * RENDERING flag is not set.+ *+ * @see #internalPrepareForRender(boolean)+ */+ public final void markRendering(boolean setRenderingFlag)+ {+ internalMarkRendering(setRenderingFlag);+ }++ /**+ * Called to indicate that the model content for this component has been changed+ */+ public final void modelChanged()+ {+ // Call user code+ internalOnModelChanged();+ onModelChanged();+ }++ /**+ * Called to indicate that the model content for this component is about to change+ */+ public final void modelChanging()+ {+ checkHierarchyChange(this);++ // Call user code+ onModelChanging();++ // Tell the page that our model changed+ final Page page = findPage();+ if (page != null)+ {+ page.componentModelChanging(this);+ }+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ * <p>+ * Prepares the component and it's children for rendering. On whole page render this method must+ * be called on the page. On AJAX request, this method must be called on the updated component.+ *+ * @param setRenderingFlag+ * Whether to set the rendering flag. This must be true if the page is about to be+ * rendered. However, there are usecases to call this method without an immediate+ * render (e.g. on stateless listener request target to build the component+ * hierarchy), in that case setRenderingFlag should be false.+ */+ public void internalPrepareForRender(boolean setRenderingFlag)+ {+ beforeRender();++ if (setRenderingFlag)+ {+ // only process feedback panel when we are about to be rendered.+ // setRenderingFlag is false in case prepareForRender is called only to build component+ // hierarchy (i.e. in BookmarkableListenerInterfaceRequestHandler).+ // prepareForRender(true) is always called before the actual rendering is done so+ // that's where feedback panels gather the messages++ List<Component> feedbacks = getRequestCycle().getMetaData(FEEDBACK_LIST);+ if (feedbacks != null)+ {+ // iterate over a copy because a IFeedback may add more IFeedback children+// (WICKET-4687)+ Component[] feedbacksCopy = feedbacks.toArray(new Component[feedbacks.size()]);+ for (Component feedback : feedbacksCopy)+ {+ // render it only if it is still in the page hierarchy (WICKET-4895)+ if (feedback.findPage() != null)+ {+ feedback.internalBeforeRender();+ }+ }+ }+ getRequestCycle().setMetaData(FEEDBACK_LIST, null);+ }++ markRendering(setRenderingFlag);+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * Prepares the component and it's children for rendering. On whole page render this method must+ * be called on the page. On AJAX request, this method must be called on updated component.+ */+ public final void prepareForRender()+ {+ internalPrepareForRender(true);+ }++ /**+ * Redirects browser to an intermediate page such as a sign-in page. The current request's URL+ * is saved for future use by method {@link #continueToOriginalDestination()}; only use this method when+ * you plan to continue to the current URL at some later time; otherwise just set a new response page.+ *+ * @param page+ * The sign in page+ *+ * @see #setResponsePage(Class)+ * @see #setResponsePage(IRequestablePage)+ * @see #setResponsePage(Class, PageParameters)+ * @see Component#continueToOriginalDestination()+ */+ public final void redirectToInterceptPage(final Page page)+ {+ throw new RestartResponseAtInterceptPageException(page);+ }++ /**+ * Removes this component from its parent. It's important to remember that a component that is+ * removed cannot be referenced from the markup still.+ * <p>+ * You must not use this method in your callback to any of the+ * {@link MarkupContainer#visitChildren(IVisitor)} methods. See <a+ * href="https://issues.apache.org/jira/browse/WICKET-3229">WICKET-3329</a>.+ */+ public final void remove()+ {+ if (parent == null)+ {+ throw new IllegalStateException("Cannot remove " + this + " from null parent!");+ }+ parent.remove(this);+ }+++ /**+ * Render the Component.+ */+ public final void render()+ {+ ComponentContext.push(new ComponentContext(this));+ try {+ RuntimeException exception = null;++ try+ {+ // Invoke prepareForRender only if this is the root component to be rendered+ MarkupContainer parent = getParent();+ if ((parent == null) || (parent.getFlag(FLAG_RENDERING) == false) || isAuto())+ {+ internalPrepareForRender(true);+ }++ // Do the render+ internalRender();+ }+ catch (final RuntimeException ex)+ {+ // Remember it as the originating exception+ exception = ex;+ }+ finally+ {+ try+ {+ // Cleanup+ afterRender();+ }+ catch (RuntimeException ex2)+ {+ // Only remember it if not already another exception happened+ if (exception == null)+ {+ exception = ex2;+ }+ }+ }++ // Re-throw if needed+ if (exception != null)+ {+ throw exception;+ }+ } finally {+ ComponentContext.pop();+ }+ }++ /**+ * Performs a render of this component as part of a Page level render process.+ */+ private void internalRender()+ {+ // Make sure there is a markup available for the Component+ IMarkupFragment markup = getMarkup();+ if (markup == null)+ {+ throw new MarkupNotFoundException("Markup not found for Component: " + toString());+ }++ // MarkupStream is an Iterator for the markup+ MarkupStream markupStream = new MarkupStream(markup);++ // Flag: we started the render process+ markRendering(true);++ MarkupElement elem = markup.get(0);+ if (elem instanceof ComponentTag)+ {+ // Guarantee that the markupStream is set and determineVisibility not yet tested+ // See WICKET-2049+ ((ComponentTag)elem).onBeforeRender(this, markupStream);+ }++ // Determine if component is visible using it's authorization status+ // and the isVisible property.+ if (determineVisibility())+ {+ setFlag(FLAG_HAS_BEEN_RENDERED, true);++ // Rendering is beginning+ if (log.isDebugEnabled())+ {+ log.debug("Begin render {}", this);+ }++ try+ {+ notifyBehaviorsComponentBeforeRender();+ onRender();+ notifyBehaviorsComponentRendered();++ // Component has been rendered+ rendered();+ }+ catch (RuntimeException ex)+ {+ onException(ex);+ }++ if (log.isDebugEnabled())+ {+ log.debug("End render {}", this);+ }+ }+ // elem is null when rendering a page+ else if ((elem != null) && (elem instanceof ComponentTag))+ {+ if (getFlag(FLAG_PLACEHOLDER))+ {+ renderPlaceholderTag((ComponentTag)elem, getResponse());+ }+ }+ }++ /**+ * Called when a runtime exception is caught during the render process+ *+ * @param ex+ * The exception caught.+ */+ private void onException(final RuntimeException ex)+ {+ // Call each behaviors onException() to allow the+ // behavior to clean up+ for (Behavior behavior : getBehaviors())+ {+ if (isBehaviorAccepted(behavior))+ {+ try+ {+ behavior.onException(this, ex);+ }+ catch (Exception ex2)+ {+ log.error("Error while cleaning up after exception", ex2);+ }+ }+ }++ // Re-throw the exception+ throw ex;+ }++ /**+ * Renders a placeholder tag for the component when it is invisible and+ * {@link #setOutputMarkupPlaceholderTag(boolean)} has been called with <code>true</code>.+ *+ * @param tag+ * component tag+ * @param response+ * response+ */+ protected void renderPlaceholderTag(final ComponentTag tag, final Response response)+ {+ String ns = Strings.isEmpty(tag.getNamespace()) ? null : tag.getNamespace() + ':';++ response.write("<");+ if (ns != null)+ {+ response.write(ns);+ }+ response.write(tag.getName());+ response.write(" id=\"");+ response.write(getAjaxRegionMarkupId());+ response.write("\" style=\"display:none\"></");+ if (ns != null)+ {+ response.write(ns);+ }+ response.write(tag.getName());+ response.write(">");+ }+++ /**+ * Returns the id of the markup region that will be updated via ajax. This can be different to+ * the markup id of the component if a {@link IAjaxRegionMarkupIdProvider} behavior has been+ * added.+ *+ * @return the markup id of the region to be updated via ajax.+ */+ public final String getAjaxRegionMarkupId()+ {+ String markupId = null;+ for (Behavior behavior : getBehaviors())+ {+ if (behavior instanceof IAjaxRegionMarkupIdProvider && behavior.isEnabled(this))+ {+ markupId = ((IAjaxRegionMarkupIdProvider)behavior).getAjaxRegionMarkupId(this);+ break;+ }+ }+ if (markupId == null)+ {+ if (this instanceof IAjaxRegionMarkupIdProvider)+ {+ markupId = ((IAjaxRegionMarkupIdProvider)this).getAjaxRegionMarkupId(this);+ }+ }+ if (markupId == null)+ {+ markupId = getMarkupId();+ }+ return markupId;+ }+++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT.+ * <p>+ * Renders the component at the current position in the given markup stream. The method+ * onComponentTag() is called to allow the component to mutate the start tag. The method+ * onComponentTagBody() is then called to permit the component to render its body.+ */+ public final void internalRenderComponent()+ {+ final IMarkupFragment markup = getMarkup();+ if (markup == null)+ {+ throw new MarkupException("Markup not found. Component: " + toString());+ }++ final MarkupStream markupStream = new MarkupStream(markup);++ // Get mutable copy of next tag+ final ComponentTag openTag = markupStream.getTag();+ final ComponentTag tag = openTag.mutable();++ // call application-wide tag listeners+ getApplication().getOnComponentTagListeners().onComponentTag(this, tag);++ // Call any tag handler+ onComponentTag(tag);++ // If we're an openclose tag+ if (!tag.isOpenClose() && !tag.isOpen())+ {+ // We were something other than <tag> or <tag/>+ markupStream.throwMarkupException("Method renderComponent called on bad markup element: " ++ tag);+ }++ if (tag.isOpenClose() && openTag.isOpen())+ {+ markupStream.throwMarkupException("You can not modify a open tag to open-close: " + tag);+ }++ try+ {+ // Render open tag+ boolean renderBodyOnly = getRenderBodyOnly();+ if (renderBodyOnly)+ {+ ExceptionSettings.NotRenderableErrorStrategy notRenderableErrorStrategy = ExceptionSettings.NotRenderableErrorStrategy.LOG_WARNING;+ if (Application.exists())+ {+ notRenderableErrorStrategy = getApplication().getExceptionSettings().getNotRenderableErrorStrategy();+ }++ if (getFlag(FLAG_OUTPUT_MARKUP_ID))+ {+ String message = String.format("Markup id set on a component that renders its body only. " ++ "Markup id: %s, component id: %s.", getMarkupId(), getId());+ if (notRenderableErrorStrategy == ExceptionSettings.NotRenderableErrorStrategy.THROW_EXCEPTION)+ {+ throw new IllegalStateException(message);+ }+ log.warn(message);+ }+ if (getFlag(FLAG_PLACEHOLDER))+ {+ String message = String.format("Placeholder tag set on a component that renders its body only. " ++ "Component id: %s.", getId());+ if (notRenderableErrorStrategy == ExceptionSettings.NotRenderableErrorStrategy.THROW_EXCEPTION)+ {+ throw new IllegalStateException(message);+ }+ log.warn(message);+ }+ }+ else+ {+ renderComponentTag(tag);+ }+ markupStream.next();++ // Render the body only if open-body-close. Do not render if open-close.+ if (tag.isOpen())+ {+ // Render the body. The default strategy will simply call the component's+ // onComponentTagBody() implementation.+ getMarkupSourcingStrategy().onComponentTagBody(this, markupStream, tag);++ // Render close tag+ if (openTag.isOpen())+ {+ renderClosingComponentTag(markupStream, tag, renderBodyOnly);+ }+ else if (renderBodyOnly == false)+ {+ if (needToRenderTag(openTag))+ {+ // Close the manually opened tag. And since the user might have changed the+ // tag name ...+ getResponse().write(tag.syntheticCloseTagString());+ }+ }+ }+ }+ catch (WicketRuntimeException wre)+ {+ throw wre;+ }+ catch (RuntimeException re)+ {+ throw new WicketRuntimeException("Exception in rendering component: " + this, re);+ }+ }++ /**+ *+ * @param openTag+ * @return true, if the tag shall be rendered+ */+ private boolean needToRenderTag(final ComponentTag openTag)+ {+ // If a open-close tag has been modified to be open-body-close then a+ // synthetic close tag must be rendered.+ boolean renderTag = (openTag != null && !(openTag instanceof WicketTag));+ if (renderTag == false)+ {+ renderTag = !getApplication().getMarkupSettings().getStripWicketTags();+ }+ return renderTag;+ }++ /**+ * Called to indicate that a component has been rendered. This method should only very rarely be+ * called at all. Some components may render its children without calling render() on them.+ * These components need to call rendered() to indicate that its child components were actually+ * rendered, the framework would think they had never been rendered, and in development mode+ * this would result in a runtime exception.+ */+ public final void rendered()+ {+ Page page = findPage();+ if (page != null)+ {+ // Tell the page that the component rendered+ page.componentRendered(this);+ }+ else+ {+ log.error("Component is not connected to a Page. Cannot register the component as being rendered. Component: " ++ toString());+ }+ }++ /**+ * Get the markup sourcing strategy for the component. If null,+ * {@link #newMarkupSourcingStrategy()} will be called.+ *+ * @return Markup sourcing strategy+ */+ protected final IMarkupSourcingStrategy getMarkupSourcingStrategy()+ {+ if (markupSourcingStrategy == null)+ {+ markupSourcingStrategy = newMarkupSourcingStrategy();++ // If not strategy by provided, than we use a default one.+ if (markupSourcingStrategy == null)+ {+ markupSourcingStrategy = DefaultMarkupSourcingStrategy.get();+ }+ }+ return markupSourcingStrategy;+ }++ /**+ * If {@link #getMarkupSourcingStrategy()} returns null, this method will be called. By default+ * it returns null, which means that a default markup strategy will be attached to the+ * component.+ * <p>+ * Please note that markup source strategies are not persisted. Instead they get re-created by+ * calling this method again. That's ok since markup sourcing strategies usually do not maintain+ * a state.+ *+ * @return Markup sourcing strategy+ */+ protected IMarkupSourcingStrategy newMarkupSourcingStrategy()+ {+ return null;+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT.+ *+ * Print to the web response what ever the component wants to contribute to the head section.+ * Make sure that all attached behaviors are asked as well.+ * <p>+ * NOT intended for overriding by framework clients. Rather, use+ * {@link Component#renderHead(org.apache.wicket.markup.head.IHeaderResponse)}+ * </p>+ *+ * @param container+ * The HtmlHeaderContainer+ */+ public void internalRenderHead(final HtmlHeaderContainer container)+ {+ ComponentContext.push(new ComponentContext(this));+ try {+ if (isVisibleInHierarchy() && isRenderAllowed())+ {+ if (log.isDebugEnabled())+ {+ log.debug("internalRenderHead: {}", toString(false));+ }++ IHeaderResponse response = container.getHeaderResponse();++ // Allow component to contribute+ if (response.wasRendered(this) == false)+ {+ StringResponse markupHeaderResponse = new StringResponse();+ Response oldResponse = getResponse();+ RequestCycle.get().setResponse(markupHeaderResponse);+ try+ {+ // Make sure the markup source strategy contributes to the header first+ // to be backward compatible. WICKET-3761+ getMarkupSourcingStrategy().renderHead(this, container);+ CharSequence headerContribution = markupHeaderResponse.getBuffer();+ if (Strings.isEmpty(headerContribution) == false)+ {+ response.render(StringHeaderItem.forString(headerContribution));+ }+ }+ finally+ {+ RequestCycle.get().setResponse(oldResponse);+ }+ // Then let the component itself to contribute to the header+ renderHead(this, response);++ response.markRendered(this);+ }++ // Then ask all behaviors+ for (Behavior behavior : getBehaviors())+ {+ if (isBehaviorAccepted(behavior))+ {+ if (response.wasRendered(behavior) == false)+ {+ behavior.renderHead(this, response);+ List<IClusterable> pair = Arrays.asList(this, behavior);+ response.markRendered(pair);+ }+ }+ }+ }+ } finally {+ ComponentContext.pop();+ }+ }++ /**+ * Replaces this component with another. The replacing component must have the same component id+ * as this component. This method serves as a shortcut to+ *+ * <code>this.getParent().replace(replacement)</code>+ *+ * and provides a better context for errors.+ * <p>+ * Usage: <code>component = component.replaceWith(replacement);</code>+ * </p>+ *+ * @since 1.2.1+ *+ * @param replacement+ * component to replace this one+ * @return the component which replaced this one+ */+ public Component replaceWith(Component replacement)+ {+ Args.notNull(replacement, "replacement");++ if (!getId().equals(replacement.getId()))+ {+ throw new IllegalArgumentException(+ "Replacement component must have the same id as the component it will replace. Replacement id [[" ++ replacement.getId() + "]], replaced id [[" + getId() + "]].");+ }+ if (parent == null)+ {+ throw new IllegalStateException(+ "This method can only be called on a component that has already been added to its parent.");+ }+ parent.replace(replacement);+ return replacement;+ }++ /**+ * @param component+ * The component to compare with+ * @return True if the given component's model is the same as this component's model.+ */+ public final boolean sameInnermostModel(final Component component)+ {+ return sameInnermostModel(component.getDefaultModel());+ }++ /**+ * @param model+ * The model to compare with+ * @return True if the given component's model is the same as this component's model.+ */+ public final boolean sameInnermostModel(final IModel<?> model)+ {+ // Get the two models+ IModel<?> thisModel = getDefaultModel();++ // If both models are non-null they could be the same+ if (thisModel != null && model != null)+ {+ return getInnermostModel(thisModel) == getInnermostModel(model);+ }++ return false;+ }++ /**+ * Sets whether this component is enabled. Specific components may decide to implement special+ * behavior that uses this property, like web form components that add a disabled='disabled'+ * attribute when enabled is false. If it is not enabled, it will not be allowed to call any+ * listener method on it (e.g. Link.onClick) and the model object will be protected (for the+ * common use cases, not for programmer's misuse)+ *+ * @param enabled+ * whether this component is enabled+ * @return This+ */+ public final Component setEnabled(final boolean enabled)+ {+ // Is new enabled state a change?+ if (enabled != getFlag(FLAG_ENABLED))+ {+ // Tell the page that this component's enabled was changed+ if (isVersioned())+ {+ final Page page = findPage();+ if (page != null)+ {+ addStateChange();+ }+ }++ // Change visibility+ setFlag(FLAG_ENABLED, enabled);+ onEnabledStateChanged();+ }+ return this;+ }++ void clearEnabledInHierarchyCache()+ {+ setRequestFlag(RFLAG_ENABLED_IN_HIERARCHY_SET, false);+ }++ void onEnabledStateChanged()+ {+ clearEnabledInHierarchyCache();+ }++ /**+ * Sets whether model strings should be escaped.+ *+ * @param escapeMarkup+ * True is model strings should be escaped+ * @return This+ */+ public final Component setEscapeModelStrings(final boolean escapeMarkup)+ {+ setFlag(FLAG_ESCAPE_MODEL_STRINGS, escapeMarkup);+ return this;+ }++ /**+ * Set markup ID, which must be String or Integer+ *+ * @param markupId+ */+ public final void setMarkupIdImpl(Object markupId)+ {+ if (markupId != null && !(markupId instanceof String) && !(markupId instanceof Integer))+ {+ throw new IllegalArgumentException("markupId must be String or Integer");+ }++ setOutputMarkupId(true);+ if (markupId instanceof Integer)+ {+ generatedMarkupId = (Integer)markupId;+ setMetaData(MARKUP_ID_KEY, null);+ return;+ }++ generatedMarkupId = -1;+ setMetaData(MARKUP_ID_KEY, (String)markupId);++ }++ /**+ * Copy markupId+ *+ * @param comp+ */+ final void setMarkupId(Component comp)+ {+ Args.notNull(comp, "comp");++ generatedMarkupId = comp.generatedMarkupId;+ setMetaData(MARKUP_ID_KEY, comp.getMetaData(MARKUP_ID_KEY));+ if (comp.getOutputMarkupId())+ {+ setOutputMarkupId(true);+ }+ }++ /**+ * Sets this component's markup id to a user defined value. It is up to the user to ensure this+ * value is unique.+ * <p>+ * The recommended way is to let wicket generate the value automatically, this method is here to+ * serve as an override for that value in cases where a specific id must be used.+ * <p>+ * If null is passed in the user defined value is cleared and markup id value will fall back on+ * automatically generated value+ *+ * @see #getMarkupId()+ *+ * @param markupId+ * markup id value or null to clear any previous user defined value+ * @return this for chaining+ */+ public Component setMarkupId(String markupId)+ {+ Args.notEmpty(markupId, "markupId");++ // TODO check if an automatic id has already been generated or getmarkupid() called+ // previously and throw an illegalstateexception because something else might be depending+ // on previous id++ setMarkupIdImpl(markupId);+ return this;+ }++ /**+ * Sets the metadata for this component using the given key. If the metadata object is not of+ * the correct type for the metadata key, an IllegalArgumentException will be thrown. For+ * information on creating MetaDataKeys, see {@link MetaDataKey}.+ *+ * @param <M>+ * The type of the metadata+ *+ * @param key+ * The singleton key for the metadata+ * @param object+ * The metadata object+ * @throws IllegalArgumentException+ * @see MetaDataKey+ */+ public final <M extends Serializable> Component setMetaData(final MetaDataKey<M> key, final M object)+ {+ MetaDataEntry<?>[] old = getMetaData();++ Object metaData = null;+ MetaDataEntry<?>[] metaDataArray = key.set(getMetaData(), object);+ if (metaDataArray != null && metaDataArray.length > 0)+ {+ metaData = (metaDataArray.length > 1) ? metaDataArray : metaDataArray[0];+ }++ int index = getFlag(FLAG_MODEL_SET) ? 1 : 0;++ if (old == null && metaData != null)+ {+ data_insert(index, metaData);+ }+ else if (old != null && metaData != null)+ {+ data_set(index, metaData);+ }+ else if (old != null && metaData == null)+ {+ data_remove(index);+ }+ return this;+ }++ /**+ * Sets the given model.+ * <p>+ * WARNING: DO NOT OVERRIDE THIS METHOD UNLESS YOU HAVE A VERY GOOD REASON FOR IT. OVERRIDING+ * THIS MIGHT OPEN UP SECURITY LEAKS AND BREAK BACK-BUTTON SUPPORT.+ * </p>+ *+ * @param model+ * The model+ * @return This+ */+ public Component setDefaultModel(final IModel<?> model)+ {+ IModel<?> prevModel = getModelImpl();++ IModel<?> wrappedModel = prevModel;+ if (prevModel instanceof IWrapModel)+ {+ wrappedModel = ((IWrapModel<?>)prevModel).getWrappedModel();+ }++ // Change model+ if (wrappedModel != model)+ {+ // Detach the old/current model+ if (prevModel != null)+ {+ prevModel.detach();+ }++ modelChanging();+ setModelImpl(wrap(model));+ modelChanged();++ // WICKET-3413 reset 'inherited model' when model is explicitely set+ setFlag(FLAG_INHERITABLE_MODEL, false);+ }++ return this;+ }++ /**+ * @return model+ */+ IModel<?> getModelImpl()+ {+ if (getFlag(FLAG_MODEL_SET))+ {+ return (IModel<?>)data_get(0);+ }+ return null;+ }++ /**+ *+ * @param model+ */+ void setModelImpl(IModel<?> model)+ {+ if (getFlag(FLAG_MODEL_SET))+ {+ if (model != null)+ {+ data_set(0, model);+ }+ else+ {+ data_remove(0);+ setFlag(FLAG_MODEL_SET, false);+ }+ }+ else+ {+ if (model != null)+ {+ data_insert(0, model);+ setFlag(FLAG_MODEL_SET, true);+ }+ }+ }++ /**+ * Sets the backing model object. Unlike <code>getDefaultModel().setObject(object)</code>, this+ * method checks authorisation and model comparator, and invokes <code>modelChanging</code> and+ * <code>modelChanged</code> if the value really changes.+ *+ * @param object+ * The object to set+ * @return This+ * @throws IllegalStateException If the component has neither its own model nor any of its+ * parents uses {@link IComponentInheritedModel}+ */+ @SuppressWarnings("unchecked")+ public final Component setDefaultModelObject(final Object object)+ {+ final IModel<Object> model = (IModel<Object>)getDefaultModel();++ // Check whether anything can be set at all+ if (model == null)+ {+ throw new IllegalStateException(+ "Attempt to set a model object on a component without a model! " ++ "Either pass an IModel to the constructor or use #setDefaultModel(new SomeModel(object)). " ++ "Component: " + getPageRelativePath());+ }++ // Check authorization+ if (!isActionAuthorized(ENABLE))+ {+ throw new UnauthorizedActionException(this, ENABLE);+ }++ // Check whether this will result in an actual change+ if (!getModelComparator().compare(this, object))+ {+ modelChanging();+ model.setObject(object);+ modelChanged();+ }++ return this;+ }++ /**+ * Sets whether or not component will output id attribute into the markup. id attribute will be+ * set to the value returned from {@link Component#getMarkupId()}.+ *+ * @param output+ * True if the component will output the id attribute into markup. Please note that+ * the default behavior is to use the same id as the component. This means that your+ * component must begin with [a-zA-Z] in order to generate a valid markup id+ * according to: http://www.w3.org/TR/html401/types.html#type-name+ *+ * @return this for chaining+ */+ public final Component setOutputMarkupId(final boolean output)+ {+ setFlag(FLAG_OUTPUT_MARKUP_ID, output);+ return this;+ }++ /**+ * Render a placeholder tag when the component is not visible. The tag is of form:+ * <componenttag style="display:none;" id="markupid"/>. This method will also call+ * <code>setOutputMarkupId(true)</code>.+ *+ * This is useful, for example, in ajax situations where the component starts out invisible and+ * then becomes visible through an ajax update. With a placeholder tag already in the markup you+ * do not need to repaint this component's parent, instead you can repaint the component+ * directly.+ *+ * When this method is called with parameter <code>false</code> the outputmarkupid flag is not+ * reverted to false.+ *+ * @param outputTag+ * @return this for chaining+ */+ public final Component setOutputMarkupPlaceholderTag(final boolean outputTag)+ {+ if (outputTag != getFlag(FLAG_PLACEHOLDER))+ {+ if (outputTag)+ {+ setOutputMarkupId(true);+ setFlag(FLAG_PLACEHOLDER, true);+ }+ else+ {+ setFlag(FLAG_PLACEHOLDER, false);+ // I think it's better to not setOutputMarkupId to false...+ // user can do it if she want+ }+ }+ return this;+ }++ /**+ * If false the component's tag will be printed as well as its body (which is default). If true+ * only the body will be printed, but not the component's tag.+ *+ * @param renderTag+ * If true, the component tag will not be printed+ * @return This+ */+ public final Component setRenderBodyOnly(final boolean renderTag)+ {+ setFlag(FLAG_RENDER_BODY_ONLY, renderTag);+ return this;+ }++ /**+ * Sets the page that will respond to this request+ *+ * @param <C>+ *+ * @param cls+ * The response page class+ * @see RequestCycle#setResponsePage(Class)+ */+ public final <C extends IRequestablePage> void setResponsePage(final Class<C> cls)+ {+ getRequestCycle().setResponsePage(cls, (PageParameters)null);+ }++ /**+ * Sets the page class and its parameters that will respond to this request+ *+ * @param <C>+ *+ * @param cls+ * The response page class+ * @param parameters+ * The parameters for this bookmarkable page.+ * @see RequestCycle#setResponsePage(Class, PageParameters)+ */+ public final <C extends IRequestablePage> void setResponsePage(final Class<C> cls,+ PageParameters parameters)+ {+ getRequestCycle().setResponsePage(cls, parameters);+ }++ /**+ * Sets the page that will respond to this request+ *+ * @param page+ * The response page+ *+ * @see RequestCycle#setResponsePage(org.apache.wicket.request.component.IRequestablePage)+ */+ public final void setResponsePage(final IRequestablePage page)+ {+ getRequestCycle().setResponsePage(page);+ }++ /**+ * @param versioned+ * True to turn on versioning for this component, false to turn it off for this+ * component and any children.+ * @return This+ */+ public Component setVersioned(boolean versioned)+ {+ setFlag(FLAG_VERSIONED, versioned);+ return this;+ }++ /**+ * Sets whether this component and any children are visible.+ *+ * @param visible+ * True if this component and any children should be visible+ * @return This+ */+ public final Component setVisible(final boolean visible)+ {+ // Is new visibility state a change?+ if (visible != getFlag(FLAG_VISIBLE))+ {+ // record component's visibility change+ addStateChange();++ // Change visibility+ setFlag(FLAG_VISIBLE, visible);+ onVisibleStateChanged();+ }+ return this;+ }++ void clearVisibleInHierarchyCache()+ {+ setRequestFlag(RFLAG_VISIBLE_IN_HIERARCHY_SET, false);+ }++ void onVisibleStateChanged()+ {+ clearVisibleInHierarchyCache();+ }+++ /**+ * Gets the string representation of this component.+ *+ * @return The path to this component+ */+ @Override+ public String toString()+ {+ return toString(false);+ }++ /**+ * @param detailed+ * True if a detailed string is desired+ * @return The string+ */+ public String toString(final boolean detailed)+ {+ try+ {+ final StringBuilder buffer = new StringBuilder();+ buffer.append("[Component id = ").append(getId());++ if (detailed)+ {+ final Page page = findPage();+ if (page == null)+ {+ buffer.append(", page = <No Page>, path = ")+ .append(getPath())+ .append('.')+ .append(Classes.simpleName(getClass()));+ }+ else+ {+ buffer.append(", page = ")+ .append(Classes.name(getPage().getPageClass()))+ .append(", path = ")+ .append(getPageRelativePath())+ .append(", type = ")+ .append(Classes.name(getClass()))+ .append(", isVisible = ")+ .append((determineVisibility()))+ .append(", isVersioned = ")+ .append(isVersioned());+ }++ if (markup != null)+ {+ buffer.append(", markup = ").append(new MarkupStream(getMarkup()).toString());+ }+ }++ buffer.append(']');++ return buffer.toString();+ }+ catch (Exception e)+ {+ log.warn("Error while building toString()", e);+ return String.format(+ "[Component id = %s <attributes are not available because exception %s was thrown during toString()>]",+ getId(), e.getClass().getName());+ }+ }++ /**+ * Returns a bookmarkable URL that references a given page class using a given set of page+ * parameters. Since the URL which is returned contains all information necessary to instantiate+ * and render the page, it can be stored in a user's browser as a stable bookmark.+ *+ * @param <C>+ *+ * @see RequestCycle#urlFor(Class, org.apache.wicket.request.mapper.parameter.PageParameters)+ *+ * @param pageClass+ * Class of page+ * @param parameters+ * Parameters to page+ * @return Bookmarkable URL to page+ */+ public final <C extends Page> CharSequence urlFor(final Class<C> pageClass,+ final PageParameters parameters)+ {+ return getRequestCycle().urlFor(pageClass, parameters);+ }++ /**+ * Gets a URL for the listener interface on a behavior (e.g. IBehaviorListener on+ * AjaxPagingNavigationBehavior).+ *+ * @param behaviour+ * The behavior that the URL should point to+ * @param listener+ * The listener interface that the URL should call+ * @param parameters+ * The parameters that should be rendered into the urls+ * @return The URL+ */+ public final CharSequence urlFor(final Behavior behaviour,+ final RequestListenerInterface listener, final PageParameters parameters)+ {+ int id = getBehaviorId(behaviour);+ IRequestHandler handler = createRequestHandler(listener, parameters, id);+ return getRequestCycle().urlFor(handler);+ }++ /**+ * Create a suitable request handler depending whether the page is stateless or bookmarkable.+ */+ private IRequestHandler createRequestHandler(RequestListenerInterface listener,+ PageParameters parameters, Integer id)+ {+ Page page = getPage();++ PageAndComponentProvider provider = new PageAndComponentProvider(page, this, parameters);++ if (page.isPageStateless()+ || (page.isBookmarkable() && page.wasCreatedBookmarkable()))+ {+ return new BookmarkableListenerInterfaceRequestHandler(provider, listener, id);+ }+ else+ {+ return new ListenerInterfaceRequestHandler(provider, listener, id);+ }+ }++ /**+ * Returns a URL that references the given request target.+ *+ * @see RequestCycle#urlFor(IRequestHandler)+ *+ * @param requestHandler+ * the request target to reference+ *+ * @return a URL that references the given request target+ */+ public final CharSequence urlFor(final IRequestHandler requestHandler)+ {+ return getRequestCycle().urlFor(requestHandler);+ }++ /**+ * Gets a URL for the listener interface (e.g. ILinkListener).+ *+ * @see RequestCycle#urlFor(IRequestHandler)+ *+ * @param listener+ * The listener interface that the URL should call+ * @param parameters+ * The parameters that should be rendered into the urls+ * @return The URL+ */+ public final CharSequence urlFor(final RequestListenerInterface listener,+ final PageParameters parameters)+ {+ IRequestHandler handler = createRequestHandler(listener, parameters, null);+ return getRequestCycle().urlFor(handler);+ }++ /**+ * Returns a URL that references a shared resource through the provided resource reference.+ *+ * @see RequestCycle#urlFor(IRequestHandler)+ *+ * @param resourceReference+ * The resource reference+ * @param parameters+ * parameters or {@code null} if none+ * @return The url for the shared resource+ */+ public final CharSequence urlFor(final ResourceReference resourceReference,+ PageParameters parameters)+ {+ return getRequestCycle().urlFor(resourceReference, parameters);+ }++ /**+ * Traverses all parent components of the given class in this parentClass, calling the visitor's+ * visit method at each one.+ *+ * @param <R>+ * the type of the result object+ * @param parentClass+ * Class+ * @param visitor+ * The visitor to call at each parent of the given type+ * @return First non-null value returned by visitor callback+ */+ public final <R, C extends MarkupContainer> R visitParents(final Class<C> parentClass,+ final IVisitor<C, R> visitor)+ {+ return visitParents(parentClass, visitor, IVisitFilter.ANY);+ }++ /**+ * Traverses all parent components of the given class in this parentClass, calling the visitor's+ * visit method at each one.+ *+ * @param <R>+ * the type of the result object+ * @param parentClass+ * the class of the parent component+ * @param visitor+ * The visitor to call at each parent of the given type+ * @param filter+ * a filter that adds an additional logic to the condition whether a parent container+ * matches+ * @return First non-null value returned by visitor callback+ */+ @SuppressWarnings("unchecked")+ public final <R, C extends MarkupContainer> R visitParents(final Class<C> parentClass,+ final IVisitor<C, R> visitor, IVisitFilter filter)+ {+ Args.notNull(filter, "filter");++ // Start here+ MarkupContainer current = getParent();++ Visit<R> visit = new Visit<R>();++ // Walk up containment hierarchy+ while (current != null)+ {+ // Is current an instance of this class?+ if (parentClass.isInstance(current) && filter.visitObject(current))+ {+ visitor.component((C)current, visit);+ if (visit.isStopped())+ {+ return visit.getResult();+ }+ }++ // Check parent+ current = current.getParent();+ }+ return null;+ }++ /**+ * Registers a warning feedback message for this component.+ *+ * @param message+ * The feedback message+ */+ public final void warn(final Serializable message)+ {+ getFeedbackMessages().warn(this, message);+ addStateChange();+ }++ /**+ * {@link Behavior#beforeRender(Component)} Notify all behaviors that are assigned to this+ * component that the component is about to be rendered.+ */+ private void notifyBehaviorsComponentBeforeRender()+ {+ for (Behavior behavior : getBehaviors())+ {+ if (isBehaviorAccepted(behavior))+ {+ behavior.beforeRender(this);+ }+ }+ }++ /**+ * {@link Behavior#afterRender(Component)} Notify all behaviors that are assigned to this+ * component that the component has rendered.+ */+ private void notifyBehaviorsComponentRendered()+ {+ // notify the behaviors that component has been rendered+ for (Behavior behavior : getBehaviors())+ {+ if (isBehaviorAccepted(behavior))+ {+ behavior.afterRender(this);+ }+ }+ }++ /**+ * TODO WICKET-NG rename to something more useful - like componentChanged(), this method used to+ * be called with a Change object+ *+ * Adds state change to page.+ */+ protected final void addStateChange()+ {+ checkHierarchyChange(this);+ final Page page = findPage();+ if (page != null)+ {+ page.componentStateChanging(this);+ }+ }++ /**+ * Checks whether the given type has the expected name.+ *+ * @param tag+ * The tag to check+ * @param name+ * The expected tag name+ * @throws MarkupException+ * Thrown if the tag is not of the right name+ */+ protected final void checkComponentTag(final ComponentTag tag, final String name)+ {+ if (!tag.getName().equalsIgnoreCase(name))+ {+ String msg = String.format("Component [%s] (path = [%s]) must be "+ + "applied to a tag of type [%s], not: %s", getId(), getPath(), name,+ tag.toUserDebugString());++ findMarkupStream().throwMarkupException(msg);+ }+ }++ /**+ * Checks that a given tag has a required attribute value.+ *+ * @param tag+ * The tag+ * @param key+ * The attribute key+ * @param values+ * The required value for the attribute key+ * @throws MarkupException+ * Thrown if the tag does not have the required attribute value+ */+ protected final void checkComponentTagAttribute(final ComponentTag tag, final String key,+ final String... values)+ {+ if (key != null)+ {+ final String tagAttributeValue = tag.getAttributes().getString(key);++ boolean found = false;+ if (tagAttributeValue != null)+ {+ for (String value : values)+ {+ if (value.equalsIgnoreCase(tagAttributeValue))+ {+ found = true;+ break;+ }+ }+ }++ if (found == false)+ {+ String msg = String.format("Component [%s] (path = [%s]) must be applied to a tag "+ + "with [%s] attribute matching any of %s, not [%s]", getId(), getPath(), key,+ Arrays.toString(values), tagAttributeValue);++ findMarkupStream().throwMarkupException(msg);+ }+ }+ }++ /**+ * Checks whether the hierarchy may be changed at all, and throws an exception if this is not+ * the case.+ *+ * @param component+ * the component which is about to be added or removed+ */+ protected void checkHierarchyChange(final Component component)+ {+ // Throw exception if modification is attempted during rendering+ if (getFlag(FLAG_RENDERING) && !component.isAuto())+ {+ throw new WicketRuntimeException(+ "Cannot modify component hierarchy after render phase has started (page version cant change then anymore)");+ }+ }++ /**+ * Detaches the model for this component if it is detachable.+ */+ protected void detachModel()+ {+ IModel<?> model = getModelImpl();+ if (model != null)+ {+ model.detach();+ }+ // also detach the wrapped model of a component assigned wrap (not+ // inherited)+ if (model instanceof IWrapModel && !getFlag(FLAG_INHERITABLE_MODEL))+ {+ ((IWrapModel<?>)model).getWrappedModel().detach();+ }+ }++ /**+ * Suffixes an exception message with useful information about this. component.+ *+ * @param message+ * The message+ * @return The modified message+ */+ protected final String exceptionMessage(final String message)+ {+ return message + ":\n" + toString();+ }++ /**+ * Finds the markup stream for this component.+ *+ * @return The markup stream for this component. Since a Component cannot have a markup stream,+ * we ask this component's parent to search for it.+ */+ protected final MarkupStream findMarkupStream()+ {+ return new MarkupStream(getMarkup());+ }++ /**+ * If this Component is a Page, returns self. Otherwise, searches for the nearest Page parent in+ * the component hierarchy. If no Page parent can be found, {@code null} is returned.+ *+ * @return The Page or {@code null} if none can be found+ */+ protected final Page findPage()+ {+ // Search for page+ return (Page)(this instanceof Page ? this : findParent(Page.class));+ }++ /**+ * Gets the subset of the currently coupled {@link Behavior}s that are of the provided type as+ * an unmodifiable list. Returns an empty list if there are no behaviors coupled to this+ * component.+ *+ * @param type+ * The type or null for all+ * @return The subset of the currently coupled behaviors that are of the provided type as an+ * unmodifiable list+ * @param <M>+ * A class derived from Behavior+ */+ public <M extends Behavior> List<M> getBehaviors(Class<M> type)+ {+ return new Behaviors(this).getBehaviors(type);+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * @param flag+ * The flag to test+ * @return True if the flag is set+ */+ protected final boolean getFlag(final int flag)+ {+ return (flags & flag) != 0;+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * @param flag+ * The flag to test+ * @return True if the flag is set+ */+ protected final boolean getRequestFlag(final short flag)+ {+ return (requestFlags & flag) != 0;+ }++ /**+ * Finds the innermost IModel object for an IModel that might contain nested IModel(s).+ *+ * @param model+ * The model+ * @return The innermost (most nested) model+ */+ protected final IModel<?> getInnermostModel(final IModel<?> model)+ {+ IModel<?> nested = model;+ while (nested != null && nested instanceof IWrapModel)+ {+ final IModel<?> next = ((IWrapModel<?>)nested).getWrappedModel();+ if (nested == next)+ {+ throw new WicketRuntimeException("Model for " + nested + " is self-referential");+ }+ nested = next;+ }+ return nested;+ }++ /**+ * Gets the component's current model comparator. Implementations can be used for testing the+ * current value of the components model data with the new value that is given.+ *+ * @return the value defaultModelComparator+ */+ public IModelComparator getModelComparator()+ {+ return defaultModelComparator;+ }++ /**+ * Returns whether the component can be stateless. Also the component behaviors must be+ * stateless, otherwise the component will be treat as stateful. In order for page to be+ * stateless (and not to be stored in session), all components (and component behaviors) must be+ * stateless.+ *+ * @return whether the component can be stateless+ */+ protected boolean getStatelessHint()+ {+ return true;+ }++ /**+ * Called when a null model is about to be retrieved in order to allow a subclass to provide an+ * initial model.+ * <p>+ * By default this implementation looks components in the parent chain owning a+ * {@link IComponentInheritedModel} to provide a model for this component via+ * {@link IComponentInheritedModel#wrapOnInheritance(Component)}.+ * <p>+ * For example a {@link FormComponent} has the opportunity to instantiate a model on the fly+ * using its {@code id} and the containing {@link Form}'s model, if the form holds a+ * {@link CompoundPropertyModel}.+ *+ * @return The model+ */+ protected IModel<?> initModel()+ {+ IModel<?> foundModel = null;+ // Search parents for IComponentInheritedModel (i.e. CompoundPropertyModel)+ for (Component current = getParent(); current != null; current = current.getParent())+ {+ // Get model+ // Don't call the getModel() that could initialize many in between+ // completely useless models.+ // IModel model = current.getDefaultModel();+ IModel<?> model = current.getModelImpl();++ if (model instanceof IWrapModel && !(model instanceof IComponentInheritedModel))+ {+ model = ((IWrapModel<?>)model).getWrappedModel();+ }++ if (model instanceof IComponentInheritedModel)+ {+ // return the shared inherited+ foundModel = ((IComponentInheritedModel<?>)model).wrapOnInheritance(this);+ setFlag(FLAG_INHERITABLE_MODEL, true);+ break;+ }+ }++ // No model for this component!+ return foundModel;+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL OR OVERRIDE.+ *+ * <p>+ * Called anytime a model is changed via setModel or setModelObject.+ * </p>+ */+ protected void internalOnModelChanged()+ {+ }++ /**+ * Components are allowed to reject behavior modifiers.+ *+ * @param behavior+ * @return False, if the component should not apply this behavior+ */+ protected boolean isBehaviorAccepted(final Behavior behavior)+ {+ // Ignore AttributeModifiers when FLAG_IGNORE_ATTRIBUTE_MODIFIER is set+ if ((behavior instanceof AttributeModifier) &&+ (getFlag(FLAG_IGNORE_ATTRIBUTE_MODIFIER) != false))+ {+ return false;+ }++ return behavior.isEnabled(this);+ }++ /**+ * If true, all attribute modifiers will be ignored+ *+ * @return True, if attribute modifiers are to be ignored+ */+ protected final boolean isIgnoreAttributeModifier()+ {+ return getFlag(FLAG_IGNORE_ATTRIBUTE_MODIFIER);+ }++ /**+ * Called just after a component is rendered.+ */+ protected void onAfterRender()+ {+ setFlag(FLAG_AFTER_RENDERING, false);+ }++ /**+ * Called just before a component is rendered only if the component is visible.+ * <p>+ * <strong>NOTE</strong>: If you override this, you *must* call super.onBeforeRender() within+ * your implementation.+ *+ * Because this method is responsible for cascading {@link #onBeforeRender()} call to its+ * children it is strongly recommended that super call is made at the end of the override.+ * </p>+ *+ * Changes to the component tree can be made only <strong>before</strong> calling+ * super.onBeforeRender().+ *+ * @see org.apache.wicket.MarkupContainer#addOrReplace(Component...)+ */+ protected void onBeforeRender()+ {+ setFlag(FLAG_PREPARED_FOR_RENDER, true);+ onBeforeRenderChildren();+ setRequestFlag(RFLAG_BEFORE_RENDER_SUPER_CALL_VERIFIED, true);+ }++ /**+ * Processes the component tag.+ *+ * Overrides of this method most likely should call the super implementation.+ *+ * @param tag+ * Tag to modify+ */+ @SuppressWarnings("deprecation")+ protected void onComponentTag(final ComponentTag tag)+ {+ // We can't try to get the ID from markup. This could be different than+ // id returned from getMarkupId() prior first rendering the component+ // (due to transparent resolvers and borders which break the 1:1+ // component <-> markup relation)+ if (getFlag(FLAG_OUTPUT_MARKUP_ID))+ {+ tag.putInternal(MARKUP_ID_ATTR_NAME, getMarkupId());+ }++ DebugSettings debugSettings = getApplication().getDebugSettings();+ String componentPathAttributeName = debugSettings.getComponentPathAttributeName();+ if (Strings.isEmpty(componentPathAttributeName) && debugSettings.isOutputComponentPath())+ {+ // fallback to the old 'wicketpath'+ componentPathAttributeName = "wicketpath";+ }+ if (Strings.isEmpty(componentPathAttributeName) == false)+ {+ String path = getPageRelativePath();+ path = path.replace("_", "__");+ path = path.replace(':', '_');+ tag.put(componentPathAttributeName, path);+ }++ // The markup sourcing strategy may also want to work on the tag+ getMarkupSourcingStrategy().onComponentTag(this, tag);+ }++ /**+ * Processes the body.+ *+ * @param markupStream+ * The markup stream+ * @param openTag+ * The open tag for the body+ */+ public void onComponentTagBody(final MarkupStream markupStream, final ComponentTag openTag)+ {+ }++ /**+ * Called to allow a component to detach resources after use.+ *+ * Overrides of this method MUST call the super implementation, the most logical place to do+ * this is the last line of the override method.+ */+ protected void onDetach()+ {+ setFlag(FLAG_DETACHING, false);+ }++ /**+ * Called to notify the component it is being removed from the component hierarchy+ *+ * Overrides of this method MUST call the super implementation, the most logical place to do+ * this is the last line of the override method.+ */+ protected void onRemove()+ {+ setFlag(FLAG_REMOVING_FROM_HIERARCHY, false);+ }++ /**+ * Called anytime a model is changed after the change has occurred+ */+ protected void onModelChanged()+ {+ }++ /**+ * Called anytime a model is changed, but before the change actually occurs+ */+ protected void onModelChanging()+ {+ }++ /**+ * Implementation that renders this component.+ */+ protected abstract void onRender();++ /**+ * Writes a simple tag out to the response stream. Any components that might be referenced by+ * the tag are ignored. Also undertakes any tag attribute modifications if they have been added+ * to the component.+ *+ * @param tag+ * The tag to write+ */+ protected final void renderComponentTag(ComponentTag tag)+ {+ if (needToRenderTag(tag))+ {+ // apply behaviors that are attached to the component tag.+ if (tag.hasBehaviors())+ {+ Iterator<? extends Behavior> tagBehaviors = tag.getBehaviors();+ while (tagBehaviors.hasNext())+ {+ final Behavior behavior = tagBehaviors.next();+ if (behavior.isEnabled(this))+ {+ behavior.onComponentTag(this, tag);+ }+ behavior.detach(this);+ }+ }++ // Apply behavior modifiers+ List<? extends Behavior> behaviors = getBehaviors();+ if ((behaviors != null) && !behaviors.isEmpty() && !tag.isClose() &&+ (isIgnoreAttributeModifier() == false))+ {+ tag = tag.mutable();+ for (Behavior behavior : behaviors)+ {+ // Components may reject some behavior components+ if (isBehaviorAccepted(behavior))+ {+ behavior.onComponentTag(this, tag);+ }+ }+ }++ if ((tag instanceof WicketTag) && !tag.isClose() &&+ !getFlag(FLAG_IGNORE_ATTRIBUTE_MODIFIER))+ {+ ExceptionSettings.NotRenderableErrorStrategy notRenderableErrorStrategy = ExceptionSettings.NotRenderableErrorStrategy.LOG_WARNING;+ if (Application.exists())+ {+ notRenderableErrorStrategy = getApplication().getExceptionSettings().getNotRenderableErrorStrategy();+ }++ String tagName = tag.getNamespace() + ":" + tag.getName();+ String componentId = getId();+ if (getFlag(FLAG_OUTPUT_MARKUP_ID))+ {+ String message = String.format("Markup id set on a component that is usually not rendered into markup. " ++ "Markup id: %s, component id: %s, component tag: %s.",+ getMarkupId(), componentId, tagName);+ if (notRenderableErrorStrategy == ExceptionSettings.NotRenderableErrorStrategy.THROW_EXCEPTION)+ {+ throw new IllegalStateException(message);+ }+ log.warn(message);+ }+ if (getFlag(FLAG_PLACEHOLDER))+ {+ String message = String.format(+ "Placeholder tag set on a component that is usually not rendered into markup. " ++ "Component id: %s, component tag: %s.", componentId, tagName);+ if (notRenderableErrorStrategy == ExceptionSettings.NotRenderableErrorStrategy.THROW_EXCEPTION)+ {+ throw new IllegalStateException(message);+ }+ log.warn(message);+ }+ }++ // Write the tag+ tag.writeOutput(getResponse(), !needToRenderTag(null),+ getMarkup().getMarkupResourceStream().getWicketNamespace());+ }+ }++ /**+ * Replaces the body with the given one.+ *+ * @param markupStream+ * The markup stream to replace the tag body in+ * @param tag+ * The tag+ * @param body+ * The new markup+ */+ protected final void replaceComponentTagBody(final MarkupStream markupStream,+ final ComponentTag tag, final CharSequence body)+ {+ // The tag might have been changed from open-close to open. Hence+ // we'll need what was in the markup itself+ ComponentTag markupOpenTag = null;++ // If tag has a body+ if (tag.isOpen())+ {+ // Get what tag was in the markup; not what the user it might+ // have changed it to.+ markupOpenTag = markupStream.getPreviousTag();++ // If it was an open tag in the markup as well, than ...+ if (markupOpenTag.isOpen())+ {+ // skip any raw markup in the body+ markupStream.skipRawMarkup();+ }+ }++ if (body != null)+ {+ // Write the new body+ getResponse().write(body);+ }++ // If we had an open tag (and not an openclose tag) and we found a+ // close tag, we're good+ if (tag.isOpen())+ {+ // If it was an open tag in the markup, than there must be+ // a close tag as well.+ if ((markupOpenTag != null) && markupOpenTag.isOpen() && !markupStream.atCloseTag())+ {+ // There must be a component in this discarded body+ markupStream.throwMarkupException("Expected close tag for '" + markupOpenTag ++ "' Possible attempt to embed component(s) '" + markupStream.get() ++ "' in the body of this component which discards its body");+ }+ }+ }++ /**+ * @param auto+ * True to put component into auto-add mode+ */+ protected final Component setAuto(final boolean auto)+ {+ setFlag(FLAG_AUTO, auto);+ return this;+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * @param flag+ * The flag to set+ * @param set+ * True to turn the flag on, false to turn it off+ */+ protected final Component setFlag(final int flag, final boolean set)+ {+ if (set)+ {+ flags |= flag;+ }+ else+ {+ flags &= ~flag;+ }+ return this;+ }++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT USE IT!+ *+ * @param flag+ * The flag to set+ * @param set+ * True to turn the flag on, false to turn it off+ */+ protected final Component setRequestFlag(final short flag, final boolean set)+ {+ if (set)+ {+ requestFlags |= flag;+ }+ else+ {+ requestFlags &= ~flag;+ }+ return this;+ }++ /**+ * If true, all attribute modifiers will be ignored+ *+ * @param ignore+ * If true, all attribute modifiers will be ignored+ * @return This+ */+ protected final Component setIgnoreAttributeModifier(final boolean ignore)+ {+ setFlag(FLAG_IGNORE_ATTRIBUTE_MODIFIER, ignore);+ return this;+ }++ /**+ * @param <V>+ * The model type+ * @param model+ * The model to wrap if need be+ * @return The wrapped model+ */+ protected final <V> IModel<V> wrap(final IModel<V> model)+ {+ if (model instanceof IComponentAssignedModel)+ {+ return ((IComponentAssignedModel<V>)model).wrapOnAssignment(this);+ }+ return model;+ }++ /**+ * Detaches any child components+ */+ void detachChildren()+ {+ }++ /**+ * Signals this components removal from hierarchy to all its children.+ */+ void removeChildren()+ {+ }++ /**+ * Gets the component at the given path.+ *+ * @param path+ * Path to component+ * @return The component at the path+ */+ @Override+ public Component get(final String path)+ {+ // Path to this component is an empty path+ if (path.length() == 0)+ {+ return this;+ }+ throw new IllegalArgumentException(+ exceptionMessage("Component is not a container and so does not contain the path " ++ path));+ }++ /**+ * @param setRenderingFlag+ * rendering flag+ */+ void internalMarkRendering(boolean setRenderingFlag)+ {+ // WICKET-5460 no longer prepared for render+ setFlag(FLAG_PREPARED_FOR_RENDER, false);++ setFlag(FLAG_RENDERING, setRenderingFlag);+ }++ /**+ * @return True if this component or any of its parents is in auto-add mode+ */+ public final boolean isAuto()+ {+ // Search up hierarchy for FLAG_AUTO+ for (Component current = this; current != null; current = current.getParent())+ {+ if (current.getFlag(FLAG_AUTO))+ {+ return true;+ }+ }+ return false;+ }++ /**+ *+ * @return <code>true</code> if component has been prepared for render+ */+ boolean isPreparedForRender()+ {+ return getFlag(FLAG_PREPARED_FOR_RENDER);+ }++ /**+ *+ */+ protected void onAfterRenderChildren()+ {+ }++ /**+ * This method is here for {@link MarkupContainer}. It is broken out of+ * {@link #onBeforeRender()} so we can guarantee that it executes as the last in+ * onBeforeRender() chain no matter where user places the <code>super.onBeforeRender()</code>+ * call.+ */+ void onBeforeRenderChildren()+ {+ }++ /**+ * Renders the close tag at the current position in the markup stream.+ *+ * @param markupStream+ * the markup stream+ * @param openTag+ * the tag to render+ * @param renderBodyOnly+ * if true, the tag will not be written to the output+ */+ final void renderClosingComponentTag(final MarkupStream markupStream,+ final ComponentTag openTag, final boolean renderBodyOnly)+ {+ // Tag should be open tag and not openclose tag+ if (openTag.isOpen())+ {+ // If we found a close tag and it closes the open tag, we're good+ if (markupStream.atCloseTag() && markupStream.getTag().closes(openTag))+ {+ // Render the close tag+ if ((renderBodyOnly == false) && needToRenderTag(openTag))+ {+ getResponse().write(openTag.syntheticCloseTagString());+ }+ }+ else if (openTag.requiresCloseTag())+ {+ // Missing close tag. Some tags, e.g. <p> are handled like <p/> by most browsers and+ // thus will not throw an exception.+ markupStream.throwMarkupException("Expected close tag for " + openTag);+ }+ }+ }++ /**+ * Sets the id of this component.+ *+ * @param id+ * The non-null id of this component+ */+ final Component setId(final String id)+ {+ if (!(this instanceof Page))+ {+ if (Strings.isEmpty(id))+ {+ throw new WicketRuntimeException("Null or empty component ID's are not allowed.");+ }+ }++ if ((id != null) && (id.indexOf(':') != -1 || id.indexOf('~') != -1))+ {+ throw new WicketRuntimeException("The component ID must not contain ':' or '~' chars.");+ }++ this.id = id;+ return this;+ }++ /**+ * THIS IS A WICKET INTERNAL API. DO NOT USE IT.+ *+ * Sets the parent of a component. Typically what you really want is parent.add(child).+ * <p/>+ * Note that calling setParent() and not parent.add() will connect the child to the parent, but+ * the parent will not know the child. This might not be a problem in some cases, but e.g.+ * child.onDetach() will not be invoked (since the parent doesn't know it is his child).+ *+ * @param parent+ * The parent container+ */+ public final void setParent(final MarkupContainer parent)+ {+ if (this.parent != null && log.isDebugEnabled())+ {+ log.debug("Replacing parent " + this.parent + " with " + parent);+ }+ this.parent = parent;+ }++ /**+ * Sets the render allowed flag.+ *+ * @param renderAllowed+ */+ final void setRenderAllowed(boolean renderAllowed)+ {+ setFlag(FLAG_IS_RENDER_ALLOWED, renderAllowed);+ }++ /**+ * Sets the render allowed flag.+ *+ * Visit all this page's children (overridden in MarkupContainer) to check rendering+ * authorization, as appropriate. We set any result; positive or negative as a temporary boolean+ * in the components, and when a authorization exception is thrown it will block the rendering+ * of this page+ */+ void setRenderAllowed()+ {+ setRenderAllowed(isActionAuthorized(RENDER));+ }++ /**+ * Sets whether or not this component is allowed to be visible. This method is meant to be used+ * by components to control visibility of other components. A call to+ * {@link #setVisible(boolean)} will not always have a desired effect because that component may+ * have {@link #isVisible()} overridden. Both {@link #setVisibilityAllowed(boolean)} and+ * {@link #isVisibilityAllowed()} are <code>final</code> so their contract is enforced always.+ *+ * @param allowed+ * @return <code>this</code> for chaining+ */+ public final Component setVisibilityAllowed(boolean allowed)+ {+ setFlag(FLAG_VISIBILITY_ALLOWED, allowed);+ return this;+ }++ /**+ * Gets whether or not visibility is allowed on this component. See+ * {@link #setVisibilityAllowed(boolean)} for details.+ *+ * @return true if this component is allowed to be visible, false otherwise.+ */+ public final boolean isVisibilityAllowed()+ {+ return getFlag(FLAG_VISIBILITY_ALLOWED);+ }++ /**+ * Determines whether or not a component should be visible, taking into account all the factors:+ * {@link #isVisible()}, {@link #isVisibilityAllowed()}, {@link #isRenderAllowed()}+ *+ * @return <code>true</code> if the component should be visible, <code>false</code> otherwise+ */+ public final boolean determineVisibility()+ {+ return isVisible() && isRenderAllowed() && isVisibilityAllowed();+ }+++ /**+ * Calculates enabled state of the component taking its hierarchy into account. A component is+ * enabled iff it is itself enabled ({@link #isEnabled()} and {@link #isEnableAllowed()} both+ * return <code>true</code>), and all of its parents are enabled.+ *+ * @return <code>true</code> if this component is enabled</code>+ */+ public boolean isEnabledInHierarchy()+ {+ if (getRequestFlag(RFLAG_ENABLED_IN_HIERARCHY_SET))+ {+ return getRequestFlag(RFLAG_ENABLED_IN_HIERARCHY_VALUE);+ }++ final boolean state;+ Component parent = getParent();+ if (parent != null && !parent.isEnabledInHierarchy())+ {+ state = false;+ }+ else+ {+ state = isEnabled() && isEnableAllowed();+ }++ setRequestFlag(RFLAG_ENABLED_IN_HIERARCHY_SET, true);+ setRequestFlag(RFLAG_ENABLED_IN_HIERARCHY_VALUE, state);+ return state;+ }++ /**+ * Says if the component is rendering or not checking the corresponding flag.+ *+ * @return true if this component is rendering, false otherwise.+ */+ public final boolean isRendering()+ {+ return getFlag(FLAG_RENDERING);+ }++ /**+ * Checks whether or not a listener method can be invoked on this component. Usually components+ * deny these invocations if they are either invisible or disabled in hierarchy. Components can+ * examine which listener interface is being invoked by examining the declaring class of the+ * passed in {@literal method} parameter.+ * <p>+ * WARNING: be careful when overriding this method because it may open security holes - such as+ * allowing a user to click on a link that should be disabled.+ * </p>+ * <p>+ * Example usecase for overriding: Suppose you are building an component that displays images.+ * The component generates a callback to itself using {@link IRequestListener} interface and+ * uses this callback to stream image data. If such a component is placed inside a disabled+ * webmarkupcontainer we still want to allow the invocation of the request listener callback+ * method so that image data can be streamed. Such a component would override this method and+ * return {@literal true} if the listener method belongs to {@link IRequestListener}.+ * </p>+ *+ * @param method+ * listener method about to be invoked on this component. Could be {@code null} - in+ * this case it means <em>any</em> method.+ *+ * @return {@literal true} iff the listener method can be invoked on this component+ */+ public boolean canCallListenerInterface(Method method)+ {+ return isEnabledInHierarchy() && isVisibleInHierarchy();+ }++ /**+ * CAUTION: this method is not meant to be overridden like it was in wicket 1.4 when+ * implementing {@link IHeaderContributor}. overload+ * {@link Component#renderHead(org.apache.wicket.markup.head.IHeaderResponse)} instead to+ * contribute to the response header.+ *+ * @param component+ * @param response+ */+ public final void renderHead(Component component, IHeaderResponse response)+ {+ if (component != this)+ {+ throw new IllegalStateException(+ "This method is only meant to be invoked on the component where the parameter component==this");+ }+ renderHead(response);+ }++ /**+ * Render to the web response whatever the component wants to contribute to the head section.+ *+ * @param response+ * Response object+ */+ @Override+ public void renderHead(IHeaderResponse response)+ {+ // noop+ }++ /** {@inheritDoc} */+ @Override+ public void onEvent(IEvent<?> event)+ {+ }++ /** {@inheritDoc} */+ @Override+ public final <T> void send(IEventSink sink, Broadcast type, T payload)+ {+ new ComponentEventSender(this, getApplication().getFrameworkSettings()).send(sink, type,+ payload);+ }++ /**+ * Removes behavior from component+ *+ * @param behaviors+ * behaviors to remove+ *+ * @return this (to allow method call chaining)+ */+ public Component remove(final Behavior... behaviors)+ {+ Behaviors helper = new Behaviors(this);+ for (Behavior behavior : behaviors)+ {+ helper.remove(behavior);+ }+ return this;+ }++ /** {@inheritDoc} */+ @Override+ public final Behavior getBehaviorById(int id)+ {+ return new Behaviors(this).getBehaviorById(id);+ }++ /** {@inheritDoc} */+ @Override+ public final int getBehaviorId(Behavior behavior)+ {+ return new Behaviors(this).getBehaviorId(behavior);+ }++ /**+ * Adds a behavior modifier to the component.+ *+ * @param behaviors+ * The behavior modifier(s) to be added+ * @return this (to allow method call chaining)+ */+ public Component add(final Behavior... behaviors)+ {+ new Behaviors(this).add(behaviors);+ return this;+ }++ /**+ * Gets the currently coupled {@link Behavior}s as a unmodifiable list. Returns an empty list+ * rather than null if there are no behaviors coupled to this component.+ *+ * @return The currently coupled behaviors as a unmodifiable list+ */+ public final List<? extends Behavior> getBehaviors()+ {+ return getBehaviors(null);+ }++ @Override+ public boolean canCallListenerInterfaceAfterExpiry()+ {+ return getApplication().getPageSettings()+ .getCallListenerInterfaceAfterExpiry() || isStateless();+ }+ /**+ * This method is called whenever a component is re-added to the page's component tree, if it+ * had been removed at some earlier time, i.e., if it is already initialized+ * (see {@link org.apache.wicket.Component#isInitialized()}).+ *+ * This is similar to onInitialize, but only comes after the component has been removed and+ * then added again:+ *+ * <ul>+ * <li>onInitialize is only called the very first time a component is added</li>+ * <li>onReAdd is not called the first time, but every time it is re-added after having been+ * removed</li>+ * </ul>+ *+ * You can think of it as the opposite of onRemove. A component that was once removed will+ * not be re-initialized but only re-added.+ *+ * Subclasses that override this must call super.onReAdd().+ */+ protected void onReAdd()+ {+ setRequestFlag(RFLAG_ON_RE_ADD_SUPER_CALL_VERIFIED, true);+ }+}diff --git a/server-core/src/main/java/org/apache/wicket/RequestListenerInterface.java b/server-core/src/main/java/org/apache/wicket/RequestListenerInterface.javanew file mode 100644index 0000000000..369401a904--- /dev/null+++ b/server-core/src/main/java/org/apache/wicket/RequestListenerInterface.java@@ -0,0 +1,356 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You under the Apache License, Version 2.0+ * (the "License"); you may not use this file except in compliance with+ * the License. You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.apache.wicket;++import java.lang.reflect.InvocationTargetException;+import java.lang.reflect.Method;+import java.util.Collection;+import java.util.Collections;+import java.util.HashMap;+import java.util.Map;++import org.apache.wicket.authorization.AuthorizationException;+import org.apache.wicket.behavior.Behavior;+import org.apache.wicket.core.request.handler.ListenerInvocationNotAllowedException;+import org.apache.wicket.request.RequestHandlerStack.ReplaceHandlerException;+import org.apache.wicket.request.component.IRequestableComponent;+import org.apache.wicket.util.lang.Classes;+import org.slf4j.Logger;+import org.slf4j.LoggerFactory;++import io.onedev.server.util.ComponentContext;+++/**+ * Base class for request listener interfaces.+ *+ * @author Jonathan Locke+ */+public class RequestListenerInterface+{+ /** Map from name to request listener interface */+ private static final Map<String, RequestListenerInterface> interfaces = Collections.synchronizedMap(new HashMap<String, RequestListenerInterface>());++ /** Log. */+ private static final Logger log = LoggerFactory.getLogger(RequestListenerInterface.class);++ /**+ * Looks up a request interface listener by name.+ *+ * @param interfaceName+ * The interface name+ * @return The RequestListenerInterface object, or null if none is found+ *+ */+ public static RequestListenerInterface forName(final String interfaceName)+ {+ return interfaces.get(interfaceName);+ }++ /** The listener interface method */+ private Method method;++ /** The name of this listener interface */+ private final String name;++ /**+ * Whether the render count should be included in URL. This should be true for every listener+ * interface URL that should only be active on last rendered page (links, etc) and false for+ * other (resources);+ */+ private boolean includeRenderCount = true;++ /**+ * Whether the page should be rendered by default after the invocation of this listener+ * interface. Applies only during non-ajax requests.+ */+ private boolean renderPageAfterInvocation = true;++ final Class<? extends IRequestListener> listenerInterfaceClass;++ /**+ * Constructor.+ *+ * @param listenerInterfaceClass+ * The interface class, which must extend IRequestListener.+ */+ public RequestListenerInterface(final Class<? extends IRequestListener> listenerInterfaceClass)+ {+ this.listenerInterfaceClass = listenerInterfaceClass;++ // Ensure that it extends IRequestListener+ if (!IRequestListener.class.isAssignableFrom(listenerInterfaceClass))+ {+ throw new IllegalArgumentException("Class " + listenerInterfaceClass ++ " must extend IRequestListener");+ }++ // Get interface methods+ final Method[] methods = listenerInterfaceClass.getMethods();++ // If there is only one method+ if (methods.length == 1)+ {+ // and that method takes no parameters+ if (methods[0].getParameterTypes().length == 0)+ {+ method = methods[0];+ }+ else+ {+ throw new IllegalArgumentException("Method " + methods[0] + " in interface " ++ listenerInterfaceClass + " cannot take any arguments");+ }+ }+ else+ {+ throw new IllegalArgumentException("Interface " + listenerInterfaceClass ++ " can have only one method");+ }++ // Save short class name+ name = Classes.simpleName(listenerInterfaceClass);++ // Register this listener+ register();+ }+++ /**+ * @return The interface class, which must extend IRequestListener.+ */+ public Class<? extends IRequestListener> getListenerInterfaceClass()+ {+ return listenerInterfaceClass;+ }+++ /**+ * @param includeRenderCount+ * @return self+ */+ public RequestListenerInterface setIncludeRenderCount(boolean includeRenderCount)+ {+ this.includeRenderCount = includeRenderCount;+ return this;+ }++ /**+ * @return whether the render count should be included in url+ */+ public boolean isIncludeRenderCount()+ {+ return includeRenderCount;+ }++ /**+ * @param renderPageAfterInvocation+ * @return self+ */+ public RequestListenerInterface setRenderPageAfterInvocation(boolean renderPageAfterInvocation)+ {+ this.renderPageAfterInvocation = renderPageAfterInvocation;+ return this;+ }++ /**+ * @return whether the page should be rendered after invocation of this interface (during+ * non-ajax requests)+ */+ public boolean isRenderPageAfterInvocation()+ {+ return renderPageAfterInvocation;+ }++ /**+ * @return The method for this request listener interface+ */+ public final Method getMethod()+ {+ return method;+ }++ /**+ * @return The name of this request listener interface+ */+ public final String getName()+ {+ return name;+ }++ /**+ * Invokes a given interface on a component.+ *+ * @param rcomponent+ * The component+ *+ * @throws ListenerInvocationNotAllowedException+ * when listener invocation attempted on a component that does not allow it+ */+ public final void invoke(final IRequestableComponent rcomponent)+ {+ // we are in Wicket core land+ final Component component = (Component)rcomponent;++ ComponentContext.push(new ComponentContext(component));+ try {+ if (!component.canCallListenerInterface(method))+ {+ // just return so that we have a silent fail and just re-render the+ // page+ log.info("component not enabled or visible; ignoring call. Component: " + component);+ throw new ListenerInvocationNotAllowedException(this, component, null,+ "Component rejected interface invocation");+ }++ internalInvoke(component, component);+ } finally {+ ComponentContext.pop();+ }+ }++ /**+ * Invokes a given interface on a component's behavior.+ *+ * @param rcomponent+ * The component+ * @param behavior+ * @throws ListenerInvocationNotAllowedException+ * when listener invocation attempted on a component that does not allow it+ */+ public final void invoke(final IRequestableComponent rcomponent, final Behavior behavior)+ {+ // we are in Wicket core land+ final Component component = (Component)rcomponent;++ ComponentContext.push(new ComponentContext(component));+ try {+ if (!behavior.canCallListenerInterface(component, method))+ {+ log.warn("behavior not enabled; ignore call. Behavior {} at component {}", behavior,+ component);+ throw new ListenerInvocationNotAllowedException(this, component, behavior,+ "Behavior rejected interface invocation. ");+ }++ internalInvoke(component, behavior);+ } finally {+ ComponentContext.pop();+ }+ }++ private void internalInvoke(final Component component, final Object target)+ {+ // save a reference to the page because the component can be removed+ // during the invocation of the listener and thus lose its parent+ Page page = component.getPage();++ // initialization is required for stateless pages+ if (!page.isInitialized())+ {+ page.internalInitialize();+ }++ try+ {+ method.invoke(target);+ }+ catch (InvocationTargetException e)+ {+ if (e.getTargetException() instanceof ReplaceHandlerException ||+ e.getTargetException() instanceof AuthorizationException ||+ e.getTargetException() instanceof WicketRuntimeException)+ {+ throw (RuntimeException)e.getTargetException();+ }+ throw new WicketRuntimeException("Method " + method.getName() + " of " ++ method.getDeclaringClass() + " targeted at " + target + " on component " ++ component + " threw an exception", e);+ }+ catch (Exception e)+ {+ throw new WicketRuntimeException("Method " + method.getName() + " of " ++ method.getDeclaringClass() + " targeted at " + target + " on component " ++ component + " threw an exception", e);+ }+ }++ /**+ * Method to call to register this interface for use+ */+ public void register()+ {+ // Register this listener interface+ registerRequestListenerInterface(this);+ }++ /**+ * @see java.lang.Object#toString()+ */+ @Override+ public String toString()+ {+ return "[RequestListenerInterface name=" + name + ", method=" + method + "]";+ }+++ /**+ * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT.+ * <p>+ * In previous versions of Wicket, request listeners were manually registered by calling this+ * method. Now there is a first class RequestListenerInterface object which should be+ * constructed as a constant member of the interface to enable automatic interface registration.+ * <p>+ * Adds a request listener interface to the map of interfaces that can be invoked by outsiders.+ *+ * @param requestListenerInterface+ * The request listener interface object+ */+ private void registerRequestListenerInterface(final RequestListenerInterface requestListenerInterface)+ {+ // Check that a different interface method with the same name has not+ // already been registered+ final RequestListenerInterface existingInterface = RequestListenerInterface.forName(requestListenerInterface.getName());+ if (existingInterface != null)+ {+ if (existingInterface.getMethod().equals(requestListenerInterface.getMethod()) == false)+ {+ throw new IllegalStateException("Cannot register listener interface " ++ requestListenerInterface ++ " because it conflicts with the already registered interface " + existingInterface);+ }+ }+ else+ {+ // Save this interface method by the non-qualified class name+ interfaces.put(requestListenerInterface.getName(), requestListenerInterface);++ log.info("registered listener interface " + this);+ }+ }++ /**+ *+ * @return collection of all registered interfaces+ */+ public static Collection<RequestListenerInterface> getRegisteredInterfaces()+ {+ return Collections.unmodifiableCollection(interfaces.values());+ }+++}diff --git a/server-core/src/main/java/org/apache/wicket/extensions/ajax/markup/html/autocomplete/AutoCompleteBehavior.java b/server-core/src/main/java/org/apache/wicket/extensions/ajax/markup/html/autocomplete/AutoCompleteBehavior.javanew file mode 100644index 0000000000..9d3c044193--- /dev/null+++ b/server-core/src/main/java/org/apache/wicket/extensions/ajax/markup/html/autocomplete/AutoCompleteBehavior.java@@ -0,0 +1,144 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You under the Apache License, Version 2.0+ * (the "License"); you may not use this file except in compliance with+ * the License. You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.apache.wicket.extensions.ajax.markup.html.autocomplete;++import java.util.Iterator;++import org.apache.wicket.Application;+import org.apache.wicket.request.IRequestCycle;+import org.apache.wicket.request.IRequestHandler;+import org.apache.wicket.request.cycle.RequestCycle;+import org.apache.wicket.request.http.WebResponse;+import org.apache.wicket.util.lang.Args;++import io.onedev.server.util.ComponentContext;+++/**+ * This behavior builds on top of {@link AbstractAutoCompleteBehavior} by introducing the concept of+ * a {@link IAutoCompleteRenderer} to make response writing easier.+ *+ * @param <T>+ *+ * @see IAutoCompleteRenderer+ *+ * @since 1.2+ *+ * @author Igor Vaynberg (ivaynberg)+ * @author Janne Hietamäki (jannehietamaki)+ */+public abstract class AutoCompleteBehavior<T> extends AbstractAutoCompleteBehavior+{+ private static final long serialVersionUID = 1L;++ private final IAutoCompleteRenderer<T> renderer;++ /**+ * Constructor+ *+ * @param renderer+ * renderer that will be used to generate output+ */+ public AutoCompleteBehavior(final IAutoCompleteRenderer<T> renderer)+ {+ this(renderer, false);+ }++ /**+ * Constructor+ *+ * @param renderer+ * renderer that will be used to generate output+ * @param preselect+ * highlight/preselect the first item in the autocomplete list automatically+ */+ public AutoCompleteBehavior(final IAutoCompleteRenderer<T> renderer, final boolean preselect)+ {+ this(renderer, new AutoCompleteSettings().setPreselect(preselect));+ }++ /**+ * Constructor+ *+ * @param renderer+ * renderer that will be used to generate output+ * @param settings+ * settings for the autocomplete list+ */+ public AutoCompleteBehavior(final IAutoCompleteRenderer<T> renderer,+ final AutoCompleteSettings settings)+ {+ super(settings);++ this.renderer = Args.notNull(renderer, "renderer");+ }++ @Override+ protected final void onRequest(final String val, final RequestCycle requestCycle)+ {+ IRequestHandler target = new IRequestHandler()+ {+ @Override+ public void respond(final IRequestCycle requestCycle)+ {+ ComponentContext.push(new ComponentContext(getComponent()));+ try {+ WebResponse r = (WebResponse)requestCycle.getResponse();++ // Determine encoding+ final String encoding = Application.get()+ .getRequestCycleSettings()+ .getResponseRequestEncoding();++ r.setContentType("text/xml; charset=" + encoding);+ r.disableCaching();++ Iterator<T> comps = getChoices(val);+ int count = 0;+ renderer.renderHeader(r);+ while (comps.hasNext())+ {+ final T comp = comps.next();+ renderer.render(comp, r, val);+ count += 1;+ }+ renderer.renderFooter(r, count);+ } finally {+ ComponentContext.pop();+ }+ }++ @Override+ public void detach(final IRequestCycle requestCycle)+ {+ }+ };++ requestCycle.scheduleRequestHandlerAfterCurrent(target);+ }++ /**+ * Callback method that should return an iterator over all possible choice objects. These+ * objects will be passed to the renderer to generate output. Usually it is enough to return an+ * iterator over strings.+ *+ * @param input+ * current input+ * @return iterator over all possible choice objects+ */+ protected abstract Iterator<T> getChoices(String input);+}\ No newline at end of filediff --git a/server-ee b/server-eeindex b06c5ddc86..6ffb63b7ac 160000--- a/server-ee+++ b/server-ee@@ -1 +1 @@-Subproject commit b06c5ddc869e62fa49e07fd1724a3a268a03afd4+Subproject commit 6ffb63b7acd33ae6c3107f71b5d31606f7ba93d4