From da6f83a159f326bc1fdd48ffcbf484c25acc440f Mon Sep 17 00:00:00 2001 From: breandan Date: Mon, 30 Nov 2015 06:25:21 -0500 Subject: [PATCH] Replace "IntelliJ IDEA" with "IntelliJ Platform" where appropriate and other minor changes --- basics.md | 2 +- basics/architectural_overview/psi_elements.md | 2 +- basics/architectural_overview/virtual_file.md | 4 ++-- basics/checkout_and_build_community.md | 6 ++--- basics/getting_started/creating_an_action.md | 16 +++++++------- .../creating_plugin_project.md | 4 ++-- basics/getting_started/deploying_plugin.md | 4 ++-- .../running_and_debugging_a_plugin.md | 2 +- basics/plugin_structure/plugin_actions.md | 4 ++-- basics/plugin_structure/plugin_components.md | 22 +++++++++---------- basics/plugin_structure/plugin_services.md | 2 +- basics/project_structure.md | 6 ++--- basics/settings_caches_logs.md | 2 +- basics/testing_plugins.md | 2 +- basics/testing_plugins/tests_and_fixtures.md | 2 +- basics/virtual_file_system.md | 8 +++---- drafts/project_model.md | 16 +++++++------- faq.md | 4 ++-- phpstorm/setting_up_environment.md | 2 +- reference_guide/color_scheme_management.md | 4 ++-- .../external_builder_api.md | 2 +- .../spring_api.md | 2 +- reference_guide/messaging_infrastructure.md | 10 ++++----- reference_guide/project_model/facet.md | 2 +- reference_guide/project_model/library.md | 2 +- reference_guide/project_model/project.md | 2 +- reference_guide/project_model/sdk.md | 2 +- .../vcs_integration_for_plugins.md | 6 ++--- reference_guide/work_with_icons_and_images.md | 4 ++-- tutorials/action_system.md | 2 +- tutorials/build_system.md | 4 ++-- tutorials/build_system/prerequisites.md | 14 ++++++------ .../custom_language_support/prerequisites.md | 8 +++---- tutorials/editor_basics.md | 2 +- tutorials/project_wizard/adding_new_steps.md | 2 +- tutorials/project_wizard/module_types.md | 2 +- .../tests_prerequisites.md | 4 ++-- user_interface_components/dialog_wrapper.md | 2 +- .../editor_components.md | 6 ++--- .../file_and_class_choosers.md | 2 +- user_interface_components/lists_and_trees.md | 2 +- user_interface_components/notifications.md | 4 ++-- user_interface_components/popups.md | 4 ++-- 43 files changed, 102 insertions(+), 102 deletions(-) diff --git a/basics.md b/basics.md index 186097cc71b..c301aa58abc 100644 --- a/basics.md +++ b/basics.md @@ -5,7 +5,7 @@ title: Quick Start Guide This section covers the basics of working with *IntelliJ Platform*. It will familiarize you with the working environment, project structure, and frequently used API components. -* [Main Types of IntelliJ IDEA Plugins](basics/types_of_plugins.md) +* [Main Types of IntelliJ Platform Plugins](basics/types_of_plugins.md) * [Getting Started](basics/getting_started.md) * [Architectural Overview](basics/architectural_overview.md) * [Project Structure](basics/project_structure.md) diff --git a/basics/architectural_overview/psi_elements.md b/basics/architectural_overview/psi_elements.md index d67f950ee3f..72a22feefe5 100644 --- a/basics/architectural_overview/psi_elements.md +++ b/basics/architectural_overview/psi_elements.md @@ -4,7 +4,7 @@ title: PSI Elements A PSI (Program Structure Interface) file represents a hierarchy of PSI elements (so-called _PSI trees_). A single PSI file may include several PSI trees in a particular programming language. A PSI element, in its turn, can have child PSI elements. -PSI elements and operations on the level of individual PSI elements are used to explore the internal structure of source code as it is interpreted by **IntelliJ IDEA**. For example, you can use PSI elements to perform code analysis, such as [code inspections](http://www.jetbrains.com/idea/help/code-inspection.html) or [intention actions](http://www.jetbrains.com/idea/help/intention-actions.html). +PSI elements and operations on the level of individual PSI elements are used to explore the internal structure of source code as it is interpreted by the **IntelliJ Platform**. For example, you can use PSI elements to perform code analysis, such as [code inspections](http://www.jetbrains.com/idea/help/code-inspection.html) or [intention actions](http://www.jetbrains.com/idea/help/intention-actions.html). The [PsiElement](upsource:///platform/core-api/src/com/intellij/psi/PsiElement.java) class is the common base class for PSI elements. diff --git a/basics/architectural_overview/virtual_file.md b/basics/architectural_overview/virtual_file.md index 420ee0bb4e1..9fca9e59ec5 100644 --- a/basics/architectural_overview/virtual_file.md +++ b/basics/architectural_overview/virtual_file.md @@ -2,7 +2,7 @@ title: Virtual Files --- -A virtual file [com.intellij.openapi.vfs.VirtualFile](upsource:///platform/core-api/src/com/intellij/openapi/vfs/VirtualFile.java) is *IntelliJ IDEA's* representation of a file in a file system (VFS). Most commonly, a virtual file is a file in your local file system. However, *IntelliJ IDEA* supports multiple pluggable file system implementations, so virtual files can also represent classes in a JAR file, old revisions of files loaded from a version control repository, and so on. +A virtual file [com.intellij.openapi.vfs.VirtualFile](upsource:///platform/core-api/src/com/intellij/openapi/vfs/VirtualFile.java) is the *IntelliJ Platform's* representation of a file in a file system (VFS). Most commonly, a virtual file is a file in your local file system. However, the *IntelliJ Platform* supports multiple pluggable file system implementations, so virtual files can also represent classes in a JAR file, old revisions of files loaded from a version control repository, and so on. The VFS level deals only with binary content. You can get or set the contents of a `VirtualFile` as a stream of bytes, but concepts like encodings and line separators are handled on higher system levels. @@ -21,7 +21,7 @@ Typical file operations are available, such as traverse the file system, get fil The VFS is built incrementally, by scanning the file system up and down starting from the project root. New files appearing in the file system are detected by VFS _refreshes_. A refresh operation can be initiated programmatically using (`VirtualFileManager.getInstance().refresh()` or `VirtualFile.refresh()`). VFS refreshes are also triggered whenever file system watchers receive file system change notifications (available on the Windows and Mac operating systems). -As a plugin developer, you may want to invoke a VFS refresh if you need to access a file that has just been created by an external tool through IntelliJ IDEA APIs. +As a plugin developer, you may want to invoke a VFS refresh if you need to access a file that has just been created by an external tool through the IntelliJ Platform APIs. ## How long does a virtual file persist? diff --git a/basics/checkout_and_build_community.md b/basics/checkout_and_build_community.md index 4595a75a514..8ee371079cd 100644 --- a/basics/checkout_and_build_community.md +++ b/basics/checkout_and_build_community.md @@ -45,13 +45,13 @@ You can also browse the source code through the Web interface. ## Forking on GitHub -As an alternative to checking out the official repository, you can fork the GitHub mirror of the IntelliJ IDEA source code, make changes in your own fork, and send us a pull request. +As an alternative to checking out the official repository, you can fork the GitHub mirror of the IntelliJ Platform source code, make changes in your own fork, and send us a pull request. The GitHub mirror can be found at [https://github.com/JetBrains/intellij-community](https://github.com/JetBrains/intellij-community). ## Building and Running from the IDE -To develop IntelliJ IDEA, you can use either [IntelliJ IDEA Community Edition](https://www.jetbrains.com/idea/download/) or [IntelliJ IDEA Ultimate](https://www.jetbrains.com/idea/download/). +To develop plugins and applications on the IntelliJ Platform, you can use either [IntelliJ IDEA Community Edition](https://www.jetbrains.com/idea/download/) or [IntelliJ IDEA Ultimate](https://www.jetbrains.com/idea/download/). **Building and running the code** @@ -61,7 +61,7 @@ To develop IntelliJ IDEA, you can use either [IntelliJ IDEA Community Edition](h Parts of IntelliJ IDEA are written in Groovy, and you will get compilation errors if you don't have the plugin enabled. -* Make sure you have the UI Designer plugin enabled. Most of IntelliJ IDEA's UI is built using the UI Designer, and the version you build will not run correctly if you don't have the plugin enabled. +* Make sure you have the UI Designer plugin enabled. Most of the IntelliJ IDEA platform UI is built using the UI Designer, and the version you build will not run correctly if you don't have the plugin enabled. ![UI Designer plugin](img/ui_designer_plugin_enabled.png) diff --git a/basics/getting_started/creating_an_action.md b/basics/getting_started/creating_an_action.md index 373117564a4..ac05aa4083d 100644 --- a/basics/getting_started/creating_an_action.md +++ b/basics/getting_started/creating_an_action.md @@ -2,14 +2,14 @@ title: Creating an action --- -Your plugins can customize the Intellij IDEA UI by adding new items to the menus and toolbars. Intellij IDEA provides the [AnAction.java](upsource:///platform/editor-ui-api/src/com/intellij/openapi/actionSystem/AnAction.java) class whose `actionPerformed` method is called each time you select a menu item or click a toolbar button. +Your plugins can customize the IntelliJ Platform UI by adding new items to the menus and toolbars. The IntelliJ Platform provides the class [AnAction.java](upsource:///platform/editor-ui-api/src/com/intellij/openapi/actionSystem/AnAction.java) whose `actionPerformed` method is called each time you select a menu item or click a toolbar button. -To customize *IntelliJ IDEA*, you should perform two basic steps: +To create custom actions in the *IntelliJ Platform*, you should perform two basic steps: 1. In your plugin, define an action or a system of actions that add their own items to menus and toolbars. 2. Register your actions. -This topic outlines the above steps. For detailed information and samples, refer to [IntelliJ IDEA Action System](/basics/action_system.md). +This topic outlines the above steps. For detailed information and samples, refer to [IntelliJ Platform Action System](/basics/action_system.md). ### Defining actions @@ -46,7 +46,7 @@ Once you have defined an action or a system of actions, you must register them t * Register actions in the `` section of the `plugin.xml` file. * Register actions from Java code. -This section provides some examples that illustrate how to register actions. For more information, refer to [IntelliJ IDEA Action System](/basics/action_system.md). +This section provides some examples that illustrate how to register actions. For more information, refer to [IntelliJ Platform Action System](/basics/action_system.md). #### Registering actions in the plugin.xml file @@ -64,15 +64,15 @@ To register your actions, make appropriate changes to the `` section of ``` -This fragment of the plugin.xml file demonstrates only some elements you can use in the `` section to register your actions. For information about all elements designed to register your actions, refer to [IntelliJ IDEA Action System](/basics/action_system.md). +This fragment of the plugin.xml file demonstrates only some elements you can use in the `` section to register your actions. For information about all elements designed to register your actions, refer to [IntelliJ Platform Action System](/basics/action_system.md). #### Registering actions from Java code -Alternatively, you can register your actions from Java code. For more information and samples that illustrate how to register actions from Java code, see [IntelliJ IDEA Action System](/basics/action_system.md). +Alternatively, you can register your actions from Java code. For more information and samples that illustrate how to register actions from Java code, see [IntelliJ Platform Action System](/basics/action_system.md). ### Quick creation of actions -IntelliJ IDEA provides the New Action wizard that suggests a simplified way of creating actions, with all the required infrastructure. The wizard helps you declare the action class and automatically makes appropriate changes to the `` section of the plugin.xml file. +The IntelliJ Platform provides the **New Action** wizard that suggests a simplified way of creating actions, with all the required infrastructure. The wizard helps you declare the action class and automatically makes appropriate changes to the `` section of the plugin.xml file. Note that you can use this wizard only to add a new action to an existing action group on the main menu or toolbar. If you want to create a new action group, and then add an action to this group, follow instructions earlier in this document. @@ -94,4 +94,4 @@ Note that you can use this wizard only to add a new action to an existing action ![New Action Page](img/new_action_page.png) -IntelliJ IDEA generates a `.java` file with the specified class name, registers the newly created action in the plugin.xml file, adds a node to the module tree view, and opens the created action class file in the editor. +The IntelliJ Platform generates a `.java` file with the specified class name, registers the newly created action in the plugin.xml file, adds a node to the module tree view, and opens the created action class file in the editor. diff --git a/basics/getting_started/creating_plugin_project.md b/basics/getting_started/creating_plugin_project.md index 4562353bbec..723ae384a13 100644 --- a/basics/getting_started/creating_plugin_project.md +++ b/basics/getting_started/creating_plugin_project.md @@ -2,8 +2,8 @@ title: Creating a Plugin Project --- -This section explains how you can create a new plugin project from scratch using the New Project wizard. Optionally, you can import an existing project or import a project from external models. You can also add a new plugin module to an existing *Intellij IDEA* project. -For more information, refer to the [Intellij IDEA Web Help](https://www.jetbrains.com/idea/help/new-project-wizard.html). +This section explains how you can create a new plugin project from scratch using the New Project wizard. Optionally, you can import an existing project or import a project from external models. You can also add a new plugin module to an existing *IntelliJ Platform* project. +For more information, refer to the [IntelliJ IDEA Web Help](https://www.jetbrains.com/idea/help/new-project-wizard.html). ## To create a plugin project: diff --git a/basics/getting_started/deploying_plugin.md b/basics/getting_started/deploying_plugin.md index 3227fabc5c2..0fae56a1001 100644 --- a/basics/getting_started/deploying_plugin.md +++ b/basics/getting_started/deploying_plugin.md @@ -15,7 +15,7 @@ To deploy a plugin: ![Jar Saved Notification](deploying_plugin/img/jar_saved_notification.png) -* Copy the newly created archive file to the `.IntelliJIDEAx0\config\plugins` folder, and then restart IntelliJ IDEA so the changes take effect. To know how to locate your *plugins* directory, refer to [IDE Settings, Caches, Logs, and Plugins](/basics/settings_caches_logs.md). +* Copy the newly created archive file to the `.IntelliJIDEAx0\config\plugins` folder, and then restart your IDE so the changes may take effect. To know how to locate your *plugins* directory, refer to [IDE Settings, Caches, Logs, and Plugins](/basics/settings_caches_logs.md). ![Jar File Location](deploying_plugin/img/jar_location.png) @@ -23,4 +23,4 @@ To deploy a plugin: * In the Settings dialog box, under **IDE Settings**, click **Plugins**. * In the Plugins area, open the **Installed** tab, and then select the check-box next to your plugin name. * When finished, click OK to close the Settings dialog box. -* Restart *IntelliJ IDEA* so that your changes take effect. +* Restart the IDE so that your changes take effect. diff --git a/basics/getting_started/running_and_debugging_a_plugin.md b/basics/getting_started/running_and_debugging_a_plugin.md index bd4d8e1994b..adfdfef18a8 100644 --- a/basics/getting_started/running_and_debugging_a_plugin.md +++ b/basics/getting_started/running_and_debugging_a_plugin.md @@ -4,7 +4,7 @@ title: Running and Debugging a Plugin The *IntelliJ Platform* allows you to run and debug a plugin without leaving the IDE. To run or debug the plugin from within *IntelliJ IDEA*, you need a configured special profile (a Run/Debug configuration) that specifies the class to run, VM parameters and other specific options. In most cases, you can use the default *Run/Debug* configuration profiles for your plugin projects. -For information on how to change the Run/Debug configuration profile, refer to [Run/Debug Configuration](http://www.jetbrains.com/idea/help/run-debug-configuration.html) and [Run/Debug Configuration: Plugin](http://www.jetbrains.com/idea/help/run-debug-configuration-plugin.html) in *Intellij IDEA* Web Help. +For information on how to change the Run/Debug configuration profile, refer to [Run/Debug Configuration](http://www.jetbrains.com/idea/help/run-debug-configuration.html) and [Run/Debug Configuration: Plugin](http://www.jetbrains.com/idea/help/run-debug-configuration-plugin.html) in *IntelliJ IDEA* Web Help. Using *IntelliJ IDEA*'s debugger, you can find out the origin of the run-time errors and exceptions. diff --git a/basics/plugin_structure/plugin_actions.md b/basics/plugin_structure/plugin_actions.md index 94360586100..220de1891ec 100644 --- a/basics/plugin_structure/plugin_actions.md +++ b/basics/plugin_structure/plugin_actions.md @@ -2,6 +2,6 @@ title: Plugin Actions --- -*Intellij IDEA* provides the concept of _actions_. An action is a class, derived from the [`AnAction`](upsource:///platform/editor-ui-api/src/com/intellij/openapi/actionSystem/AnAction.java) class, whose `actionPerformed` method is called when the menu item or toolbar button is selected. +The *Intellij Platform* provides the concept of _actions_. An action is a class, derived from the [`AnAction`](upsource:///platform/editor-ui-api/src/com/intellij/openapi/actionSystem/AnAction.java) class, whose `actionPerformed` method is called when the menu item or toolbar button is selected. -The system of actions allows plugins to add their own items to IDEA menus and toolbars. Actions are organized into groups, which, in turn, can contain other groups. A group of actions can form a toolbar or a menu. Subgroups of the group can form submenus of a menu. You can find detailed information on how to create and register your actions in [IntelliJ IDEA Action System](/basics/action_system.md). +The system of actions allows plugins to add their own items to IDEA menus and toolbars. Actions are organized into groups, which, in turn, can contain other groups. A group of actions can form a toolbar or a menu. Subgroups of the group can form submenus of a menu. You can find detailed information on how to create and register your actions in the [IntelliJ Platform Action System](/basics/action_system.md). diff --git a/basics/plugin_structure/plugin_components.md b/basics/plugin_structure/plugin_components.md index 296eadaf92e..39bcc4cbc63 100644 --- a/basics/plugin_structure/plugin_components.md +++ b/basics/plugin_structure/plugin_components.md @@ -4,9 +4,9 @@ title: Plugin Components Components are the fundamental concept of plugin integration. There are three kinds of components: -* **Application level components** are created and initialized when *IntelliJ IDEA* starts up. They can be acquired from the [Application](upsource:///platform/core-api/src/com/intellij/openapi/application/Application.java) instance by using the `getComponent(Class)` method. -* **Project level components** are created for each [`Project`](upsource:///platform/core-api/src/com/intellij/openapi/project/Project.java) instance in *IntelliJ IDEA*. (Please note that components may be created even for unopened projects.) They can be acquired from the `Project` instance by using the `getComponent(Class)` method. -* **Module level components** are created for each [Module](upsource:///platform/core-api/src/com/intellij/openapi/module/Module.java) in every project loaded in *IntelliJ IDEA*. +* **Application level components** are created and initialized when your IDE starts up. They can be acquired from the [Application](upsource:///platform/core-api/src/com/intellij/openapi/application/Application.java) instance by using the `getComponent(Class)` method. +* **Project level components** are created for each [`Project`](upsource:///platform/core-api/src/com/intellij/openapi/project/Project.java) instance in the IDE. (Please note that components may be created even for unopened projects.) They can be acquired from the `Project` instance by using the `getComponent(Class)` method. +* **Module level components** are created for each [`Module`](upsource:///platform/core-api/src/com/intellij/openapi/module/Module.java) inside every project loaded in the IDE. Module level components can be acquired from a `Module` instance with the `getComponent(Class)` method. Every component should have interface and implementation classes specified in the configuration file. The interface class will be used for retrieving the component from other components, and the implementation class will be used for component instantiation. @@ -23,15 +23,15 @@ It is recommended to name components in the form `. Optionally, an application level component's implementation class may implement the [ApplicationComponent](upsource:///platform/core-api/src/com/intellij/openapi/components/ApplicationComponent.java) interface. -An application component that has no dependencies should have a constructor with no parameters which will be used for its instantiation. If an application component depends on other application components, it can specify these components as constructor parameters. *IntelliJ IDEA* will ensure that the components are instantiated in the correct order to satisfy the dependencies. +An application component that has no dependencies should have a constructor with no parameters which will be used for its instantiation. If an application component depends on other application components, it can specify these components as constructor parameters. The *IntelliJ Platform* will ensure that the components are instantiated in the correct order to satisfy the dependencies. Note that application level components must be registered in the `` section of the plugin.xml file (see [Plugin Configuration File](plugin_configuration_file.md)). ### Quick creation of application components -*IntelliJ IDEA* suggests a simplified way to create application components, with all the required infrastructure. +The *IntelliJ Platform* suggests a simplified way to create application components, with all the required infrastructure. -The IntelliJ interface will help you declare the application component's implementation class, and will automatically make appropriate changes to the `` section of the `plugin.xml` file. +The IntelliJ Platform interface will help you declare the application component's implementation class, and will automatically make appropriate changes to the `` section of the `plugin.xml` file. **To create and register an application component:** @@ -39,7 +39,7 @@ The IntelliJ interface will help you declare the application component's impleme 2. In the *New* menu, click *Application Component*. 3. In the *New Application Component* dialog box that opens, enter the application component name, and then click *OK*. -*IntelliJ IDEA* will generate a new Java class that implements the [ApplicationComponent](upsource:///platform/core-api/src/com/intellij/openapi/components/ApplicationComponent.java) interface; register the newly created component in the `plugin.xml` file; add a node to the module tree view; and open the created application component class file in the editor. +The *IntelliJ Platform* will generate a new Java class that implements the [ApplicationComponent](upsource:///platform/core-api/src/com/intellij/openapi/components/ApplicationComponent.java) interface. First register the newly created component in the `plugin.xml` file, then add a node to the module tree view; and open the created application component class file in the editor. ## Project level components @@ -52,7 +52,7 @@ Note that project level components must be registered in the ` -*IntelliJ IDEA* suggests a simplified way to create project components, with all the required infrastructure. +The *IntelliJ Platform* suggests a simplified way to create project components, with all the required infrastructure. The IDEA interface will help you declare the project component's implementation class, and will automatically make appropriate changes to the `` section of the `plugin.xml` file. @@ -62,7 +62,7 @@ The IDEA interface will help you declare the project component's implementation 2. In the *New* menu, click *Project Component*. 3. In the *New Project Component* dialog box that opens, enter the project component name, and then click *OK*. -*IntelliJ IDEA* will generate a new Java class that implements the [ProjectComponent](upsource:///platform/core-api/src/com/intellij/openapi/components/ProjectComponent.java) interface; register the newly created component in the `plugin.xml` file; add a node to the module tree view; and open the created application component class file in the editor. +The *IntelliJ Platform* will generate a new Java class that implements the [ProjectComponent](upsource:///platform/core-api/src/com/intellij/openapi/components/ProjectComponent.java) interface; register the newly created component in the `plugin.xml` file; add a node to the module tree view; and open the created application component class file in the editor. ## Module level components @@ -74,7 +74,7 @@ Note that module level components must be registered in the ` ### Quick creation of module components -*IntelliJ IDEA* suggests a simplified way to create module components, with all the required infrastructure. +The *IntelliJ Platform* suggests a simplified way to create module components, with all the required infrastructure. The IDEA interface will help you declare the module component's implementation class, and will automatically make appropriate changes to the `` section of the `plugin.xml` file. @@ -84,7 +84,7 @@ The IDEA interface will help you declare the module component's implementation c 2. In the *New* menu, click *Module Component*. 3. In the *New Module Component* dialog box that opens, enter the module component name, and then click *OK*. -*IntelliJ IDEA* will generate a new Java class that implements the [ModuleComponent](upsource:///platform/core-api/src/com/intellij/openapi/module/ModuleComponent.java) interface; register the newly created component in the `plugin.xml` file; add a node to the module tree view; and open the created application component class file in the editor. +The *IntelliJ Platform* will generate a new Java class that implements the [ModuleComponent](upsource:///platform/core-api/src/com/intellij/openapi/module/ModuleComponent.java) interface; register the newly created component in the `plugin.xml` file; add a node to the module tree view; and open the created application component class file in the editor. ## Persisting the state of components diff --git a/basics/plugin_structure/plugin_services.md b/basics/plugin_structure/plugin_services.md index 7da063fce3d..d8b27356965 100644 --- a/basics/plugin_structure/plugin_services.md +++ b/basics/plugin_structure/plugin_services.md @@ -49,7 +49,7 @@ MyServiceImplClass service = ServiceManager.getService(MyServiceImplClass.class) ### Sample Plugin -This section allows you to download and install a sample plugin illustrating how to create and use a plugin service. This plugin has a project component implementing a service that counts the number of currently opened projects in *IntelliJ IDEA*. If this number exceeds the maximum allowed number of simultaneously opened projects, the plugin returns an error message and closes the most recently opened project. +This section allows you to download and install a sample plugin illustrating how to create and use a plugin service. This plugin has a project component implementing a service that counts the number of currently opened projects in the IDE. If this number exceeds the maximum allowed number of simultaneously opened projects, the plugin returns an error message and closes the most recently opened project. diff --git a/basics/project_structure.md b/basics/project_structure.md index 7e42439432c..a032a8ca755 100644 --- a/basics/project_structure.md +++ b/basics/project_structure.md @@ -8,7 +8,7 @@ This topic considers the concept of projects based on *IntelliJ Platform* and re ## Project and its components -This section briefly discusses the IDEA project structure, project components and related terms. For more information about projects and their components, refer to [Project](http://www.jetbrains.com/idea/help/project.html), [Module](http://www.jetbrains.com/idea/help/module.html), [Library](http://www.jetbrains.com/idea/help/library.html), [Facet](http://www.jetbrains.com/idea/help/facet.html) in *IntelliJ IDEA* Web Help. +This section briefly discusses the IDEA project structure, project components and related terms. For more information about projects and their components, refer to [Project](http://www.jetbrains.com/idea/help/project.html), [Module](http://www.jetbrains.com/idea/help/module.html), [Library](http://www.jetbrains.com/idea/help/library.html), [Facet](http://www.jetbrains.com/idea/help/facet.html) in the *IntelliJ IDEA* Web Help. ### Project @@ -36,13 +36,13 @@ The SDK determines which API library is used to build the project. If your proje Optionally, you can configure individual SDK for each module. -For more information about SDKs, see [Configuring Global, Project and Module SDKs](https://www.jetbrains.com/idea/help/configuring-global-project-and-module-sdks.html) in *IntelliJ IDEA* Web Help. +For more information about SDKs, see [Configuring Global, Project and Module SDKs](https://www.jetbrains.com/idea/help/configuring-global-project-and-module-sdks.html) in the *IntelliJ IDEA* Web Help. ### Facet A _facet_ represents certain configuration, specific for a particular framework/technology, associated with a module. A module can have multiple facets. E.g. Spring specific configuration is stored in a Spring facet. -For more information about facets see [Facet](http://www.jetbrains.com/idea/help/facet.html) and [Facet Dependencies](http://www.jetbrains.com/idea/help/available-facets-and-their-dependencies.html) in *IntelliJ IDEA* Web Help. +For more information about facets see [Facet](http://www.jetbrains.com/idea/help/facet.html) and [Facet Dependencies](http://www.jetbrains.com/idea/help/available-facets-and-their-dependencies.html) in the *IntelliJ IDEA* Web Help. ## Project Structure diff --git a/basics/settings_caches_logs.md b/basics/settings_caches_logs.md index 71b9486bc7a..0aa64bebeb3 100644 --- a/basics/settings_caches_logs.md +++ b/basics/settings_caches_logs.md @@ -11,7 +11,7 @@ Every IntelliJ-based IDE stores its local settings, caches, log and installed pl In the folder you can find two subdirectories: * `config` that contains user-specific settings. - * `system` that stores `IntelliJ IDEA` data caches. + * `system` that stores `IntelliJ Platform` data caches. * **Mac OS X:** You can find internal configuration data in: * `/Applications//Contents/plugins` contains the catalog with plugins. diff --git a/basics/testing_plugins.md b/basics/testing_plugins.md index 236b1676e98..63c4c5d1821 100644 --- a/basics/testing_plugins.md +++ b/basics/testing_plugins.md @@ -2,7 +2,7 @@ title: Testing Plugins --- -Most of the tests in the *IntelliJ IDEA* codebase are *model level functional tests*. What this means is the following: +Most of the tests in the *IntelliJ Platform* codebase are *model level functional tests*. What this means is the following: * The tests run in a headless environment which uses real production implementations for the majority of components, except for a number of UI components. * The tests usually test a feature as a whole, rather than individual functions that comprise its implementation. diff --git a/basics/testing_plugins/tests_and_fixtures.md b/basics/testing_plugins/tests_and_fixtures.md index 75c063597c2..b99315d029c 100644 --- a/basics/testing_plugins/tests_and_fixtures.md +++ b/basics/testing_plugins/tests_and_fixtures.md @@ -2,7 +2,7 @@ title: Tests and Fixtures --- -The *IntelliJ Platform* testing infrastructure is not tied to any specific test framework. In fact, the IntelliJ IDEA team uses both JUnit, TestNG and Cucumber for testing different parts of the project. However, most of the tests are written using JUnit 3. +The *IntelliJ Platform* testing infrastructure is not tied to any specific test framework. In fact, the IntelliJ IDEA Team uses both JUnit, TestNG and Cucumber for testing different parts of the project. However, most of the tests are written using JUnit 3. When writing your own tests, you have the choice between using a standard base class to perform the test set up for you and using a fixture class, which lets you perform the setup manually and does not tie you to a specific test framework. diff --git a/basics/virtual_file_system.md b/basics/virtual_file_system.md index 03729a48bbc..e351f5b1c65 100644 --- a/basics/virtual_file_system.md +++ b/basics/virtual_file_system.md @@ -16,13 +16,13 @@ All VFS access operations go through the snapshot. If some information is requested through the VFS APIs and is not available in the snapshot, it is loaded from disk and stored into the snapshot. If the information is available in the snapshot, the snapshot data is returned. The contents of files and the lists of files in directories are stored in the snapshot only if that specific information was accessed - otherwise, only file metadata like name, length, timestamp, attributes is stored. -> **Note** This means that the state of the file system and the file contents displayed in the IntelliJ IDEA UI comes from the snapshot, which may not always match the actual contents of the disk. +> **Note** This means that the state of the file system and the file contents displayed in the IntelliJ Platform UI comes from the snapshot, which may not always match the actual contents of the disk. > -> For example, in some cases deleted files can still be visible in the UI for some time before the deletion is picked up by IntelliJ IDEA. +> For example, in some cases deleted files can still be visible in the UI for some time before the deletion is picked up by the IntelliJ Platform. The snapshot is updated from disk during _refresh operations_, which generally happen asynchronously. All write operations made through the VFS are synchronous - i.e. the contents is saved to disk immediately. -A refresh operation synchronizes the state of a part of the VFS with the actual disk contents. Refresh operations are explicitly invoked from *IntelliJ IDEA* or plugin code - i.e. when a file is changed on disk while *IntelliJ IDEA* is running, the change will not be immediately picked up by the VFS. The VFS will be updated during the next refresh operation which includes the file in its scope. +A refresh operation synchronizes the state of a part of the VFS with the actual disk contents. Refresh operations are explicitly invoked by the *IntelliJ Platform* or plugin code - i.e. when a file is changed on disk while the IDE is running, the change will not be immediately picked up by the VFS. The VFS will be updated during the next refresh operation which includes the file in its scope. *IntelliJ Platform* refreshes the entire project contents asynchronously on startup. By default, it performs a refresh operation when the user switches to it from another app, but users can turn this off via **Settings \| Appearance & Behavior \| System Settings \| Synchronize files on frame activation**. @@ -34,7 +34,7 @@ There is currently no facility for removing files from the snapshot. If a file w The VFS itself does not honor ignored files listed in **Settings \| File Types \| Files** and folders to ignore and excluded folders listed in **Project Structure \| Modules \| Sources \| Excluded**. If the application code accesses them, the VFS will load and return their contents. In most cases, the ignored files and excluded folders must be skipped from processing by higher level code. -During the lifetime of a running instance of *IntelliJ IDEA*, multiple `VirtualFile` instances may correspond to the same disk file. They are equal, have the same `hashCode` and share the user data. +During the lifetime of a running instance of an IntelliJ Platform IDE, multiple `VirtualFile` instances may correspond to the same disk file. They are equal, have the same `hashCode` and share the user data. ## Synchronous and asynchronous refreshes diff --git a/drafts/project_model.md b/drafts/project_model.md index c00d4bc7d87..ab5c8fe5941 100644 --- a/drafts/project_model.md +++ b/drafts/project_model.md @@ -1,7 +1,7 @@ Project model. Project roots and libraries. Configuring the project from code. ================= -This topic considers the concept of IntelliJ IDEA projects and related subjects, such as modules, facets, libraries, SDK. +This topic considers the concept of IntelliJ Platform projects and related subjects, such as modules, facets, libraries, SDK. The project structure and Java classes you can use to manage projects and modules have been considered. #Project and It's Components @@ -11,12 +11,12 @@ This section briefly discusses the IDEA project structure, project components an [Library] (http://www.jetbrains.com/idea/webhelp/library.html), and [Facet] (http://www.jetbrains.com/idea/webhelp/facet.html) -in +in the [IntelliJ IDEA Web Help] (https://www.jetbrains.com/idea/help/intellij-idea.html). ##Project -In IntelliJ IDEA, a project encapsulates all your source code, libraries, build instructions into a single organizational unit. -Everything you do in IntelliJ IDEA, is done within the context of a project. +In the IntelliJ Platform, a project encapsulates all your source code, libraries, build instructions into a single organizational unit. +Everything you do in the IDE, is done within the context of a project. A project defines some collections referred to as modules and libraries. Depending on the logical and functional requirements to the project, you can create a single-module or a multi-module project. @@ -28,7 +28,7 @@ A module can depend on other modules of the project. ##Library A library is an archive of compiled code (such as JAR files) that your modules depend on. -IntelliJ IDEA supports three types of libraries: +The IntelliJ Platform supports three types of libraries: * **Module Library**: the library classes are visible only in this module and the library information is recorded in the module *.iml file. * **Project Library**: the library classes are visible within the project and the library information is recorded in the project *.ipr file or in .idea/libraries. @@ -46,7 +46,7 @@ For more information about SDKs, see [JDKs] (http://www.jetbrains.com/idea/webhelp/jdks.html) and [Configuring Project JDK] (http://www.jetbrains.com/idea/webhelp/configuring-project-jdk.html) -in IntelliJ IDEA Web Help. +in the IntelliJ IDEA Web Help. ##Facet A facet represents certain configuration, specific for a particular framework/technology, associated with a module. A module can have multiple facets. E.g. Spring specific configuration is stored in a Spring facet. @@ -54,7 +54,7 @@ For more information about facets see [Facet] (http://www.jetbrains.com/idea/webhelp/facet.html) and [Facet Dependencies] (http://www.jetbrains.com/idea/webhelp/available-facets-and-their-dependencies.html) -in IntelliJ IDEA Web Help. +in the IntelliJ IDEA Web Help. #Project Structure A project consists of one or several modules. @@ -68,7 +68,7 @@ This section explains how to complete some common tasks related to management of The Java classes and interfaces that you can use to explore and change the project contents are discussed. ##How to Work with Project Files? -**IntelliJ IDEA** stores the project configuration data in XML files. +The IntelliJ Platform stores the project configuration data in XML files. The list of those files depends on the plugin [project] (http://www.jetbrains.com/idea/webhelp/project.html) format. diff --git a/faq.md b/faq.md index 40c08d61437..896f6963de1 100644 --- a/faq.md +++ b/faq.md @@ -79,8 +79,8 @@ This FAQ is a topical index of questions that have been asked (and answered) on * [Why are the extension elements in my plugin.xml red?](https://devnet.jetbrains.com/thread/269517) * [How can I read the plugin descriptor of my plugin from code?](https://devnet.jetbrains.com/thread/225115) * [How do I provide a custom exception reporter for my plugin?](https://devnet.jetbrains.com/thread/264619) -* [How can I add the help topics of my plugin to the IntelliJ IDEA help system?](https://devnet.jetbrains.com/thread/261416) -* [How do I get the version of IntelliJ IDEA under which my plugin is running?](https://devnet.jetbrains.com/thread/156440) +* [How can I add the help topics of my plugin to the IntelliJ Platform help system?](https://devnet.jetbrains.com/thread/261416) +* [How do I get the version of IntelliJ Platform under which my plugin is running?](https://devnet.jetbrains.com/thread/156440) ## Editors, Documents and Files * [Why doesn't the file change on disk after I changed it through the PSI?](https://devnet.jetbrains.com/thread/269379) diff --git a/phpstorm/setting_up_environment.md b/phpstorm/setting_up_environment.md index 76272b41a9a..a334aef69ea 100644 --- a/phpstorm/setting_up_environment.md +++ b/phpstorm/setting_up_environment.md @@ -16,7 +16,7 @@ The choice affects how you will configure SDK for the plugin. In the first case > OpenAPI is available for PhpStorm 6 and above. -This section explains how to configure IntelliJ IDEA for using PhpStorm OpenAPI. +This section explains how to configure the IntelliJ Platform for using PhpStorm OpenAPI. ### Adding library to a module diff --git a/reference_guide/color_scheme_management.md b/reference_guide/color_scheme_management.md index fb39d4a2d98..f9432851ea8 100644 --- a/reference_guide/color_scheme_management.md +++ b/reference_guide/color_scheme_management.md @@ -1,10 +1,10 @@ --- -title: Color Scheme Management in Intellij IDEA 12.1+ +title: Color Scheme Management in IntelliJ IDEA 12.1+ --- # Preface -Color scheme management in Intellij IDEA 12.1 was changed to ease the work of scheme designers and make schemes look equally well for different programming languages even if not designed specifically for these languages. Previously language plug-ins were using fixed default colors incompatible, for example, with dark schemes. The new implementation allows to specify a dependency on a set of standard text attributes which are linked to a scheme but not to any specific language. Language-specific attributes still can be set by a scheme designer if needed but it's optional. New color schemes have got a new .icls (Idea CoLor Scheme) extension to avoid confusion about compatibility problems with older platform versions: +Color scheme management in IntelliJ IDEA 12.1 was changed to ease the work of scheme designers and make schemes look equally well for different programming languages even if not designed specifically for these languages. Previously language plug-ins were using fixed default colors incompatible, for example, with dark schemes. The new implementation allows to specify a dependency on a set of standard text attributes which are linked to a scheme but not to any specific language. Language-specific attributes still can be set by a scheme designer if needed but it's optional. New color schemes have got a new .icls (Idea CoLor Scheme) extension to avoid confusion about compatibility problems with older platform versions: if only standard attributes are set, they will not be used by the version prior to 12.1 and this will result in different highlighting colors. # Plug-in Developers diff --git a/reference_guide/frameworks_and_external_apis/external_builder_api.md b/reference_guide/frameworks_and_external_apis/external_builder_api.md index bc233634941..17914afca59 100644 --- a/reference_guide/frameworks_and_external_apis/external_builder_api.md +++ b/reference_guide/frameworks_and_external_apis/external_builder_api.md @@ -96,7 +96,7 @@ There both `build-log.log` and `build-log.properties` files can be found. The `build-log.properties` is a log4j configuration file, where the log level and desired logging categories can be adjusted. This file contains logging from all build sessions, including those from the auto-make. -In IntelliJ IDEA versions before version 14.1 log4j configuration was stored in `build-log.xml`. +In IntelliJ Platform versions before version 14.1 log4j configuration was stored in `build-log.xml`. ### Accessing project model and configuration from External Build diff --git a/reference_guide/frameworks_and_external_apis/spring_api.md b/reference_guide/frameworks_and_external_apis/spring_api.md index ddcf6f5af22..ae5bc837c73 100644 --- a/reference_guide/frameworks_and_external_apis/spring_api.md +++ b/reference_guide/frameworks_and_external_apis/spring_api.md @@ -4,7 +4,7 @@ title: Spring API ## Using Spring-API -To develop plugins integrating with Spring-API you will need to use IntelliJ IDEA _Ultimate Edition_ version 13.1 (or higher). +To develop plugins integrating with Spring-API you will need to use _IntelliJ IDEA Ultimate Edition_ version 13.1 (or higher). ### Setting up IntelliJ Platform SDK diff --git a/reference_guide/messaging_infrastructure.md b/reference_guide/messaging_infrastructure.md index 859b93014e8..4e18fa3bfd4 100644 --- a/reference_guide/messaging_infrastructure.md +++ b/reference_guide/messaging_infrastructure.md @@ -5,11 +5,11 @@ title: Messaging infrastructure # Purpose -The purpose of this document is to introduce messaging infrastructure available at _IntelliJ IDEA_ to the product's developers and plugin writers. It is intended to answer why, when and how to use it. +The purpose of this document is to introduce the messaging infrastructure available in the IntelliJ Platform to developers and plugin writers. It is intended to answer why, when and how to use it. # Rationale -So, what is messaging in _IntelliJ IDEA_ and why do we need it? Basically, its implementation of +So, what is messaging in the IntelliJ Platform and why do we need it? Basically, its implementation of [Observer pattern](https://en.wikipedia.org/wiki/Observer_pattern) that provides additional features like _broadcasting on hierarchy_ and special _nested events_ processing (_nested event_ here is a situation when new event is fired (directly or indirectly) from the callback of another event). @@ -110,7 +110,7 @@ public void doChange(Context context) { [Application](upsource:///platform/core-api/src/com/intellij/openapi/application/Application.java), [Project](upsource:///platform/core-api/src/com/intellij/openapi/project/Project.java); -* number of public topics are used by *IntelliJ IDEA*, e.g. +* number of public topics are used by the *IntelliJ Platform*, e.g. [AppTopics](upsource:///platform/platform-api/src/com/intellij/AppTopics.java), [ProjectTopics](upsource:///platform/projectModel-api/src/com/intellij/ProjectTopics.java) etc. @@ -118,7 +118,7 @@ So, it's possible to subscribe to them in order to receive information about the # Broadcasting -Message buses can be organised into hierarchies. Moreover, *IntelliJ IDEA* has them already: +Message buses can be organised into hierarchies. Moreover, the *IntelliJ Platform* has them already: ![Standard hierarchy](img/standard-hierarchy.png) @@ -157,7 +157,7 @@ Broadcast configuration is defined per-topic. Following options are available: # Nested messages _Nested message_ is a message sent (directly or indirectly) during another message processing. -Messaging infrastructure of _IntelliJ IDEA_ guarantees that all messages sent to particular topic will be delivered at the sending order. +The IntelliJ Platform's Messaging infrastructure guarantees that all messages sent to particular topic will be delivered at the sending order. *Example:* diff --git a/reference_guide/project_model/facet.md b/reference_guide/project_model/facet.md index e155a1df3cf..4d2105794e8 100644 --- a/reference_guide/project_model/facet.md +++ b/reference_guide/project_model/facet.md @@ -8,4 +8,4 @@ For more information about facets see [Facet](http://www.jetbrains.com/idea/help/facet.html) and [Facet Dependencies](http://www.jetbrains.com/idea/help/available-facets-and-their-dependencies.html) -in IntelliJ IDEA Web Help. +in the IntelliJ IDEA Web Help. diff --git a/reference_guide/project_model/library.md b/reference_guide/project_model/library.md index cb4b0c56f0c..005bc196067 100644 --- a/reference_guide/project_model/library.md +++ b/reference_guide/project_model/library.md @@ -3,7 +3,7 @@ title: Library --- A library is an archive of compiled code (such as JAR files) that your modules depend on. -IntelliJ IDEA supports three types of libraries: +The IntelliJ Platform supports three types of libraries: * **Module Library**: the library classes are visible only in this module and the library information is recorded in the module *.iml file. * **Project Library**: the library classes are visible within the project and the library information is recorded in the project *.ipr file or in .idea/libraries. diff --git a/reference_guide/project_model/project.md b/reference_guide/project_model/project.md index 6de24bde595..d6c68c823dd 100644 --- a/reference_guide/project_model/project.md +++ b/reference_guide/project_model/project.md @@ -2,7 +2,7 @@ title: Project --- -In *IntelliJ IDEA*, a project encapsulates all your source code, libraries, build instructions into a single organizational unit. Everything you do in *IntelliJ IDEA*, is done within the context of a project. A project defines some collections referred to as modules and libraries. Depending on the logical and functional requirements to the project, you can create a single-module or a multi-module project. +In the *IntelliJ Platform*, a project encapsulates all your source code, libraries, build instructions into a single organizational unit. Everything you do in the IDE, is done within the context of a project. A project defines some collections referred to as modules and libraries. Depending on the logical and functional requirements to the project, you can create a single-module or a multi-module project. ## Working with projects diff --git a/reference_guide/project_model/sdk.md b/reference_guide/project_model/sdk.md index c83dfe7b565..b1e0b8897d4 100644 --- a/reference_guide/project_model/sdk.md +++ b/reference_guide/project_model/sdk.md @@ -2,7 +2,7 @@ title: SDK --- -Every project uses a Software Development Kit (SDK). For Java projects, the SDK is referred to as the JDK (Java Development Kit). The SDK determines which API library is used to build the project. If your project is multi-module, the project SDK by default is common for all modules within the project. Optionally, you can configure individual SDKs for each module. For more information about SDKs, see [SDK](https://www.jetbrains.com/idea/help/sdk.html) and [Configuring Global, Project and Module SDKs](https://www.jetbrains.com/idea/help/configuring-global-project-and-module-sdks.html) in IntelliJ IDEA Web Help. +Every project uses a Software Development Kit (SDK). For Java projects, the SDK is referred to as the JDK (Java Development Kit). The SDK determines which API library is used to build the project. If your project is multi-module, the project SDK by default is common for all modules within the project. Optionally, you can configure individual SDKs for each module. For more information about SDKs, see [SDK](https://www.jetbrains.com/idea/help/sdk.html) and [Configuring Global, Project and Module SDKs](https://www.jetbrains.com/idea/help/configuring-global-project-and-module-sdks.html) in the IntelliJ IDEA Web Help. ## Getting project SDK information diff --git a/reference_guide/vcs_integration_for_plugins.md b/reference_guide/vcs_integration_for_plugins.md index d52e95784d3..44de89384d5 100644 --- a/reference_guide/vcs_integration_for_plugins.md +++ b/reference_guide/vcs_integration_for_plugins.md @@ -129,7 +129,7 @@ This section describes the different components which comprise a VCS integration ### AbstractVcs -This is the main entry point for a VCS plugin, which is used by IntelliJ IDEA to retrieve all other services provided by the plugin. +This is the main entry point for a VCS plugin, which is used by the IntelliJ Platform to retrieve all other services provided by the plugin. The recommended way to register an AbstractVcs implementation is to add an extension declaration to plugin.xml, as shown in the following example: ```xml @@ -145,13 +145,13 @@ Here `name` is the unique name of the VCS (this must match the string returned b ### ChangeProvider -This component is responsible for keeping track of the local changes done by the user in his working copy, and reporting these changes to the IntelliJ IDEA core. +This component is responsible for tracking user changes to the working copy, and reporting these changes to the IntelliJ Platform core. An implementation of this class is returned from [AbstractVcs.getChangeProvider()](upsource:///platform/vcs-api/src/com/intellij/openapi/vcs/AbstractVcs.java). The ChangeProvider works in tandem with [VcsDirtyScopeManager](upsource:///platform/vcs-api/src/com/intellij/openapi/vcs/changes/VcsDirtyScopeManager.java), -which is a component in IntelliJ IDEA core. +which is a component in IntelliJ Platform core. [VcsDirtyScopeManager](upsource:///platform/vcs-api/src/com/intellij/openapi/vcs/changes/VcsDirtyScopeManager.java) keeps track of the 'dirty scope' - the set of files for which the VCS file status may be out of date. Files are added to the dirty scope either when they are modified on disk, or when their VCS status is invalidated by an explicit call to diff --git a/reference_guide/work_with_icons_and_images.md b/reference_guide/work_with_icons_and_images.md index 88096870ee6..3ec870e02d3 100644 --- a/reference_guide/work_with_icons_and_images.md +++ b/reference_guide/work_with_icons_and_images.md @@ -3,7 +3,7 @@ title: Work with Icons and Images --- -Icons and images are used widely by IntelliJ IDEA plugins. +Icons and images are used widely by IntelliJ Platform plugins. Plugins need icons mostly for actions, custom components renderers, tool windows and so on. This page describes how to organize your work with icons and images under IntelliJ Platform. @@ -36,7 +36,7 @@ and use icons inside plugin.xml as well: ### Image formats and naming notations -IntelliJ IDEA Platform supports Retina displays and has dark look and feel called Darcula. +IntelliJ Platform supports Retina displays and has dark look and feel called Darcula. According this all images should have 4 different representations (in some cases only 2). Let's take a look on the example above. We've got three icons: diff --git a/tutorials/action_system.md b/tutorials/action_system.md index 3272c44b288..d98404c912f 100644 --- a/tutorials/action_system.md +++ b/tutorials/action_system.md @@ -2,7 +2,7 @@ title: IntelliJ Action System --- -This tutorial is meant to give general information about the IntelliJ IDEA Action System and lead you through a series of steps +This tutorial is meant to give general information about the IntelliJ Platform Action System and lead you through a series of steps which show how to create, register, and customize custom actions and action groups. Action system provides an option to handle certain events in a desired way. Action can either be simply a response to some state, or be bound to UI element and could be invoked on demand. diff --git a/tutorials/build_system.md b/tutorials/build_system.md index bd9549e153b..a3b426c10b6 100644 --- a/tutorials/build_system.md +++ b/tutorials/build_system.md @@ -1,7 +1,7 @@ --- -title: Building plugins with the Gradle +title: Building plugins with Gradle --- When building a plugin on the IntelliJ Platform SDK, occasionally major version upgrades may cause breaking API changes. In order to prevent this from occurring unexpectedly, we recommend using Gradle with the [gradle-intellij-plugin](https://github.com/JetBrains/gradle-intellij-plugin). This Gradle plugin allows you to build plugins for the IntelliJ Platform using a specific IntelliJ Platform SDK. Furthermore, it codifies a reproducible build process for compiling a plugin, to running it inside your IDE, and finally publishing it on the plugin repo, within an explicit build script which is managed by the Gradle build system. The following tutorial refers to materials that can be found in the included [gradle_plugin_demo](https://github.com/JetBrains/intellij-sdk-docs/tree/master/code_samples/gradle_plugin_demo). Below are a series of steps to configure Gradle support. -* [1. Prerequisites](build_system/prerequisites.md) +* [1. Prerequisites](build_system/prerequisites.md) \ No newline at end of file diff --git a/tutorials/build_system/prerequisites.md b/tutorials/build_system/prerequisites.md index dbb31af3d74..e7211cf1301 100644 --- a/tutorials/build_system/prerequisites.md +++ b/tutorials/build_system/prerequisites.md @@ -1,5 +1,5 @@ --- -title: Prerequisites +title: Getting Started --- Adding Gradle build support to an IntelliJ Platform Plugin requires a recent distribution the Gradle build system and IntelliJ IDEA. @@ -14,7 +14,7 @@ Download and install either IntelliJ IDEA Ultimate or the IntelliJ IDEA Communit ### 1.2. Ensure the Gradle plugin is enabled -The Gradle plugin is required if you want to add a [Gradle Run Configuration](https://www.jetbrains.com/idea/help/create-run-debug-configuration-for-gradle-tasks.html) to IntelliJ IDEA. You can verify the Gradle plugin is enabled by visiting **Settings | Plugins | Gradle**. +The Gradle plugin is required if you want to add a [Gradle Run Configuration](https://www.jetbrains.com/idea/help/create-run-debug-configuration-for-gradle-tasks.html) to IntelliJ IDEA. You can verify the Gradle plugin is enabled by visiting **Settings \| Plugins \| Gradle**. ![Ensure the Gradle plugin is enabled](img/step0_gradle_enabled.png) @@ -50,9 +50,9 @@ To add Gradle support to an existing project, copy the above Gradle buildscript gradle cleanIdea ``` -This will clean any existing IntelliJ IDEA configuration files and generate a new Gradle build configuration recognized by IntelliJ IDEA. Once your project refreshes, you should be able to view and click the Gradle tool window displayed under **View | Tool Windows | Gradle**. This indicates that IntelliJ IDEA recognizes the Gradle facet. +This will clean any existing IntelliJ IDEA configuration files and generate a new Gradle build configuration recognized by IntelliJ IDEA. Once your project refreshes, you should be able to view and click the Gradle tool window displayed under **View \| Tool Windows \| Gradle**. This indicates that IntelliJ IDEA recognizes the Gradle facet. -The second method to add Gradle support is by creating a new project from scratch in IntelliJ IDEA and copying over any existing sources. This may be the preferred option in case Gradle is not able to convert an existing project. To do so, create a new project in IntelliJ IDEA by opening **File | New... | Project**, and select Gradle from the dialog box: +The second method to add Gradle support is by creating a new project from scratch in IntelliJ IDEA and copying over any existing sources. This may be the preferred option in case Gradle is not able to convert an existing project. To do so, create a new project in IntelliJ IDEA by opening **File \| New... \| Project**, and select Gradle from the dialog box: ![Select the Gradle facet in the Project Creation Wizard](img/step1_new_gradle_project.png) @@ -62,7 +62,7 @@ The Project Creation Wizard will now guide you through the Gradle project creati Finally, make sure Gradle is using the correct JVM. This should be the same version as the corresponding 64- or 32-bit Gradle distribution from [Step 1.0](#download-and-install-gradle): -![Verify the JVM is the correct version](img/step2_group_artifact_version.png) +![Verify the JVM is the correct version](img/step3_gradle_config.png) Now, add the above script to your `build.gradle` file, overwriting any existing contents. @@ -139,10 +139,10 @@ Add a new Gradle Run Configuration, configured like so: ![Gradle Run Configuration](img/gradle_run_config.png) -Launch the new Gradle Run Configuration. From the Run Window, there should be some output. +Launch the new Gradle Run Configuration. From the Run Window, the following output should be visible. ![Gradle task output](img/launched.png) -Finally, when the IDE launches, there should be a new menu to the right of **Help**. Your plugin has launched! +Finally, when the IDE launches, there should be a new menu to the right of the **Help** menu. Your plugin is now configured on Gradle. [Top](/tutorials/build_system.md) \ No newline at end of file diff --git a/tutorials/custom_language_support/prerequisites.md b/tutorials/custom_language_support/prerequisites.md index 567ef0fe169..4f9afb03d6b 100644 --- a/tutorials/custom_language_support/prerequisites.md +++ b/tutorials/custom_language_support/prerequisites.md @@ -24,9 +24,9 @@ plugins. ### 1.4. Configure SDK and source files -Configure a common JDK and an IntelliJ IDEA Plugin SDK. -For IntelliJ IDEA Plugin SDK you should specify the directory with installed IntelliJ IDEA. -By default it offers the directory of the currently running IntelliJ IDEA. +Configure a common JDK and an IntelliJ Platform SDK. +For the IntelliJ Platform SDK you may need to specify the directory containing the installed version IntelliJ IDEA. +By default it should offer the directory of the currently running version of IntelliJ IDEA. To attach the Community Edition source files to the SDK, open the Sourcepath tab in the SDK configuration dialog, press the Add button and select the directory with the Community Edition source checkout. IntelliJ IDEA will scan the directory for roots and offer the list of roots to add, with everything checked by default. @@ -38,7 +38,7 @@ Accept the list of roots by pressing OK. ### 1.5. Create a project -Create an IntelliJ IDEA Plugin project and specify IntelliJ IDEA Plugin SDK. +Create an IntelliJ Platform Plugin project and specify IntelliJ Platform SDK. ![New Project](img/new_project.png) diff --git a/tutorials/editor_basics.md b/tutorials/editor_basics.md index 07dcec66969..7165affd1ea 100644 --- a/tutorials/editor_basics.md +++ b/tutorials/editor_basics.md @@ -7,7 +7,7 @@ title: Basics of working with the Editor ---------- -This tutorial will lead you through the series of steps showing how to work with the Editor in IntelliJ IDEA, how access and modify text it contains, +This tutorial will lead you through the series of steps showing how to work with the IntelliJ Platform Editor, how access and modify text it contains, and how to handle events sent to the Editor. * [1. Working With Text](editor_basics/working_with_text.md) diff --git a/tutorials/project_wizard/adding_new_steps.md b/tutorials/project_wizard/adding_new_steps.md index 8339887ce5d..700e71383fe 100644 --- a/tutorials/project_wizard/adding_new_steps.md +++ b/tutorials/project_wizard/adding_new_steps.md @@ -91,7 +91,7 @@ public class DemoModuleWizardStep extends ModuleBuilder { ## 5. Checking UI Appearance -After compiling and running the plugin create a new project using compiled from sources instance of IntelliJ IDEA. +After compiling and running the plugin create a new project using a source-compiled instance of *IntelliJ IDEA*. ![New Project](img/empty_project.png) diff --git a/tutorials/project_wizard/module_types.md b/tutorials/project_wizard/module_types.md index 4fef87cea3f..983f843ed85 100644 --- a/tutorials/project_wizard/module_types.md +++ b/tutorials/project_wizard/module_types.md @@ -117,7 +117,7 @@ public class DemoModuleWizardStep extends ModuleWizardStep { ## 5. Creating a Module of New Type -After compiling and running the plugin, create a new project with the instance of *IntelliJ IDEA* being run from sources. +After compiling and running the plugin, create a new project with a source-compiled instance of *IntelliJ IDEA*. You will see a new module type and it's settings panel available in the Project Wizard. ![New Module Type](module_types/img/new_module_type.png) diff --git a/tutorials/writing_tests_for_plugins/tests_prerequisites.md b/tutorials/writing_tests_for_plugins/tests_prerequisites.md index 36f334c433a..6b4d11266da 100644 --- a/tutorials/writing_tests_for_plugins/tests_prerequisites.md +++ b/tutorials/writing_tests_for_plugins/tests_prerequisites.md @@ -15,10 +15,10 @@ In our tests we will use test data, so we need one more folder *"testData"* to s ### 1.3. Run Configuration Parameters Since some of our tests will use Java files as test data, we need to mock up the project SDK. -IntelliJ IDEA does everything automatically when we use special utility class +IntelliJ IDEA does everything automatically when we use the special utility class [LightCodeInsightFixtureTestCase](upsource:///java/testFramework/src/com/intellij/testFramework/fixtures/LightCodeInsightFixtureTestCase.java). -All we need to do is to point the working directory of the run configuration to the root of IntelliJ IDEA Community Edition sources and enable the following VM options: +All we need to do is point the the run configuration's working directory to the root of the IntelliJ IDEA Community Edition sources and enable the following VM options: ``` -ea -Xbootclasspath/p:../out/classes/production/boot -XX:+HeapDumpOnOutOfMemoryError -Xmx512m -XX:MaxPermSize=320m -Didea.system.path=../test-system -Didea.home.path=../ -Didea.config.path=../test-config -Didea.test.group=ALL_EXCLUDE_DEFINED diff --git a/user_interface_components/dialog_wrapper.md b/user_interface_components/dialog_wrapper.md index 2c5aaad2d5a..c38391f1761 100644 --- a/user_interface_components/dialog_wrapper.md +++ b/user_interface_components/dialog_wrapper.md @@ -7,7 +7,7 @@ title: DialogWrapper The [DialogWrapper](upsource:///platform/platform-api/src/com/intellij/openapi/ui/DialogWrapper.java) -is the base class which is supposed to be used for all modal dialogs (and some non-modal dialogs) shown in *IntelliJ IDEA* plugins. +is the base class which is supposed to be used for all modal dialogs (and some non-modal dialogs) shown in *IntelliJ Platform* plugins. It provides the following features: * Button layout (platform-specific order of `OK/Cancel` buttons, Mac OS-specific `Help` button) diff --git a/user_interface_components/editor_components.md b/user_interface_components/editor_components.md index 540494d9bc1..2ec8ff619ec 100644 --- a/user_interface_components/editor_components.md +++ b/user_interface_components/editor_components.md @@ -5,9 +5,9 @@ title: Editor Components ## EditorTextField Compared to -[Swing JTextArea](http://docs.oracle.com/javase/8/docs/api/javax/swing/JTextArea.html), -*IntelliJ IDEA's* editor component has a ton of advantages: syntax highlighting support, code completion, code folding and much more. -*IntelliJ IDEA's* editors are normally displayed in editor tabs, but they can be embedded in dialogs or toolwindows, too. +[Swing JTextArea](http://docs.oracle.com/javase/8/docs/api/javax/swing/JTextArea.html), the +*IntelliJ Platform's* editor component has a ton of advantages: syntax highlighting support, code completion, code folding and much more. +*IntelliJ Platform* editors are normally displayed in editor tabs, but they can be embedded in dialogs or toolwindows, too. This is enabled by the [EditorTextField](upsource:///platform/platform-impl/src/com/intellij/ui/EditorTextField.java) component. diff --git a/user_interface_components/file_and_class_choosers.md b/user_interface_components/file_and_class_choosers.md index ef22d9a637f..addc545b3b3 100644 --- a/user_interface_components/file_and_class_choosers.md +++ b/user_interface_components/file_and_class_choosers.md @@ -18,7 +18,7 @@ The constructor parameters specify whether files and/or directories can be selec For more fine-grained control over the allowed selection, you can overload the `isFileSelectable()` method. You can also customize the presentation of files by overloading `getIcon()`, `getName()` and `getComment()` methods on [FileChooserDescriptor](upsource:///platform/platform-api/src/com/intellij/openapi/fileChooser/FileChooserDescriptor.java). -Note that the native Mac OS X file chooser does not support most of the customizations, so if you rely on them, you need to use an overload of `chooseFiles()` which displays the standard *IntelliJ IDEA* dialog. +Note that the native Mac OS X file chooser does not support most of the customizations, so if you rely on them, you need to use an overload of `chooseFiles()` which displays the standard *IntelliJ Platform* dialog. A very common way of using file choosers is to use a text field for entering the path with an ellipsis button ("...") for showing the file chooser. To create such a control, use the diff --git a/user_interface_components/lists_and_trees.md b/user_interface_components/lists_and_trees.md index 54a30a437dd..ba8b90c630d 100644 --- a/user_interface_components/lists_and_trees.md +++ b/user_interface_components/lists_and_trees.md @@ -63,7 +63,7 @@ The implementation of this task is greatly facilitated by the [ToolbarDecorator](upsource:///platform/platform-api/src/com/intellij/ui/ToolbarDecorator.java) class. This class provides a toolbar with actions on items and automatically enables drag & drop reordering of items in list boxes if supported by the underlying list model. -The position of the toolbar above or below the list depends on the platform under which *IntelliJ IDEA* is running. +The position of the toolbar above or below the list depends on the graphics platform under which the IDE is running. To use a toolbar decorator: diff --git a/user_interface_components/notifications.md b/user_interface_components/notifications.md index 876a7d9dd1d..5b162711c10 100644 --- a/user_interface_components/notifications.md +++ b/user_interface_components/notifications.md @@ -5,8 +5,8 @@ title: Notifications ## Notifications -One of the leading design principles in recent versions of *IntelliJ IDEA* is avoiding the use of modal message boxes for notifying the user about errors and other situations that may warrant his attention. -As a replacement, *IntelliJ IDEA* provides multiple non-modal notification UI options. +One of the leading design principles in recent versions of *IntelliJ IDEA* is avoiding the use of modal message boxes for notifying the user about errors and other situations that may warrant the user's attention. +As a replacement, the *IntelliJ Platform* provides multiple non-modal notification UI options. ### Dialogs diff --git a/user_interface_components/popups.md b/user_interface_components/popups.md index c6fca131688..2139a9ad54e 100644 --- a/user_interface_components/popups.md +++ b/user_interface_components/popups.md @@ -5,7 +5,7 @@ title: Popups ## Popups -The *IntelliJ IDEA* user interface makes extensive use of popups \- semi-modal windows that have no chrome (explicit closing buttons) and disappear automatically on focus loss. +The *IntelliJ Platform* user interface makes extensive use of popups \- semi-modal windows that have no chrome (explicit closing buttons) and disappear automatically on focus loss. Making use of these controls in your plugin ensures a consistent user experience between your plugin and the rest of the IDE. Popups can optionally display a title, are optionally movable and resizable (and support remembering their size), and can be nested (show another popup when an item is selected). @@ -47,7 +47,7 @@ The key methods to override are `getTextFor()` (returning the text to display fo By returning a new popup step from the `onChosen()` method, you can implement hierarchical (nested) popups. Once you've created the popup, you need to display it by calling one of the `show()` methods. -You can let *IntelliJ IDEA* automatically choose the position based on the context, by calling `showInBestPositionFor()`, or specify the position explicitly through methods like `showUnderneathOf()` and `showInCenterOf()`. +You can let the IntelliJ Platform automatically choose the position based on the context, by calling `showInBestPositionFor()`, or specify the position explicitly through methods like `showUnderneathOf()` and `showInCenterOf()`. **Note:**