bundles/org.eclipse.rap.ui/schema/handlers.exsd

<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appinfo>
         <meta.schema plugin="org.eclipse.ui" id="handlers" name="Handlers"/>
      </appinfo>
      <documentation>
         &lt;p&gt;
The handlers extension point is an elaboration of the experimental &lt;code&gt;handlerSubmission&lt;/code&gt; element defined in Eclipse 3.0.  A handler is the behaviour of a command at a particular point in time.  A command can have zero or more handlers associated with it.  At any one point in time, however, a command will either have no active handler or one active handler.  The active handler is the one which is currently responsible for carrying out the behaviour of the command.  This is very similar to the concept of an action handler and a retargettable action.
&lt;/p&gt;
&lt;p&gt;
The handlers extension point allows a plug-in developer to specify a handler that should become active and/or enabled under certain conditions.  If a handler is inactive, then no command will delegate its behaviour to the handler.  If a handler is disabled, then the handler will not be asked to execute; execution of the handler is blocked.  The conditions are defined using the expression language facility added during 3.0.  They are expressed using &lt;code&gt;activeWhen&lt;/code&gt; and &lt;code&gt;enabledWhen&lt;/code&gt; clauses.
&lt;/p&gt;
&lt;p&gt;
The workbench provides some variables that these expressions can rely on.  Variables that are valid in activeWhen and enabledWhen expressions can be found in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.  The types of the variables are determined by the &lt;code&gt;org.eclipse.ui.ISourceProvider&lt;/code&gt; that provides them.
&lt;/p&gt;
&lt;p&gt;
A handler that specifies no conditions is a default handler.  A default handler is only active if no other handler has all of its conditions satisfied.  If two handlers still have conditions that are satisfied, then the conditions are compared.  The idea is to select a handler whose condition is more specific or more local.  To do this, the variables referred to by the condition are looked at.  The condition that refers to the most specific variable &quot;wins&quot;.  The order of specificity (from least specific to most specific) is suggested in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.
&lt;/p&gt;
&lt;p&gt;
If this still doesn&apos;t resolve the conflict, then no handler is active.  If a particular tracing option is turned on, then this leads to a message in the log.  A conflict can also occur if there are two default handlers.  It is the responsibility of the plug-in developers and integration testers to ensure that this does not happen.
&lt;/p&gt;
&lt;p&gt;
These conditions are used to avoid unnecessary plug-in loading.  These handler definitions are wrapped in a proxy.  For a proxy to load its underlying handler, two things must happen: the conditions for the proxy must be met so that it becomes active, and the command must be asked to do something which it must delegate (e.g., execute(), isEnabled()).
&lt;/p&gt;
      </documentation>
   </annotation>

   <include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>

   <element name="extension">
      <complexType>
         <sequence>
            <element ref="handler" minOccurs="0" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="handler">
      <annotation>
         <documentation>
            &lt;p&gt;Associated a command with a handler implementation.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <sequence>
            <element ref="activeWhen" minOccurs="0" maxOccurs="1"/>
            <element ref="class" minOccurs="0" maxOccurs="1"/>
            <element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
         </sequence>
         <attribute name="commandId" type="string" use="required">
            <annotation>
               <documentation>
                  &lt;p&gt;The id of the command to associate with this handler implementation.&lt;/p&gt;
               </documentation>
               <appinfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.ui.commands/command/@id"/>
               </appinfo>
            </annotation>
         </attribute>
         <attribute name="class" type="string">
            <annotation>
               <documentation>
                  &lt;p&gt;The handler class that imlements &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt; or extends &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt;.&lt;/p&gt;
               </documentation>
               <appinfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
               </appinfo>
            </annotation>
         </attribute>
         <attribute name="helpContextId" type="string">
            <annotation>
               <documentation>
                  &lt;p&gt;
The identifier of the help context that relates to this specific handler.  While a command can provide a general description of a command&apos;s behaviour, it is sometimes appropriate for a handler to provide help more specific to their implementation.
&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Since: 3.2&lt;/em&gt;&lt;/p&gt;
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="activeWhen">
      <annotation>
         <documentation>
            &lt;p&gt;Contains a core expression used by the &lt;code&gt;IHandlerService&lt;/code&gt; to determine when this handler is active.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <choice>
            <element ref="not"/>
            <element ref="and"/>
            <element ref="or"/>
            <element ref="instanceof"/>
            <element ref="test"/>
            <element ref="systemTest"/>
            <element ref="equals"/>
            <element ref="count"/>
            <element ref="with"/>
            <element ref="resolve"/>
            <element ref="adapt"/>
            <element ref="iterate"/>
            <element ref="reference"/>
         </choice>
      </complexType>
   </element>

   <element name="enabledWhen">
      <annotation>
         <documentation>
            &lt;p&gt;Contains a core expression used by the workbench handler proxy to determine when this handler is enabled without loading it.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <choice>
            <element ref="not"/>
            <element ref="and"/>
            <element ref="or"/>
            <element ref="instanceof"/>
            <element ref="test"/>
            <element ref="systemTest"/>
            <element ref="equals"/>
            <element ref="count"/>
            <element ref="with"/>
            <element ref="resolve"/>
            <element ref="adapt"/>
            <element ref="iterate"/>
            <element ref="reference"/>
         </choice>
      </complexType>
   </element>

   <element name="class">
      <annotation>
         <documentation>
            &lt;p&gt;Used when creating an &lt;code&gt;IExecutableExtension&lt;/code&gt; with a named parameter, or more than one.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <sequence>
            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="class" type="string">
            <annotation>
               <documentation>
                  &lt;p&gt;The handler class that imlements &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt; or extends &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt;.&lt;/p&gt;
               </documentation>
               <appinfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
               </appinfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="parameter">
      <annotation>
         <documentation>
            &lt;p&gt;A parameter for an &lt;code&gt;IExecutableExtension&lt;/code&gt;.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  &lt;p&gt;The parameter name.&lt;/p&gt;
               </documentation>
            </annotation>
         </attribute>
         <attribute name="value" type="string" use="required">
            <annotation>
               <documentation>
                  &lt;p&gt;The parameter value.&lt;/p&gt;
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appinfo>
         <meta.section type="since"/>
      </appinfo>
      <documentation>
         3.1
      </documentation>
   </annotation>

   <annotation>
      <appinfo>
         <meta.section type="examples"/>
      </appinfo>
      <documentation>
         &lt;p&gt;
Variables that are valid in activeWhen and enabledWhen expressions can be found in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.  The types of the variables are determined by the &lt;code&gt;org.eclipse.ui.ISourceProvider&lt;/code&gt; that provides them.
&lt;/p&gt;
&lt;pre&gt;
&lt;extension
 point=&quot;org.eclipse.ui.handlers&quot;&gt;
 &lt;handler
  commandId=&quot;commandId&quot;
  class=&quot;org.eclipse.compare.Command&quot;&gt;
  &lt;activeWhen&gt;
   &lt;with variable=&quot;selection&quot;&gt;
    &lt;count value=&quot;1&quot; /&gt;
    &lt;iterate operator=&quot;and&quot;&gt;
     &lt;adapt type=&quot;org.eclipse.core.resources.IResource&quot; /&gt;
    &lt;/iterate&gt;
   &lt;/with&gt;
  &lt;/activeWhen&gt;
 &lt;/handler&gt;
 &lt;handler
  commandId=&quot;other.commandId&quot;
  class=&quot;org.eclipse.ui.TalkToMe&quot;&gt;
  &lt;activeWhen&gt;
   &lt;with variable=&quot;activePartId&quot;&gt;
    &lt;equals value=&quot;org.eclipse.ui.views.SampleView&quot;/&gt;
   &lt;/with&gt;
  &lt;/activeWhen&gt;
 &lt;/handler&gt;
&lt;/extension&gt;
&lt;/pre&gt;
&lt;p&gt;
To further avoid plug-in loading, it is possible to specify when the handler is enabled.  If the proxy has not yet loaded the handler, then only the expressions syntax is used to decide if the handler is enabled.  If the proxy has loaded the handler, then the expressions syntax is consulted first.  If the expressions syntax evaluates to true, then the handler is asked if it is enabled.  (This is a short-circuit Boolean &quot;and&quot; operation between the expressions syntax and the handler&apos;s enabled state.)
&lt;/p&gt;
&lt;pre&gt;
&lt;extension
 point=&quot;org.eclipse.ui.handlers&quot;&gt;
 &lt;handler
  commandId=&quot;commandId&quot;
  class=&quot;org.eclipse.Handler&quot;&gt;
  &lt;enabledWhen&gt;
   &lt;with variable=&quot;activeContexts&quot;&gt;
     &lt;iterator operator=&quot;or&quot;&gt;
       &lt;equals value=&quot;org.eclipse.ui.contexts.window&quot;/&gt;
     &lt;/iterator&gt;
   &lt;/with&gt;
  &lt;/enabledWhen&gt;
 &lt;/handler&gt;
&lt;/extension&gt;
&lt;/pre&gt;
      </documentation>
   </annotation>

   <annotation>
      <appinfo>
         <meta.section type="apiInfo"/>
      </appinfo>
      <documentation>
         &lt;p&gt;
All handlers implement &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt;, and can use &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt; as a base class.  Within the workbench, it is possible to activate and deactivate handlers using the &lt;code&gt;org.eclipse.ui.handlers.IHandlerService&lt;/code&gt; interface.  This interface can be retrieved from supporting workbench objects, such as &lt;code&gt;IWorkbench&lt;/code&gt; itself, a workbench window, or a part site.  To retrieve the service, you would make a call like &lt;code&gt;IWorkbench.getService(IHandlerService.class)&lt;/code&gt;.
&lt;/p&gt;
&lt;p&gt;
It is also possible to activate and deactive handlers using legacy code in the workbench.  This can be done through the legacy mechanism shown below.  This mechanism is useful to clients who are using actions to contribute to menus or toolbars.  This is deprecated and not recommended.
&lt;/p&gt;
&lt;pre&gt;
 IWorkbenchPartSite mySite;
 IAction myAction;
 
 myAction.setActionDefinitionId(commandId);
 IKeyBindingService service = mySite.getKeyBindingService();
 service.registerAction(myAction);
&lt;/pre&gt;
      </documentation>
   </annotation>



   <annotation>
      <appinfo>
         <meta.section type="copyright"/>
      </appinfo>
      <documentation>
         Copyright (c) 2005, 2007 IBM Corporation and others.&lt;br&gt;
All rights reserved. This program and the accompanying materials are made
available under the terms of the Eclipse Public License v1.0 which accompanies
this distribution, and is available at &lt;a 
href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
      </documentation>
   </annotation>

</schema>