Eclipse plug-ins embody an architectural pattern for building an application from constituent parts. This article presents an in-depth view of the participant roles and collaborations of this architectural pattern, as they exist in an instance of the Eclipse workbench. The goal is to provide an understanding of plug-ins, and of how plug-in extensions are defined and processed, independently of the mechanics of using the Eclipse workbench to produce plug-ins.
Eclipse is an extensible platform for building IDEs. It provides a core of services for controlling a set of tools working together to support programming tasks. Tool builders contribute to the Eclipse platform by wrapping their tools in pluggable components, called Eclipse plug-ins, which conform to Eclipse's plug-in contract. The basic mechanism of extensibility in Eclipse is that new plug-ins can add new processing elements to existing plug-ins. And Eclipse provides a set of core plug-ins to bootstrap this process. For a general introduction to Eclipse as an extensible IDE platform, see the literature available at this site.
Even though the Eclipse platform is specialized for building IDEs, the core of its concepts and facilities supports a general model for composing an application from constituent parts developed by multiple vendors. This general model of system composition in Eclipse will be described and placed in the context of other software patterns in this article. The article is intended for new plug-in developers who need to understand the overall model of how plug-ins work, either before, or in conjunction with, working through the mechanics of building plug-ins.
The article is structured as follows. Section 2 outlines the Eclipse plug-in model and the declarative specification of plug-ins and their relationships within this model. Section 3 explains what plug-in developers must do programmatically to allow their plug-ins to be extended. Section 4 provides a complete example of an extensible plug-in and its extensions by other plug-ins. Section 5 contrasts the Eclipse plug-in model with the much simpler observer pattern of . Section 6 concludes the article by summarizing the main architectural concepts used in Eclipse plug-ins.
This article specifically avoids the mechanics of the required user interactions with the Eclipse plug-in development environment (PDE) to build and test plug-ins. See Beck and Gamma , Shavor, et. al. , the online help documentation, and other articles at this site for the required procedures to build and test plug-ins in the PDE.
The companion plug-ins zip file includes the plug-in samples appearing in this article. Installation instructions for the samples appear at the end of this article. Also accompanying this article is the samples API reference.
A plug-in in Eclipse is a component that provides a certain type of service within the context of the Eclipse workbench. By a component here I mean an object that may be configured into a system at system deployment time. The Eclipse runtime provides an infrastructure to support the activation and operation of a set of plug-ins working together to provide a seamless environment for development activities. Within a running Eclipse instance, a plug-in is embodied in an instance of some plug-in runtime class, or plug-in class, for short. The plug-in class provides configuration and management support for the plug-in instance. A plug-in class in Eclipse must extend org.eclipse.core.runtime.Plugin, which is an abstract class that provides generic facilities for managing plug-ins.
An Eclipse installation includes a plugins folder where individual plug-ins are deployed. Each plug-in is installed in its own folder under the plugins folder. A plug-in is described in an XML manifest file, called plugin.xml, residing in the plug-in's folder. The manifest file tells the Eclipse runtime what it needs to know to activate the plug-in.
The parsed contents of plug-in manifest files are made available programmatically through a plug-in registry API. And parsed plug-in specifications are cached in an in-memory repository called the plug-in registry. The Eclipse runtime instantiates an instance of each plug-in by using the plug-in registry API. The plug-in registry API is also used by provider-supplied plug-in code to obtain information about plug-ins.
Listing 2.1. A Minimal Plug-in Manifest File.
The Eclipse Platform Plug-in Manifest Specification documents the XML elements and attributes used in defining plug-ins. (This specification is also available in the Eclipse platform help documentation under Platform Plug-In Developer Guide/Other reference information/Plug-in manifest).
Plug-in instances are managed by the Eclipse runtime, and are accessed by using the Eclipse platform as shown above. Plug-in instances are not constructed by application programs.
Deploying a plug-in in an Eclipse installation involves copying the resources that constitute the plug-in (the manifest file, jar files, and other resources) into an individual folder for the plug-in, under the installation's plugins directory. Such a plug-in can then be activated by the Eclipse runtime when it is required to perform some function. Activating a plug-in means loading its runtime class and instantiating and initializing its instance.
The main function of a plug-in class is to do special processing during plug-in activation and deactivation, e.g., to allocate and release resources. For simple plug-ins, like the JUnit plug-in above, no specific activation or deactivation processing is required, and therefore no specific plug-in class need be provided by the plug-in designer. In that case, the Eclipse runtime automatically provides a default plug-in class for the plug-in instance.
When the plug-in needs to do something specific to activate or deactivate itself, the plug-in designer subclasses org.eclipse.core.runtime.Plugin, provides overrides for the activation and deactivation methods of the class, respectively called startup and shutdown, and includes the fully-qualified name of this specific plug-in subclass as the value of the attribute class in the corresponding plug-in manifest file.
Eclipse includes a plug-in management kernel, known as the Eclipse platform, or the Eclipse runtime, and certain core plug-ins that are present in every Eclipse deployment. The identities of these core plug-ins are hard-coded into the Eclipse platform, and the platform knows to activate these plug-ins in each running instance of Eclipse. Non-core plug-ins, on the other hand, are activated when required by other plug-ins, as described below.
Dependency. The roles in this relationship are dependent plug-in and prerequisite plug-in. A prerequisite plug-in supports the functions of a dependent plug-in.
Extension. The roles in this relationship are host plug-in and extender plug-in. An extender plug-in extends the functions of a host plug-in.
These relationships are specified declaratively in plug-in manifest files through the XML elements requires and extension (the details of which appear in later subsections).
A non-core plug-in that has been deployed in an Eclipse installation may be activated in a running instance of Eclipse if it is transitively related to a core Eclipse plug-in by the union of the dependency and the extension relations. Such a plug-in will be activated when its functions are required to support or to extend the functions of another plug-in. A plug-in that is deployed but unreachable from any core plug-in via the dependency and extension relations might as well not be deployed from the point of view of plug-in activation. Of course, even a reachable plug-in may remain unactivated in a running instance for some time (or for the lifetime of the instance), if no user action or other triggering event elicits its use.
Listing 2.2. Specifying Plug-in Dependencies.
In this example, the sample plug-in com.bolour.sample.eclipse.demo is declared to be dependent on (i.e., to make use of) the base Eclipse UI plug-in org.eclipse.ui.
Dependency as defined in the plug-in manifest file is both a runtime and a compile-time directive. At runtime, Eclipse has to make sure that a prerequisite plug-in can be made available to a dependent plug-in when the dependent plug-in is activated. At compile time, Eclipse can be directed to augment the classpath for compiling a dependent plug-in by the jar files of all of its prerequisite plug-ins.
When the facilities of a plug-in are to be made directly available to the user, one or more user interface elements have to be added to the base Eclipse workbench. For example, to make the workbench's help plug-in available to the user, help menu items must be added to the workbench user interface.
The process of adding some processing element or elements to a plug-in is known as an extension. This process is not restricted to UI elements, however. Any plug-in may allow other plug-ins to extend it by adding processing elements. An extension is defined by an extender plug-in and causes a host plug-in to modify its behavior. Typically, this modification of behavior includes the addition of processing elements to the host plug-in (e.g., the addition of new menu items to the Eclipse workbench), and the customization of the behavior of these additional elements by services provided by the extender plug-in (e.g., the customization of new menu items by specific menu event handlers).
In simple cases, a single act of extension adds a single callback object to the environment, through which the host and extender plug-ins communicate. The callback object is different from the host and extender plug-in objects. And unlike these objects, which are components that are automatically instantiated and managed by the Eclipse platform, a callback object is a plain old Java objects that is instantiated and managed specifically by provider-supplied code. A single act of extension can also add more than one callback object to the environment. For example, Eclipse allows a set of menus to be added to its user interface via a single extension.
Note, however, that the extension model, per se, is quite general, and does not necessarily require that an extender plug-in provide custom callback objects. It is possible, for example, that the kind of behavior modification required of a host plug-in can be provided entirely by objects whose classes are known to the host plug-in at compile-time, so that an extension declaration serves merely to parameterize instances of such built-in classes.
Similarly, the extension model, per se, does not require that the host plug-in directly expose aspects of each of its extensions in its interface. For example, an extension may merely ask that an extender plug-in be notified of certain events known to occur in the host plug-in independently of the extender plug-in, without any changes visible in the host plug-in's interface.
A plug-in may allow itself to be augmented by different kinds of extensions. For example, the workbench UI allows both its menus and its editors to be extended. In each case, the extension must conform to a unique set of configuration and behavioral requirements. Therefore, an extensible plug-in provides different types of slots that extensions can plug into. These slot types are called extension points. In the remainder of this article I will use the compound form extension-point to refer to these slots. An extension-point allows any number of extensions to be plugged into it.
Extension and extension-point are standard Eclipse plug-in terminology. Host plug-in, extender plug-in, and callback object are terms used in this article to describe the different roles of objects in an extension.
Figure 1 illustrates the relationships between the participants of an extension, in this case, the extension of the Eclipse workbench by the menu items of the Eclipse help system. In this extension, the host plug-in is the Eclipse workbench user interface, org.eclipse.ui, whose menus can be extended via an extension-point known as actionSets. The extender plug-in is the Eclipse help system's user interface, org.eclipse.help.ui. In order to make help functions available to the user, the help UI plug-in uses the actionSets extension-point to extend the workbench UI plug-in by specific help-related menu items, among them, Help->Help Contents and Search->Help. The extension is defined by the extender plug-in. And in this case, the single extension augments the workbench UI by multiple menu items.
Figure 1. Participants of a plug-in extension. The workbench UI plug-in is extended by the workbench help plug-in via an actionSets extension that defines specific help-related menu items.
Also shown in the figure are the classes of the extension's callback objects: that is, the classes of the help system's menu handlers. As we will see shortly, callback classes are typically identified by name in the declarative specification of each extension. Thus, this extension's Help->Help Contents menu specification declares its custom callback class (menu handler) to be HelpContentsAction. And the extension's Search->Help menu specification declares its custom callback class (menu handler) to be OpenHelpSearchPageAction (see blow for details).
Note that to reduce clutter, package prefixes are not shown in this and later figures. Here the workbench plug-in class belongs to the org.eclipse.ui.internal package; and the help plug-in and related classes belong to the org.eclipse.help.ui.internal package.
The remainder of this section provides a detailed account of how extension-points and extensions are defined.
Let us now look more closely at the various roles played by the objects participating in an extension. There are two plug-in roles, host and extender, a generic role of a callback object, and specific callback roles defined by each extension-point.
In the context of a particular extension, a plug-in that stands in the host role provides the extension-point and is extended. In addition to providing services in its own right, such a plug-in also acts as the coordinator and controller of a number of extensions.
Listing 2.3. Declaring an Extension-Point.
The documentation for this extension-point is provided in a reference page (and is also available in the Eclipse platform on-line help at Platform Plugin Developer Guide/Reference/Extension Points Reference/Workbench/org.eclipse.ui.actionSets). The documentation indicates, among other things, that this extension-point provides a plug-in slot for sets of menus, menu items, and buttons to be added to the base Eclipse workbench.
The extension-point specification defines a unique identifier for the extension-point within this host plug-in. To identify an extension-point uniquely in global context, the extension-point identifier is prepended with the unique identifier of the host plug-in (as in ) to form a fully-qualified identifier for the extension-point. Thus, the fully-qualified identifier of the actionSets extension-point of the Eclipse UI plug-in is org.eclipse.ui.actionSets. Plug-ins that extend an extension-point refer to it by its fully-qualified identifier.
The extension-point specification ( ) also declares an XML schema for the extensions of this extension-point, which provides the syntax for declaring menus, menu items, and buttons to be added to the workbench UI. We'll have more to say about the structure and contents of such a schema in section 2.3.3.
Listing 2.4. Declaring an Extension.
Note that in this extender plug-in, the actionSets extension-point is referred to by its fully-qualified identifier ( ).
The portion of the actionSets extension shown in Listing 2.4 defines two actions ( , ). The actions shown are made available through the workbench menu items Help->Help Contents and Search->Help, respectively.
In the context of a particular extension, an object that stands in a callback role is a plain old Java object (not a plug-in) that is called by the host plug-in when certain events specified in the corresponding extension-point contract are recognized by the host plug-in. The interface for callback objects is provided by the host plug-in, and is documented in the documentation of the extension-point being extended. The implementation of callback objects is typically a custom class specific to the particular extension, and is furnished by the provider of the extender plug-in. Because the implementation of the callback object in the extender references the callback interface, which is typically packaged with the host, an extender plug-in typically also depends on the host plug-in.
Each callback object fills a certain specific role within an extension. I will refer to these specific roles simply as callback roles. In the XML definition of an extension, callback roles are defined by child or descendent XML elements. The actionSets extension-point, for example, defines a descendent callback role known as action. Multiple callback objects may stand in this role within an actionSets extension, each servicing a particular workbench menu item or button.
When a custom implementation of a callback object is required, the XML schema of the corresponding extension-point typically includes an attribute for specifying the fully-qualified name of the custom callback implementation class. For the help UI plug-in, the name of the XML attribute designating an action class is "class", as exemplified in Listing 2.4 ( ).
But while the extender plug-in defines the required specific callback objects, and declares their custom implementation classes, the callback objects only come into existence as a result of specific action by the host plug-in (and usually only when they are required for the first time to perform some action on behalf of the extension). For example, in Listing 2.4 , the action callback class for the workbench Search->Help menu is specified by the extender plug-in org.eclipse.help.ui to be OpenHelpSearchPageAction (package org.eclipse.help.ui.internal). But the associated callback instance is created by the host plug-in org.eclipse.ui. In this case, the callback instance is created the first time the Search->Help menu item is invoked.
As extension designers for an extender plug-in, we need to know about the callback roles of an extension, and supply concrete callback objects for these roles. The roles are defined as particular elements in the XML schema associated with the extension-point (see section 2.3.3), and are described in the documentation of the XML schema, which, among other things, must include the interfaces expected of callback objects filling each role.
Therefore, when a new service is to be made accessible through the main workbench menu, the service's plug-in provides an implementation of IWorkbenchWindowActionDelegate in which the run method invokes the service. And the fully-qualified name of the implementation class is added to the service's plug-in manifest file as the callback class of the service's menu.
Note that not all XML elements used in defining an extension correspond to custom callback roles. Some elements may be purely descriptive, supplying, for example, certain parameters to the host plug-in to shape corresponding UI elements, or to use in creating non-custom internal host objects representing parts of the extension. In our example, an actionSet element in and of itself (i.e., independently of its child elements) does not define a custom callback object. But such an element does cause an internal object to come into existence within the org.eclipse.ui plug-in to represent the action set.
Similarly, the actionSets extension-point allows the declaration of new top-level workbench menus through an actionSet menu element. But the action associated with a top-level menu is generic: "expose the list of lower-level menu items". Therefore, there is no need for an extender-specific callback object to be associated with a top-level workbench menu. And the workbench top-level menus are represented by internal workbench UI objects.
As users of extension-points, we need not be concerned with these non-specific internal objects supplied by the host plug-in. But as designers of host plug-ins, we see that we have the flexibility to design complex extension structures, parts of which may be exposed as callbacks to be provided by extensions, and other parts of which would be generic, built-in to the host plug-in code, and possibly parameterizable through corresponding XML attributes of extensions.
The act of extension is quite a general concept in Eclipse, and to understand its full generality, it is useful to summarize the types of relationships that may exist between plug-in objects, extension-points, and callback objects.
Multiple extension-points may exist in a host plug-in.
A plug-in may act both as a host plug-in, exposing some extension-points, and as an extender plug-in, extending some plug-ins.
Multiple plug-ins may extend a given extension-point.
A given plug-in may extend a given extension-point multiple times.
An extender plug-in may include different extensions of different host plug-ins.
A single act of extension of an extension-point by a particular extension of a particular plug-in may create multiple callback objects.
A plug-in can define extensions of its own extension-points.
Note. The idea of a plug-in extending itself may seem odd at first. A prominent example of a self-extending plug-in is the workbench UI itself. This plug-in adds various facilities, e.g., editors, to its own UI by extending its own extension-points.
To get an idea of the structure and contents of extension-point schemas, you can browse the extension-point schemas for the Eclipse platform plug-ins. These schemas are available in each Eclipse installation below the folder plugins/org.eclipse.platform.source_<ver>/src (where <ver> is the version of Eclipse). Under this folder, the extension-point schemas for a given platform plug-in may be found in the folder <plugin>_<plugin_ver>/schema, where <plugin> is the id of the plug-in, and <plugin_ver> is the version of the plug-in. For example, for Eclipse 2.1, the actionSets extension-point schema, actionSets.exsd, may be found in the folder org.eclipse.ui_2.1.0/schema below the platform.source folder.
Listing 2.5. Extension-Point Schema Definition (.exsd File).
The schema defines an actionSets extension as an element that includes some attributes and a sequence of actionSet's, and an actionSet as an element that includes some attributes and a sequence of menus and actions.
In the full version of this file, each attribute is annotated with a human-readable documentation element. The documentation elements of extension-point schemas are used to generate HTML reference pages for extension-points (e.g., the actionSets reference page mentioned earlier in this article), similarly to the way in which Java API reference pages are generated via javadoc. Such a reference page is made available as part of the documentation of the host plug-in, and is integrated with the workbench's help system.
Configuration of an extension in the extender plug-in's manifest file.
The reference page specifies the XML configuration syntax required for the extension.
Provision of custom implementations for the extension-point's callback objects.
The reference page includes an API section for documenting the callback interfaces expected by the host plug-in for each callback role.
What goes into an extension-point schema definition is up to the designer of the host plug-in. And the extension XML in the Eclipse Platform Plug-in Manifest Specification is defined as an XML ANY, meaning that it is arbitrary. That designation is too general, however. In fact, an XML extension specification is always a (possibly degenerate) sequence of elements. I will refer to an item within this sequence of elements as an extension member. An actionSets extension, for example, is a sequence of actionSet members. Often the members of an extension have the same element type: that is, the sequence represents a homogeneous list of members.
In XML, the number of elements of each type within a sequence may be bounded by using the minOccurs and the maxOccurs element definition attributes. This usage is illustrated in the actionSets schema (Listing 2.5, ), where an actionSets extension is specified to contain at least one, but an otherwise unrestricted number of actionSet elements.
When an extension-point defines a homogeneous sequence of members and allows its extensions to have more than one member, the extension-point is assigned a plural name. Such extension-points and their extensions may be referred to as plural-form. The plural form is typically provided as a shorthand for representing multiple single-member extensions.
The notion of an extension member, that is, a top-level XML element of an extension's (top-level) sequence, may be contrasted with the Eclipse notion of a configuration element, an arbitrary element (either a top-level element or a lower-level descendent element) in the XML specification of an extension. Both terms will be used here for the XML element itself and for its parsed programmatic representation.
In section 2, the extension model of Eclipse was presented at a high level, and the declarative specifications of extensions and their callback objects was introduced. In this section, we will see how such declarations are processed programmatically to support the obligations of a host plug-in under an extension-point contract. In other words, we will see the kind of code host plug-in designers must write for each extension-point they define.
Consider again the plug-in org.eclipse.ui and its actionsSets extension-point. When this plug-in is activated, the extension declarations in all plug-ins that extend it must be processed, so that the UI knows how to configure its menus and buttons, and what callback objects to call when corresponding menu and button events occur. This section presents the API calls provided by the Eclipse platform to aid in this type of extension processing, and exemplifies the idioms used by plug-in developers to process extensions by using these API calls.
How are the extension declarations processed for a given extension-point? Well, in general, the configuration of an extension is quite arbitrary. And the part of the system that has the knowledge of this configuration is the host plug-in, whose design produced the extension-point schema definition. For example, the knowledge of how to process the actionsSets extension of the UI help plug-in, org.eclipse.help.ui, resides within the plug-in that defines the actionsSets extension-point, namely, the plug-in org.eclipse.ui.
In order for a host plug-in to process the extensions of one of its extension-points, it needs to be able to obtain a list of those extensions from the Eclipse runtime, and, for each extension, to get a parsed version of that extension's members.
Recall that the plug-in registry API provides programmatic access to the parsed representation of all available plug-in specifications. This API provides methods for traversing the information about plug-ins, their components, and their relationships. A configuration element in the registry API (interface IConfigurationElement) represents the parsed version of an extension element in an extender plug-in's manifest file. The following sample code shows how to use the plug-in registry API to iterate over all members of all extensions of an extension-point.
Listing 3.1. Iterating over the Extensions and the Members of an Extension-Point.
The class ProcessExtensions provides an extension processing method process ( ), which uses the nested loop idiom for extension processing: loop over all extensions of the given extension-point ( ), and for each extension, loop over all members of that extension ( ). The process method is made generic by providing it with a member processing visitor: an instance of interface IProcessMember that is called back on for each member being processed ( ).
Suppose this extension processing method is called with the id of the actionSets extension-point, namely, org.eclipse.ui.actionSets, as the first argument. One of the extensions of the actionSets extension-point is the help extension of Listing 2.4, and that extension happens to have a single actionSet member. So when the help extension is reached in the outer loop, its actionSet member is supplied to the inner loop, and can be processed by the member processing visitor.
A similar processing loop occurs in the Eclipse workbench UI plug-in (the owner of the actionSets extension-point) when that plug-in is activated. And the UI plug-in can then pick apart the attributes and sub-elements of the actionSet member by using the methods of IConfigurationElement and related interfaces, and use them to configure the specified menu and button elements into the workbench user interface, and to instantiate the required callback objects, when required.
Within the member processing function called in the inner loop , of course, the host plug-in is free to do whatever is necessary to process each member, as directed by that member's XML configuration element.
Listing 3.1 exemplifies the use of the method IConfigurationElement getConfigurationElements() to obtain the configurations of all members of an extension (Listing 3.1 ). A method with an identical signature also exists for an extension-point as a whole, that is, for the interface IExtensionPoint, and returns the configurations of all members of all extensions of an extension-point. By using this shorthand method, the extension/member nested loop (Listing 3.1, , ) is reduced to a single loop spanning all members of all extensions of an extension-point. Often this simpler idiom is sufficient for processing an extension-point.
Listing 3.2. Printing Identification Data for Extension-Point Members.
This extension processing demo is included with the companion plug-ins of this article. To try it out, see the plug-in installation instructions at the end of this article.
A principal function of extension processing is the instantiation of an extension's callback objects. As we shall see in section 3.3, for performance reasons, this function is normally performed in a lazy manner, as callback objects are required to do actual work. In this section, however, I will ignore this important performance optimization, and concentrate instead on the main functional aspects of callback instantiation.
Eclipse defines a standard for instantiating and initializing callback objects. As we have seen, a callback object is typically represented in a specific child-level or descendent XML element of an extension, and its fully-qualified class name is provided as the value of some attribute of this element. Also, the initial state of a callback object is usually completely parameterized by the corresponding element and its XML descendants. When these conditions hold, the callback object may be instantiated and initialized by using the standard callback object instantiation and initialization facilities of Eclipse.
where ICallback is the expected interface for the corresponding callback role.
Instantiate a member of the required class by using its 0-argument public constructor (one must exist).
The fully-qualified name of the required class is looked up in the configuration as the value of an attribute whose name is provided in the method's classPropertyName argument.
Initialize this instance if it is initializable in a standard manner.
So if the instantiated callback object is an instance of IExecutableExtension, the method createExecutableExtension automatically calls setInitializationData on this extension object, giving it the configuration element of the callback object as a parameter (as well as its class attribute name, and a data parameter whose details are beyond the scope of this article, but can safely be ignored for now (see the Eclipse documentation for more details)).
What this initialization method actually does, of course, is up to the callback object's designer. The configuration of the callback object provided to this method as a parameter would drive the initialization process and would be reflected in the callback object's state by the initialization method.
A complete example of the use of this machinery to instantiate and initialize callback objects appears in section 4.
Note. As mentioned earlier and as we shall see in the next section, this entire machinery is generally used in a lazy fashion only, i.e., when the callback object is actually required to do specific work. In the same spirit, a callback object's initialization method should, to the extent possible, defer time-consuming work to subsequent method calls on the object that would require or benefit from such work. For example, when a callback object manages access to a set of resources, it is often possible and preferable to open a managed resource only when it is actually required in a subsequent method call to the callback object.
When a host plug-in is activated, an eager processing of its extensions would cause the activation of all of its extender plug-ins, and, recursively, their extender plug-ins, down the plug-in hierarchy (or, more accurately, through the plug-in extension network). Activating all plug-ins reachable from a given plug-in involves loading their classes. And processing all extension-points of these plug-ins means loading the custom callback classes of all extensions of these extension-points. As a result, an eager extension processing regime can considerably slow down plug-in activation, and therefore system startup.
Plug-in developers are therefore encouraged to attempt to delay the creation of extender-specific callback objects, until such objects are actually required to perform some action.
One way to implement a lazy activation regime is to use a virtual proxy for each callback object during the activation of a host plug-in. (See the virtual usage of the proxy pattern in .) Such a proxy stands in the role of a real callback object, and causes the real callback object to be instantiated only when some action is required of it. Often, it is possible to provide, within the proxy class, certain generic functions that are required of a callback object. These functions can then be furnished to the host plug-in without reference to particular custom extension classes, and without the need to activate particular extender plug-ins.
When using virtual proxies to initialize the extensions of a host plug-in, only a limited number of extension classes, one for each extension-point role, would be loaded in activating a host plug-in.
As an example, the internal package org.eclipse.ui.internal contains an abstract virtual proxy class called PluginAction for UI actions, and a number of concrete subclasses of this class. And initial extension processing for the actionSets extension point only instantiates such a proxy class for each UI action.
The parameter actionElement provides a reference to the parsed representation of an extension XML element representing an action. And the parameter runAttribute identifies the XML attribute that represents the name of the custom action class to be instantiated to perform the action. The PluginAction proxy class simply keeps track of these properties for later use in instantiating and initializing the real action object.
The proxy class fields action calls by implementing the workbench's action interface, called IAction. The first time a call is made on the run method of this interface, the proxy instantiates the custom action implementation class whose name is provided in runAttribute, The run method call is then dispatched to this custom action instance. The custom action instance is known as the action delegate.
In a canonical proxy pattern, both the proxy class and the delegate implementation class implement the same functional interface. But it is not necessary to adhere to a strict interpretation of the proxy pattern in implementing the virtual proxies of callback objects. In fact, an implementation following the adapter pattern provides a more flexible mechanism for the purpose of lazy callback instantiation.
For example, the Eclipse UI action handler, PluginAction, is more precisely described as a virtual adapter. It implements a high-level interface IAction and adapts it to a lower-level interface, IActionDelegate, which is expected of implementers of custom action callbacks. And the two interfaces IAction and IActionDelegate are unrelated. The handler class PluginAction provides some basic services without reference to a particular custom action handler, and adapts the run method of of the workbench's IAction interface to the run method of the action callback interface IActionDelegate to actually perform a requested action.
Even though Eclipse developers do not necessarily use a strict proxy regime to affect lazy callback instantiation, the term proxy is commonly used in Eclipse parlance as a generic designation for internal objects used to front custom callback objects for the purpose of delaying their instantiation.
So far in this article, we have used only pre-existing extension-points. But with the machinery of extension processing in place, we are now ready to create an extension-point of our own. Our example extension-point is similar in its outline structure to the actionSets extension-point which we have been using so far.
It provides a slot for augmenting the functions of a host plug-in by a custom set of services.
It has a plural form, so that each of its extensions is free to add more than one service to the host plug-in.
It requires each extension to provide concrete callback objects that embody the services provided by that extension.
It obligates the host to add elements to its user interface for each extension (actually for each member of each extension), so that the user may interact with the services provided by the extension.
In addition, our example provides for the specific initialization of callback objects by using the standard callback initialization facilities of Eclipse.
The goal is to illustrate these salient features of extensions with as simple an extension-point as possible. Our major concern, of course, is to illustrate architectural issues, patterns of usage, and extension processing. User interface design issues are specifically excluded from this article. In fact, our example uses a very simple user interface, just sufficient to illustrate the types of interactions required between the user interface functions and extension processing functions.
The host plugin, which supplies the user interface for this example, will be referred to as the UI plug-in.
In our example, each member of each extension will provide an implementation of such a function through a callback object that implements the IFunction interface.
In order to illustrate the use of standard extension processing to initialize callback objects, we would like our functions to be configurable via configuration parameters (constants of the computation) supplied as XML attributes in extension declarations. Of course, we will have different classes of computations implemented by different callback classes, e.g., addition of a parameter, multiplication by a parameter, etc. And, in general, each type of computation would be parameterized differently.
But to keep our example simple, we stipulate that our computations may be parameterized by at most one integer parameter. For example, if the function doubles the value of its argument, then it is considered as a multiplication by a constant factor of 2. And in this case the value 2 is supplied as an XML configuration parameter in the extension declaration of the corresponding callback object.
The UI plug-in provides an input field to enter the argument of a service function, a result field to display the function's value, and a constant field to display the constant parameter (if any) used in the computation. Each function also requires a specific button for invoking it, and a specific label for giving information about it. Therefore, for each member of each extension, the UI plug-in adds a corresponding button and label to its user interface. And when the button is selected, the UI plug-in calls back to the associated service function.
Figure 2 shows the UI plug-in's user interface for a typical configuration of extender plug-ins.
Figure 2. Service UI plug-in's function invocation view. Extensions of this host plug-in declare arithmetic functions that are made accessible through this plug-in's function invocation view.
The UI plug-in class is com.bolour.sample.eclipse.service.ui. The extension-point is called functions.
class: The member function's custom callback class.
name: The member function's name. Used in labeling the function on the user interface.
constant: An optional attribute used to parameterize the member's function by a constant.
In this case, the Multiplication class implements the standard Eclipse callback initialization interface IExecutableExtension to allow its instances to be initialized with the supplied constant factor. The details are provided in section 4.3.2. Of course, the designer of a computation may decide not to parameterize it with a constant. The echo function, compute(x) = x (see section 4.3.1), provides an example of such a non-parameterized computation. In this case, no specific initialization is required for the corresponding callback object, and the associated callback class would not implement IExecutableExtension.
Figure 3 shows the relationship between the functions UI plug-in and its extensions.
Figure 3. The functions extension-point and its extensions. Sets of arithmetic functions are added to the UI plug-in by extending that plug-in's functions extension-point.
At this point, we have in place all the information we need to create sample extensions of the functions extension-point. So before getting into the implementation details of the UI plug-in, we will present sample extensions of this extension-point. Section 4.3 presents two such sample extensions. Then in section 4.4 we will return to the implementation of the UI plug-in by providing the details of extension processing in that plug-in.
Listing 4.1. The Echo Callback Function Class.
The echo plug-in makes itself available to the user by extending the functions extension-point. Here is the specification of an echo extension.
Listing 4.2. An Echo Extension Specification.
This specification declares the service callback class, and specifies the name of the service operation to be ECHO.
Note that in this simple case, no specific state is required to initialize an Echo object. So the optional constant attribute is not used, and the Echo callback class does not implement the IExecutableExtension interface.
Suppose now that the service function to be provided is the multiplication of the input argument by a constant value. Such a service is more useful if it can be configured at deployment time with the required multiplication factor. The function attribute constant is used for this purpose.
Here is a sample multiplication extension.
Listing 4.3. A Multiplication Extension Specification.
When this extension is processed, the attribute constant is interpreted as a multiplication factor.
The multiplication callback class is reproduced below (minimally redacted for brevity).
Listing 4.3. The Multiplication Function Callback Class.
Note that the compute method ( ) of this class provides the implementation of the service interface IFunction, and that the setInitializationData method ( ) of this class provides the implementation of the standard initialization interface IExecutableExtension.
We will see in the next section that extension processing for the functions extension-point uses the standard callback instantiation method createExecutableExtension. So because the Multiplication class implements the IExecutableExtension interface, the method createExecutableExtension automatically calls a callback instance's setInitializationData method, providing that instance's parsed XML element as a parameter. The initialization method can then extract the specified multiplication factor from the element's constant XML attribute, and keep track of it for future computations ( , ).
Now that we have examined some sample test cases for the functions extension-point, we are ready to dig deeper into the implementation of this extension-point and its defining UI plug-in. Our extension-processing class is called ProcessServiceMembers. This class embodies the standard idioms of extension processing in Eclipse, specialized to the functions extension-point. In particular, this class implements a standard and lazy extension processing regime for the functions extension-point. A separate UI class called FunctionsGrid encapsulates all UI processing for our UI plug-in.
As usual in lazy extension processing, processing is required in two distinct phases of the operation of the application.
Then, in the interactive phase of the application, the specific callback objects required to perform the computations of each configured function are created in a lazy fashion, as calls are received by proxy objects. During this phase, selecting the UI button for a function causes a callback to that function through a proxy callback object provided by the extension processing class. The call is delegated by the proxy to the real callback object. And the first time such a call is made to each proxy, the real callback object is instantiated and initialized via standard extension processing.
Section 4.4.1 outlines the extension processing class. Section 4.4.2 outlines the parts of the UI class that interact with extension processing. The bulk of the user interface code concerns UI details not directly related to extension processing and is therefore not presented in this article.
// Invalid function. Inform the user ... and ignore.
Listing 4.4. Extension Member Processing for Service Functions.
Note that certain configuration errors, such as an invalid constant in our example, can be detected in a generic manner, that is, without recourse to specific callback objects (whose instantiations we are deferring). Such errors should be handled during initial extension processing, so that, to the extent possible, the host plug-in is not polluted with invalid callback objects and associated widgets. Thus, when a non-integral constant is encountered in the initial extension processing of the functions extension-point, the corresponding misconfigured function is ignored ( ).
During the interactive phase of the application, when a function call is received by a callback proxy, it must be delegated to the custom implementation of the function. And that implementation is instantiated in a lazy fashion the first time a call is received by a proxy. The details appear in the following code fragment.
private IFunction delegate = null;      // The real callback.
private IConfigurationElement element;  // Function's configuration.
private boolean invoked = false;        // Called already.
Listing 4.5. Extension Member Processing for Service Functions.
This is a straightforward example of the use of the virtual proxy pattern, and other than error processing, which is discussed in the next section, requires no further comment.
In the previous section, we saw that certain configuration errors may be detected in a generic manner during initial extension processing, and can be handled at that time. Unfortunately, not all configuration errors are of this variety, since deferring the instantiation of callback objects in a lazy regime also defers the detection of errors related to instantiating and initializing callback objects. We will call configuration errors that are detected during the interactive phase of the application, interaction time configuration errors.
Interaction time configuration errors fall into two categories: interface mismatches: callback classes that do not implement their required callback interfaces, and creation/initialization errors, e.g., non-existent classes, or invalid specific configuration parameters (for example, 0 denominator for a division function). In Listing 4.5, interface mismatches are detected at , and creation/initialization errors are detected at . Note that an error detected anywhere within the execution of createExecutableExtension, including an error in the initialization of a callback object, is communicated back to the caller via a CoreException.
In our application, an interaction time configuration error causes an ArithmeticException to be thrown. The exception is handled in the UI trivially by displaying error in the result field of function invocations. However, our simple application does not disable the UI elements associated with such misconfigured functions once the configuration error is detected, and allows the user to repeat the failure. A more sophisticated application might dynamically disable or remove user interface elements associated with misconfigured members of extensions.
The companion plug-ins zip file includes a sample plug-in, errortest, that exemplifies configuration errors. By default the functions extension that includes these errors is commented out. To test the effect of configuration errors in this application, uncomment the functions.error extension in the errortest plug-in's manifest file, and restart Eclipse.
In summary, the late detection of configuration errors in lazy extension processing makes it more difficult to handle configuration errors gracefully. And in general, a tension exists between application startup performance, graceful error processing, and the customizability of callback objects standing in a given role.
This section outlines the user interface class of the UI plug-in insofar as it interacts with the extension processing class.
private Composite buttons;      // Function invocation area.
private IFunction function;     // Callback object.
private Button button;          // UI widget.
private Label functionLabel;    // UI widget.
// Constant of the computation (for display only).
Listing 4.6. Adding a Function to the User Interface.
IFunction function: provides the callback object to be called when the button is selected.
String functionName: provides the display name of the function's button.
String label: provides the text of the associated label.
Integer constant: provides the constant parameter (if any) used in the computation. The constant is transmitted to the UI for display purposes only, and is displayed along with the result of a computation when the corresponding button is selected.
Each invocation of the addFunction method is delegated to a GridRow constructor with identical parameters. A GridRow encapsulates the representation of a function in the user interface. For each function, the GridRow constructor saves the reference to the callback object for future calls ( ). It also associates a button event handler handleButton ( ) with the button. When the button is later selected by the user, the event handler obtains the user input from the UI input field, invokes the service function associated with the button on that input, and displays the resulting value of the function ( ). It also displays the constant parameter (if any) used in the computation.
This completes the description of our arithmetic function invocation service The function invocation UI plug-in and sample extender plug-ins are included in this article's companion samples. See the instructions at the end of this article for configuring the companion plug-ins.
The previous section provided a simple example of what might be called the service extension pattern. Each member of a service extension defines a unique set of user interface widgets, and events on these widgets trigger callbacks to objects unique to the extension.
Other usage patterns of extensions are possible, of course. And in this section we briefly outline one such pattern that is akin to the observer design pattern of . Our examination of this usage pattern leads naturally to a comparison of the extension model of Eclipse with the much simpler observer pattern.
In the language of Java APIs, observers are called listeners, and the pattern of extension usage discussed in this section may be called the listener extension pattern. In the listener extension pattern, multiple extension members may listen for the same event in a host plug-in. And the host plug-in notifies all these extension members, or rather their associated listener callbacks, when the event occurs.
The Eclipse JDT JUnit plug-in org.eclipse.jdt.junit uses such a pattern to allow multiple observers within the Eclipse workbench to get notification of testing events, such as the start or the completion of a JUnit test. This usage is covered in the Beck and Gamma manuscript , which is where I was first introduced to the listener extension pattern.
In the listener extension pattern, the host plug-in acts as the subject of the observation, and extender plug-ins act as the observers or listeners. The host plug-in therefore provides an extension-point that may be called listeners, and a corresponding interface that may be called IListener. Each extender plug-in then extends the listeners extension-point by supplying a specific listener that implements the IListener interface, or by supplying a sequence of such listeners.
Because the listeners are then specified declaratively through the plug-in extension mechanism, these listeners can be automatically registered for event notification by extension processing. The first time notification is required, the subject plug-in processes its listeners members, and for each member, instantiates a specific listener callback object and registers that listener for event notification.
The companion sample plug-ins include an example of the listener extension pattern, whose structure is shown in Figure 4.
Figure 4. Extension structure of the listener extension pattern. Each member of each listener extension provides a notification callback for subject events.
In this example, an update of the subject causes notifications to be broadcast to all members of all extensions of the listeners extension-point.
Here is the reference page of the listeners extension-point.
Listing 5.1. A Listener Extension Specification.
The host plug-in defines a menu item, which, when selected, causes the state of the subject to be updated. In turn, the state change in the subject causes listener notifications to be broadcast to each listener configured into the system.
Listing 5.2. A Listener Callback Implementation.
Callback Bundle versus Single Callback. A single extension may provide multiple callback objects. A single observer provides a single callback object.
Differentiation of Extenders versus Uniform Treatment of Observers. Depending on the parameters of an extension and the specifics of the extension-point contract, different extensions of a given extension-point can be treated differently. In contrast, the observer pattern treats all observers of a given subject uniformly, notifying every one of an observable event.
Arbitrary Semantics in Host versus Fixed Notification Semantics in Subject. There can be arbitrary parameterized host semantics associated with an extension instance. Based on the configuration of the extension, the host can accept a variety of customizable responsibilities under the extension contract, e.g., the provision of user interface elements. There is no such parameterization and customizability in the observer design pattern.
But a closer comparison exists between the Eclipse extension model and the extension model of a microkernel by so-called internal servers, e.g., OS device drivers (see, for example, the microkernel pattern in ). Both models allow a core set of services to be extended by additional provider-supplied services. But the Eclipse extension model generalizes the internal extension model of the microkernel architecture in two ways. First, Eclipse plug-ins provide a packaging mechanism for sets of related extensions. Second, in Eclipse any plug-in may provide extension-points and make itself extensible by other plug-ins. In contrast, in the microkernel architecture, the microkernel core (e.g., an OS kernel) has unique standing as the sole extensible component in a system.
The plug-in extension model of Eclipse provides a powerful and general paradigm for architecting extensible systems based on loosely-coupled components. The principle use of this architecture, of course, is the Eclipse workbench. But the basic extension model is an abstract architectural pattern quite apart from its specific incarnation in the workbench.
Deployment-time pluggable components. Plug-ins are components that are assembled into a system at deployment time. A plug-in is implemented in a running system as an instance of a plug-in class. Characteristics of each plug-in are declaratively specified in a manifest file, which is interpreted at runtime to instantiate the plug-in and relate it to other plug-ins.
Extension-points. A particular way in which a plug-in allows itself to be extended is embodied in an extension-point. An extension-point is defined by a plug-in that stands in a host role with respect to the extension-point, and may be extended by one or more plug-ins that stand in an extender role with respect the extension-point. There is a contract associated with each extension-point. The contract puts obligations on both the host and the extender plug-ins.
Extensions as Parameterized Callback Bundles. An extension-point contract generally provides one or more callback interfaces, and requires extenders to provide custom implementations (callback objects) for these interfaces. Then the host is obligated to call back on these callback objects under certain conditions specified in the contract, and based on a particular extension's configuration parameters.
Obligations of the Host. The host obligations under an extension-point contract may include additional requirements on the behavior of the host, such as a requirement on the host to augment its interface by additional processing elements.
Obligations of the Extender. The extender describes the characteristics of an extension declaratively in its manifest file. The extension-point contract provides an XML schema for this description, and the extension specification in the extender's manifest file must conform to this schema. The schema includes slots for the concrete classes of the extension's callback objects, and for the parameters required to construct these objects. The concrete classes are furnished by the extender, and must conform to expected interfaces defined by the host. At runtime, the host instantiates the configured callback objects based on their configuration parameters.
In summary, Eclipse plug-ins offer a flexible model of extensibility, and their abstract architecture for composing systems out of loosely-coupled components provides a significant addition to the available repertoire of architectural patterns for software systems (see, e.g., ).
To run the samples appearing in this article and view their source code, extract the contents of the companion plug-ins zip file into your Eclipse installation.
Extension Processing Demo. Bring up the Windows->Customize Perspective dialog, and under Other, enable Demo Menu Actions. Close the dialog. The Demo menu should now be available.
Arithmetic Service. Bring up the Windows->Customize Perspective dialog, and under Window->Show View enable Functions Grid View, and close the dialog. In the workbench Window->Show View list, you should now see the list item Functions Grid View. Select that item to display the view for this sample.
Listener Extensions. Bring up the Windows->Customize Perspective dialog, and under Other enable Listener Menu Actions. Close the dialog. The Listener menu should now be available.
The samples have been tested with Eclipse 2.1 and JDK 1.3.1_02 on Windows 2000.
Gamma, Erich, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns, Elements of Reusable Object-Oriented Software, Addition-Wesley, 1995.
Beck, Kent, and Erich Gamma, Contributing to Eclipse (pre-publication draft) 2003.
Shavor, S., Jim D'Anjou, et. al. The Java Developer's Guide to Eclipse, Addison-Wesley, 2003.
Buschmann, Frank, et. al., Pattern-Oriented Software Architecture, A System of Patterns, Volume 1, John Wiley and Sons, 1996.
Estberg, Don. How the Minimum Set of Platform Plugins Are Related, Wiki Page 2587, Eclipse Wiki.
This article originated in discussions within the Silicon Valley Patterns Group on Eclipse plug-ins. Thanks to the members of the group, and in particular to Tracy Bialik, Phil Goodwin, Jan Looney, Jerry Louis, Chris Lopez, Russ Rufer, Rich Smith, and Carol Thistlethwaite for the original conversations leading to these notes, and for many great suggestions for improving the content and presentation of the material. Special thanks to Russ Rufer and Tracy Bialik for blazing the Eclipse trail for the rest of the group. The group discussions were organized around a review of an early manuscript by Kent Beck and Erich Gamma: Contributing to Eclipse . These notes, therefore, owe much to Beck and Gamma for introducing us to the concepts and facilities of Eclipse plug-ins. Don Estberg devised the diagrammatic representation of extension-points used in this article, based on the power-strip metaphor. Thanks also to Don for his detailed comments. Finally, my thanks to Dennis Allard and Dan Conde for their generous offer of time in reviewing the final draft of this article, and to Jim des Rivières for his detailed review and numerous suggestions for enhancements.


Check Model Papers or Sample Papers for UP Board Exams 2019. These NCERT based totally UP Board Model Papers are specifically ready scholars of 10th Class or High School who're going to put in writing UP Board Exams 2019.
As consistent with UP Board 10th Date Sheet 2019 the tests are going to start out from seventh February 2019. This is the time when scholars focal point extra on observe and revision. Model Papers or Sample Papers are some of the absolute best assets in relation to observe and revision in an overly quick period of time.
As UP Board could also be following NCERT Textbooks so some adjustments are anticipated within the stage of questions. Keeping this necessary factor in thoughts Jagran Josh is offering Model Papers for all necessary topic of Class 10th like English, Maths, Hindi, Science and Social Science.
Links to get right of entry to UP Board Class 10th Model Papers or Sample Papers are given within the desk. As you're going to click on the hyperlink a brand new article will open, the place you're going to get necessary information about the paper and a hyperlink to obtain the entire fashion paper in PDF layout.
Students making ready for High School or Class 10th UP Board Exams 2019 are recommended to obtain those NCERT based totally Model Papers/ Sample Papers and clear up them with pen and paper. Students also are recommended to unravel those papers inside the point in time as this will likely improve their writing pace.


Reason I choose it: I've had this book on my Kindle for 1.5 years since buying my kindle and I originally choose it just to have some books on my kindle to read.
When Livy O'Brien spies a young boy jostling a man walking along the boardwalk, she recognizes the act for what it is. After all, she used to be known as Light-fingered Livy. But that was before she put her past behind her and moved to the growing town of Chestnut, Illinois, where she's helping to run an orphanage. Now she'll do almost anything to protect the street kids like herself. Sheriff's deputy Jake Russell had no idea what he was in for when he ran into Livy--literally--while chasing down a pickpocket. With a rash of robberies and a growing number of street kids in town--as well as a loan on the family farm that needs to be paid off--Jake doesn't have time to pursue a girl. Still, he can't seem to get Livy out of his mind. He wants to get to know her better . . . but Livy isn't willing to trust any man, especially not a lawman.
This is another Christian Fiction but the only thing that bothered me was the fact that every time they worried about something you'd hear those silent prayer... e.g we have no food in the cupboard please god provide us with something... next minute there is a knock at the door, 3 children turn up whose carriage has gone off the road and their father has died. The father had stocked up his carriage with food that will feed the town (almost). Yet no silent prayer went up to find the childrens relatives etc.... That seemed to get wary after a bit.
As for the book I think it was a nice read but there was so much potential to do so much more. It would have been nice to have a chapter for Livy and a chapter for the street children and those abducted as their stories would have been interesting to read. Instead you got stuck reading about the teenage crush style romance between Livy and Jake with crimes in between. Its the crimes and the street children that keep you reading as you want to find out who it is, what will happen and how it will end for all of them.


Some of my best friends have a problem with the dirty poor.
These are the folks below the dirt-poor — which describes a financial level not the person himself. These are the dirt-encrusted, unemployed, possibly begging (relying on strangers, kindness, and a fair economy as much as the rest of us, anyway), frequently transient (the weather when warm is welcome), simple-dieted types.
Weirdos — #AmIRight? — who seem to be talking to themselves much of the time, and when they're talking to others most people don't see the thread, can't quite get it. Trouble with the law — outright opposition to it — is in both their past and future.
Not just white but black and yellow and red trash. It's usually them furriners — not the ones on the EB5 Visas or the foreign exchange student progs. They dress funny.
Some are little better than a dog, really.


Finishing up some 802w speakers this week!
My father-in-law found some nice 802w (wooden) speakers curbside and gave them to me to restore.
Ordered the foam kit and just finished up one finally after months of them sitting and sitting..
I found the correct active EQ on ebay too.
Has anyone ever heard them inside for home use?
I have a feeling they may not sound very good unless a serious amount of power are pumped through them..
I know nothing about Bose but you piqued my interest. Looks like the 802 is essentially the "professional" version of the 901. You can't beat the price you got them for, even factoring in the 20 new foam surrounds.
IMHO the "w" is much nicer looking for home use and I suspect they will sound good. Many people love the 901s.
I don't think I've heard any of the 802 models. I have had several pairs of 901's since 1976 (series II and VI). The acoustic series are much better than the ported ones - that's why I went back to the acoustic version. I will also say having the EQ rebuilt with quality caps will definitely give better SQ. My 901_II are pretty much rears for HT use but I do enjoy listening to them for 2-channel listening from time to time. The more power the better but as with any speaker, the better the equipment the better the sound.
The 802 was more of a braodcast speaker as the drivers are meant to face the audience and not reflective. Public announcers and bands used them. Make great outdoor speakers.


text:
Q: How do I get java to exit when piped to head I have a java process which prints out a lot of text. Sometimes I just want to see a bit of the text. With normal programs I can just do:
$ myprog | head

I'll just see 10 lines of output from myprog and it will exit immediately. But with java, if I do:
$ java MyClass | head

I get the first 10 lines of output, but the java process won't exit until it's done with all of its processing. It's like java doesn't care that stdout (System.out) is gone and the head process is dead and gone.
All other programs either exit silently, like cat:
$ cat /etc/group | head
root:x:0:
daemon:x:1:
bin:x:2:
sys:x:3:
adm:x:4:
tty:x:5:
disk:x:6:
lp:x:7:
mail:x:8:
news:x:9:

Or exit with a broken pipe error/exception, like python:
$ python -c 'while True: print "hi"' | head
hi
hi
hi
hi
hi
hi
hi
hi
hi
hi
Traceback (most recent call last):
  File "<string>", line 1, in <module>
IOError: [Errno 32] Broken pipe

How can get java to raise an exception when calling System.out.println() when I pipe output to something like head? I'd love to be able to do something like:
try {
    while(true) {
        System.out.println("hi");
    }
} catch(BrokenPipeException e) {
    // exit gracefully
}

A: i'm using checkError()
From PrintStream-API-Docu:

Unlike other output streams, a PrintStream never throws an
  IOException; instead, exceptional situations merely set an internal
  flag that can be tested via the checkError method.

so try somthing like this:
        while(!System.out.checkError()) {
            System.out.println("hi");
        }

A: If you don't like the .checkError() method from Sascha's answer and would rather receive exceptions you can use
OutputStream stream = new FileOutputStream(FileDescriptor.out);

You lose the PrintStream specific functions. In my case, they weren't relevant and this approach was easier than building a bunch of hacky checks.
Note that this will not behave if you've redirected the System.out via System.setOut, as FileDescriptor.out will point to the original output descriptor, not your redirected one.

redpajama_set_name: RedPajamaStackExchange


The new ABT Sportsline SQ7 TDI is a Torque-Filled Beast!
Number-11 is strutting its stuff.
Premium luxury with some serious performance.
Time for some affordable mid-size fun.
Continuing the 30-year tuning tradition.
Speeding through Europe in a 735-HP wagon.
ABT Sportsline celebrates their prestigious history with a rare super car.
Putting the 'S' in SUV.
Packed with a six-time "International Engine of the Year".


text:
Welcome to CRIMEWATCH York County:
This resource is for building public awareness of crimes and those that commit criminal acts in York County. The information contained within this site is owned and managed by Pennsylvania law enforcement agencies and has been deemed part of the public's right-to-know.
Sign up for Free Notifications!
If your local police department is a subscriber, you can receive alerts through email about crime and arrests in your local community. Click here to sign up for free.
Mobile App Available
Download the CRIMEWATCH mobile application and stay up to date with crime in your area. Our app lets you browse nearby crime and anonymously submit tips to authorities.
Android - IOS
Shooting Under Investigation
The West Manchester Township Police Department is investigating a shooting that occurred last evening at the West Manchester Town Center. Officers of the West Manchester Township Police Department responded to a report of a shooting around 10:17 p.m. According to police, two victims were found on...
West Manchester Township Police Department
Attempt to identify retail theft
The West York Borough Police Department is attempting to identify the pictured suspect in a retail theft. Theft took place at the Smoker's Outlet located at 1636 W. Market St. on 11/29/2019. If you can help identify please contact West York Borough Police at 717-854-1975.
West York Borough Police Department
Spring Garden Investigating Shooting
On Saturday, November 30th, at 2:11 PM, officers responded to the 700 Block Lancaster for a report of a shooting. On-scene, officers located a 18 year-old male that had been shot in the right forearm. The victim stated that while walking in the 700 Block Sunshine Alley, a dark blue or black sedan,...
Spring Garden Township Police Department
POLICE INVESTIGATE FALL FROM WINDOW
On November 29, 2019 the York City Police Department responded to a call of an adult victim who fell from the third floor window of a building in the 100 hundred block of N George St. The victim was transported to the hospital for treatment. It is unknown at this time if the fall was accidental or...
York City Police Department
Bulldog Wins the National Dog Show
Thor the BULLDOG just won the National Dog Show! Have a safe & Happy Thanksgiving everyone. #BulldogsStickTogether
Higdon, Billy Lee Jr. - (1) Count of Harassment (M3)
Billy Lee Higdon Jr of Byron Nelson Cir. was charged with the below listed offenses stemming from a police investigation in the 300 Block of Pleasant View Dr.
Newberry Township Police Department
(1) Count of Harassment (M3)
Armstrong, Janessa Marie - (2) counts of Retail Theft (M1) and 1 additional charge
Janessa Marie Armstrong of Butler St was charged with the below listed offenses stemming from a police investigation in the 50 Block of the Newberry Parkway.
(2) counts of Retail Theft (M1), (1) count of Corruption of Minors (M1)
Rusko, Tracey L - (2) Count of Retail Theft (M1) and 1 additional charge
Tracey L. Rusko of Butler Rd was charged with the below listed offenses stemming from a police investigation at 50 Newberry Parkway.
(2) Count of Retail Theft (M1), (1) count of Corruption of Minors (M1)
Myers, Joshua Aaron - (1) Count of Terroristic Threats (M1) and 2 additional charges
Joshua Aaron Myers of S. Front St. was charged with the below listed offenses stemming from a police investigation in the 70 Block of S. Front St.
(1) Count of Terroristic Threats (M1), (1) Count of Harassment (M3), (1) count of Disorderly Conduct (M3)
Weltmer, Samantha Renae - (1) count of Possession of Drug Paraphernalia (M)
Samantha Renae Weltmer of York Haven Rd was charged with the below listed offenses stemming from a traffic stop on Yocumtown Rd @ Fielding Way.
(1) count of Possession of Drug Paraphernalia (M)
Theft From Vehicle Reported
On Sunday, November 6, 2016, at approximately 7:15 am, officers responded to the 1100 Block Hollywood Terrace for a reported theft from vehicle. The victim reported that between 6:30 pm, Saturday, November 5th and 6:45 am Sunday, November 6th, an Apple Macbook Pro valued at $2,200.00 was removed...
Incident Type:
Burglary from Motor Vehicle
Theft - Under $50 - From Automobile
Police are investigating a reported theft from a motor vehicle. The victim reported that someone removed the validation sticker from the license plate of their vehicle.
Burglary - Forced Entry - Non-Residence - Day
On Sunday October 30, 2016 at 5:30 P.M. police were called to the Valley View Elementary School for a reported burglary that had just occurred. The caller provided a description of the suspected actors to 911. A responding officer encountered two subjects that matched the description of the actors...
Motor Vehicle Theft - Street - Residential Area
Police are investigating the report of the theft of a motor vehicle from a residence in the 1200 block of Prospect Street. The victim reported their vehicle missing from the street in front of their home. The vehicle was taken between 00:30 A.M. and 10:30 A.M. on Sunday morning, October 30, 2016.
Theft - Attempted - From Automobile
Police are investigating a reported attempted theft from a motor vehicle that occurred sometime between Saturday evening at 9:00 P.M. and Sunday morning at 09:30 A.M. The incident occurred in the 1000 block of Lancaster Avenue. Anyone with information regarding this crime is asked to contact...
Burglary Reported
Between 12:00 PM, Saturday, August 4, 2018, and 6:00 AM Monday, August 6, 2018, unknown person(s) entered Standard Concrete, 700 North Sherman Street. Nothing has been reported missing. Anyone with information which may be beneficial to the investigation of this incident is asked to contact Officer...
Theft of Motor Vehicle Reported
Between 9:00 PM Sunday, August 5, 2018, and 4:30 AM, Monday, August 6, 2018, a 2009 Nissan Altima sedan was stolen from the 1500 block of Second Avenue. The Nissan is champagne in color, has a large Uber decal on the rear window and smaller Uber decals on each of the side windows. Anyone with...
Police Make Arrests for Drug Delivery
On July 31, 2018 the Fairview Township Police Department was conducting an investigation into illegal narcotics at a hotel in the 300 block of Commerce Drive. During this investigation, two individuals sold cocaine to an undercover police officer in separate transactions. As a result, police...
Fairview Township Police Department
National Night Out is Back
Neighborhoods throughout Spring Garden Township are invited to participate in National Night Out being held on Tuesday, August 7, 2018 from 6:00 P.M. to 8:00 P.M. on the West Campus of York College of PA. at the Grumbacher Sport and Fitness Center, 899 South Richland Avenue, York, 17403. National...
Prolonged Heavy Rain Causing Problems
With the heavy rains we have already received and much more yet to come, please use caution if you have to be on the roads. The amount of rain we may get is impossible to predict, but forcasters have said that at any given moment we could find ourselves under a storm that would drop 1 or 2 inches...
Fire 11 S Highland
12-19-2019 @ 16:54 PM
West York Borough Children's Christmas Party
Police Incident
Member of Law Enforcement?
Visit crimewatchtech.com
You can also download the CRIMEWATCH app.

redpajama_set_name: RedPajamaCommonCrawl


text:
Dariq Miller-Whitehead (born August 1, 2004) is an American college basketball player for the Duke Blue Devils of the Atlantic Coast Conference (ACC). He was a consensus five-star recruit and one of the top players in the 2022 class. As a senior, he was named national player of the year.

High school career
Whitehead attended Montverde Academy in Montverde, Florida. Whitehead won the Naismith Prep Player of the Year Award his senior year in 2022. He was selected to play in the 2022 McDonald's All-American Boys Game. Whitehead was named the McDonald's All-American Game MVP, where he had 13 points, seven rebounds, and seven assists.

Recruiting
Whitehead was a consensus five-star recruit and one of the top players in the 2022 class, according to major recruiting services. On August 1, 2021, he committed to playing college basketball for Duke over offers from Florida State, Kansas and NBA G League.

Career statistics

College

|-
| style="text-align:left;"| 2022–23
| style="text-align:left;"| Duke
| 26 || 6 || 20.1 || .408 || .411 || .885 || 2.4 || 1.0 || .8 || .2 || 8.1
|- class="sortbottom"
| style="text-align:center;" colspan="2"| Career
|| 26 || 6 || 20.1 || .408 || .411 || .885 || 2.4 || 1.0 || .8 || .2 || 8.1

Personal life
His brother, Tahir, played in the National Football League (NFL).

References

External links
Duke Blue Devils bio
ESPN profile
Montverde Academy Eagles bio
USA Basketball bio

2004 births
Living people
American men's basketball players
Basketball players from Newark, New Jersey
Duke Blue Devils men's basketball players
Small forwards

redpajama_set_name: RedPajamaWikipedia


text:
Q: nan loss for custom loss function in keras for image segmentation CNN I am trying to implement a custom loss function in keras for image segmentation network. But when I am training the model, I am getting nan for loss. This is the custom loss function:
def seedloss(y_true,y_pred):
    count = K.sum(K.abs(y_true),axis=[1,2,3],keepdims = True)
    loss = -K.mean(K.sum(y_true*K.log(K.abs(y_pred)),axis=[1,2,3],keepdims=True)/(count))
    return loss

This is my conversion of the below given loss function in Caffe to keras:
class SeedLossLayer(caffe.Layer):

def setup(self, bottom, top):
    if len(bottom) != 2:
        raise Exception("The layer needs two inputs!")

    probs = T.ftensor4()
    labels = T.ftensor4()

    count = T.sum(labels, axis=(1, 2, 3), keepdims=True)
    loss_balanced = -T.mean(T.sum(labels * T.log(probs), axis=(1, 2, 3), keepdims=True) / count)

    self.forward_theano = theano.function([probs, labels], loss_balanced)
    self.backward_theano = theano.function([probs, labels], T.grad(loss_balanced, probs))

def reshape(self, bottom, top):
    top[0].reshape(1)

def forward(self, bottom, top):
    top[0].data[...] = self.forward_theano(bottom[0].data[...], bottom[1].data[...])

def backward(self, top, prop_down, bottom):
    grad = self.backward_theano(bottom[0].data[...], bottom[1].data[...])
    bottom[0].diff[...] = grad

Is there any problem with my implementation. Why am I getting nan for loss. Can someone help me.

A: It doesn't look as if your loss function is differentiable? You may want to add a smoothing constant to it.


Jedi Knight II: Jedi Outcast Easter Egg - Jk2 Secret Room possibly a code ??
First get the the main menu in single player, then open up your console by hitting shift and ~ at the same time. Then in the console type devmapall doom_comm then hit enter; once you're there type devmapall and hit enter again. Then in console type noclip (a cheat that allows you to get anyone through anything) and hit enter. Once you're in noclip mode jump up right out of the hyper space bubble thingy. When you're up there you will see a picture of Earth blowing up. Slightly under it is a room/box. Go inside the room and look around; there will be one wall that has a weird code on it I dont know what it means.


19 Apr In a series of sharing useful Bank Exams Books for IBPS PO, IBPS Clerk, SBI PO Labels: ebook, ibps clerk, ibps po, pdf, sbi po, study material PrepKit for IBPS, SBI RRB - Monthly GK Digest - English Grammar PDF. India's Leading Online Community for IBPS, SBI, Bank Jobs Aspirants. (Study Materials) Numerical Ability/Quantitative Aptitude: Probability · (Study Materials) . We have designed the material with the aim of being interactive and student- centric. The Bank Exam Study Material pdf available on this page are collected from.
21 Aug IBPS Bank Exams Study Material FREE PDF Download- Get IBPS exams study material FREE PDF with sure shot Click For Latest Jobs. 16 Sep There are various exams held for recruiting aspiring candidates who are keen to apply for jobs in banking sector. Currently there is a huge. IBPS Exam Study Material Download free Pdf Online IBPS Preparation study material recommended by IBPS Recruitment Guide (Your banking exam guide).
PDF Study Material for Bank, UPSC and other Competitive Exam - Free Download Try it!!. 6 Oct Find the Important Study Materials and Practice Questions from Quantitative Aptitude and Reasoning Ability in PDF. Candidates can make use of it. India Post Payments Bank Recruitment. type PDF for Comparative Exams Free Best Study Material IBPS SSC BANK PO CLERK Naval Dockyard Fireman Group C Recruitment Online Form 15 Jan Study Material for Bank Exams -PDF Download useful for IBPS PO, IBPS Clerk, SBI PO,SBI Clerk, Syndicate PO, Canara Bank PO, RBI Grade B. 12 Aug Download the largest collection of free study material for Bank Clerical Comprehension Tricks YouTube Lecture Handouts (Download PDF).
7 Feb SBI Clerk Study Material Pdf - Download SBI Clerk Notes pdf - Free SBI Clerk Study Material Pdf - Free Download SBI Clerk. Prepare for Bank PO, Bank Clerk Exam - IBPS, SBI, RBI, other Bank exams and comprehensive Bank coaching for all the major Bank recruitment exams, CL Study Material for all major bank entrance exams like RBI Grade-B, IBPS-PO. Aspirants for a career in the banking sector have to sit for job recruitment exams conducted by the IBPS or individual banks. Whether The coverage of the study material is exhaustive. The Book . Banking Awareness pdf Capsules. Banking. 20 Jan SBI Clerk Study Material PDF Download और SBI का Full Syllabus और advised to check regularly Bank's website kreativekaring.com or.


text:
What does Don't Think I Can't Love You mean?
Jake Owen: Don't Think I Can't Love You Meaning
Don't Think I Can't Love You Lyrics
We don't currently have the lyrics for Don't Think I Can't Love You, Care to share them?
Mar 1st 2012 report
This song is basically about a guy telling his special someone that they may not have a lot of money, or a "house on a hill"; but despite that, he's telling her "don't think I can't love you", because he will love her, be there for her and treat her right no matter what.
More Jake Owen song meanings »
Jake Owen Fans Also Like:
Melanie Martinez song meanings
Lady Gaga song meanings
Alan Walker song meanings
The Neighbourhood song meanings
Email me when new interpretations are posted for Don't Think I Can't Love You
Jake Owen Song Meanings
Barefoot Blue Jean Night
Yee Haw
Alone with You
Startin' With Me
Days of Gold
American Country Love Song
Down To The Honkytonk
Something About a Woman
What We Ain't Got
If He Ain't Gonna Love You
Beachin'
Eight Second Ride
Suddenly I See anonymous


text:
The Kings Court
Elvis-TKC.com
Help Search Members Calendar Gallery
Elvis-TheKingsCourt » Elvis-TheKingsCourt » Latest Elvis News
Zac Efron To Remake Elvis Presley Film Blue Hawaii?
Lindsaygirl
Find Member's Posts
Sep 4 2007, 11:25 PM
Elvis Presley Blvd
Group: Special Members
Zac Efron makes girls squeal and scream just as much as the king, Elvis Presley once did. But is the budding nineteen year old star really ready to take on an Elvis role? Mike Walker of the National Enquirer is reporting that for his first solo breakout movie, the teen idol is set to slip into Elvis Presley's flip-flops for a big-big-budget remake of the King's smash 1961 classic, Blue Hawaii!
The Enquirer's veteran gossip reports that the major studio deal's hush-hush until the ink's dried, but an insider told me: "It's a perfect vehicle for Zac! Not only can he sing and dance, but he's a truly great surfer and wants to perform his own surfing scenes."
Walker muses, "Brace yourselves for The Zac-Attack, ladies � he's also slated for "High School Musical: The Movie," if Disney coughs up the right dough." Will he really make the Elvis film? It certainly seems like a decent fit.
But first he'll set his sights a little lower with a six degrees of separation. "We're working on developing a remake of Footloose, with me in the Kevin Bacon role, and an age-swap film like Big, Zac dished. "There�s other stuff but I don�t want to talk about it and then let people down."
zac_wenn_003.jpg ( 11.63K ) Number of downloads: 0
Sep 5 2007, 01:02 AM
Down in the Jungle Room
Joined: 6-June 05
From: Indiana U.S.A.
I think this is pathetic........
Michaelf
Almost In Memphis
This is a bit sad. I don't think I would bother to see it.
From: Malta
I don't think we should take it that way.
I don't watch High School Musical or that kind of stuff....my sisters do.....so I've had to watch parts.
I've been given the impression that Efron is a talented young good looking teenager who's not full of himself as many others are. I don't think he'll try to be a 2nd Elvis.
I'd rather go on hearing your lies....than smell your armpits son
Atlanta - December 30th 1976
Guest_curtis simpkins_*
QUOTE (MattC @ Sep 4 2007, 06:02 PM)
you said it Matt not only Pathetic it just plan sad to me.....
just wondering if there going to use same songs in "Blue Hawaii"
Group: Administrator
From: Worcestershire, England
Really can't see this happening.....so i don't think there is any need to worry. But then..........i have been wrong before (IMG:http://elvis-tkc.com/forum2/style_emoticons/default/whistling.gif)
TCB Chris
You may think that its the breeze...whistling through the lonely trees..but its only him a flyin' round the bend...
as the day comes to an end.........
did someone was thinking on doing "Viva Las Vegas" some few years ago.
i think id read that some where.
memphisblues
Listening to Elvis
From: Portsmouth, England
According to my Daughter (who tell's me Zac will be my future son in law !!) girl's and there crushe's
Zac has already made High school musical 1 and 2 and is busy making 3
and she say's he would be great in Blue Hawaii !!! (IMG:http://elvis-tkc.com/forum2/style_emoticons/default/no.gif)
Methink's i'll have to pipe Elvis tune's into her bedroom (IMG:http://elvis-tkc.com/forum2/style_emoticons/default/tongue.gif)
and stick her on a Evis dvd marathon
Out there in the dark , there's a beckoning candle
pacer1965
From: Suffolk,England
Blue Hawaii without Elvis...no thanks.I could not imagine anyone else
playing Chad Gates.I hope it's just a rumour
See How They Shine,Oh If You Need A Friend,I'm Sailing Right Behind
At The Gates Of Graceland
this particular movie doesn't need a remake especially for a new teen idol, wj\ho will be forgotten in about a year tops, i think they should cast him in the remake of "TWINK", hes much better suited for that.
« Next Oldest · Latest Elvis News · Next Newest »
Forum Home Search Help Elvis-TheKingsCourt |-- Elvis-tkc.com |-- NightRiderDesigns Updates |-- Latest Elvis News All Elvis |-- All Elvis |-- Collectors Corner |---- For CD Fans Only |---- For LP Fans Only |-- A Song In The Spotlight |-- Elvis Monthly |---- From The Archives |-- Elvis Fun Elvis - The Music |-- The Import Emporium |---- 1-9 |---- A |---- B |---- C |---- D |---- E |---- F |---- G |---- H |---- I |---- J |---- K |---- L |---- M |---- N |---- O |---- P |---- Q-R |---- S |---- T |---- U-V-W |---- X-Y-Z |-- Follow That Dream |---- Standard FTD's |---- The 7" Delux Custom Packs |---- Special Releases |-- Discographies & Chart Info |-- Elvis album Polls |---- 1950s Albums |---- 1960's Albums ( Part One 60-64) |---- 60s Albums ( Part Two 65-69 ) Hollywood Magic |-- Hollywood Magic |---- Hollywood Magic |---- Love Me Tender (1956) |---- Loving You (1957) |---- Jailhouse Rock (1957) |---- King Creole (1958) |---- G.I. Blues (1960) |---- Flaming Star (1960) |---- Wild In The Country (1961) |---- Blue Hawaii (1961) |---- Follow That Dream (1962) |---- Kid Galahad (1962) |---- Girls! Girls! Girls! (1962) |---- It Happened At The World's Fair (1963) |---- Fun In Acapulco (1963) |---- Viva Las Vegas (1964) |---- Kissin' Cousins (1964) |---- Roustabout (1964) |---- Girl Happy (1965) |---- Tickle Me (1965) |---- Harum Scarum (1965) |---- Frankie And Johnny (1966) |---- Paradise, Hawaiian Style (1966) |---- Spinout (1966) |---- Double Trouble (1967) |---- Easy Come, Easy Go (1967) |---- Clambake (1967) |---- Speedway (1968) |---- Stay Away, Joe (1968) |---- Live A Little, Love A Little (1968) |---- Charro! (1969) |---- The Trouble With Girls (And How To Get Into It) (1969) |---- Change Of Habit (1969) |---- That's The Way It Is (1970) |---- Elvis On Tour (1972) |---- This Is Elvis (1981) Everything Else |-- Off Topic |-- Wanted/For Sale
Licensed to: elvis-tkc.com
Hosted By: ElviCities


text:
ICCPP in collaboration with
Krasnoyarsk State University - Prof. V.F. Voino-Yasenetsky
International Centre for Clinical Psychology and Psychotherapy
Seminar with Prof. Dr. H.-W. Gessmann 24.-28.09.12
Seminar with lecturer Maria Marta Schmitz (08. – 12.04.2013)
Humanistic Psychodrama
Psychological-psychotherapeutic assistance
Gerontological Therapy
Psycho-oncology
Literature about Systemic and Family Therapy
Development of the KTMS Aptitude Test
Aptitude test for medical studies
Non-violent Communication
Sexual behavior and experience
ICCPP Books
ICCPP Films
Freud – Interpretation of Dreams
Teaching and Examination
Reference formats
How to structure empirical term papers
Criteria for the evaluation of theses
International Center inaugurated
Two students on a tour through Germany
Day 1 to 11
Day 12 to 21
Psychiatry Fliedner Hospital
Child psychodrama - birthplace of Bergerhausen Castle
On the occasion of the 1st Psychodrama Congress for Working with Children and Adolescents Germany – Austria – Switzerland, Professor Dr. Hans-Werner Gessmann, the head of the Psychotherapeutic Institute Bergerhausen, opened the archive and presented film and text documents about the development of this form of therapy in Europe that were previously inaccessible to the public.
As early as 1974, when Moreno student Ella Mae Shearon was spending her sabbatical in Germany, she had completed her research on her thesis as a psychodrama director with an empirical thesis on the effectiveness of psychodrama therapy on the self-concept of 4th graders in elementary school. She was a brilliant practitioner on children's psychodrama.
A few days after her arrival in Germany, E.M. Shearon presented the Moreno psychodrama at the Georg August University in Göttingen. She got to know Hans-Werner Gessmann in the further training course that was subsequently set up at the Cologne therapist collective. A collaboration developed that led both to European countries and also to the USA (New York, Chicago, De Land). In Germany, a psychodrama therapy group for dyslexic children was set up in Düsseldorf, which E. M. Shearon personally led continuously for over a year. From 1976, the training work with psychodrama training was moved to the Wasserburg Bergerhausen near Kerpen / Cologne. The first curricular training courses in child psychodrama took place here in weekend seminars. Every Saturday, parents had the opportunity to visit the Bergerhausen moated castle with their children and take part in the advanced training events on offer. Zerka Moreno was also a guest here, as were many other prominent psychodramatists from the USA, e.g. Ann Hale. Hildegard Pruckner visited us from Austria and was one of the first to work psychodramatically with children there. Special seminars were held for the Moreno Institutes in Stuttgart (child psychodrama in Gellnhausen, Rüdesheim) and Überlingen, and in Basel for Jean Paul Gonseth in Switzerland. Hans-Werner Gessmann led the training for Swiss special school teachers in St. Johann in the canton of St. Gallen.
From 1989 onwards, the social pedagogue Ingrid Sevecke and the special school pedagogue Stefanie Unsin took over the management of the psychodramatic training work with children at the Bergerhausen Psychotherapeutic Institute. You had been trained in humanistic psychodrama by Hans-Werner Gessmann for many years. Youtube: Child psychodrama. Research is currently being carried out on German-language literature on child psychodrama under the direction of special educator Markus Färber from Wuppertal. This documentation is to be published for the congress and provides an overview of the current state of development in this field.


Been hurt in an accident?
Get your settlement cash today.
N0 RISK. NO STRESS! IF YOU LOSE your case, YOU DON'T PAY.
We immediately respond to your application. We are available 24 hours a day.
Apply Now! Easy and Fast!
Apply now! We immediately respond to all applications!


text:
Q: IE with position absolute element will create horizontal scroll I want to use position: absolute to create a centered element, but it will create a horizontal scrollbar on Internet Explorer 11. Please see the script below. Anyone here knows how to fix this problem?
*Update: I figured out that using overflow:hidden seems to solve this problem somehow. But when there are another one outside of the container, it will be hidden as well.

.container {
  width: 80%;
  margin: 0 auto;
  height: 100vh;
  border: 1px solid green;
  position: relative;
  overflow: hidden; /*This one is not the solution, though*/
}
.content {
  width: 80%;
  height: 30px;
  position: absolute;
  top: 50px;
  left: 50%;
  transform: translate(-50%, 0);
  border: 1px solid red;
}
.another-content {
  width: 40px;
  height: 40px;
  border: 1px solid blue;
  position: absolute;
  bottom: 20px;
  right: -20px;
}

A: You need to add following properties with the position absolute in IE
position: absolute;
top:0;
right: 0;
left: 0;
bottom:0;   //specify all including bottom:0

A: The scrollbar show up in all browsers, not only IE. You can do the following:

*

*The biggest issue is that the left: 50% and width: 80% together are adding to the total width and forcing the horizontal scrollbar to show up in some browsers (e.g. Internet Explorer and MS Edge). You set the width to 80%, so divide the remaining 20% between the left and right border and you'll end up with 10% each. Simply use left: 10% to achieve the same result, but without the side effect of the horizontal scrollbar.

*Also when you set the size to 100% and then add border, those borders will be out of the view and cause the scrollbars to show up. This is the same in all browsers. Use box-sizing: border-box to force the browser to include the border in the height and width calculation.

*The height: 100vh makes the box height equals to the view port. However, the body has default margins which vary from one browser to another. You can either set those margins to zero body { margin: 0; }, or change the height to height: 100% which is 100% of the container which the body in this case.

Try this:

.container {
  width: 100%;
  height: 100%;
  border: 1px solid green;
  position: relative;
  box-sizing: border-box;
}

.content {
  width: 80%;
  height: 30px;
  position: absolute;
  top: 50px;
  left: 10%;
  border: 1px solid red;
}

A: Thanks for your replies. Though they are not direct solution, they helped me a lot to figure out how to solve it.
The cause is as what Racil Hilan said. When I use left:50% and width:80%, the content width will be added up and create a horizontal scroll, which is not ignored by only IE. And my point is to avoid creating that added-up width. Here is my two way to workaround this one.

* {
  box-sizing: border-box;
}

.container {
  width: 100%;
  height: 100vh;
  border: 1px solid green;
  position: relative;
}
.content {
  width: 80%;
  height: 30px;
  position: absolute;
  top: 50px;
  left: 0;
  right: 0;
  border: 1px solid red;
  margin: 0 auto;
}

.content-wrapper {
  border: 1px solid black;
  height: 30px;
  position: absolute;
  top: 100px;
  left: 0;
  right: 0;
}

.another-content {
  width: 80%;
  display: block;
  height: 100%;
  border: 1px solid red;
  margin: 0 auto;
}


Traditional: We will finish reading Freak the Mighty the week of March 22. Please bring a DEAR book with you every day to class from now until May 6!
Reading SOL for traditional: May 6- look out for study guide!
Extended- we are reading The Outsiders! Please bring your book to class every day. We will wrap up the book the week of March 29.


Special Example Of Lovely Short Asymmetrical Haircuts Shaved Regard To Existing Hair Uploaded by Braxton Kuhn on Tuesday, September 20th, 2016 in category Assymetrical.
See also Special Example Of Lovely Short Asymmetrical Haircuts Shaved Regard To Existing Hair from Assymetrical Topic.
Here we have another image Special Example Of 35 Vogue Hairstyles For Short Hair Popular Haircuts featured under Special Example Of Lovely Short Asymmetrical Haircuts Shaved Regard To Existing Hair. We hope you enjoyed it and if you want to download the pictures in high quality, simply right click the image and choose "Save As". Thanks for reading Special Example Of Lovely Short Asymmetrical Haircuts Shaved Regard To Existing Hair.