-
OntoUML.Container
A representation of the model object '
Container'.
The following features are supported:
- {@link OntoUML.Container#getInstanciarElement Instanciar Element}
@see OntoUML.OntoUMLPackage#getContainer()
@model
@generated
-
aQute.bnd.build.Container
-
ae.java.awt.Container
sun.com/docs/books/tutorial/uiswing/misc/focus.html"> 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
@see #add(ae.java.awt.Component,int)
@see #getComponent(int)
@see LayoutManager
@since JDK1.0
-
atunit.core.Container
-
biz.paluch.maven.configurator.model.Container
-
br.com.caelum.vraptor.ioc.Container
Provides components.
Registerable components can have different scopes: request (by default), session and application scope (only one instance for the entire app). App scoped components are registered through the use of the annotation \@ApplicatonScope.
@author Guilherme Silveira
-
ch.iterate.openstack.swift.model.Container
-
charva.awt.Container
Container is the abstract superclass of Window and Panel.
-
com.calclab.suco.client.ioc.Container
A Provider container
-
com.codename1.ui.Container
-
com.dbxml.db.core.Container
Container is a generic container for objects that are stored in a collection. A container can either contain a DocumentTable or a Value, depending on the collection type. Container associates the internal document or binary representation with its original collection and key, so that the contents of the container can be stored without having to maintain three separate references.
-
com.dodo.blog.ui.component.container.Container
-
com.dotmarketing.portlets.containers.model.Container
@author Hibernate CodeGenerator
-
com.emitrom.touch4j.client.ui.Container
a.com/touch/2-0/#!/api/Ext.Container>Ext.Container
-
com.extjs.gxt.ui.client.widget.Container
Class for any {@link BoxComponent} that can contain other components.Containers handle the basic behavior of containing components, namely managing, attaching, and detaching the child widgets.
When children are added to a container they are not physically added to the DOM of the container. Subclasses are responsible for connecting the child components.
Container does not define a root element. setElement must be called by any subclass to ensure the container has an element.
- Events:
- BeforeAdd : ContainerEvent(container, item, index)
Fires before a item is added or inserted. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- container : this
- item : the component being added
- index : the index at which the component will be added
- BeforeRemove : ContainerEvent(container, item)
Fires before a item is removed. Listeners can cancel the action by calling {@link BaseEvent#setCancelled(boolean)}.
- container : this
- item : the component being removed
- Add : ContainerEvent(container, item, index)
Fires after a item has been added or inserted.
- container : this
- item : the item that was added
- index : the index at which the item will be added
- Remove : ContainerEvent(container, item)
Fires after a item has been removed.
- container : this
- item : the item being removed
- Inherited Events:
- BoxComponent Move
- BoxComponent Resize
- Component Enable
- Component Disable
- Component BeforeHide
- Component Hide
- Component BeforeShow
- Component Show
- Component Attach
- Component Detach
- Component BeforeRender
- Component Render
- Component BrowserEvent
- Component BeforeStateRestore
- Component StateRestore
- Component BeforeStateSave
- Component SaveState
@param < T> the child component type
-
com.google.enterprise.connector.sharepoint.generated.gsbulkauthorization.Container
-
com.google.gwt.topspin.ui.client.Container
Base interface for all objects that can contain widgets. A typical use would be new Button(panel.getContainer());
-
com.hlcl.rql.as.Container
Diese Klasse beschreibt einen RedDot MultiLink Container.
@author LEJAFR
-
com.hp.hpl.jena.rdf.model.Container
An RDF Container.
This interface defines methods for accessing RDF container resources. These methods operate on the RDF statements contained in a model. The container implementation may cache state from the underlying model, so objects should not be added to or removed from the container by directly manipulating its properties, whilst the container is being accessed through this interface.
When a member is deleted from a container using this interface, or an iterator returned through this interface, all the other members with higher ordinals are renumbered using an algorithm which may depend on the type of the container.
This interface provides methods supporting typed literals. This means that methods are provided which will translate a built in type, or an object to an RDF Literal. This translation is done by invoking the toString()
method of the object, or its built in equivalent. The reverse translation is also supported. This is built in for built in types. Factory objects, provided by the application, are used for application objects.
This interface provides methods for supporting enhanced resources. An enhanced resource is a resource to which the application has added behaviour. RDF containers are examples of enhanced resources built in to this package. Enhanced resources are supported by encapsulating a resource created by an implementation in another class which adds the extra behaviour. Factory objects are used to construct such enhanced resources.
-
com.kpelykh.docker.client.model.Container
@author Konstantin Pelykh (kpelykh@gmail.com)
-
com.onpositive.commons.elements.Container
-
com.opensymphony.xwork2.inject.Container
ct the int constant named "i". @Inject("i") int i; // Inject the default implementation of Bar and the String constant // named "s". @Inject Foo(Bar bar, @Inject("s") String s) { ... } // Inject the default implementation of Baz and the Bob implementation // named "foo". @Inject void initialize(Baz baz, @Inject("foo") Bob bob) { ... } // Inject the default implementation of Tee. @Inject void setTee(Tee tee) { ... } }
To create and inject an instance of {@code Foo}:
Container c = ...; Foo foo = c.inject(Foo.class);
@see ContainerBuilder
@author crazybob@google.com (Bob Lee)
-
com.sencha.gxt.widget.core.client.container.Container
Abstract base for components that can contain child widgets.
-
com.spotify.docker.client.messages.Container
-
com.sun.appserv.management.base.Container
All MBeans which logically contain other MBeans implement this interface; such an MBean is considered a Container, and the contained MBean is considered a Containee. The interface indicates the potential to contain other MBeans; at any given time MBeans may or may not be contained.
-
com.sun.ejb.Container
A Container stores EJB instances and is responsible for the lifecycle, state management, concurrency, transactions, security, naming, resource management, etc. It does the above by interposing actions before and after invocations on EJBs. It uses the ProtocolManager, SecurityManager, TransactionManager, NamingManager for help with the above responsibilities. There are four types of Containers: StatefulSessionContainer, StatelessSessionContainer, EntityContainer, and MessageBeanContainer. Note: the term "Container" here refers to an instance of one of the above container classes. In the EJB spec "container" refers to a process or JVM which hosts EJB instances.
There is one instance of the Container for each EJB type (deployment desc). When a JAR is deployed on the EJB server, a Container instance is created for each EJB declared in the ejb-jar.xml for the EJB JAR.
The Container interface provides methods called from other parts of the RI as well as from generated EJBHome/EJBObject implementations.
-
com.sun.jersey.samples.storageservice.Container
-
com.sun.lwuit.Container
-
com.sun.xml.internal.ws.api.server.Container
Root of the SPI implemented by the container (such as application server.)
Often technologies that are built on top of JAX-WS (such as Tango) needs to negotiate private contracts between them and the container. This interface allows such technologies to query the negotiated SPI by using the {@link #getSPI(Class)}.
For example, if a security pipe needs to get some information from a container, they can do the following:
- Negotiate an interface with the container and define it. (let's call it ContainerSecuritySPI.)
- The container will implement ContainerSecuritySPI.
- At the runtime, a security pipe gets {@link WSEndpoint} and then to {@link Container}.
- It calls container.getSPI(ContainerSecuritySPI.class)
- The container returns an instance of ContainerSecuritySPI.
- The security pipe talks to the container through this SPI.
This protects JAX-WS from worrying about the details of such contracts, while still providing the necessary service of hooking up those parties.
Technologies that run inside JAX-WS server runtime can access this object through {@link WSEndpoint#getContainer()}. In the client runtime, it can be accessed from {@link ContainerResolver#getContainer()}
@author Kohsuke Kawaguchi
@see WSEndpoint
-
com.sun.xml.ws.api.server.Container
Root of the SPI implemented by the container (such as application server.)
Often technologies that are built on top of JAX-WS (such as Tango) needs to negotiate private contracts between them and the container. This interface allows such technologies to query the negotiated SPI by using the {@link #getSPI(Class)}.
For example, if a security pipe needs to get some information from a container, they can do the following:
- Negotiate an interface with the container and define it. (let's call it ContainerSecuritySPI.)
- The container will implement ContainerSecuritySPI.
- At the runtime, a security pipe gets {@link WSEndpoint} and then to {@link Container}.
- It calls container.getSPI(ContainerSecuritySPI.class)
- The container returns an instance of ContainerSecuritySPI.
- The security pipe talks to the container through this SPI.
This protects JAX-WS from worrying about the details of such contracts, while still providing the necessary service of hooking up those parties.
Technologies that run inside JAX-WS server runtime can access this object through {@link WSEndpoint#getContainer()}. In the client runtime, it can be accessed from {@link ContainerResolver#getContainer()}
@author Kohsuke Kawaguchi
@see WSEndpoint
-
com.tensegrity.palo.gwt.widgets.client.container.Container
-
com.vaadin.data.Container
A specialized set of identified Items. Basically the Container is a set of {@link Item}s, but it imposes certain constraints on its contents. These constraints state the following:
- All Items in the Container must have the same number of Properties.
- All Items in the Container must have the same Property ID's (see {@link Item#getItemPropertyIds()}).
- All Properties in the Items corresponding to the same Property ID must have the same data type.
- All Items within a container are uniquely identified by their non-null IDs.
The Container can be visualized as a representation of a relational database table. Each Item in the Container represents a row in the table, and all cells in a column (identified by a Property ID) have the same data type. Note that as with the cells in a database table, no Property in a Container may be empty, though they may contain null
values.
Note that though uniquely identified, the Items in a Container are not necessarily {@link Container.Ordered ordered} or {@link Container.Indexed indexed}.
Containers can derive Item ID's from the item properties or use other, container specific or user specified identifiers.
If a container is {@link Filterable filtered} or {@link Sortable sorted}, most of the the methods of the container interface and its subinterfaces (container size, {@link #containsId(Object)}, iteration and indices etc.) relate to the filtered and sorted view, not to the full container contents. See individual method javadoc for exceptions to this (adding and removing items).
The Container interface is split to several subinterfaces so that a class can implement only the ones it needs.
@author Vaadin Ltd
@since 3.0
-
com.vaadin.terminal.gwt.client.Container
-
com.vmware.bdd.placement.Container
-
de.ailis.xadrian.data.Container
-
de.iritgo.aktera.core.container.Container
@author SchatterjeeTo change the template for this generated type comment go to Window - Preferences - Java - Code Generation - Code and Comments
-
de.javakaffee.kryoserializers.TestClasses.Container
-
de.javakaffee.web.msm.serializer.javolution.TestClasses.Container
-
de.sebastianbenz.task.Container
A representation of the model object '
Container'.
The following features are supported:
- {@link de.sebastianbenz.task.Container#getChildren Children}
@see de.sebastianbenz.task.TaskPackage#getContainer()
@model abstract="true"
@generated
-
de.tuclausthal.informatik.winf.mobileagents.container.Container
A container object provides a execution environment for mobile agent. It is responsible for managing the execution of agents, starting and stopping them and has to provide internal message passing and resource management.
To manage agents a Container
uses an instance of a class implementing AgentInfo
by which an agent can be identified and all resources can be mapped to it; the container functions as a factory for the AgentInfo
object.
@author dluebke
@version 1.0.15 (2003-10-02)
@since 1.0
-
de.willuhn.jameica.gui.util.Container
-
edu.mit.simile.fresnel.util.Container
Convenience class representing a generic RDF container (super class of bag, alt, seq).
@author ryanlee
-
fr.dyade.aaa.jndi2.server.Container
-
io.fabric8.api.Container
-
java.awt.Container
sun.com/docs/books/tutorial/uiswing/misc/focus.html"> How to Use the Focus Subsystem, a section in
The Java Tutorial, and the
Focus Specification for more information.
@version 1.302, 02/11/09
@author Arthur van Hoff
@author Sami Shaio
@see #add(java.awt.Component,int)
@see #getComponent(int)
@see LayoutManager
@since JDK1.0
-
jfun.yan.Container
The facade interface which provides the full functionality of yan container.
Codehaus.org.
@author Ben Yu
-
juzu.impl.inject.spi.cdi.Container
-
lab5.common.Container
-
mdes.slick.sui.Container
-
net.datacrow.core.objects.helpers.Container
-
net.java.sip.communicator.service.gui.Container
The Container wraps a string which is meant to point to a plugin container. The plugin container is a GUI container that contains plugin components.
@author Yana Stamcheva
-
net.minecraft.inventory.Container
-
net.sf.block.Container
-
net.sf.cram.structure.Container
-
net.sf.joafip.export_import.Container
@author luc peuvrier
-
net.sf.orexio.lopf.container.Container
-
net.sourceforge.javautil.container.annotation.Container
-
objot.container.Container
-
org.apache.cactus.integration.ant.container.Container
Interface for classes that can be used as nested elements in the <containers>
element of the <cactus>
task.
@version $Id: Container.java 239130 2005-01-29 15:49:18Z vmassol $
-
org.apache.click.control.Container
Provides the interface for a container which holds a list of child controls.
Container extends {@link org.apache.click.Control} and enables the creation ofnested controls.
Container allows one to add, remove and retrieve child controls.
Please note {@link AbstractContainer} providesa default implementation of the Container interface to make it easier for developers to create their own containers.
@see org.apache.click.util.ContainerUtils
-
org.apache.commons.jxpath.Container
A Container is an object implementing an indirection mechanism transparent to JXPath. For example, if property "foo" of the context node has a Container as its value, the XPath "foo" will produce the contents of that Container, rather than the container itself.
@author Dmitri Plotnikov
@version $Revision: 1.4 $ $Date: 2003/03/11 00:59:11 $
-
org.apache.hadoop.yarn.api.records.Container
Container
represents an allocated resource in the cluster.
The ResourceManager
is the sole authority to allocate any Container
to applications. The allocated Container
is always on a single node and has a unique {@link ContainerId}. It has a specific amount of {@link Resource} allocated.
It includes details such as:
- {@link ContainerId} for the container, which is globally unique.
- {@link NodeId} of the node on which it is allocated.
- HTTP uri of the node.
- {@link Resource} allocated to the container.
- {@link Priority} at which the container was allocated.
- {@link ContainerState} of the container.
- {@link ContainerToken} of the container, used to securely verify authenticity of the allocation.
- {@link ContainerStatus} of the container.
Typically, an ApplicationMaster
receives the Container
from the ResourceManager
during resource-negotiation and then talks to the NodManager
to start/stop containers.
@see AMRMProtocol#allocate(org.apache.hadoop.yarn.api.protocolrecords.AllocateRequest)
@see ContainerManager#startContainer(org.apache.hadoop.yarn.api.protocolrecords.StartContainerRequest)
@see ContainerManager#stopContainer(org.apache.hadoop.yarn.api.protocolrecords.StopContainerRequest)
-
org.apache.hadoop.yarn.server.nodemanager.containermanager.container.Container
-
org.apache.openejb.Container
-
org.apache.openejb.config.sys.Container
3.org/2001/XMLSchema>string"> <attribute name="ctype" use="required" type="{http://www.openejb.org/System/Configuration}ContainerTypes" /> <attribute name="id" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /> <attribute name="jar" type="{http://www.openejb.org/System/Configuration}JarFileLocation" /> <attribute name="provider" type="{http://www.w3.org/2001/XMLSchema}string" /> </extension> </simpleContent> </complexType>
-
org.apache.pivot.wtk.Container
Abstract base class for containers.
-
org.apache.qpid.amqp_1_0.transport.Container
-
org.apache.struts2.jquery.components.Container
-
org.apache.tomcat.Container
A
Container is an object that can execute requests received from a client, and return responses based on those requests. A Container may optionally support a pipeline of Valves that process the request in an order configured at runtime, by implementing the
Pipeline interface as well.
Containers will exist at several conceptual levels within Tomcat. The following examples represent common cases:
- Engine - Representation of the entire Tomcat servlet engine, most likely containing one or more subcontainers that are either Host or Context implementations, or other custom groups.
- Host - Representation of a virtual host containing a number of Contexts.
- Context - Representation of a single ServletContext, which will typically contain one or more Wrappers for the supported servlets.
- Wrapper - Representation of an individual servlet definition (which may support multiple servlet instances if the servlet itself implements SingleThreadModel).
A given deployment of Tomcat need not include Containers at all of the levels described above. For example, an administration application embedded within a network device (such as a router) might only contain a single Context and a few Wrappers, or even a single Wrapper if the application is relatively small. Therefore, Container implementations need to be designed so that they will operate correctly in the absence of parent Containers in a given deployment.
A Container may also be associated with a number of support components that provide functionality which might be shared (by attaching it to a parent Container) or individually customized. The following support components are currently recognized:
- Loader - Class loader to use for integrating new Java classes for this Container into the JVM in which Tomcat is running.
- Logger - Implementation of the
log()
method signatures of the ServletContext
interface. - Manager - Manager for the pool of Sessions associated with this Container.
- Realm - Read-only interface to a security domain, for authenticating user identities and their corresponding roles.
- Resources - Implementation of the resource access method signatures of the
ServletContext
interface, enabling custom linkages to existing server components when Tomcat is embedded in a larger server.
@author Craig R. McClanahan
@version $Revision: 1.5 $ $Date: 2000/04/10 18:44:39 $
-
org.apache.tomcat.core.Container
A group of resources, with some common properties. Container is similar with Apache "dir_conf" structue. Each Context has a default Container and one container for each URL property ( mapping handlers and security constraints ). The ContextManager has a defaultContainer containing global properties. Each time a container is added to a Context, addContainer() hook is called to notify all modules of a new URL property. Modules that implement contextMap/requestMap and security constraints ( authenticate/authorize hooks ) will construct specialized data structures. You can associate trees, hashtables or other data types with the context using notes - no application/module should assume any particular structure is in used, the user can choose any mapper. See SimpleMapper1 for an example of such structures. A container will be selected by best-matching a request using the alghoritms described in the servlet API.
-
org.apache.tomee.embedded.Container
@version $Rev$ $Date$
-
org.apache.xmlbeans.impl.store.Splay.Container
-
org.castor.cache.hashbelt.container.Container
An interface describing implementation strategies for containers on the hashbelt; containers hold objects that are in the hashbelt, and provide the time-based grouping that allows the container to be efficiently dealt with as a group of objects to be expired.
Implementations of this interface need to be appropriately synchronized -- the implementations of the hashbelt rely on this object to be threadsafe.
@author Gregory Block
@author Ralf Joachim
@version $Revision: 7950 $ $Date: 2006-04-25 16:09:10 -0600 (Tue, 25 Apr 2006) $
@since 1.0
-
org.codehaus.cargo.container.Container
-
org.csu.idl.idlmm.Container
A representation of the model object '
Container'.
The following features are supported:
- {@link org.csu.idl.idlmm.Container#getContains Contains}
@see org.csu.idl.idlmm.IdlmmPackage#getContainer()
@model abstract="true"
@generated
-
org.directwebremoting.Container
A very basic IoC container. See ContainerUtil for information on how to setup a {@link Container}
@author Joe Walker [joe at getahead dot ltd dot uk]
-
org.eclipse.core.internal.resources.Container
-
org.exoplatform.container.spi.Container
This interface defines all the methods that we need to implement in order to allow eXo Kernel to delegate the whole life cycle of the components. An implementation needs to be able to:
- Register a new component
- Manage the creation of the components
- Manage the initialization of the components
- Manage the startup of the components
- Manage the shutdown of the components
- Manage the destruction of the components
- Provide the components matching with some specific criteria
@author
Nicolas Filotto
@version $Id$
-
org.exoplatform.portal.config.model.Container
@author Tuan Nguyen
-
org.fcrepo.utilities.install.container.Container
Abstract class representing a servlet container.
@author Edwin Shin
-
org.gatein.api.composition.Container
A block of content to be displayed on a {@link Page}. Its main responsibility is to provide a template that renders the children of this {@link Container} in the user interface.
@author
Juraci Paixão Kröhling
-
org.gephi.io.importer.api.Container
A container is created each time data are imported by
importers. Its role is to host all data collected by importers during import process. After pushing data in the container, its content can be analysed to verify its validity and then be processed by
processors. Thus containers are
loaded by importers and
unloaded by processors.
See {@link ContainerLoader} for how to push graph and attributes data in the container and see{@link ContainerUnloader} for how to retrieve data in the container.
@author Mathieu Bastian
@see Importer
@see Processor
-
org.glassfish.api.admin.config.Container
Tag interface for container related configuration. Inheriting from this interface allows glassfish to replicate the container configuration in a clustered environment allowing per server configuration, etc...
@author Jerome Dochez
-
org.glassfish.api.container.Container
Contract identifying a container implementation. Usually the names of the container should be specific enough to ensure uniqueness. In most cases, it is recommended to use the full class name as the @Service name attribute to ensure that two containers do no collide.
@author Jerome Dochez
-
org.groovymud.object.Container
basic interface for all containers.
@author matt
-
org.huihoo.willow.Container
@author zosatapoTo change the template for this generated type comment go to Window - Preferences - Java - Code Generation - Code and Comments
-
org.jboss.arquillian.container.spi.Container
-
org.jboss.arquillian.impl.domain.Container
-
org.jboss.ejb.Container
This is the base class for all EJB-containers in JBoss. A Container functions as the central hub of all metadata and plugins. Through this the container plugins can get hold of the other plugins and any metadata they need.
The EJBDeployer creates instances of subclasses of this class and calls the appropriate initialization methods.
A Container does not perform any significant work, but instead delegates to the plugins to provide for all kinds of algorithmic functionality.
@see EJBDeployer
@author Rickard Oberg
@author Marc Fleury
@author Scott Stark.
@author Bill Burke
@author David Jencks
@author Christoph G. Jung
@author Dimitris Andreadis
@author adrian@jboss.org
@author anil.saldhana@jboss.org
@version $Revision: 98925 $
@jmx.mbean extends="org.jboss.system.ServiceMBean"
-
org.jboss.ejb3.Container
Comment A container is optionally associated with a security manager. If it is the container is running in secured mode, if not the container is running in unchecked mode.
@author
Bill Burke
@version $Revision: 76905 $
-
org.jboss.errai.ioc.client.Container
-
org.jboss.forge.arquillian.container.Container
@Author Paul Bakker - paul.bakker.nl@gmail.com
-
org.jboss.mbui.model.structure.Container
A container is used to hierarchically structure the abstract interaction objects.
@author Harald Pehl
@date 10/31/2012
-
org.jboss.test.xml.any.Container
-
org.jboss.test.xml.initializer.Container
-
org.jboss.weld.Container
A Weld application container
@author pmuir
-
org.jboss.weld.environment.Container
Abstract the web container setup notion. e.g. Tomcat, Jetty, GAE, ...
@author
Ales Justin
-
org.jclouds.docker.domain.Container
-
org.jclouds.openstack.swift.v1.domain.Container
ck.org/api/openstack-object-storage/1.0/content/s_listcontainers.html">api
doc
-
org.jclouds.snia.cdmi.v1.domain.Container
@author Kenneth Nagin
-
org.joshy.gfx.node.layout.Container
-
org.kite9.diagram.primitives.Container
Interface to say that this diagram element contains others rendered within it.
@see Leaf
@author robmoffat
-
org.ofbiz.base.container.Container
An OFBiz container. A container can be thought of as a background process.
When OFBiz starts, the main thread will create the Container
instance and then call the container's init
method. If the method returns without throwing an exception the container will be added to a list of initialized containers. After all instances have been created and initialized, the main thread will call the start
method of each container in the list. When OFBiz shuts down, a separate shutdown thread will call the stop
method of each container. Implementations should anticipate asynchronous calls to the methods by different threads.
Containers might be loaded more than once (have more than one instance).
-
org.olat.core.gui.components.Container
Description:
@author Felix Jost
-
org.omg.CORBA.Container
-
org.openqreg.element.Container
@author OlovF TODO To change the template for this generated type comment goto Window - Preferences - Java - Code Style - Code Templates
@responsible Olov
-
org.simpleframework.http.core.Container
The
Container
object is used to process HTTP requests and compose HTTP responses. The
Request
objects that are handed to this container contain all information relating to the received message. The responsibility of the container is to interpret the request and compose a suitable response.
All implementations must ensure that the container is thread safe as it will receive multiple HTTP transactions concurrently. Also it should be known that the Response
object used to deliver the HTTP response will only commit and send once it has its OutputStream
closed.
The Container
is entirely responsible for the HTTP message headers and body. It is up to the implementation to ensure that it complies to RFC 2616 or any previous specification. All headers and the status line can be modified by this object.
@author Niall Gallagher
-
org.springframework.extensions.webscripts.Container
-
org.springframework.xd.dirt.cluster.Container
Domain object for an XD container. This object is typically constructed from container data maintained in ZooKeeper.
@author Patrick Peralta
@author Ilayaperumal Gopinathan
-
org.teleal.cling.support.model.container.Container
-
org.useware.kernel.model.structure.Container
A container is used to hierarchically structure the abstract interaction objects.
@author Harald Pehl
@date 10/31/2012
-
org.vertx.java.platform.Container
g">Tim Fox
-
pivot.wtk.Container
Abstract base class for containers.
NOTES:
- Child components that have special meaning to a container should be installed via a dedicated method (for example, {@link pivot.wtk.Window#setContent(Component)}); additional components may be added by the skin when installed. Other components may still be added but may not be rendered properly by the installed skin.
- Callers should not rely on component position within container to mean anything other than paint order.
@author gbrown
-
pu.web.client.gui.Container
-
ru.vassaev.core.container.Container
-
sc.client.world.Container
-
selenium.step3.Container