-
ae.java.awt.Component
, now aButton has a listener with a reference // to bigOne! aButton.addActionListener(this); } public void actionPerformed(ActionEvent e) { System.out.println("Hello There"); } } In this example, serializing
aButton
by itself will cause
MyApp
and everything it refers to to be serialized as well. The problem is that the listener is serializable by coincidence, not by design. To separate the decisions about
MyApp
and the
ActionListener
being serializable one can use a nested class, as in the following example:
import ae.java.awt.*; import ae.java.awt.event.*; import java.io.Serializable; class MyApp java.io.Serializable { BigObjectThatShouldNotBeSerializedWithAButton bigOne; Button aButton = new Button(); static class MyActionListener implements ActionListener { public void actionPerformed(ActionEvent e) { System.out.println("Hello There"); } } MyApp() { aButton.addActionListener(new MyActionListener()); } }
Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.
For details on the focus subsystem, see How to Use the Focus Subsystem, a section in The Java Tutorial, and the Focus Specification for more information.
@author Arthur van Hoff
@author Sami Shaio
-
archmapper.main.model.architecture.Component
-
au.net.ocean.maven.plugin.annotation.Component
-
ca.uhn.hl7v2.conf.spec.message.Component
The specification for a particular field component in a message profile.
@author Bryan Tripp
-
charva.awt.Component
Component is the abstract superclass of all the other CHARVA widgets.
-
cn.wensiqun.asmsupport.utils.Component
@author 温斯群(Joe Wen)
-
com.apple.component.Component
-
com.atlassian.jira.rest.client.api.domain.Component
Project component
@since v0.1
-
com.atlassian.jira.rest.client.domain.Component
Project component
@since v0.1
-
com.cburch.logisim.comp.Component
-
com.citytechinc.cq.component.annotations.Component
-
com.codename1.ui.Component
-
com.day.cq.wcm.api.components.Component
-
com.emitrom.touch4j.client.core.Component
a.com/touch/2-0/#!/api/Ext.Component>Ext.Component
-
com.extjs.gxt.ui.client.widget.Component
Base class for GXT components. All subclasses of Component can automatically participate in the standard GXT component lifecycle of creation, attach and detach. They also have automatic support for basic hide/show and enable/disable behavior. Component allows any subclass to be lazy-rendered into any GXT {@link Container}. Components added to a GWT {@link Panel} willbe rendered when inserted. All visual widgets that require rendering into a layout should subclass Component (or {@link BoxComponent} if managed boxmodel handling is required).
The following 4 methods inherited from UIObject (setSize, setWidth, setHeight, setPixelSize) have been overridden and do nothing. Any component whose size can change should subclass {@link BoxComponent}.
All components are registered and unregistered with the {@link ComponentManager} when the are attached and detached.
- Events:
- Enable : ComponentEvent(component)
Fires after the component is enabled.
- Disable : ComponentEvent(component)
Fires after the component is disabled.
- BeforeHide : ComponentEvent(component)
Fires before the component is hidden. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- BeforeShow : ComponentEvent(component)
Fires before the component is shown. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- Hide : ComponentEvent(component)
Fires after the component is hidden.
- Show : ComponentEvent(component)
Fires after the component is shown.
- Attach : ComponentEvent(component)
Fires after the component is attached.
- Detach : ComponentEvent(component)
Fires after the component is detached.
- BeforeRender : ComponentEvent(component)
Fires before the component is rendered. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- Render : ComponentEvent(component)
Fires after the component is rendered.
- BrowserEvent : ComponentEvent(component, event)
Fires on any browser event the component receives. Listeners will be called prior to any event processing and before {@link #onComponentEvent(ComponentEvent)} is called. Listeners can call{@link BaseEvent#setCancelled(boolean)} to cancel the processing of theevent.
- component : this
- event : event
- BeforeStateRestore : ComponentEvent(component, state)
Fires before the state of the component is restored. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- component : this
- state : the state values
- StateRestore : ComponentEvent(component, state)
Fires after the state of the component is restored.
- component : this
- state : map of state key / value pairs
- BeforeStateSave : ComponentEvent(component, state)
Fires before the state of the component is saved to the configured state provider. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- component : this
- state : map of state key / value pairs
- StateSave : ComponentEvent(component, state)
Fires after the state of the component is saved to the configured state provider.
- component : this
- state : map of state key / value pairs
@see ComponentManager
-
com.firefly.annotation.Component
-
com.google.gwt.visualization.client.visualizations.Toolbar.Component
-
com.google.testing.testify.risk.frontend.model.Component
JDO object for Component.
@author jimr@google.com (Jim Reardon)
-
com.google.walkaround.proto.ProtocolDocumentOperation.Component
-
com.googlecode.mashups4jsf.jsfplugin.digester.Component
@author Latest modification by $Author: cagatay_civici $
@version $Revision: 361 $ $Date: 2007-06-10 19:12:06 +0300 (Sun, 10 Jun 2007) $
-
com.gwtext.client.widgets.Component
Base class for all Ext components. All subclasses of Component can automatically participate in the standard Ext component lifecycle of creation, rendering and destruction. They also have automatic support for basic hide/show and enable/disable behavior. All visual widgets that require rendering into a layout should subclass Component (or BoxComponent if managed box model handling is required).
Every component has a specific xtype. This is the list of all valid xtypes:
xtype Class ------------- ------------------ box BoxComponent button Button colorpalette ColorPalette component Component container Container cycle CycleButton dataview DataView datepicker DatePicker editor Editor editorgrid EditorGridPanel grid GridPanel paging PagingToolbar panel Panel progress ProgressBar splitbutton SplitButton tabpanel TabPanel treepanel TreePanel viewport ViewPort window Window Toolbar components --------------------------------------- toolbar Toolbar Form components --------------------------------------- checkbox Checkbox combo ComboBox datefield DateField field Field fieldset FieldSet form FormPanel hidden Hidden htmleditor HtmlEditor numberfield NumberField radio Radio textarea TextArea textfield TextField timefield TimeField
@author Sanjiv Jivan
-
com.ibm.ucp.Component
-
com.l2client.component.Component
Just a base for components.
-
com.netflix.astyanax.annotations.Component
-
com.nineteendrops.tracdrops.client.api.ticket.component.Component
Created www.19drops.com User: 19drops Date: 09-sep-2009 Time: 22:02:57
This material is made available to anyone wishing to use, modify, copy, or redistribute it subject to the terms and conditions of the GNU Lesser General Public License, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with this distribution; if not, write to: Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor Boston, MA 02110-1301 USA
-
com.qspin.qtaste.kernel.testapi.Component
Interface for all Test API components
@author David Ergo
-
com.salesforce.ide.core.model.Component
Encapsulates properties and functionality associated with Force.com components.
@author cwall
-
com.scriptographer.ui.Component
@author lehni
-
com.sencha.gxt.widget.core.client.Component
Base class for all GXT widgets.
-
com.sun.dtv.lwuit.Component
Base class for all the widgets in the toolkit using the composite pattern in a similar way to the AWT Container/Component relationship. All components are potentially animated (need to be registered in {@link Display}).
@author Chen FishbeinFormato JAVA DTV 1.1 por
@author Leonardo Baptista
-
com.sun.enterprise.admin.servermgmt.xml.stringsubs.Component
3.org/2001/XMLSchema}anyType"> <sequence> <element ref="{http://xmlns.oracle.com/cie/glassfish/stringsubs}group-ref" maxOccurs="unbounded" minOccurs="0"/> </sequence> <attribute name="id" use="required" type="{http://xmlns.oracle.com/cie/glassfish/stringsubs}non-empty-string" /> </restriction> </complexContent> </complexType>
-
com.sun.xml.ws.api.Component
Interface that allows components to hook up with each other. Replaces {@link com.sun.xml.ws.api.server.EndpointComponent} so that componentpattern can apply to more RI types.
@since 2.2.6
@see WSEndpoint#getComponents()
@see ComponentRegistry
-
com.vaadin.ui.Component
{@code Component} is the top-level interface that is and must be implementedby all Vaadin components. {@code Component} is paired with{@link AbstractComponent}, which provides a default implementation for all the methods defined in this interface.
Components are laid out in the user interface hierarchically. The layout is managed by layout components, or more generally by components that implement the {@link ComponentContainer} interface. Such a container is theparent of the contained components.
The {@link #getParent()} method allows retrieving the parent component of acomponent. While there is a {@link #setParent(Component) setParent()}, you rarely need it as you normally add components with the {@link ComponentContainer#addComponent(Component) addComponent()} method ofthe layout or other {@code ComponentContainer}, which automatically sets the parent.
A component becomes attached to an application (and the {@link #attach()} is called) when it or one of its parents is attached to themain window of the application through its containment hierarchy.
@author IT Mill Ltd.
@version 6.7.1
@since 3.0
-
components.Component
Component
representa la clase base para cualquier componente, real o virtual, permitido en una simulaci�n. Un componente es una entidad lo suficientemente abstracta, como para que a partir de ella puedan construirse diferentes objetos (robots reales o virtuales, sensores, redes neuronales, etc).
A su vez, esta clase extiende a Observable
, lo que permite que cualquier componente pueda ser "observado" y actuar ante cambios en el mismo (por ejemplo, la interfaz gr�fica de usuario puede redibujarse ante un cambio en la posici�n de un robot).
Tambi�n implementa ComponentInterface
, que es la forma en que el mundo exterior puede acceder a las caracter�sticas de un componente.
Esta clase no puede ser instanciada (necesariamente, deber� extenderse).
-
de.fu_berlin.inf.dpp.annotations.Component
-
de.javakaffee.web.msm.serializer.TestClasses.Component
-
dnb.data.filetree.Component
-
edu.harvard.hul.ois.ots.schemas.MIX.Component
-
edu.indiana.extreme.xbaya.component.Component
@author Satoshi Shirasuna
-
fiftyone.mobile.detection.entities.Component
Every device can be split into the major components of hardware, operating system and browser. These the properties and values associated with these components are represented via this class.
-
fm.ak.otse.twod.Component
most 2d things that are visible. Commonly extended
-
fr.imag.adele.apam.Component
-
framework.component.Component
-
java.awt.Component
, now aButton has a listener with a reference // to bigOne! aButton.addActionListener(this); } public void actionPerformed(ActionEvent e) { System.out.println("Hello There"); } } In this example, serializing
aButton
by itself will cause
MyApp
and everything it refers to to be serialized as well. The problem is that the listener is serializable by coincidence, not by design. To separate the decisions about
MyApp
and the
ActionListener
being serializable one can use a nested class, as in the following example:
import java.awt.*; import java.awt.event.*; import java.io.Serializable; class MyApp java.io.Serializable { BigObjectThatShouldNotBeSerializedWithAButton bigOne; Button aButton = new Button(); static class MyActionListener implements ActionListener { public void actionPerformed(ActionEvent e) { System.out.println("Hello There"); } } MyApp() { aButton.addActionListener(new MyActionListener()); } }
Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.
For details on the focus subsystem, see How to Use the Focus Subsystem, a section in The Java Tutorial, and the Focus Specification for more information.
@version 1.451, 07/29/09
@author Arthur van Hoff
@author Sami Shaio
-
javax.jbi.component.Component
-
jfun.yan.Component
Responsible for component instance creation and verification.
Component is immutable. All update functions such as the ones started with "with" are functional-update, which means a new Component object is created to reflect the change, while the state of the old object remains the same.
Component is the core of Yan in the sense that most customizations of instance creation strategy can be done by combining existing Component objects.
This is called a "combinator" approach where complex components can be constructed by combining simpler components who may be combinations of yet simpler components.
Common combinators are included in this class to make the syntax simpler for combining components. For example:
comp1.withArguments(args) rather than Components.withArguments(comp1, args)
Codehaus.org.
@author Ben Yu
@see Components
@see jfun.yan.Monad
-
jp.co.acroquest.endosnipe.javelin.bean.Component
-
net.fortuna.ical4j.model.Component
-
net.java.games.input.Component
An axis is a single button, slider, or dial, which has a single range. An axis can hold information for motion (linear or rotational), velocity, force, or acceleration.
-
net.sf.jasperreports.engine.component.Component
A marker interface that is to be implemented by classes that can be used as report components.
Implementing classes should consider implementing {@link JRCloneable} as wellin order to have component clones created when components elements are cloned.
@author Lucian Chirita (lucianc@users.sourceforge.net)
@version $Id: Component.java 3033 2009-08-27 11:46:22Z teodord $
@see JRComponentElement
-
net.sf.minuteProject.configuration.bean.model.data.Component
-
net.sourceforge.stripes.examples.bugzooky.biz.Component
Class that represents a compopnent of a software system against which bugs can be filed.
@author Tim Fennell
-
nexj.core.meta.Component
Component metadata. Components are objects, which can be activated by name. Their initial state is configured in the metadata.
-
nextapp.echo2.app.Component
A representation of an Echo component. This is an abstract base class from which all Echo components are derived.
A hierarchy of Component
objects is used to represent the state of an application's user interface. A Component
may have a single parent Component
and may contain zero or more child Component
s. Certain Component
s may limit the number or type(s) of children which may be added to them, and may even establish requirements for what type(s) of parent Component
s they may be added to. In the event that an application attempts to add a child Component
to a parent Component
in spite of these requirements, an IllegalChildException
is thrown.
Properties and Styles
The state of a single Component
is represented by its properties. Properties can be categorized into two types: "style" and "non-style". Style properties are generally used to represent the "look-and-feel" of a Component--information such as colors, fonts, location, and borders. "Non-style" properties are generally used to represent non-stylistic information such as data models, selection models, and locale.
"Style Properties" have a special definition because they may be stored in Style
or StyleSheet
objects instead of as properties of a specific Component
instance. Property values contained in a relevant Style
or StyleSheet
will be used for rendering when the property values are not specified by a Component
itself. Style properties are identified by the presence of a public static constant name in a Component
implementation with the prefix PROPERTY_
. In the base Component
class itself there are several examples of style properties, such as PROPERTY_BACKGROUND
,PROPERTY_FONT
and PROPERTY_LAYOUT_DATA
. The rendering application container will use the Component.getRenderProperty()
and Component.getRenderIndexedProperty()
to retrieve the values of stylistic properties, in order that their values might be obtained from the Component
's shared Style
or the ApplicationInstance
's StyleSheet
in the event they are not directly set in the Component
.
A Component
implementation should not store the values of style properties as instance variables. Rather, the values of style properties should be stored in the local Style
instance, by way of the setProperty()
method. The getProperty()
method may be used to obtain the value of such properties. Only style properties should be stored using these methods; properties such as models should never be stored using the getProperty()
/setProperty()
interface.
Events
Many Component
s will provide the capability to register EventListener
s to notify interested parties when various state changes occur. The base Component
class provides an EventListenerList
as a convenient and memory efficient means of storing such listeners. The internal EventListenerList
may be obtained using the getEventListenerList()
method. The EventListenerList
is lazy-created and will only be instantiated on the first invocation of the getEventListenerList()
method. If the intent is only to inquire about the state of event listeners without necessarily forcing instantiation of an EventListenerList
, the hasEventListenerList()
should be queried prior to invoking getEventListenerList()
.
-
org.apache.airavata.workflow.model.component.Component
-
org.apache.airavata.xbaya.component.Component
-
org.apache.avalon.framework.component.Component
This interface identifies classes that can be used as
Components
by a
Composable
.
The contract surrounding the Component
is that it is used, but not a user. When a class implements this interface, it is stating that other entities may use that class.
A Component
is the basic building block of the Avalon Framework. When a class implements this interface, it allows itself to be managed by a ComponentManager
and used by an outside element called a Composable
. The Composable
must know what type of Component
it is accessing, so it will re-cast the Component
into the type it needs.
In order for a Component
to be useful you must either extend this interface, or implement this interface in conjunction with one that actually has methods. The new interface is the contract with the Composable
that this is a particular type of component, and as such it can perform those functions on that type of component.
For example, we want a component that performs a logging function so we extend the Component
to be a LoggingComponent
.
interface LoggingComponent extends Component { log(String message); }
Now all Composable
s that want to use this type of component, will re-cast the Component
into a LoggingComponent
and the Composable
will be able to use the log
method.
Deprecated: Deprecated without replacement. Should only be used while migrating away from a system based on Composable/ComponentManager. A generic java.lang.Object
can be used as a replacement.
@author
Avalon Development Team
@version CVS $Revision: 1.16 $ $Date: 2004/02/11 14:34:24 $
-
org.apache.camel.Component
emq.apache.org/camel/component.html">component is a factory of {@link Endpoint} objects.
@version $Revision: 519901 $
-
org.apache.felix.dm.Component
Component interface. Components are the main building blocks for OSGi applications. They can publish themselves as a service, and they can have dependencies. These dependencies will influence their life cycle as component will only be activated when all required dependencies are available.
@author
Felix Project Team
-
org.apache.felix.scr.Component
The Component
interface represents a single component managed by the Service Component Runtime. Management agents may access the Component instances through the {@link ScrService}.
-
org.apache.isis.viewer.html.component.Component
-
org.apache.maven.plugin.assembly.model.Component
-
org.apache.maven.plugins.changes.model.Component
-
org.apache.muse.ws.dm.muws.events.Component
@author Dan Jemiolo (danj)
-
org.apache.pivot.wtk.Component
Top level abstract base class for all components. In MVC terminology, a component represents the "controller". It has no inherent visual representation and acts as an intermediary between the component's data (the "model") and the skin, an implementation of {@link Skin} which serves asthe "view".
-
org.apache.servicemix.jbi.deployer.Component
This interface represents a JBI Component and will be registered in the OSGi registry
-
org.apache.servicemix.jbi.deployment.Component
@version $Revision: 426415 $
-
org.apache.struts2.components.Component
Base class to extend for UI components.
This class is a good extension point when building reuseable UI components.
-
org.apache.tapestry.annotations.Component
-
org.apache.tapestry.internal.Component
Represents the
internal component api exposed for use by core framework code only.
Use at your own risk as everything in this API is subject to change without notice from release to release.
-
org.apache.tapestry.runtime.Component
Interface that defines the lifecycle of a component, within a page, allowing for callbacks into the component for many different events. This interface is part of the public API for Tapestry, but is
not expected to be directly implemented by component classes; it should only be implemented as part of the component class transformation process.
Most of the methods are related to render phases; see the corresponding annotations and component rendering documentation to see how they relate to each other.
This interface is likely to change without notice.
-
org.apache.tapestry5.annotations.Component
A mixin for a text field that allows for autocompletion of text fields. This is based on Prototype's autocompleter control.
The mixin renders an (initially invisible) progress indicator after the field (it will also be after the error icon most fields render). The progress indicator is made visible during the request to the server. The mixin then renders a <div> that will be filled in on the client side with dynamically obtained selections.
Multiple selection on the client is enabled by binding the tokens parameter (however, the mixin doesn't help split multiple selections up on the server, that is still your code's responsibility).
The container is responsible for providing an event handler for event "providecompletions". The context will be the partial input string sent from the client. The return value should be an array or list of completions, in presentation order. I.e.
String[] onProvideCompletionsFromMyField(String input) { return . . .; }
-
org.apache.tapestry5.runtime.Component
Interface that defines the lifecycle of a component, within a page, allowing for callbacks into the component for many different events. This interface is part of the public API for Tapestry, but is
not expected to be directly implemented by component classes; it should only be implemented as part of the component class transformation process.
Most of the methods are related to render phases; see the corresponding annotations and component rendering documentation to see how they relate to each other.
Starting in 5.3 this interface no longer implements {@link PageLifecycleListener}. Normally, this would be an incompatible change, but Component is not supposed to be directly implemented by user code.
-
org.apache.tuscany.model.assembly.Component
A component is a configured instance of a generic {@link Implementation}.
-
org.apache.tuscany.sca.assembly.Component
Represents a component. A component is a configured instance of an implementation.
@version $Rev: 937981 $ $Date: 2010-04-26 10:35:27 +0100 (Mon, 26 Apr 2010) $
@tuscany.spi.extension.asclient
-
org.apache.tuscany.sca.topology.Component
Represents an SCA component and is used to represent which components will run on a node
@version $Rev: 567542 $ $Date: 2007-08-20 06:13:29 +0100 (Mon, 20 Aug 2007) $
-
org.apache.tuscany.spi.component.Component
The runtime instantiation of an SCA component
@version $$Rev: 441893 $$ $$Date: 2006-09-09 20:41:09 -0700 (Sat, 09 Sep 2006) $$
-
org.apache.vysper.xmpp.server.components.Component
a component is a server subsystem providing a dedicated extension. components operate on their own subdomain, e.g. conference.vysper.org for MUC. components have a dedicated context in which they receive stanzas
-
org.apache.wicket.Component
Component serves as the highest level abstract base class for all components.
- Identity - 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, butdoes not have to be globally unique or unique within a Page's component hierarchy.
- Hierarchy - 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.
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()}.
- LifeCycle - Components participate in the following lifecycle phases:
- Visibility - If a component is not visible (see {@link #setVisible(boolean)}) it will not render a response (nor will their children).
- Enabling - Component subclasses take into account their enabled state (see {@link #setEnabled(boolean)} when rendering, and in case of a {@link FormComponent} will not notupdate its model while the request is handled.
- Models - 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 retrievethe 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.
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()}.
Note that a component can have more models besides its default model. - Behaviors - 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.
- Locale - The Locale for a Component is available through {@link #getLocale()}, which delegates to its parent's locale, finally consulting the {@link Session}'s locale.
- Style - 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.
- Variation - Whereas styles are Session (user) specific, variations are component specific. E.g. if the Style is "ocean" and {@link #getVariation()} returnss "NorthSea", than theresources are given the names suffixed with "_ocean_NorthSea".
- String Resources - 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 theApplication Localizer for easy access in Components.
- Feedback Messages - The {@link Component#debug(Serializable)}, {@link Component#info(Serializable)}, {@link Component#warn(Serializable)}, {@link Component#error(java.io.Serializable)} and {@link Component#fatal(Serializable)} methodsassociate 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}.
- Versioning - 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 Componentcan be retrieved with {@link Component#isVersioned()}.
- Page - 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 specialcircumstances where it might be desirable to get a null reference back instead.
- Application - The {@link #getApplication()} method provides convenient access to the{@link Application} for a Component.
- AJAX support- Components can be re-rendered after the whole Page has been rendered at least once by calling doRender().
- Security - All components are subject to an {@link IAuthorizationStrategy} whichcontrols instantiation, visibility and enabling. See {@link SimplePageAuthorizationStrategy} fora simple implementation.
@author Jonathan Locke
@author Chris Turner
@author Eelco Hillenius
@author Johan Compagner
@author Juergen Donnerstag
@author Igor Vaynberg (ivaynberg)
-
org.appfuse.mojo.exporter.Component
Bean in charge to hold the default values needed to run a goal.
@author
Johann Reyes
@version $Id$
-
org.araneaframework.Component
An entity with a licecycle (
init
,
destroy
) and an Environment.
A components lifecycle is simple. It starts with init and ends with destroy.
- A component once inited, cannot be reinited.
- A component once destroyed, cannot be reinited.
- A component not inited, cannot be destroyed.
If a lifecycle contract is broken {@link org.araneaframework.core.AraneaRuntimeException}will be thrown.
The component is initialized with an {@link org.araneaframework.Environment}. The component's Environment cannot be altered after the initialization process.
The Component follows the template pattern by defining
_getComponent()
which returns the implementation.
@author "Toomas Römer"
@author Jevgeni Kabanov (ekabanov@webmedia.ee)
-
org.auraframework.instance.Component
This is the interface of a runtime instance of a component as it is exposed to the rest of the world.
-
org.beangle.model.Component
-
org.beangle.struts2.view.component.Component
- remove actionMapper\determineActionURL\determineNamespace
- remove copy parameter
@author chaostone
-
org.codehaus.plexus.component.annotations.Component
-
org.dmd.mvw.tools.mvwgenerator.extended.Component
-
org.eclipse.sapphire.samples.architecture.Component
-
org.eclipse.uml2.uml.Component
-
org.exoplatform.container.xml.Component
@author Tuan Nguyen (tuan08@users.sourceforge.net)
@since Apr 18, 2005
@version $Id: Component.java 5799 2006-05-28 17:55:42Z geaz $
-
org.exoplatform.webui.config.Component
Created by The eXo Platform SARL Author : Tuan Nguyen tuan08@users.sourceforge.net May 4, 2006
-
org.ggp.base.util.propnet.architecture.Component
The root class of the Component hierarchy, which is designed to represent nodes in a PropNet. The general contract of derived classes is to override all methods.
-
org.grouplens.grapht.Component
-
org.gwtoolbox.ioc.core.client.annotation.Component
-
org.hibernate.envers.test.entities.customtype.Component
@author Adam Warski (adam at warski dot org)
-
org.hibernate.mapping.Component
The mapping for a component, composite element, composite identifier, etc.
@author Gavin King
@author Steve Ebersole
-
org.hibernate.metamodel.domain.Component
Models the notion of a component (what JPA calls an Embeddable).
NOTE : Components are not currently really hierarchical. But that is a feature I want to add.
@author Steve Ebersole
-
org.ice4j.ice.Component
-
org.jboss.as.ee.component.Component
Common contract for an EE component. Implementations of this will be available as a service and can be used as the backing for a JNDI ObjectFactory reference.
@author John Bailey
@author
Carlo de Wolf
@author
David M. Lloyd
-
org.jboss.dashboard.factory.Component
This class holds all the properties regarding a Factory bean definition. Such definition is usually implemented by means of a .properties file inside the etc/factory directory..
-
org.jboss.dna.jcr.xpath.XPath.Component
-
org.jboss.seam.Component
Metamodel class for component classes. A Seam component is any class with a @Name annotation.
@author Thomas Heute
@author Gavin King
-
org.jtalks.common.model.entity.Component
-
org.milyn.edisax.model.internal.Component
-
org.modeshape.jcr.query.xpath.XPath.Component
-
org.mule.api.component.Component
A
Component
component processes a {@link MuleEvent} by invoking thecomponent instance that has been configured, optionally returning a result.
Implementations of
Component
can use different types of component implementation, implement component instance pooling or implement
bindings which allow for service composition.
-
org.netbeans.server.componentsmatch.Component
Issuezilla component with assigned numbers of issues
@author Petr Zajac
@author Jindrich Sedek
-
org.objectweb.fractal.api.Component
-
org.olat.core.gui.components.Component
Description:
@author Felix Jost
-
org.openxri.config.Component
Server components are pluggable parts of the OpenXRI server. They include: - Server - Store - URIMapper - Plugin
@author =peacekeeper
-
org.osgi.service.component.annotations.Component
-
org.restlet.Component
estlet.org/schemas/2.0/Component">online and inside the API JAR under the "org.restlet.Component.xsd" name. Here is a sample of XML configuration:
<?xml version="1.0"?> <component xmlns="http://www.restlet.org/schemas/2.0/Component"> <client protocol="CLAP" /> <client protocol="FILE" /> <client protocols="HTTP HTTPS" /> <server protocols="HTTP HTTPS" /> <defaultHost> <attach uriPattern="/abcd/{xyz}" targetClass="org.restlet.test.MyApplication" /> <attach uriPattern="/efgh/{xyz}" targetDescriptor="clap://class/org/restlet/test/MyApplication.wadl" /> </defaultHost> </component>
Components also have useful services associated. They are all enabled by default and are available as properties that can be eventually overridden:
- "logService" to configure access logging.
- "statusService" to provide common representations for exception status.
Concurrency note: instances of this class or its subclasses can be invoked by several threads at the same time and therefore must be thread-safe. You should be especially careful when storing state in member variables.
@see
Source
dissertation
@author Jerome Louvel
-
org.seattlegamer.spacegame.core.Component
-
org.servicemix.jbi.deployment.Component
@version $Revision: 174 $
-
org.sonar.api.component.Component
-
org.sonar.core.persistence.migration.v50.Component
-
org.sonar.wsclient.component.Component
-
org.sonatype.nexus.component.model.Component
An {@link Entity} that may contain any number of {@link Asset}s.
-
org.springframework.stereotype.Component
-
org.springmodules.xt.ajax.component.Component
Interface representing a web component to render.
@author Sergio Bossa
-
org.terasology.entitySystem.Component
A Component is (a collection of)
data that
- can be attached to/carried by an entity, and
- can be inspected and/or edited by one or more {@link org.terasology.entitySystem.systems.ComponentSystem}s.
@author Immortius
-
org.tubo.resource.component.Component
Created: Jun 17, 2005 6:05:40 AM Last Modification Date: $Date: 2006-10-26 01:10:31 -0500 (Thu, 26 Oct 2006) $
@author jlorenzo (jvlio@users.sourceforge.net)
@version $Revision: 49 $
-
org.vraptor.annotations.Component
-
org.waveprotocol.wave.federation.Proto.ProtocolDocumentOperation.Component
-
org.waveprotocol.wave.federation.ProtocolDocumentOperation.Component
-
org.waveprotocol.wave.model.operation.testing.StringDomain.StringOp.Component
-
org.wso2.carbon.ui.deployment.beans.Component
-
org.wso2.carbon.utils.component.xml.Component
-
org.xmatthew.spy2servers.core.Component
Component interface. ����ӿڣ��ṩ����Ļ�����������״̬��ء� �����������Ҫʵ�ָýӿڡ�
@author Matthew Xie
-
org.xmpp.component.Component
Component enhance the functionality of an XMPP server. Components are JavaBeans and will have their properties exposed as ad-hoc commands.
@author Matt Tucker
-
org.xulfaces.annotation.faces.COMPONENT
-
org.zkoss.zk.ui.Component
An UI component.
There are two kind of life-cycles: one is page creations and the other is asynchronous updates.
The Page Creation
The page creation occurs when a page is about to render at the first time. The detailed phases can be found in the devloper's guide.
The Asynchronous Update
The asynchronous update occurs when users does something on the browser, such as changing the content of input, clicking buttons and so on. Such behaviors are packed as requests, queue in the browser, and then send to the server at the proper time. The detailed phases can be found in the developer's guide.
No Synchronization Required
To simplify the development of components and applications, invocations of methods of components and event listener are all serialized. In other words, application and component developers need not worry synchronization and other thread issues (unless you are developing background thread to handle long operations).
It also implies a limitation that you cannot access components belonging to other desktops when processing an event.
@author tomyeh
-
pivot.wtk.Component
Top level abstract base class for all components. In MVC terminology, a component represents the "controller". It has no inherent visual representation and acts as an intermediary between the component's data (the "model") and the skin, an implementation of {@link Skin} which serves asthe "view".
TODO Add a contains() method or some equivalent that will support mouse interaction with non-rectangular components.
-
plan_runner.components.Component
-
railo.runtime.Component
interface for a Component
-
sw_digitalworks.Model.Component
@author Robi
@version 1.0
@created 22-febr.-2011 16:10:31
-
tridion.contentmanager.contentmanagement.Component