hxuanyu/intellij-sdk-code-samples
1
0
Fork 0
mirror of https://github.com/JetBrains/intellij-sdk-code-samples.git synced 2025-07-30 18:27:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

add links to elements in plugin configuration file

Browse Source 
Some occurrences are intentionally skipped. I added links only to the first occurrences of a given element in a section (not a page).
This commit is contained in:
Karol Lewandowski 2022-09-07 10:47:16 +02:00
parent 419b189d9c
commit f0a02fe5b5
31 changed files with 117 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
code_samples/action_basics/README.md
View File

@ -12,8 +12,8 @@ This Plugin registers the [`PopupDialogAction`][file:PopupDialogAction] action,
- by adding an action to a new group in the `EditorPopupMenu`, which is the Editor's context menu.
Additional features of the plugin:
- [Using the `<override-text>`][docs:action-override] element in an `<action>` element is demonstrated in the `plugin.xml` declaration to add the `PopupDialogAction` action directly to the `ToolsMenu`.
- [Localization of action and group][docs:action-locale] `text` and `description` attributes using a `<resource-bundle>` is demonstrated in the declaration to add a new group to the `EditorPopupMenu`.
- [Using the `<override-text>`][docs:action-override] element in an [`<action>`][docs:plugin-configuration-file:actions:action] element is demonstrated in the `plugin.xml` declaration to add the `PopupDialogAction` action directly to the `ToolsMenu`.
- [Localization of action and group][docs:action-locale] `text` and `description` attributes using a [`<resource-bundle>`][docs:plugin-configuration-file:resource-bundle] is demonstrated in the declaration to add a new group to the `EditorPopupMenu`.
### Actions
@ -32,6 +32,8 @@ Additional features of the plugin:
[docs:actions]: https://plugins.jetbrains.com/docs/intellij/basic-action-system.html
[docs:action-override]: https://plugins.jetbrains.com/docs/intellij/basic-action-system.html#setting-the-override-text-element
[docs:action-locale]: https://plugins.jetbrains.com/docs/intellij/basic-action-system.html#localizing-actions-and-groups
[docs:plugin-configuration-file:actions:action]: https://plugins.jetbrains.com/docs/intellij/plugin-configuration-file.html#idea-plugin__actions__action
[docs:plugin-configuration-file:resource-bundle]: https://plugins.jetbrains.com/docs/intellij/plugin-configuration-file.html#idea-plugin__resource-bundle
[file:PopupDialogAction]: ./src/main/java/org/intellij/sdk/action/PopupDialogAction.java
[file:CustomDefaultActionGroup]: ./src/main/java/org/intellij/sdk/action/CustomDefaultActionGroup.java

2
reference_guide/api_changes_list_2020.md
View File

@ -352,7 +352,7 @@ Java code migrated to use `TYPE_USE` nullability annotations
: This may break source-compatibility with inheritors written in Kotlin.
Images module functionality (package `org.intellij.images.*`) extracted to plugin
: The dependency [must be declared](plugin_dependencies.md) explicitly now:
: The dependency [must be declared](plugin_dependencies.md) explicitly now by the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element:
* Add `<depends>com.intellij.platform.images</depends>` in <path>plugin.xml</path>
* Add to <path>build.gradle</path>:

2
topics/appendix/api_notable/api_notable_list_2019.md
View File

@ -10,7 +10,7 @@
: Now reflects its "heavy test" characteristics (see [Light and Heavy Tests](light_and_heavy_tests.md)).
Support for transitive optional plugin dependencies
: Optional <path>plugin.xml</path> configuration files can now specify `<depends>`. [Issue](https://youtrack.jetbrains.com/issue/IDEA-209769)
: Optional <path>plugin.xml</path> configuration files can now specify [`<depends>`](plugin_configuration_file.md#idea-plugin__depends). [Issue](https://youtrack.jetbrains.com/issue/IDEA-209769)
Theme/Keymap plugins do not require restart
: (Un)Installing or enabling/disabling [Theme](themes_intro.md) or [Keymap](https://plugins.jetbrains.com/search?tags=Keymap) plugins doesn't require an IDE restart anymore.

4
topics/appendix/api_notable/api_notable_list_2020.md
View File

@ -25,7 +25,7 @@ Extensible HTML Lexer/Parser
Please note that old API from `com.intellij.lexer.BaseHtmlLexer` is no longer working.
Action System
: New features in [Action System](basic_action_system.md): `<override-text>` works now for `<group>` as well, `<synonym>` provides alternative names when searching for actions, and groups can be excluded from search results.
: New features in [Action System](basic_action_system.md): `<override-text>` works now for [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) as well, [`<synonym>`](plugin_configuration_file.md#idea-plugin__actions__action__synonym) provides alternative names when searching for actions, and groups can be excluded from search results.
Welcome Screen customization
: To provide additional custom tabs, implement `com.intellij.openapi.wm.WelcomeTabFactory` and register in `com.intellij.welcomeTabFactory` extension point.
@ -124,7 +124,7 @@ JCEF Support (_Experimental Feature_)
: Allows [embedding](jcef.md) Chromium-based browser in the IDE.
Override text presentation for actions depending on menu context
: Set the [`<override-text>`](basic_action_system.md#setting-the-override-text-element) element within the `<action>` declaration in <path>plugin.xml</path>.
: Set the [`<override-text>`](basic_action_system.md#setting-the-override-text-element) element within the [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) declaration in <path>plugin.xml</path>.
Changes in Project Open/Import
: **Import from Existing Sources** has been removed from the Welcome Screen, leaving only **Open or Import**, which calls a different extension than the one previously used to contribute a wizard step to **Import from Existing Sources** (which is still available in the <control>File</control> menu). To support **Open or Import**, a plugin must provide [`ProjectOpenProcessor`](%gh-ic%/platform/platform-api/src/com/intellij/projectImport/ProjectOpenProcessor.java).

12
topics/appendix/resources/custom_plugin_repository.md
View File

@ -92,9 +92,9 @@ It is recommended to avoid adding unnecessary elements as they will have to be s
The additional candidate elements:
| Element | Effects & Requirements |
|:--------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `<name>`<br/>My Plugin Name<br/>`</name>` | By default the name of the plugin JAR/ZIP file is displayed before installation. <br/>Using the `<name>` element displays the name of the plugin. <br/>Contents should match the `<name>` element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. |
| `<description>`<br/>My plugin is awesome<br/>`</description>` | By default no description for the plugin is displayed before installation. <br/>Using the `<description>` element will cause a description to be displayed before installation. <br/>Contents should match the `<description>` element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. <br/>Optionally, an enclosing `<![CDATA[ ]]>` element can be used if the description needs to contain HTML tags. |
| `<change-notes>`<br/>Added cool feature<br/>`</change-notes>` | By default no change notes for the plugin are displayed before installation. <br/>Using the `<change-notes>` element will cause a description of changes to be displayed before installation. <br/>Contents should match the `<change-notes>` element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. <br/>Optionally, an enclosing `<![CDATA[ ]]>` element can be used if the change notes need to contain HTML tags. |
| `<depends>`<br/>dependency.plugin.id<br/>`</depends>` | Adding a plugin dependency in the `<depends>` element will cause asking a user about enabling the dependency plugin, if it is installed and disabled in the IDE. A plugin can specify multiple `<depends>` elements. <br/>A plugin entry should include only the dependencies on other plugins that are defined in the plugin's <path>plugin.xml</path> file. The `optional` and `config-file` attributes are ignored and shouldn't be specified. |
| Element | Effects & Requirements |
|:--------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `<name>`<br/>My Plugin Name<br/>`</name>` | By default the name of the plugin JAR/ZIP file is displayed before installation. <br/>Using the `<name>` element displays the name of the plugin. <br/>Contents should match the [`<name>`](plugin_configuration_file.md#idea-plugin__name) element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. |
| `<description>`<br/>My plugin is awesome<br/>`</description>` | By default no description for the plugin is displayed before installation. <br/>Using the `<description>` element will cause a description to be displayed before installation. <br/>Contents should match the [`<description>`](plugin_configuration_file.md#idea-plugin__description) element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. <br/>Optionally, an enclosing `<![CDATA[ ]]>` element can be used if the description needs to contain HTML tags. |
| `<change-notes>`<br/>Added cool feature<br/>`</change-notes>` | By default no change notes for the plugin are displayed before installation. <br/>Using the `<change-notes>` element will cause a description of changes to be displayed before installation. <br/>Contents should match the [`<change-notes>`](plugin_configuration_file.md#idea-plugin__change-notes) element contents in the plugin's <path>plugin.xml</path> file to avoid confusion. <br/>Optionally, an enclosing `<![CDATA[ ]]>` element can be used if the change notes need to contain HTML tags. |
| `<depends>`<br/>dependency.plugin.id<br/>`</depends>` | Adding a plugin dependency in the `<depends>` element will cause asking a user about enabling the dependency plugin, if it is installed and disabled in the IDE. A plugin can specify multiple `<depends>` elements. <br/>A plugin entry should include only the dependencies on other plugins that are defined by the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) elements in the plugin's <path>plugin.xml</path> file. The `optional` and `config-file` attributes are ignored and shouldn't be specified. |

2
topics/appendix/resources/explore_api.md
View File

@ -66,7 +66,7 @@ you can use
to find all the files that meet the following criteria:
- The file type is XML
- It contains the tag `<idea-plugin>`
- It contains the tag [`<idea-plugin>`](plugin_configuration_file.md#idea-plugin)
- The file is in the scope <control>Project and Libraries</control>
![Search Structurally for plugin.xml](search_structurally_for_plugin_xml.png)

14
topics/appendix/resources/extension_point_list.md
View File

@ -40,13 +40,13 @@
### Tags
| Icon | Description | Details |
|-----------------------------------|-------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ![Deprecated][deprecated] | Deprecated API | Please see code documentation for replacement |
| ![Experimental API][experimental] | Experimental API | Annotated with [`@ApiStatus.Experimental`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java), API might be altered or removed without prior notice |
| ![Internal API][internal] | Internal API | Annotated with [`@ApiStatus.Internal`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java), should not be used by 3rd party, see [](api_internal.md) |
| ![Project-Level][project-level] | Project-Level Extension Point/Topic | Can have [`Project`](%gh-ic%/platform/core-api/src/com/intellij/openapi/project/Project.java) as constructor parameter<br/><br/>Extension Point: Declared with `area="IDEA_PROJECT"`<br/>Listener: registered in `<projectListeners>` |
| ![Non-Dynamic][non-dynamic] | Non-Dynamic Extension Point | Installation/update of plugin requires IDE restart ([Dynamic Plugins](dynamic_plugins.md)) |
| Icon | Description | Details |
|-----------------------------------|-------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ![Deprecated][deprecated] | Deprecated API | Please see code documentation for replacement |
| ![Experimental API][experimental] | Experimental API | Annotated with [`@ApiStatus.Experimental`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java), API might be altered or removed without prior notice |
| ![Internal API][internal] | Internal API | Annotated with [`@ApiStatus.Internal`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java), should not be used by 3rd party, see [](api_internal.md) |
| ![Project-Level][project-level] | Project-Level Extension Point/Topic | Can have [`Project`](%gh-ic%/platform/core-api/src/com/intellij/openapi/project/Project.java) as constructor parameter<br/><br/>Extension Point: Declared with `area="IDEA_PROJECT"`<br/>Listener: registered in [`<projectListeners>`](plugin_configuration_file.md#idea-plugin__projectListeners) |
| ![Non-Dynamic][non-dynamic] | Non-Dynamic Extension Point | Installation/update of plugin requires IDE restart ([Dynamic Plugins](dynamic_plugins.md)) |
[experimental]: https://img.shields.io/badge/-Experimental_API-red?style=flat-square
[internal]: https://img.shields.io/badge/-Internal_API-darkred?style=flat-square

26
topics/basics/basic_action_system.md
View File

@ -111,7 +111,7 @@ An example of inspecting PSI elements is demonstrated in the SDK code sample `ac
### Action IDs
Every action and action group has a unique identifier.
Basing the identifier for a custom action on the fully qualified name of the implementation is the best practice, assuming the package incorporates the `<id>` of the plugin.
Basing the identifier for a custom action on the fully qualified name of the implementation is the best practice, assuming the package incorporates the [`<id>`](plugin_configuration_file.md#idea-plugin__id) of the plugin.
Including the plugin identifier in the action identifier should prevent it from clashing with other plugins' actions.
An action must have a unique identifier for each place.
It is used in the IDE UI, even though the FQN of the implementation is the same.
@ -154,27 +154,27 @@ See the [Grouping Actions](grouping_action.md) tutorial for examples of creating
## Registering Actions
There are two main ways to register an action: either by listing it in the `<actions>` section of a plugin's <path>plugin.xml</path> file or through code.
There are two main ways to register an action: either by listing it in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>plugin.xml</path> file or through code.
### Registering Actions in plugin.xml
Registering actions in <path>plugin.xml</path> is demonstrated in the following reference examples, which document all elements and attributes used in the `<actions>` section and describe each element's meaning.
Registering actions in <path>plugin.xml</path> is demonstrated in the following reference examples, which document all elements and attributes used in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section and describe each element's meaning.
#### Setting the Override-Text Element
Beginning in 2020.1, an alternate version of an action's menu text can be declared for use depending on where an action appears.
Using the `<override-text>` element, the menu text for an action can be different depending on context: menu location, toolbar, etc.
Using the [`<override-text>`](plugin_configuration_file.md#idea-plugin__actions__action__override-text) element, the menu text for an action can be different depending on context: menu location, toolbar, etc.
This is also available for groups in 2020.3 and later.
In the `action` element reference example (below) with `id` attribute `VssIntegration.GarbageCollection`, the default is to use the menu text "Garbage Collector: Collect _Garbage."
The `add-to-group` element declares the action is added to the <menupath>Tools</menupath> menu.
In the `<action>` element reference example (below) with `id` attribute `VssIntegration.GarbageCollection`, the default is to use the menu text "Garbage Collector: Collect _Garbage."
The `<add-to-group>` element declares the action is added to the <menupath>Tools</menupath> menu.
However, the `override-text` element declares that text for `VssIntegration.GarbageCollection` displayed anywhere in the main menu system should be the alternate text "Collect _Garbage."
However, the `<override-text>` element declares that text for `VssIntegration.GarbageCollection` displayed anywhere in the main menu system should be the alternate text "Collect _Garbage."
The <menupath>Tools</menupath> menu is part of the main menu, so the displayed menu text is "Collect _Garbage."
A different context, such as searching for the action using <menupath>Help | Find Action</menupath>, displays the default text "Garbage Collector: Collect _Garbage" to give the user additional information about the action.
A second `override-text` element uses `place` and `use-text-of-place` attributes to declare the same version of the text used in the main menu is also used in the editor popup menu.
Additional `override-text` elements could be used to specify other places where the main menu text should be used.
A second `<override-text>` element uses `place` and `use-text-of-place` attributes to declare the same version of the text used in the main menu is also used in the editor popup menu.
Additional `<override-text>` elements could be used to specify other places where the main menu text should be used.
An example of using `<override-text>` is demonstrated in the [Creating Actions](working_with_custom_actions.md#using-override-text-for-an-action) tutorial.
@ -183,7 +183,7 @@ An example of using `<override-text>` is demonstrated in the [Creating Actions](
_2020.3_
Users can locate actions via their name by invoking <menupath>Help | Find Action</menupath>.
To allow using alternative names in search, add one or more `<synonym>` elements inside `<action>` or `<reference>`:
To allow using alternative names in search, add one or more [`<synonym>`](plugin_configuration_file.md#idea-plugin__actions__action__synonym) elements inside [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) or [`<reference>`](plugin_configuration_file.md#idea-plugin__actions__reference):
```xml
<action id="MyAction" text="My Action Name" ...>
@ -214,7 +214,7 @@ In the case of `action_basics`, only a default localization resource bundle (<pa
```
_2020.1_
If necessary, a dedicated resource bundle to use for actions and groups can be defined on `<actions>`:
If necessary, a dedicated resource bundle to use for actions and groups can be defined on [`<actions>`](plugin_configuration_file.md#idea-plugin__actions):
```xml
<actions resource-bundle="messages.MyActionsBundle">
@ -234,7 +234,7 @@ For Actions, the key in property files incorporates the action `id` in this spec
* `action.<action-id>.description=Translated Action Description`
_2020.1_
If `<override-text>` is used for an action `id`, the key includes the `<place>` attribute:
If `<override-text>` is used for an action `id`, the key includes the `place` attribute:
* `action.<action-id>.<place>.text=Place-dependent Translated Action Text`
</tab>
@ -401,6 +401,6 @@ Use [`BackAction`](%gh-ic%/platform/platform-api/src/com/intellij/ui/navigation/
### Runtime Placeholder Action
For actions registered at runtime (e.g., in a tool window toolbar), add an `<action>` entry with
For actions registered at runtime (e.g., in a tool window toolbar), add an [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) entry with
[`EmptyAction`](%gh-ic%/platform/platform-api/src/com/intellij/openapi/actionSystem/EmptyAction.java)
to "reserve" Action ID so they become visible in <menupath>Settings/Preferences | Keymap</menupath>.

60
topics/basics/getting_started/plugin_compatibility.md
View File

@ -36,7 +36,7 @@ This section identifies and discusses modules of both types.
### Declaring Incompatibility with Module
Starting in 2020.2, a plugin can declare incompatibility with an arbitrary module by specifying `<incompatible-with>` containing module ID in its <path>plugin.xml</path> (see [](plugin_configuration_file.md#idea-plugin__incompatible-with)).
Starting in 2020.2, a plugin can declare incompatibility with an arbitrary module by specifying [`<incompatible-with>`](plugin_configuration_file.md#idea-plugin__incompatible-with) containing module ID in its <path>plugin.xml</path>.
### Modules Available in All Products
@ -48,13 +48,13 @@ The following table lists modules that are currently available in all products.
>
{type="note"}
| Module for `<depends>` Element<br/>Declaration in <path>plugin.xml</path> File | <br/>Functionality |
|--------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
| **`com.intellij.modules.platform`** | Messaging, UI Themes, UI Components, Files, Documents, Actions, Components, Services, Extensions, Editors |
| `com.intellij.modules.lang` | File Type, Lexer, Parser, Highlighting, References, Code Completion, Find, Rename, Formatter, Code Navigation |
| `com.intellij.modules.xml` | XML, XML DOM, XSD/DTD, DOM Model |
| `com.intellij.modules.vcs` | VCS Revision Numbers, File Status, Change Lists, File History, Annotations |
| `com.intellij.modules.xdebugger` | Debug Session, Stack Frames, Break Points, Source Positions, Memory Views, Tracked Instances |
| Module for [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) Element<br/>Declaration in <path>plugin.xml</path> File | <br/>Functionality |
|-------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
| **`com.intellij.modules.platform`** | Messaging, UI Themes, UI Components, Files, Documents, Actions, Components, Services, Extensions, Editors |
| `com.intellij.modules.lang` | File Type, Lexer, Parser, Highlighting, References, Code Completion, Find, Rename, Formatter, Code Navigation |
| `com.intellij.modules.xml` | XML, XML DOM, XSD/DTD, DOM Model |
| `com.intellij.modules.vcs` | VCS Revision Numbers, File Status, Change Lists, File History, Annotations |
| `com.intellij.modules.xdebugger` | Debug Session, Stack Frames, Break Points, Source Positions, Memory Views, Tracked Instances |
As of this writing, if a plugin: **A)** is dependent _only_ on one or more of the modules in the table above, **and B)** declares those module dependencies in <path>plugin.xml</path>, then any product developed by JetBrains based on the IntelliJ Platform will load it.
@ -75,24 +75,24 @@ A plugin project is compatible with PHP functionality if it declares a dependenc
The following table lists **(1)** modules or built-in plugins that provide specific functionality, and the products currently shipping with them.
| Module or Plugin for `<depends>` Element<br/>Declaration in <path>plugin.xml</path> File | <br/>Functionality | IntelliJ Platform-Based<br/>Product Compatibility |
|------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `com.intellij.modules.java` See **(2)** below. <br/>`com.intellij.java` | **Java** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | IntelliJ IDEA, Android Studio |
| `com.intellij.modules.androidstudio` | Android SDK Platform, Build Tools, Platform Tools, SDK Tools | Android Studio |
| `com.intellij.modules.cidr.lang` | **C, C++, Objective-C/C++** language PSI Model, Swift/Objective-C Interaction, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.intellij.modules.cidr.debugger` | Debugger Watches, Evaluations, Breakpoints, Inline Debugging | AppCode, CLion, RubyMine |
| `com.intellij.modules.appcode` See **(3)** below. <br/>`com.intellij.appcode` | Xcode Project Model, CocoaPods, Core Data Objects, Device & Simulator Support | AppCode |
| `com.intellij.modules.clion` See **(3)** below. <br/>`com.intellij.clion` | CMake, Profiler, Embedded Development, Remote Development, Remote Debug, Disassembly | CLion |
| `com.intellij.cidr.base` | Native Debugger Integration, Utility Classes, C/C++ Project Model/Workspace Support (OCWorkspace, CidrWorkspace, etc.), C/C++ Build and Run Support | AppCode, CLion |
| `com.intellij.database` | **Database Tools and SQL** language PSI Model, Inspections, Completion, Refactoring, Queries | DataGrip, IntelliJ IDEA Ultimate, AppCode, PhpStorm, PyCharm Professional, RubyMine, CLion, GoLand, Rider, and WebStorm if the Database Tools and SQL plugin is installed. |
| `com.intellij.modules.goland` See **(4)** below.<br/>`com.intellij.modules.go` | **Go** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | GoLand |
| `com.intellij.modules.python` | **Python** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PyCharm, and other products if the Python plugin is installed. |
| `com.intellij.modules.rider` | Connection to **ReSharper** Process in Background | Rider |
| `com.intellij.modules.ruby` | **Ruby** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | RubyMine, and IntelliJ IDEA Ultimate if the Ruby plugin is installed. |
| `com.intellij.modules.ultimate` | Licensing | All commercial IDEs (IntelliJ IDEA Ultimate, PhpStorm, DataGrip, ...) |
| `com.intellij.swift` | **Swift** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.jetbrains.php` | **PHP** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PhpStorm, and other products if the PHP plugin is installed. |
| `JavaScript` | **JavaScript** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | WebStorm, and other products if the JavaScript plugin is installed. |
| Module or Plugin for [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) Element<br/>Declaration in <path>plugin.xml</path> File | <br/>Functionality | IntelliJ Platform-Based<br/>Product Compatibility |
|-----------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `com.intellij.modules.java` See **(2)** below. <br/>`com.intellij.java` | **Java** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | IntelliJ IDEA, Android Studio |
| `com.intellij.modules.androidstudio` | Android SDK Platform, Build Tools, Platform Tools, SDK Tools | Android Studio |
| `com.intellij.modules.cidr.lang` | **C, C++, Objective-C/C++** language PSI Model, Swift/Objective-C Interaction, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.intellij.modules.cidr.debugger` | Debugger Watches, Evaluations, Breakpoints, Inline Debugging | AppCode, CLion, RubyMine |
| `com.intellij.modules.appcode` See **(3)** below. <br/>`com.intellij.appcode` | Xcode Project Model, CocoaPods, Core Data Objects, Device & Simulator Support | AppCode |
| `com.intellij.modules.clion` See **(3)** below. <br/>`com.intellij.clion` | CMake, Profiler, Embedded Development, Remote Development, Remote Debug, Disassembly | CLion |
| `com.intellij.cidr.base` | Native Debugger Integration, Utility Classes, C/C++ Project Model/Workspace Support (OCWorkspace, CidrWorkspace, etc.), C/C++ Build and Run Support | AppCode, CLion |
| `com.intellij.database` | **Database Tools and SQL** language PSI Model, Inspections, Completion, Refactoring, Queries | DataGrip, IntelliJ IDEA Ultimate, AppCode, PhpStorm, PyCharm Professional, RubyMine, CLion, GoLand, Rider, and WebStorm if the Database Tools and SQL plugin is installed. |
| `com.intellij.modules.goland` See **(4)** below.<br/>`com.intellij.modules.go` | **Go** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | GoLand |
| `com.intellij.modules.python` | **Python** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PyCharm, and other products if the Python plugin is installed. |
| `com.intellij.modules.rider` | Connection to **ReSharper** Process in Background | Rider |
| `com.intellij.modules.ruby` | **Ruby** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | RubyMine, and IntelliJ IDEA Ultimate if the Ruby plugin is installed. |
| `com.intellij.modules.ultimate` | Licensing | All commercial IDEs (IntelliJ IDEA Ultimate, PhpStorm, DataGrip, ...) |
| `com.intellij.swift` | **Swift** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.jetbrains.php` | **PHP** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PhpStorm, and other products if the PHP plugin is installed. |
| `JavaScript` | **JavaScript** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | WebStorm, and other products if the JavaScript plugin is installed. |
**Notes about Module and Plugin Dependency:**
@ -239,7 +239,7 @@ If the project is not up-to-date, [reimport the Gradle project](https://www.jetb
Reimporting the project will automatically update the dependencies.
In the Project Window, select Project View and scroll to the bottom to see [External Libraries](https://www.jetbrains.com/help/idea/project-tool-window.html#content_pane).
Look for the library `Gradle:unzipped.com.jetbrains.plugins:foo:`, where "foo" matches, or is similar to the contents of the `<depends>` tags in <path>plugin.xml</path> or the [`intellij.plugins`](tools_gradle_intellij_plugin.md#intellij-extension-plugins) declaration in the Gradle build script.
Look for the library `Gradle:unzipped.com.jetbrains.plugins:foo:`, where "foo" matches, or is similar to the contents of the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags in <path>plugin.xml</path> or the [`intellij.plugins`](tools_gradle_intellij_plugin.md#intellij-extension-plugins) declaration in the Gradle build script.
The image below shows the External Libraries for the example plugin project configuration explained in [Configuring Gradle build script](dev_alternate_products.md#configuring-gradle-build-script-using-the-intellij-idea-product-attribute) and [Configuring plugin.xml](dev_alternate_products.md#configuring-pluginxml).
![Example PhpStorm Project Libraries](php_prj_libs.png){width="700"}
@ -256,15 +256,15 @@ If a project is dependent on a plugin or module, in some cases, the project can
>
{type="tip"}
To browse the opportunities for an extension, start by placing the cursor on the contents of the `<depends>` elements in the project's <path>plugin.xml</path> file.
To browse the opportunities for an extension, start by placing the cursor on the contents of the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) elements in the project's <path>plugin.xml</path> file.
Use the [Go to Declaration](https://www.jetbrains.com/help/idea/navigating-through-the-source-code.html#go_to_declaration) IDE feature to navigate to the <path>plugin.xml</path> file for the plugin on which the project depends.
For example, performing this procedure on the `<depends>com.jetbrains.php</depends>` declaration in a project's <path>plugin.xml</path> file will navigate to the <path>plugin.xml</path> file for the `com.jetbrains.php` (PHP) project.
A common, but not universal, pattern in the IntelliJ platform is for a plugin (like PHP) to declare `<extensionPoints>` and then implement each one as `<extensions>`.
A common, but not universal, pattern in the IntelliJ platform is for a plugin (like PHP) to declare [`<extensionPoints>`](plugin_configuration_file.md#idea-plugin__extensionPoints) and then implement each one as [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions).
Continuing the example, search the PHP plugin's <path>plugin.xml</path> file for:
* `<extensionPoints>` to find the opportunities for extending the PHP plugin's functionality.
* `<extensions defaultExtensionNs="com.jetbrains.php">` to find where the PHP plugin extends functionality.
The extension namespace (in this example `com.jetbrains.php`) will match the `<id>` defined in the <path>plugin.xml</path> file.
The extension namespace (in this example `com.jetbrains.php`) will match the [`<id>`](plugin_configuration_file.md#idea-plugin__id) defined in the <path>plugin.xml</path> file.
> If a dependency plugin [bundles its API sources](bundling_plugin_openapi_sources.md) in the distribution file, the Gradle IntelliJ Plugin (1.7.0+) will attach them to the plugin dependency in IDE, making sources available when navigating to the plugin API classes.
>

4
topics/basics/plugin_structure/dynamic_plugins.md
View File

@ -9,7 +9,7 @@ To test whether dynamic installation works correctly, verify installing [local b
Please note that any unloading problems in a production environment will simply ask the user to restart the IDE.
> If a plugin _requires_ restart (e.g., due to using native libraries) specify `require-restart="true"` for `<idea-plugin>` root tag in <path>plugin.xml</path>.
> If a plugin _requires_ restart (e.g., due to using native libraries) specify `require-restart="true"` for [`<idea-plugin>`](plugin_configuration_file.md#idea-plugin) root tag in <path>plugin.xml</path>.
>
{type="note"}
@ -27,7 +27,7 @@ No Components must be used; existing ones [must be migrated](plugin_components.m
### Action Group Requires ID
All `<group>`s must declare a unique `id`.
All [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) elements must declare a unique `id`.
### Use Only Dynamic Extensions

2
topics/basics/plugin_structure/plugin_class_loaders.md
View File

@ -34,7 +34,7 @@ configurations.all {
## Classes from Plugin Dependencies
By default, the main IDE class loader loads classes that are not found in the plugin class loader.
However, in the <path>plugin.xml</path> file, you may use the `<depends>` element to specify that a [plugin depends](plugin_dependencies.md) on one or more other plugins.
However, in the <path>plugin.xml</path> file, you may use the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element to specify that a [plugin depends](plugin_dependencies.md) on one or more other plugins.
In this case, the class loaders of those plugins will be used for classes not found in the current plugin.
This allows a plugin to reference classes from other plugins.

4
topics/basics/plugin_structure/plugin_dependencies.md
View File

@ -37,7 +37,7 @@ For plugins published on [JetBrains Marketplace](https://plugins.jetbrains.com):
### Bundled and Other Plugins
For bundled and non-public plugins, locate the plugin's main JAR file containing <path>META-INF/plugin.xml</path> descriptor with `<id>` tag (or `<name>` if not specified).
For bundled and non-public plugins, locate the plugin's main JAR file containing <path>META-INF/plugin.xml</path> descriptor with [`<id>`](plugin_configuration_file.md#idea-plugin__id) tag (or [`<name>`](plugin_configuration_file.md#idea-plugin__name) if not specified).
Bundled plugins are located in <path>$PRODUCT_ROOT$/plugins/$PLUGIN_NAME$/lib/$PLUGIN_NAME$.jar</path>.
#### IDs of Bundled Plugins
@ -129,7 +129,7 @@ Regardless of whether a plugin project uses [](plugin_compatibility.md#modules-a
If a project depends on another plugin, the dependency must be declared like a [module](plugin_compatibility.md#modules).
If only general IntelliJ Platform features (APIs) are used, then a default dependency on `com.intellij.modules.platform` must be declared.
To display a list of available IntelliJ Platform modules, invoke the [code completion](https://www.jetbrains.com/help/idea/auto-completing-code.html#4eac28ba) feature for the `<depends>` element contents while editing the plugin project's <path>plugin.xml</path> file.
To display a list of available IntelliJ Platform modules, invoke the [code completion](https://www.jetbrains.com/help/idea/auto-completing-code.html#4eac28ba) feature for the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element contents while editing the plugin project's <path>plugin.xml</path> file.
In the <path>plugin.xml</path>, add a `<depends>` tag with the dependency plugin's ID as its content.
Continuing with the example from [Project Setup](#2-project-setup) above, the dependency declaration in <path>plugin.xml</path> would be:

8
topics/basics/plugin_structure/plugin_extension_points.md
View File

@ -17,10 +17,10 @@ There are two types of extension points:
## Declaring Extension Points
You can declare extensions and extension points in the plugin configuration file <path>plugin.xml</path>, within the `<extensions>` and `<extensionPoints>` sections.
You can declare extensions and extension points in the plugin configuration file <path>plugin.xml</path>, within the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) and [`<extensionPoints>`](plugin_configuration_file.md#idea-plugin__extensionPoints) sections.
To declare extension points in your plugin, add an `<extensionPoints>` section to your <path>plugin.xml</path>.
Then insert a child element `<extensionPoint>` that defines the extension point name and the name of a bean class or an interface that is allowed to extend the plugin functionality in the `name`, `beanClass` and `interface` attributes, respectively.
Then insert a child element [`<extensionPoint>`](plugin_configuration_file.md#idea-plugin__extensionPoints__extensionPoint) that defines the extension point name and the name of a bean class or an interface that is allowed to extend the plugin functionality in the `name`, `beanClass` and `interface` attributes, respectively.
<path>myPlugin/META-INF/plugin.xml</path>
@ -42,7 +42,7 @@ Then insert a child element `<extensionPoint>` that defines the extension point
```
The `name` attribute assigns a unique name for this extension point.
Its fully qualified name required in [Using Extension Points](#using-extension-points) is built by prefixing `<id>` + `.`: `my.plugin.myExtensionPoint1` and `my.plugin.myExtensionPoint2`.
Its fully qualified name required in [Using Extension Points](#using-extension-points) is built by prefixing [`<id>`](plugin_configuration_file.md#idea-plugin__id) + `.`: `my.plugin.myExtensionPoint1` and `my.plugin.myExtensionPoint2`.
The `beanClass` attribute sets a bean class that specifies one or several properties annotated with the [`@Attribute`](%gh-ic%/platform/util/src/com/intellij/util/xmlb/annotations/Attribute.java) annotation.
Note that bean classes do not follow the JavaBean standard.
@ -133,7 +133,7 @@ public class MyExtensionUsingService {
}
```
A gutter icon for the `ExtensionPointName` declaration allows navigating to the corresponding `<extensionPoint>` declaration in <path>plugin.xml</path>.
A gutter icon for the `ExtensionPointName` declaration allows navigating to the corresponding [`<extensionPoint>`](plugin_configuration_file.md#idea-plugin__extensionPoints__extensionPoint) declaration in <path>plugin.xml</path>.
## Dynamic Extension Points
To support [Dynamic Plugins](dynamic_plugins.md) (2020.1 and later), an extension point must adhere to specific usage rules:

8
topics/basics/plugin_structure/plugin_extensions.md
View File

@ -20,7 +20,7 @@ There are more than 1000 extension points available in the platform and the bund
Additionally, dedicated Extension Point and Listener Lists specific to IDEs are available under _Part VIII — Product Specific_.
Browse usages inside existing implementations of open-source IntelliJ Platform plugins via [IntelliJ Platform Explorer](https://jb.gg/ipe).
Alternatively (or when using 3rd party extension points), all available extension points for the specified namespace (`defaultExtensionNs`) can be listed using auto-completion inside the `<extensions>` block in <path>plugin.xml</path>.
Alternatively (or when using 3rd party extension points), all available extension points for the specified namespace (`defaultExtensionNs`) can be listed using auto-completion inside the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) block in <path>plugin.xml</path>.
Use <menupath>View | Quick Documentation</menupath> in the lookup list to access more information about the extension point and implementation (if applicable).
See [](explore_api.md) for more information and strategies.
@ -30,7 +30,7 @@ See [](explore_api.md) for more information and strategies.
>
{type="tip"}
1. Add an `<extensions>` element to your <path>plugin.xml</path> if it's not yet present there.
1. Add an [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) element to your <path>plugin.xml</path> if it's not yet present there.
Set the `defaultExtensionNs` attribute to one of the following values:
* `com.intellij`, if your plugin extends the IntelliJ Platform core functionality.
* `{ID of a plugin}`, if your plugin extends the functionality of another plugin (must configure [Plugin Dependencies](plugin_dependencies.md)).
@ -94,7 +94,7 @@ Property names matching the following list will resolve to fully qualified class
- `serviceInterface` / `serviceImplementation`
- ending with `Class` (case-sensitive)
A required parent type can be specified in the extension point declaration via nested `<with>`:
A required parent type can be specified in the extension point declaration via nested [`<with>`](plugin_configuration_file.md#idea-plugin__extensionPoints__extensionPoint__with):
```xml
<extensionPoint name="myExtension" beanClass="MyExtensionBean">
@ -106,7 +106,7 @@ A required parent type can be specified in the extension point declaration via n
Property name `language` (or ending in `*Language`, 2020.2+) resolves to all present `Language` IDs.
Similarly, `action` resolves to all registered `<action>` IDs.
Similarly, `action` resolves to all registered [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) IDs.
Specifying `@org.jetbrains.annotations.Nls` validates a UI `String` capitalization according to the text property `Capitalization` enum value (2019.2 and later).

4
topics/basics/plugin_structure/plugin_listeners.md
View File

@ -23,7 +23,7 @@ The advantage is because listener instances get created lazily — the first tim
## Defining Application-Level Listeners
To define an application-level listener, add the following section to your <path>plugin.xml</path>:
To define an application-level listener, add the [`<applicationListeners>`](plugin_configuration_file.md#idea-plugin__applicationListeners) section to your <path>plugin.xml</path>:
```xml
<idea-plugin>
@ -78,7 +78,7 @@ public class MyVfsListener implements BulkFileListener {
## Defining Project-Level Listeners
[Project](project.md)-level listeners are registered in the same way, except that the top-level tag is `<projectListeners>`.
[Project](project.md)-level listeners are registered in the same way, except that the top-level tag is [`<projectListeners>`](plugin_configuration_file.md#idea-plugin__projectListeners).
They can be used to listen to project-level events, for example, [tool window](tool_windows.md) operations:
```xml

16
topics/intro/sdk_code_guidelines.md
View File

@ -77,7 +77,7 @@ A plugin with a longer directory name, such as <path>conditional_operator_intent
## Plugin ID Conventions
The plugin ID appears between `<id>` elements in the <path>plugin.xml</path> file.
The plugin ID appears between [`<id>`](plugin_configuration_file.md#idea-plugin__id) elements in the <path>plugin.xml</path> file.
In general, the plugin ID is the `Group ID` concatenated with the `Artifact ID`.
For example, a plugin like <path>facet_basics</path> has the plugin ID `org.intellij.sdk.facet`.
@ -153,20 +153,20 @@ A consistent structure for the <path>plugin.xml</path> [configuration file](plug
Comment profusely about unique elements and configurations, and comment sparingly for the rest.
The sequence of elements in an SDK code sample <path>plugin.xml</path> file is:
* `<id>` Use the fully qualified [Plugin ID](#plugin-id-conventions).
* `<name>` The name value does not have to match the [Plugin Directory Name](#directory-naming-conventions-for-sdk-plugins).
* [`<id>`](plugin_configuration_file.md#idea-plugin__id) Use the fully qualified [Plugin ID](#plugin-id-conventions).
* [`<name>`](plugin_configuration_file.md#idea-plugin__name) The name value does not have to match the [Plugin Directory Name](#directory-naming-conventions-for-sdk-plugins).
The name is used for display purposes and should reflect the functionality of the plugin.
The name must start with "SDK: ".
* `<version>` The code sample's version in MAJOR.MINOR.FIX format.
* [`<version>`](plugin_configuration_file.md#idea-plugin__version) The code sample's version in MAJOR.MINOR.FIX format.
* MAJOR corresponds to a significant upgrade in functionality.
* MINOR corresponds to minor refactoring and small improvements in functionality.
* FIX corresponds to changes that fix problems without significant refactoring.
* `<depends>` Include at least one dependency with the module `com.intellij.modules.platform` to indicate basic plugin compatibility with IntelliJ Platform-based products.
* [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) Include at least one dependency with the module `com.intellij.modules.platform` to indicate basic plugin compatibility with IntelliJ Platform-based products.
Add `<depends>` elements containing module FQNs as needed to describe more specialized [Compatibility with Multiple Products](plugin_compatibility.md), and any other [Plugin Dependencies](plugin_dependencies.md).
* `<description>` is a concise explanation of what is being demonstrated and how a user would access the functionality.
* [`<description>`](plugin_configuration_file.md#idea-plugin__description) is a concise explanation of what is being demonstrated and how a user would access the functionality.
If the plugin by default overrides IDE behavior (such as <path>tree_structure_provider</path>) it must be noted in the description.
* `<change-notes>` is an ordered list by version numbers with a brief description of changes for each version.
* `<vendor>` Set the value to `IntelliJ Platform SDK`.
* [`<change-notes>`](plugin_configuration_file.md#idea-plugin__change-notes) is an ordered list by version numbers with a brief description of changes for each version.
* [`<vendor>`](plugin_configuration_file.md#idea-plugin__vendor) Set the value to `IntelliJ Platform SDK`.
Set the attributes:
* `email` omit this attribute.
* `url` to the JetBrains Marketplace `"https://plugins.jetbrains.com"`

2
topics/products/appcode/app_code.md
View File

@ -30,7 +30,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
| [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir) | Path to locally installed target version of AppCode. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/AppCode/ch-0/193.5662.55/AppCode.app/Contents</path>. |
The dependency on the AppCode APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` tags must declare `com.intellij.modules.appcode` module dependency, or `com.intellij.appcode` plugin dependency for plugins targeting only versions 2020.3+.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.appcode` module dependency, or `com.intellij.appcode` plugin dependency for plugins targeting only versions 2020.3+.
## Available AppCode APIs

2
topics/products/clion/clion.md
View File

@ -29,7 +29,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
| [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir) | Not needed; the Development Instance will automatically match `intellij.type`. |
The dependency on the CLion APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` tags must declare `com.intellij.modules.clion` module dependency, or `com.intellij.clion` plugin dependency for plugins targeting only versions 2020.3+.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.clion` module dependency, or `com.intellij.clion` plugin dependency for plugins targeting only versions 2020.3+.
## Available CLion APIs

2
topics/products/datagrip/data_grip.md
View File

@ -24,7 +24,7 @@ To see how these attributes appear in a similar Gradle build script for PhpStorm
| [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir) | Path to locally installed target version of DataGrip. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/datagrip/ch-0/193.5233.139/DataGrip.app/Contents</path>. |
The dependency on the DataGrip APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` tags must declare `com.intellij.database`.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.database`.
**Note** that DataGrip plugins must also declare a dependency on `com.intellij.modules.platform` because `com.intellij.database` is not recognized as a module.
Consequently, without the `com.intellij.modules.platform` declaration the plugin is assumed to be a [legacy plugin](plugin_compatibility.md#declaring-plugin-dependencies) and will not load in DataGrip.

2
topics/products/goland/goland.md
View File

@ -68,7 +68,7 @@ Select a [version](https://plugins.jetbrains.com/plugin/9568-go/versions) of the
</tabs>
The dependency on the Go plugin APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` tags must declare `com.intellij.modules.goland`.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.goland`.
The <path>plugin.xml</path> file must also declare a dependency on `com.intellij.modules.platform` as explained in [Configuring the plugin.xml File](dev_alternate_products.md#configuring-pluginxml).
The dependency declaration is illustrated in the <path>plugin.xml</path> snippet below:

2
topics/products/pycharm/pycharm.md
View File

@ -23,7 +23,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
| [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir) | Not needed; the Development Instance will automatically match `intellij.type`. |
The dependency on the PyCharm APIs must be declared in the <path>plugin.xml</path> file.
As described in [Configuring the plugin.xml File](dev_alternate_products.md#configuring-pluginxml), the `<depends>` tags must declare `com.intellij.modules.python`.
As described in [Configuring the plugin.xml File](dev_alternate_products.md#configuring-pluginxml), the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.python`.
See the SDK code sample [`pycharm_basics`](%gh-sdk-samples%/product_specific/pycharm_basics/) for an example configuration.
Please note that this code sample must be imported into Gradle explicitly, as it is not included in the `_gradleCompositeBuild`.

4
topics/products/rider/rider.md
View File

@ -34,8 +34,8 @@ This is useful e.g. when a plugin brings its own file templates.
For the ReSharper part to pick these settings, the settings files should be available in the plugin JAR file under the path <path>dotnet/Extensions/$backend-plugin-id$/settings</path>, where `backend-plugin-id` is calculated according to the following rules:
- if the IntelliJ plugin id (the `<id>` element of the <path>plugin.xml</path>) includes a dot, then `backend-plugin-id` is the same as the IntelliJ plugin id;
- otherwise, the `backend-plugin-id` is a concatenation of the IntelliJ plugin vendor name (the `<vendor>` element of the <path>plugin.xml</path>) and the IntelliJ plugin id.
- if the IntelliJ plugin id (the [`<id>`](plugin_configuration_file.md#idea-plugin__id) element of the <path>plugin.xml</path>) includes a dot, then `backend-plugin-id` is the same as the IntelliJ plugin id;
- otherwise, the `backend-plugin-id` is a concatenation of the IntelliJ plugin vendor name (the [`<vendor>`](plugin_configuration_file.md#idea-plugin__vendor) element of the <path>plugin.xml</path>) and the IntelliJ plugin id.
For example, for a plugin with the following <path>plugin.xml</path> contents, the file <path>dotnet/Extensions/com.example.awesomeplugin/settings/templates.DotSettings</path> would be picked up:

2
topics/products/rubymine/rubymine.md
View File

@ -30,7 +30,7 @@ The Ruby plugin isn't bundled with `IU`, so the Ruby plugin version must be expl
The correct Ruby plugin version is also determined from the Ruby plugin version page.
The dependency on the Ruby plugin APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` elements must contain `com.intellij.modules.ruby`.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) elements must contain `com.intellij.modules.ruby`.
The dependency declaration is illustrated in the <path>plugin.xml</path> snippet below:
```xml

2
topics/products/webstorm/webstorm.md
View File

@ -28,7 +28,7 @@ To see how these attributes appear in a similar Gradle build script for PhpStorm
| [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir) | Path to locally installed target version of WebStorm. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/WebStorm/ch-0/192.7142.35/WebStorm.app/Contents</path>. |
The dependency on the WebStorm APIs must be declared in the <path>plugin.xml</path> file.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the `<depends>` tags must declare `JavaScriptLanguage`.
As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `JavaScriptLanguage`.
**Note** that for WebStorm, the <path>plugin.xml</path> file must also declare a dependency on `com.intellij.modules.platform` because `JavaScriptLanguage` is not recognized as a module.
Consequently, without the `com.intellij.modules.platform` declaration the plugin is assumed to be a [legacy plugin](plugin_compatibility.md#declaring-plugin-dependencies) and will not load in WebStorm.

2
topics/reference_guide/ui_themes/themes.md
View File

@ -85,7 +85,7 @@ The value of the `author` key is by default empty.
The `editorScheme` section will be addressed in [Adding a Custom Editor Scheme](themes_extras.md#adding-a-custom-editor-scheme)
The `ui` section will be addressed in [Customizing UI Control Colors](themes_customize.md#customizing-ui-controls).
The Wizard also creates a `themeProvider` declaration in the `<extensions>` section of the plugin's <path>plugin.xml</path> file.
The Wizard also creates a `themeProvider` declaration in the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) section of the plugin's <path>plugin.xml</path> file.
This declaration binds the Theme description file to a theme provider extension using a generated unique `id`.
```xml

2
topics/reference_guide/work_with_icons_and_images.md
View File

@ -72,7 +72,7 @@ object MyIcons {
{type="note"}
Use these constants inside <path>plugin.xml</path> when specifying `icon` attribute for `<action>` or extension point, as well in [`@Presentation`](%gh-ic%/platform/analysis-api/src/com/intellij/ide/presentation/Presentation.java) `icon` attribute.
Use these constants inside <path>plugin.xml</path> when specifying `icon` attribute for [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) or extension point, as well in [`@Presentation`](%gh-ic%/platform/analysis-api/src/com/intellij/ide/presentation/Presentation.java) `icon` attribute.
Note that the package name `icons` will be automatically prefixed and must not be specified.
```xml

16
topics/tutorials/action_system/grouping_action.md
View File

@ -15,7 +15,7 @@ The group is based on a default IntelliJ Platform implementation.
### Creating Simple Groups
Grouping can be registered by adding a `<group>` element to the `<actions>` section of a plugin's <path>plugin.xml</path> file.
Grouping can be registered by adding a [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) element to the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>plugin.xml</path> file.
This example has no `class` attribute in the `<group>` element because the IntelliJ Platform framework will supply a default implementation class for the group.
This default implementation is used if a set of actions belonging to the group is static, i.e., does not change at runtime, which is the majority of cases.
The `id` attribute must be unique, so incorporating the plugin ID or package name is the best practice.
@ -35,7 +35,7 @@ See [](basic_action_system.md#registering-actions-in-pluginxml) for more informa
### Binding Action Groups to UI Components
The following sample shows how to use an `<add-to-group>` element to place a custom action group relative to an entry in the <menupath>Tools</menupath> menu.
The following sample shows how to use an [`<add-to-group>`](plugin_configuration_file.md#idea-plugin__actions__action__add-to-group) element to place a custom action group relative to an entry in the <menupath>Tools</menupath> menu.
The attribute `relative-to-action` references the action `id` for `PopupDialogAction`, not a native IntelliJ menu entry.
Rather `PopupDialogAction` is defined in the same [`plugin.xml`](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml) file.
This group is placed after the single entry for the action `PopupDialogAction`, as defined in the tutorial [Creating Actions](working_with_custom_actions.md#registering-an-action-with-the-new-action-form).
@ -57,7 +57,7 @@ This group is placed after the single entry for the action `PopupDialogAction`,
The `PopupDialogAction` implementation will be reused and registered in the newly created static group.
The `id` attribute for the reused `PopupDialogAction` implementation is set to a unique value, `org.intellij.sdk.action.GroupPopDialogAction`.
This value differentiates this new `<action>` entry from the `id` previously used to register this action implementation in the [Creating Actions](working_with_custom_actions.md#registering-an-action-with-the-new-action-form) tutorial.
This value differentiates this new [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) entry from the `id` previously used to register this action implementation in the [Creating Actions](working_with_custom_actions.md#registering-an-action-with-the-new-action-form) tutorial.
A unique `id` supports reuse of action classes in more than one menu or group.
The action in this group will be displayed in the menu as "A Group Action".
@ -116,7 +116,7 @@ public class CustomDefaultActionGroup extends DefaultActionGroup {
### Registering the Custom Action Group
As in the case with the static action group, the action `<group>` should be declared in the `<actions>` section of the <path>plugin.xml</path> file, for example, the [action_basics](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml) plugin.
As in the case with the static action group, the action [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) should be declared in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of the <path>plugin.xml</path> file, for example, the [action_basics](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml) plugin.
For demonstration purposes, this implementation will use localization.
The `<group>` element declaration below shows:
@ -125,7 +125,7 @@ The `<group>` element declaration below shows:
* Setting the group's `popup` attribute to allow submenus.
* The `text` and `description` attributes are omitted in the `<group>` declaration in favor of using the localization resource bundle to define them.
* There is no `icon` attribute for the group; the `CustomDefaultActionGroup` implementation will [add an icon for the group](#providing-specific-behavior-for-the-custom-group).
* The `<add-to-group>` element specifies adding the group in the first position of the existing `EditorPopupMenu`.
* The [`<add-to-group>`](plugin_configuration_file.md#idea-plugin__actions__action__add-to-group) element specifies adding the group in the first position of the existing `EditorPopupMenu`.
```xml
<resource-bundle>messages.BasicActionsBundle</resource-bundle>
@ -142,7 +142,7 @@ The `<group>` element declaration below shows:
### Adding Actions to the Custom Group
As in [Static Grouped Actions](#adding-a-new-action-to-the-static-grouped-actions), the `PopupDialogAction` action is added as an `<action>` element in the `<group>` element.
As in [Static Grouped Actions](#adding-a-new-action-to-the-static-grouped-actions), the `PopupDialogAction` action is added as an [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) element in the [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) element.
In the `<action>` element declaration below:
* The `class` attribute in the `<action>` element has the same FQN to reuse this action implementation.
* The `id` attribute is unique to distinguish it from other uses of the implementation in the Action System.
@ -165,7 +165,7 @@ In the `<action>` element declaration below:
Now the translations for the `text` and `description` attributes must be provided in the resource bundle [`BasicActionsBundle.properties`](%gh-sdk-samples%/action_basics/src/main/resources/messages/BasicActionsBundle.properties) file according to [Localizing Actions and Groups](basic_action_system.md#localizing-actions-and-groups).
Note there are two sets of `text` and `description` translations, one for the action and one for the group.
Conceivably, there could be another set of translations for the action if it used the `<override-text>` attribute.
Conceivably, there could be another set of translations for the action if it used the [`<override-text>`](plugin_configuration_file.md#idea-plugin__actions__action__override-text) attribute.
```properties
action.org.intellij.sdk.action.CustomGroupedAction.text=A Popup Action[en]
@ -214,7 +214,7 @@ public class DynamicActionGroup extends ActionGroup {
### Registering a Variable Action Group
To register the dynamic menu group, a `<group>` attribute needs to be placed in the `<actions>` section of [`plugin`.xml](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml).
To register the dynamic menu group, a [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) attribute needs to be placed in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of [`plugin`.xml](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml).
When enabled, this group appears just below the [Static Grouped Actions](#binding-action-groups-to-ui-components) in the <menupath>Tools</menupath> menu:
```xml

10
topics/tutorials/action_system/working_with_custom_actions.md
View File

@ -51,7 +51,7 @@ Before fleshing out those methods, to complete this minimal implementation, `Pop
## Registering a Custom Action
Actions are registered by declaring them in code or by declaring them in the `<actions>` section of a plugin configuration (<path>plugin.xml</path>) file.
Actions are registered by declaring them in code or by declaring them in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin configuration (<path>plugin.xml</path>) file.
This section describes using IDE tooling - the <control>New Action</control> form - to add a declaration to the <path>plugin.xml</path> file, and then tuning registration attributes manually.
A more comprehensive explanation of action registration is available in the [](basic_action_system.md#registering-actions) section of this guide.
@ -83,7 +83,7 @@ The fields of the form are:
In this case, `PopupDialogAction` would be available in the <menupath>Tools</menupath> menu, it would be placed at the top, and would have no shortcuts.
After finishing the <control>New Action</control> form and applying the changes, the `<actions>` section of the plugin's <path>plugins.xml</path> file would contain:
After finishing the <control>New Action</control> form and applying the changes, the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of the plugin's <path>plugins.xml</path> file would contain:
```xml
<actions>
@ -97,8 +97,8 @@ After finishing the <control>New Action</control> form and applying the changes,
</actions>
```
The `<action>` element declares the <control>Action ID</control> (`id`), <control>Class Name</control> (`class`), <control>Name</control> (`text`), and <control>Description</control> from the <control>New Action</control> form.
The `<add-to-group>` element declares where the action will appear and mirrors the names of entries from the form.
The [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) element declares the <control>Action ID</control> (`id`), <control>Class Name</control> (`class`), <control>Name</control> (`text`), and <control>Description</control> from the <control>New Action</control> form.
The [`<add-to-group>`](plugin_configuration_file.md#idea-plugin__actions__action__add-to-group) element declares where the action will appear and mirrors the names of entries from the form.
This declaration is adequate, but adding more attributes is discussed in the next section.
@ -108,7 +108,7 @@ An action declaration can be added manually to the <path>plugin.xml</path> file.
An exhaustive list of declaration elements and attributes is presented in [](basic_action_system.md#registering-actions-in-pluginxml).
Attributes are added by selecting them from the <control>New Action</control> form, or by editing the registration declaration directly in the <path>plugin.xml</path> file.
The `<action>` declaration for `PopupDialogAction` in the `action_basics` [plugin.xml](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml) file.
The [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) declaration for `PopupDialogAction` in the `action_basics` [plugin.xml](%gh-sdk-samples%/action_basics/src/main/resources/META-INF/plugin.xml) file.
It also contains an attribute for an [`Icon`](work_with_icons_and_images.md) and encloses elements declaring text overrides, keyboard and mouse shortcuts, and to which menu group the action should be added.
The full declaration is:

6
topics/tutorials/build_system/gradle_guide.md
View File

@ -95,7 +95,7 @@ A plugin project's <path>plugin.xml</path> file has element values that are "pat
As many as possible of the attributes in the Patching DSL will be substituted into the corresponding element values in a plugin project's <path>plugin.xml</path> file:
* If a [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxml) attribute default value is defined, the attribute value will be patched in <path>plugin.xml</path> _regardless of whether the [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxml) task appears in the Gradle build script_.
* For example, the default values for the attributes [`patchPluginXml.sinceBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-sincebuild) and [`patchPluginXml.untilBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-untilbuild) are defined based on the declared (or default) value of [`intellij.version`](tools_gradle_intellij_plugin.md#intellij-extension-version).
So by default [`patchPluginXml.sinceBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-sincebuild) and [`patchPluginXml.untilBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-untilbuild) are substituted into the `<idea-version>` element's `since-build` and `until-build` attributes in the <path>plugin.xml</path> file.
So by default [`patchPluginXml.sinceBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-sincebuild) and [`patchPluginXml.untilBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-untilbuild) are substituted into the [`<idea-version>`](plugin_configuration_file.md#idea-plugin__idea-version) element's `since-build` and `until-build` attributes in the <path>plugin.xml</path> file.
* If a [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxml) attribute value is explicitly defined, the attribute value will be substituted in <path>plugin.xml</path>.
* If both [`patchPluginXml.sinceBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-sincebuild) and [`patchPluginXml.untilBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-untilbuild) attributes are explicitly set, both are substituted in <path>plugin.xml</path>.
* If one attribute is explicitly set (e.g. [`patchPluginXml.sinceBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-sincebuild)) and one is not (e.g. [`patchPluginXml.untilBuild`](tools_gradle_intellij_plugin.md#patchpluginxml-task-untilbuild) has a default value,) both attributes are patched at their respective (explicit and default) values.
@ -112,10 +112,10 @@ For those [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxm
{type="tip"}
As discussed in [Components of a Wizard-Generated Gradle IntelliJ Platform Plugin](gradle_prerequisites.md#components-of-a-wizard-generated-gradle-intellij-platform-plugin), the Gradle properties `project.version`, `project.group`, and `rootProject.name` are all generated based on the input to the Wizard.
However, the [Gradle IntelliJ Plugin](tools_gradle_intellij_plugin.md) does not combine and substitute those Gradle properties for the default `<id>` and `<name>` elements in the <path>plugin.xml</path> file.
However, the [Gradle IntelliJ Plugin](tools_gradle_intellij_plugin.md) does not combine and substitute those Gradle properties for the default [`<id>`](plugin_configuration_file.md#idea-plugin__id) and [`<name>`](plugin_configuration_file.md#idea-plugin__name) elements in the <path>plugin.xml</path> file.
The best practice is to keep `project.version` current.
By default, if you modify `project.version` in Gradle build script, the Gradle plugin will automatically update the `<version>` value in the <path>plugin.xml</path> file.
By default, if you modify `project.version` in Gradle build script, the Gradle plugin will automatically update the [`<version>`](plugin_configuration_file.md#idea-plugin__version) value in the <path>plugin.xml</path> file.
This practice keeps all version declarations synchronized.
### Verifying Plugin

2
topics/tutorials/build_system/gradle_prerequisites.md
View File

@ -139,7 +139,7 @@ tasks {
#### Plugin Gradle Properties and Plugin Configuration File Elements
The Gradle properties `rootProject.name` and `project.group` will not, in general, match the respective [plugin configuration file](plugin_configuration_file.md) <path>plugin.xml</path> elements `<name>` and `<id>`.
The Gradle properties `rootProject.name` and `project.group` will not, in general, match the respective [plugin configuration file](plugin_configuration_file.md) <path>plugin.xml</path> elements [`<name>`](plugin_configuration_file.md#idea-plugin__name) and [`<id>`](plugin_configuration_file.md#idea-plugin__id).
There is no IntelliJ Platform-related reason they should as they serve different functions.
The `<name>` element (used as the plugin's display name) is often the same as `rootProject.name`, but it can be more explanatory.

2
topics/tutorials/editor_basics/working_with_text.md
View File

@ -20,7 +20,7 @@ It may be helpful to open that project in an IntelliJ Platform-based IDE, build
In this example, we access the `Editor` from an action.
The source code for the Java class in this example is [EditorIllustrationAction](%gh-sdk-samples%/editor_basics/src/main/java/org/intellij/sdk/editor/EditorIllustrationAction.java).
To register the action, we must add the corresponding elements to the `<actions>` section of the plugin configuration file [plugin.xml](%gh-sdk-samples%/editor_basics/src/main/resources/META-INF/plugin.xml).
To register the action, we must add the corresponding elements to the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of the plugin configuration file [plugin.xml](%gh-sdk-samples%/editor_basics/src/main/resources/META-INF/plugin.xml).
For more information, refer to the [Registering Actions](working_with_custom_actions.md#registering-a-custom-action) section of the Actions Tutorial.
The `EditorIllustrationAction` action is registered in the group `EditorPopupMenu` so it will be available from the context menu when focus is on the editor: