diff --git a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/definitions.exsd b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/definitions.exsd index 21147047e9..ad07cdb214 100755 --- a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/definitions.exsd +++ b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/definitions.exsd @@ -1,166 +1,166 @@ - + - + <p> This extension point allows you to create reusable extensions. They can then be used in other core expression constructs. </p> <p> The reference element in a core expression will evaluated the expression definition with the evaluation context that is active for the reference element. </p> a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance Provides a global definition of an expression to be used with the &lt;reference/&gt; expression element. This helps to reuse common expressions. A globally unique identifier for the expression definition. You can define and the use core expressions: <p> <pre> -&lt;extension point="org.eclipse.core.expressions.definitions"&gt; +&lt;extension point="org.blueberry.core.expressions.definitions"&gt; &lt;definition id="com.example.parts.activeProblemsView"&gt; &lt;with variable="activePartId"&gt; - &lt;equals value="org.eclipse.ui.views.ProblemsView"/&gt; + &lt;equals value="org.blueberry.ui.views.ProblemsView"/&gt; &lt;/with&gt; &lt;/definition&gt; &lt;definition id="com.example.markers.markerSelection"&gt; &lt;iterate&gt; - &lt;instanceof value="org.eclipse.core.resources.IMarker"/&gt; + &lt;instanceof value="org.blueberry.core.resources.IMarker"/&gt; &lt;/with&gt; &lt;/definition&gt; &lt;/extension&gt; </pre> </p> <p> Then this expression definition can be used when composing other expressions. </p> <p> <pre> &lt;enabledWhen&gt; &lt;reference definitionId="com.example.parts.activeProblemsView"&gt; &lt;/enabledWhen&gt; </pre> <pre> &lt;visibleWhen&gt; &lt;and&gt; &lt;reference definitionId="com.example.parts.activeProblemsView"/&gt; &lt;reference definitionId="com.example.markers.markerSelection"/&gt; &lt;/and&gt; &lt;/visibleWhen&gt; </pre> </p> 3.3 Copyright (c) 2007 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/expressionLanguage.exsd b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/expressionLanguage.exsd index 419b926bca..400743a1d2 100755 --- a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/expressionLanguage.exsd +++ b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/expressionLanguage.exsd @@ -1,535 +1,535 @@ - + - + A generic root element. The element can be used inside an extension point to define its enablement expression. The children of an enablement expression are combined using the and operator. This element represent a NOT operation on the result of evaluating it's sub-element expression. This element represent an AND operation on the result of evaluating all it's sub-elements expressions. This element represent an OR operation on the result of evaluating all it's sub-element expressions. This element is used to perform an instanceof check of the object in focus. The expression returns EvaluationResult.TRUE if the object's type is a sub type of the type specified by the attribute value. Otherwise EvaluationResult.FALSE is returned. a fully qualified name of a class or interface. This element is used to evaluate the property state of the object in focus. The set of testable properties can be extended using the propery tester extension point. The test expression returns EvaluationResult.NOT_LOADED if the property tester doing the actual testing isn't loaded yet and the attribute forcePluginActivation is set to false. If forcePluginActivation is set to true and the evaluation context used to evaluate this expression support plug-in activation then evaluating the property will result in activating the plug-in defining the tester. the name of an object's property to test. additional arguments passed to the property tester. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression. the expected value of the property. Can be omitted if the property is a boolean property. The test expression is supposed to return EvaluationResult.TRUE if the property matches the value and EvaluationResult.FALSE otherwise. The value attribute is converted into a Java base type using the following rules: <ul> <li>the string &quot;true&quot; is converted into Boolean.TRUE</li> <li>the string &quot;false&quot; is converted into Boolean.FALSE</li> <li>if the string contains a dot then the interpreter tries to convert the value into a Float object. If this fails the string is treated as a java.lang.String</li> <li>if the string only consists of numbers then the interpreter converts the value in an Integer object.</li> <li>in all other cases the string is treated as a java.lang.String</li> <li>the conversion of the string into a Boolean, Float, or Integer can be suppressed by surrounding the string with single quotes. For example, the attribute value=&quot;'true'&quot; is converted into the string &quot;true&quot;</li> </ul> a flag indicating whether the plug-in contributing the property tester should be loaded if necessary. As such, this flag should be used judiciously, in order to avoid unnecessary plug-in activations. Most clients should avoid setting this flag to true. This flag is only honored if the evaluation context used to evaluate this expression allows plug-in activation. Otherwise the flag is ignored and no plug-in loading takes place. Tests a system property by calling the System.getProperty method and compares the result with the value specified through the value attribute. the name of an system property to test. the expected value of the property. The value is interpreted as a string value. This element is used to perform an equals check of the object in focus. The expression returns EvaluationResult.TRUE if the object is equal to the value provided by the attribute value. Otherwise EvaluationResult.FALSE is returned. the expected value. The value provided as a string is converted into a Java base type using the same rules as for the value attribute of the test expression. This element is used to test the number of elements in a collection. an expression to specify the number of elements in a list. Following wildcard characters can be used: <dl> <dt>*</dt> <dd>any number of elements</dd> <dt>?</dt> <dd>no elements or one element</dd> <dt>+</dt> <dd>one or more elements</dd> <dt>!</dt> <dd>no elements</dd> <dt>integer value</dt> <dd>the list must contain the exact number of elements</dd> </dl> This element changes the object to be inspected for all its child element to the object referenced by the given variable. If the variable can not be resolved then the expression will throw a ExpressionException when evaluating it. The children of a with expression are combined using the and operator. the name of the variable to be used for further inspection. It is up to the evaluator of an extension point to provide the variable in the variable pool. This element changes the object to be inspected for all its child element to the object referenced by the given variable. If the variable can not be resolved then the expression will throw a ExpressionException when evaluating it. The children of a with expression are combined using the and operator. the name of the variable to be resolved. This variable is then used as the object in focus for child element evaluation. It is up to the evaluator of an extension point to provide a corresponding variable resolver (see IVariableResolver) through the evaluation context passed to the root expression element when evaluating the expression. additional arguments passed to the variable resolver. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression. This element is used to adapt the object in focus to the type specified by the attribute type. The expression returns not loaded if either the adapter or the type referenced isn't loaded yet. It throws a ExpressionException during evaluation if the type name doesn't exist at all. The children of an adapt expression are combined using the and operator. the type to which the object in focus is to be adapted. This element is used to iterate over a variable that is of type java.util.Collection. If the object in focus is not of type java.util.Collection then an ExpressionException will be thrown while evaluating the expression. either "and" or "or". The operator defines how the child elements will be combined. If not specified, "and" will be used. the value return from the iterate expression if the collection is empty. If not specified then true is returned when the operator equals "and" and false is return if the operator equals "or". - This element is used to reference an expression from the <b>org.eclipse.core.expressions.definitions</b> extension point. The expression definition will be evaluated within the current expression element using the current evaluation context. + This element is used to reference an expression from the <b>org.blueberry.core.expressions.definitions</b> extension point. The expression definition will be evaluated within the current expression element using the current evaluation context. - The unique id of an expression from <b>org.eclipse.core.expressions.definitions</b>. + The unique id of an expression from <b>org.blueberry.core.expressions.definitions</b>. Release 3.0 Copyright (c) 2001, 2004 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/propertyTesters.exsd b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/propertyTesters.exsd index 0438e6abbd..30f9b60ca4 100755 --- a/BlueBerry/Bundles/org.blueberry.core.expressions/schema/propertyTesters.exsd +++ b/BlueBerry/Bundles/org.blueberry.core.expressions/schema/propertyTesters.exsd @@ -1,146 +1,146 @@ - + - + This extension point allows to add properties to an already existing type. Those properties can then be used inside the expression language's test expression element. a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance unique identifier for the property tester the type to be extended by this property tester a unique id determining the name space the properties are added to a comma separated list of properties provided by this property tester the name of the class that implements the testing methods. The class must be public and extend -<samp>org.eclipse.core.expressions.PropertyTester</samp> with a public 0-argument constructor. +<samp>org.blueberry.core.expressions.PropertyTester</samp> with a public 0-argument constructor. - + 3.0 The following is an example of a property tester contribution: <p> <pre> <extension point="org.eclipse.core.expressions.propertyTesters"> <propertyTester id="org.eclipse.jdt.ui.IResourceTester" type="org.eclipse.core.resources.IResource" namespace="org.eclipse.jdt.ui" properties="canDelete" class="org.eclipse.jdt.ui.internal.ResourceTester"> </propertyTester> </extension> </pre> </p> - The contributed class must extend <code>org.eclipse.core.expressions.PropertyTester</code> + The contributed class must extend <code>berry::PropertyTester</code> Copyright (c) 2001, 2004 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.osgi/schema/applications.exsd b/BlueBerry/Bundles/org.blueberry.osgi/schema/applications.exsd index 98b6e53795..7ca5ba1814 100644 --- a/BlueBerry/Bundles/org.blueberry.osgi/schema/applications.exsd +++ b/BlueBerry/Bundles/org.blueberry.osgi/schema/applications.exsd @@ -1,122 +1,113 @@ - The applications extension point allows plugins to contribute applications to the Berry Platform. + The applications extension point allows plugins to contribute applications to the BlueBerry Platform. - - - - - - 1.0 - - - Following is an example of an application declaration. <p> <pre> <extension id="sampleApplication" point="org.blueberry.osgi.applications"> <application id="my.domain.application"> - <run class="com.xyz.applications.sample"/> + <run class="xyz::SampleApp"/> </application> </extension> </pre> </p> Application classes must subclass <code>berry::IApplication</code>. diff --git a/BlueBerry/Bundles/org.blueberry.test/schema/tests.exsd b/BlueBerry/Bundles/org.blueberry.test/schema/tests.exsd index 00b7b1e760..cb2ca7893e 100644 --- a/BlueBerry/Bundles/org.blueberry.test/schema/tests.exsd +++ b/BlueBerry/Bundles/org.blueberry.test/schema/tests.exsd @@ -1,124 +1,115 @@ - + The test extension point allows plugins to contribute unit tests to the BlueBerry Platform. The tests should be written with the help of the Poco CppUnit library. - - - - - - 1.0 - - - Following is an example of a test declaration. <p> <pre> - <extension id="SampleTestSuite" point="org.blueberry.test"> + <extension id="SampleTestSuite" point="org.blueberry.tests"> <test id="SampleTest" class="xyz::SampleTest"/> </extension> </pre> </p> Test classes must be a subclass of <code>CppUnit::Test</code>. diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/commands.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/commands.exsd index 9a5143cbcd..ebcfd2d3f0 100755 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/commands.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/commands.exsd @@ -1,466 +1,466 @@ <p> The <code>org.blueberry.ui.commands</code> extension point is used to declare commands and command categories, using the <code>command</code> and <code>category</code> elements. A command is an abstract representation of some semantic behaviour, but not it's actual implementation. This allows different developers to contribute specific behaviour for their individual parts. For example, there might be a "paste" command with one implementation in an editor and a different implementation in an explorer widget. These implementations are called handlers. Commands can also be viewed as declarative function pointers, or signal handlers. </p> An optional identifier of the extension instance. An optional name of the extension instance. A fully qualified identifier of the target extension point. <p> This element is used to define commands. A command represents an request from the user that can be handled by an action, and should be semantically unique among other commands. Do not define a command if there is already one defined with the same meaning. If more than one of these elements exist with the same <code>id</code> attribute, only the last declared element (in order of reading the plugin registry) is considered valid. See the extension points <a href="org_blueberry_ui_actionSets.html">org.blueberry.ui.actionSets</a> and <a href="org_blueberry_ui_editorActions.html">org.blueberry.ui.editorActions</a> to understand how actions are connected to commands. </p> A translatable short description of this command for display in the UI. The unique identifier of this command. The translatable name of this command for display in the UI. Commands are typically named in the form of an imperative verb. The unique id of the category for this command. If this command does not specify a category it will be placed in an global "Uncategorized" category. The default handler for this command (see the <a href="org_blueberry_ui_handlers.html">org.blueberry.ui.handlers</a> extension point). If no other handler is active, this handler will be active. This handler will conflict with other handler definitions that specify no <code>activeWhen</code> conditions. If you are creating an <code>IExecutableExtension</code>, you can use the <code>defaultHandler</code> element instead. The id of a <code>commandParameterType</code> indicating the type of value returned by this command. Specifying a <code>returnTypeId</code> allows clients executing the command to associate the value returned with a type and to convert the value to a std::string form that may be stored and/or passed to another command that accepts parameters of the same type. The identifier of the help context that relates to this command in general. Handlers can override this context identifier to provide help that is more specific to their particular behaviours. <p><em>Not used yet</em></p> <p> In the UI, commands are often organized by category to make them more manageable. This element is used to define these categories. Commands can add themselves to at most one category. If more than one of these elements exist with the same <code>id</code> attribute, only the last declared element (in order of reading the plugin registry) is considered valid. </p> A translatable short description of this category for display in the UI. The unique identifier of this category. The translatable name of this category for display in the UI. <p> Defines a parameter that a command should understand. A parameter is a way to provide more information to a handler at execution time. For example, a "show view" command might take a view as a parameter. Handlers should be able to understand these parameters, so they should be treated like API. </p> The unique identifier for this parameter. The name for the parameter. This is the name as it will be displayed to an end-user. As such, it should be translatable. The name should be short -- preferrably one word. The class providing a list of parameter values for the user to select. This class should implement <code>org.blueberry.core.commands.IParameterValues</code>. If this class is not specified, you must specify the more verbose <code>values</code> element. Please see <code>org.blueberry.osgi.IExecutableExtension</code>. The id of a commandParameterType for this commandParameter. Specifying a typeId allows handlers of a command to convert string parameter values to objects in a consistent way and it allows potential callers of a command to look for commands that take objects of various types for their parameters. Whether this parameter is optional. If a parameter is optional, the handler should be able to handle the absence of the parameter. By default, all parameters are optional. <p> Defines the object type of a commandParameter and may specify an <code>org.blueberry.core.commands.AbstractParameterValueConverter</code> subclass to convert between string parameter values and objects. </p> The unique identifier for this commandParameterType. The fully qualified name of a class to use as the type of this command parameter. This attribute is optional, however if omitted, <code>org.blueberry.osgi.Object</code> will be used as the parameter type. The class for converting between objects and string representations of objects for command parameter values. This class should extend <code>org.blueberry.core.commands.AbstractParameterValueConverter</code>. The converter should produce and consume objects of the type indicated in the <code>type</code> attribute. If this class is not specified, this facility to convert between string and object values for this parameter type will not be available (the <code>GetValueConverter()</code> on class <code>ParameterType</code> will return <code>null</code>). <p> The more verbose version of the <code>values</code> attribute on the <code>commandParameter</code>. </p> The class providing a list of parameter values for the user to select. This class should implement <code>org.blueberry.core.commands.IParameterValues</code>. If this class is not specified, you must specify the more verbose <code>values</code> element. Please see <code>org.blueberry.osgi.IExecutableExtension</code>. <p> A possible value for a parameter. </p> The name of the parameter to pass to the <code>IExecutableExtension</code>. The value of the parameter to pass to the <code>IExecutableExtension</code>. <p> The default handler for this command. If no other handler is active, this handler will be active. This handler will conflict with other handler definitions that specify no <code>activeWhen</code> conditions. If you are not creating an <code>IExecutableExtension</code>, you can use the <code>defaultHandler</code> attribute instead. </p> The class which implements <code>org.blueberry.core.commands.IHandler</code>. <p> State information shared between all handlers, and potentially persisted between sessions.The state is simply a class that is loaded to look after the state. See the API Information for more details. This is not used for UI attributes like a menu contribution check box state or label. </p> The class that can be loaded to store the state of this command. State is shared amongst handlers, and can be persisted between sessions. This class must implement <code>org.blueberry.core.commands.State</code>. Please see API Information. A unique identifier for this state. This is used for persisting the state between sessions (if the state is an instance of <code>org.blueberry.core.commands.PersistentState</code>). Certain common identifiers (see <code>org.blueberry.ui.menus.IMenuStateIds</code>) are understood when the command is being rendered in the menus or tool bars. The identifier only needs to be unique within the command defining the state. <p> The class that can be loaded to store the state of this command. This element is used if you wish to pass multiple parameters to an <code>org.blueberry.osgi.IExecutableExtension</code>. </p> The class that can be loaded to store the state of this command. State is shared amongst handlers, and can be persisted between sessions. This class must implement <code>org.blueberry.core.commands.State</code>. Please see API Information. <p> -0.1 +1.0 </p> <p> The <code>plugin.xml</code> file in the <code>org.blueberry.ui</code> plugin makes extensive use of the <code>org.blueberry.ui.commands</code> extension point. </p> <p> Handlers can be registered with commands using the <code>org.blueberry.ui.handlers.IHandlerService</code>. This can be retrieved from various workbench components (e.g., workbench, workbench window, part site, etc.) by calling <code>GetService(IHandlerService::ID)</code>. </p> <p> In general, it is preferrably to declare all commands statically (in <code>plugin.xml</code>). This is so that users can attach key bindings to the commands. However, it is possible to declare commands at run-time. To do this, retrieve the <code>org.blueberry.ui.commands.ICommandService</code> from a workbench component, call <code>GetCommand(yourCommandID)</code> and then call <code>Command::Define(...)</code>. Commands defined programmatically must be cleaned up by the plugin if it is unloaded. </p> <p> There are a few default implementations of handler states that may be useful to users of this extension point: </p> <ul> <!-- <li>org.eclipse.jface.commands.TextState</li> <li>org.eclipse.jface.commands.RadioState</li> <li>org.eclipse.jface.commands.ToggleState</li> <li>org.eclipse.ui.handlers.RegistryRadioState</li> <li>org.eclipse.ui.handlers.RegistryToggleState</li> --> </ul> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/editors.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/editors.exsd index 45169a85f2..f57a084549 100755 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/editors.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/editors.exsd @@ -1,336 +1,328 @@ - + - + This extension point is used to add new editors to the workbench. A editor is a visual component within a workbench page. It is typically used to edit or browse a document or input object. To open an editor, the user will typically invoke "Open" on an <samp>IFile</samp>. When this action is performed the workbench registry is consulted to determine an appropriate editor for the file type and then a new instance of the editor type is created. The actual result depends on the type of the editor. The workbench provides support for the creation of internal editors, which are tightly integrated into the workbench, and external editors, which are launched in a separate frame window. There are also various level of integration between these extremes. <p> In the case of an internal editor tight integration can be achieved between the workbench window and the editor part. The workbench menu and toolbar are pre-loaded with a number of common actions, such as cut, copy, and paste. The active part, view or editor, is expected to provide the implementation for these actions. An internal editor may also define new actions which appear in the workbench window. These actions only appear when the editor is active. <p> The integration between the workbench and external editors is more tenuous. In this case the workbench may launch an editor but after has no way of determining the state of the external editor or collaborating with it by any means except through the file system. a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance a unique name that will be used to identify this editor a translatable name that will be used in the UI for this editor A relative name of the icon that will be used for all resources that match the specified extensions. Editors should provide an icon to make it easy for users to distinguish between different editor types. If you specify a command rather than a class, an icon is not needed. In that case, the workbench will use the icon provided by the operating system. an optional field containing the list of file types understood by the editor. This is a string containing comma separate file extensions. For instance, an editor which understands hypertext documents may register for "htm, html". - the name of a class that implements <samp>org.eclipse.ui.IEditorPart</samp>. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive. If this attribute is defined then <samp>contributorClass</samp> should also be defined. + the name of a class that implements <samp>berry::IEditorPart</samp>. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive. If this attribute is defined then <samp>contributorClass</samp> should also be defined. - + a command to run in order to launch an external editor. The executable command must be located on the system path or in the plug-in's directory. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive. - the name of a class which that implements <samp>org.eclipse.ui.IEditorLauncher</samp>. + the name of a class which that implements <samp>berry::IEditorLauncher</samp>. A launcher will open an external editor. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive. - + - the name of a class that implements <samp>org.eclipse.ui.IEditorActionBarContributor</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This class is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type. + the name of a class that implements <samp>berry::IEditorActionBarContributor</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This class is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type. - + if true, this editor will be used as the default editor for the type. This is only relevant in a case where more than one editor is registered for the same type. If an editor is not the default for the type, it can still be launched using "Open with..." submenu for the selected resource. <p> Please note that this attribute is only honored for filename and extension associations at this time. It will not be honored for content type bindings. Content type-based resolution will occur on a first come, first serve basis and is not explicitly specified.</p> an optional field containing the list of file names understood by the editor. This is a string containing comma separate file names. For instance, an editor which understands specific hypertext documents may register for "ejb.htm, ejb.html". - - - - the symbolic name of a font. The symbolic font name must be the id of a defined font (see org.eclipse.ui.fontDefinitions). If this attribute is missing or invalid then the font name is the value of "org.eclipse.jface.textfont" in the editor's preferences store. If there is no preference store or the key is not defined then the JFace text font will be used. The editor implementation decides if it uses this symbolic font name to set the font. - - - - the name of a class that implements <samp>org.eclipse.ui.IEditorMatchingStrategy</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This allows the editor extension to provide its own algorithm for matching the input of one of its editors to a given editor input. + the name of a class that implements <samp>berry::IEditorMatchingStrategy</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This allows the editor extension to provide its own algorithm for matching the input of one of its editors to a given editor input. - + Advertises that the containing editor understands the given content type and is suitable for editing files of that type. - The content type identifier. This is an ID defined by the 'org.eclipse.core.runtime.contentTypes' extension point. + The content type identifier. This is an ID defined by the 'org.blueberry.core.runtime.contentTypes' extension point. The following is an example of an internal editor extension definition: <p> <pre> - <extension point="org.eclipse.ui.editors"> + <extension point="org.blueberry.ui.editors"> <editor id="com.xyz.XMLEditor" name="Fancy XYZ XML editor" icon="./icons/XMLEditor.gif" extensions="xml" - class="com.xyz.XMLEditor" - contributorClass="com.xyz.XMLEditorContributor" - symbolicFontName="org.eclipse.jface.textfont" + class="xyz::XMLEditor" + contributorClass="xyz::XMLEditorContributor" default="false"> </editor> </extension> </pre> </p> If the command attribute is used, it will be treated as an external program command line that will be executed in a platform-dependent manner. <p> If the launcher attribute is used the editor will also be treated as an external program. In this case the specified class must implement <samp>org.eclipse.ui.IEditorLauncher</samp>. The launcher will be instantiated and then <samp>open(IPath path)</samp> will be invoked to launch the editor on the provided local file system path. <p> If the class attribute is used, the workbench will assume that it is an internal editor and the specified class must implement <samp>org.eclipse.ui.IEditorPart</samp>. It is common practice to <samp>subclass org.eclipse.ui.EditorPart</samp> when defining a new editor type. It is also necessary to define a <samp>contributorClass</samp> attribute. The specified class must implement <samp>org.eclipse.ui.IEditorActionBarContributor</samp>, and is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type. <p> Within the workbench there may be more than one open editor of a particular type. For instance, there may be one or more open Java Editors. To avoid the creation of duplicate actions and action images the editor concept has been split into two. An <samp>IEditorActionBarContributor</samp> is responsible for the creation of actions. The editor is responsible for action implementation. Furthermore, the contributor is shared by each open editor. As a result of this design there is only one set of actions for one or more open editors. <p> The contributor will add new actions to the workbench menu and toolbar which reflect the editor type. These actions are shared and, when invoked, act upon the active editor. The active editor is passed to the contributor by invoking <samp>IEditorActionBarContributor.setActiveEditor</samp>. The identifiers for actions and major groups within the workbench window are defined in <samp>org.eclipse.ui.IWorkbenchActionConstants</samp>. These should be used as a reference point for the addition of new actions. Top level menus are created by using the following values for the path attribute: <ul> <li> additions - represents a group to the left of the Window menu. </li> </ul> Actions and menus added into these paths will only be shown while the associated editor is active. When the editor is closed, menus and actions will be removed. The workbench provides a "Default Text Editor". The end user product may contain other editors as part of the shipping bundle. In that case, editors will be registered as extensions using the syntax described above. Copyright (c) 2002, 2007 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/keywords.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/keywords.exsd index f1dde3a660..298d384c99 100644 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/keywords.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/keywords.exsd @@ -1,136 +1,127 @@ - + - + The keywords extension point defines keywords and a unique id for reference by other schemas. See propertyPages and preferencePages. a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance The id is the unique id used to reference the keyword. The human readable label of the keyword - - - - - - 3.1 - - - The following is an example of a keyword extension: <p> <pre> <extension - point="org.eclipse.ui.keywords"> + point="org.blueberry.ui.keywords"> <keyword label="presentation tab themes" id="com.xyz.AppearanceKeywords"/> </extension> </pre> </p> There currently is no public API for retrieving or creating keywords other than this extension point. - Keywords are used only with preference and property pages. See the <samp>keywordReference</samp> element of the org.eclipse.ui.propertyPages and org.eclipse.ui.preferencePages extension points. + Keywords are used only with preference and property pages. See the <samp>keywordReference</samp> element of the org.blueberry.ui.propertyPages and org.blueberry.ui.preferencePages extension points. Copyright (c) 2005,2006 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/perspectives.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/perspectives.exsd index 075c613a67..9796fb4d28 100755 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/perspectives.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/perspectives.exsd @@ -1,180 +1,180 @@ - + - + This extension point is used to add perspective factories to the workbench. A perspective factory is used to define the initial layout and visible action sets for a perspective. The user can select a perspective by invoking the "Open Perspective" submenu of the "Window" menu. a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance a unique name that will be used to identify this perspective. a translatable name that will be used in the workbench window menu bar to represent this perspective. a fully qualified name of the class that implements <samp>berry::IPerspectiveFactory</samp> interface. - + a relative name of the icon that will be associated with this perspective. indicates whether the layout of the perspective is fixed. If true, then views created by the perspective factory are not closeable, and cannot be moved. The default is false. an optional subelement whose body should contain text providing a short description of the perspective. The following is an example of a perspective extension: <p> <pre> <extension point="org.blueberry.ui.perspectives"> <perspective id="org.blueberry.ui.resourcePerspective" name="Resource" class="berry::ResourcePerspective" icon="resources/MyIcon.gif"> </perspective> </extension> </pre> </p> The value of the <samp>class</samp> attribute must be the fully qualified name of a class that implements <samp>berry::IPerspectiveFactory</samp>. The class must supply the initial layout for a perspective when asked by the workbench. <p> The <samp>plugin_customization.ini</samp> file is used to define the default perspective. The <i>default perspective</i> is the first perspective which appears when the product is launched after install. It is also used when the user opens a page or window with no specified perspective. The default perspective is defined as a property within the plugin_customization.ini, as shown below. The user may also override this perspective from the workbench perspectives preference page. <pre> defaultPerspectiveId = org.blueberry.ui.resourcePerspective </pre> The perspectives which appear in the "Open Perspective" menu are shortcuts for perspective selection. This set is defined by the active perspective itself, and extensions made through the perspectiveExtensions extension point. The workbench provides a "Resource Perspective". Additional perspectives may be added by plug-ins. They are selected using the "Open Perspective" submenu of the "Window" menu. Copyright (c) 2002, 2005 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/preferencePages.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/preferencePages.exsd index 0603381f34..a95e78770c 100644 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/preferencePages.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/preferencePages.exsd @@ -1,195 +1,195 @@ - + - + The workbench provides one common dialog box for preferences. The purpose of this extension point is to allow plug-ins to add pages to the preference dialog box. When preference dialog box is opened (initiated from the menu bar), pages contributed in this way will be added to the dialog box. <p> The preference dialog box provides for hierarchical grouping of the pages. For this reason, a page can optionally specify a <samp>category</samp> attribute. This attribute represents a path composed of parent page IDs separated by '/'. If this attribute is omitted or if any of the parent nodes in the path cannot be found, the page will be added at the root level. </p> a fully qualified identifier of the target extension point an optional identifier of the extension instance an optional name of the extension instance a unique name that will be used to identify this page. a translatable name that will be used in the UI for this page. a name of the fully qualified class that implements -<samp>org.eclipse.ui.IWorkbenchPreferencePage</samp>. +<samp>berry::IWorkbenchPreferencePage</samp>. a path indicating the location of the page in the preference tree. The path may either be a parent node ID or a sequence of IDs separated by '/', representing the full path from the root node. A reference by a preference page to a keyword. See the keywords extension point. The id of the keyword being referred to. The following is an example for the preference extension point: <p> <pre> <extension - point="org.eclipse.ui.preferencePages"> + point="org.blueberry.ui.preferencePages"> <page id="com.xyz.prefpage1" name="XYZ" - class="com.xyz.prefpages.PrefPage1"> + class="xyz::PrefPage1"> <keywordReference id="xyz.Keyword"/> </page> <page id="com.xyz.prefpage2" name="Keyboard Settings" - class="com.xyz.prefpages.PrefPage2" + class="xyz::PrefPage2" category="com.xyz.prefpage1"> </page> </extension> </pre> </p> The value of the attribute class must represent a fully qualified name of the class that implements -<samp>org.eclipse.ui.IWorkbenchPreferencePage</samp>. +<samp>berry::IWorkbenchPreferencePage</samp>. The workbench adds several pages for setting the preferences of the platform. Pages registered through this extension will be added after them according to their category information. Copyright (c) 2002, 2005 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/presentationFactories.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/presentationFactories.exsd index e8f27ff109..bd8bbe9953 100755 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/presentationFactories.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/presentationFactories.exsd @@ -1,134 +1,125 @@ - + - + This extension point is used to add presentation factories to the workbench. A presentation factory defines the overall look and feel of the workbench, including how views and editors are presented. - Specify the fully qualified class to be used for the presentation factory. The specified value must be a subclass of <code>org.eclipse.ui.presentations.AbstractPresentationFactory</code>. + Specify the fully qualified class to be used for the presentation factory. The specified value must implement the interface <code>berry::IPresentationFactory</code>. a unique name that will be used to identify this presentation factory a translatable name that can be used to show this presentation factory in the UI - - - - - - 3.0 - - - The following is an example of a presentationFactory extension: <pre> - <extension point="org.eclipse.ui.presentationFactories"> + <extension point="org.blueberry.ui.presentationFactories"> <factory - class="org.eclipse.ui.workbench.ExampleWorkbenchPresentationFactory"/> + class="berry::ExampleWorkbenchPresentationFactory"/> </extension> </pre> The class specified in the factory element must be a concrete subclass of <code>org.eclipse.ui.presentations.AbstractPresentationFactory</code>. - If a presentation factory is not specified or is missing then the implementation in <code>org.eclipse.ui.presentations.WorkbenchPresentationFactory</code> will be used. + If a presentation factory is not specified or is missing then the implementation in <code>berry::QtWorkbenchPresentationFactory</code> will be used. Copyright (c) 2004, 2005 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a> diff --git a/BlueBerry/Bundles/org.blueberry.ui/schema/services.exsd b/BlueBerry/Bundles/org.blueberry.ui/schema/services.exsd index 7b3f735f19..8f47c7d6c3 100755 --- a/BlueBerry/Bundles/org.blueberry.ui/schema/services.exsd +++ b/BlueBerry/Bundles/org.blueberry.ui/schema/services.exsd @@ -1,235 +1,226 @@ - + - + - Define service factories so that services can be contributed declaratively and will be available through <code>IServiceLocator#getService(Class)</code>. The implementation of <code>AbstractServiceFactory</code> must be able to return a global service and multiple child services (if applicable). + Define service factories so that services can be contributed declaratively and will be available through <code>berry::IServiceLocator::GetService(Class)</code>. The implementation of <code>AbstractServiceFactory</code> must be able to return a global service and multiple child services (if applicable). <p> Services must follow a general contract: <ul> <li>The top level service has no parent.</li> <li>The child service may use the supplied parent, which can be cast to the service interface.</li> -<li>Any other services needed for initialization should be retrieved from the <code>IServiceLocator</code>.</li> -<li>If the service needs to clean up any state (like listeners) it should implement <code>IDisposable</code>.</li> +<li>Any other services needed for initialization should be retrieved from the <code>berry::IServiceLocator</code>.</li> +<li>If the service needs to clean up any state (like listeners) it should implement <code>berry::IDisposable</code>.</li> <li>Services should clearly specify when they perform cleanup for clients, such as removing listeners automatically on disposal.</li> </ul> </p> Contribute services to the workbench. Match a service interface to a factory that can supply a hierachical implementation of that service. The factory that extends <code>AbstractServiceFactory</code> and can create the implementation for the serviceClass. A service this factory can provide. The interface that represents a service contract. A Source Provider supplies source variables to the IEvaluationService. It can also notify the IEvaluationService when one or more of the variables change. This class must provide variables and call the appropriate fireSourceChanged(*) method when any of the variables change. A source variable from this provider. A source provider must declare all variables that it provides. The name of a contributed source variable. It is a good practice to prepend the plugin id to the variable name to avoid collisions with other source providers. For conflict resolution used by services like the IHandlerService, contributed source variables must assign a priority. <b>workbench</b> is the global default priority. See <code>ISources</code> for relative priority information. - - - - - - 3.4 - - - <p> Here is a basic definition: <pre> <extension - point="org.eclipse.ui.services"> + point="org.blueberry.ui.services"> <serviceFactory - factoryClass="org.eclipse.ui.tests.services.LevelServiceFactory"> + factoryClass="my::LevelServiceFactory"> <service - serviceClass="org.eclipse.ui.tests.services.ILevelService"> + serviceClass="my::ILevelService"> </service> </serviceFactory> </extension> </pre></p> <p> The <code>LevelServiceFactory</code> can return an <code>ILevelService</code> when it is requested from the <code>IServiceLocator</code>: <pre> - ILevelService s = (ILevelService) getSite().getService(ILevelService.class); - System.out.println(s.getLevel()); + berry::ILevelService::Pointer s = GetSite()->GetService(my::ILevelService::GetStaticClassName()); + std::cout << s->GetLevel(); </pre> </p> <p> -In this test example, the factory would instantiate three <code>ILevelService</code> implementations during the first call to <code>getSite().getService(*)</code>. The global one in the workbench, one for the workbench window, and one for the site. +In this test example, the factory would instantiate three <code>ILevelService</code> implementations during the first call to <code>GetSite()->GetService(*)</code>. The global one in the workbench, one for the workbench window, and one for the site. </p> <p> Please see <code>org.eclipse.ui.services.AbstractServiceFactory</code>, <code>org.eclipse.ui.services.IDisposable</code>, and <code>org.eclipse.ui.services.IServiceWithSources</code> for more information. </p> Copyright (c) 2007 IBM Corporation and others.<br> 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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>