IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page adding plugins to an enterprise repository appears to be missing.

You may try to find information you were looking for on one of the similar pages:

Project Tool Window
Find Tool Window
Persistence Tool Window
Ant Build Tool Window
Command Line Tools Console Tool Window
%product% Tool Windows
Command Line Tool Support
External Tools
Installing, Updating and Uninstalling Repository Plugins
Configuring Third-Party Tools
External Annotations
Enabling and Disabling Plugins
Manipulating the Tool Windows
Working with Annotations
Editor. Colors and Fonts
Adding and Editing Layout Components Using Android UI Designer
TODO Tool Window
Debug Tool Window
Repository and Incoming Tabs
Viewing Modes
Struts Assistant Tool Window
Adding Plugins to Enterprise Repositories
Menus and Toolbars
Favorites Tool Window
@Nullable and @NotNull Annotations
Run Tool Window
IDEtalk and IDEtalk Messages Tool Windows
Maven Projects Tool Window
Configuring Subversion Repository Location
JetGradle Tool Window
Changes Tool Window
Edit Tool Dialog
Markup Languages and Style Sheets
Manage TFS Servers and Workspaces
Structure Tool Window
Creating and Editing Run/Debug Configurations
Defining TODO Patterns and Filters
Android Facet Page
Adding Build File to Project
Module Dependencies Tool Window
Edit Jobs Linked to Changelist Dialog
Configuring Menus and Toolbars
PHP-Specific Command Line Tools
Android Tool Window
Navigating to Declaration or Type Declaration of a Symbol
Android Tab
Enabling a Command Line Tool
Documentation Tool Window
Adding GUI Components and Forms to the Palette
Diagram Toolbar and Context Menu
Using Command Line Tools
Hierarchy Tool Window
Annotating Source Code
EJB Tool Window
Previewing Output of Layout Definition Files
Compiler. Annotation Processors
Using Change Markers to View and Navigate Through Changes in the Editor
Manipulating Table Data in the Table Editor
Inspection Tool Window
Managing Enterprise Plugin Repositories
Sharing Android Source Code and Resources Using Library Projects
Enabling Android Support
Comparing Deployed Files and Folders with Their Local Versions
Setting Up a Local Mercurial Repository
Designer Tool Window
General Usage
Coverage Tool Window
Processing Annotations
Database Tool Window
Adding and Removing Facets
Analyzing Duplicates
Specify Dependency Analysis Scope Dialog
Select Repository Location Dialog (Subversion)
Configuring Annotation Processing
Pushing Changes to the Upstream (Git Push)
Menus and Toolbars
Select Repository to Clone Dialog
Attaching and Detaching Perforce Jobs to Changelists
Managing Your Project Favorites
Android Layout Preview Tool Window
Navigating to Class, File or Symbol by Name
Annotation Processors Support
Messages Tool Window
Seam Tool Window
Thumbnails Tool Window
TODO Example
Adding Files to a Local Git Repository
Adding Files To a Local Mercurial Repository
Importing a Local Directory to Subversion Repository
Creating an Android Run/Debug Configuration
Using Help Topics
Running Command Line Tool Commands
Testing Flex and ActionScript Applications
Committing Changes to a Local Git Repository
Creating and Running Your First Java Application
Duplicates Tool Window
Navigating Between Files and Tool Windows
New Project from Scratch. Android Page
Moving an Opened File to Another Changelist
Running and Debugging Android Applications
Deploying and Running
Viewing Ancestors, Descendants, and Usages
Convert Anonymous to Inner Dialog
CDI Tool Window
Finding and Adding Users
Binding the Form and Components to Code
Creating and Registering File Types
REST Client Tool Window
Finding and Replacing Text in File
Structural Search and Replace
Commenting and Uncommenting Blocks of Code
Updating a Command Line Tool
Remote Host Tool Window
Code Inspections
Local, Repository, and Incoming Changes
Configuring Project and Global Libraries
Using External Annotations
Adding Files to Version Control
Creating and Importing Data Sources
Tool Windows Reference
Phing Build Tool Window
Configuring Module Dependencies and Libraries
Analyzing Backward Dependencies
Analyzing Data Flow
Cutting, Copying and Pasting
Enabling AspectJ Support Plugins
Filters and Ordering Dialog
Available Facets and Their Dependencies
External Diff Tools
Version Control Tool Window
Generating Signed and Unsigned Android Application Packages
Finding and Replacing Text in Project
Differences Viewer for Folders and DB Objects
Select Android Virtual Device Dialog
Analyzing Dependencies
Navigating Between an Observer and an Event
Adding Auto-Detected Facets
Executing Ant Target
Working with Grails Plugins
Running and Debugging Plugins
Adding a Struts Facet to a Module
Binding a Form to an Existing Class
Database Console Tool Window
CVS Tool Window
Link Job to Changelist Dialog
Class Diagram Toolbar and Context Menu
Enabling Other Users to View Your Files
Viewing Structure and Hierarchy of the Source Code
Navigating Between Test and Test Subject
Pausing and Resuming the Debugger Session
Convert Anonymous to Inner
Importing a Local Directory to CVS Repository
Language and Framework-Specific Guidelines
Navigating to Underlying Code
Web Tool Window
Controlling Behavior of Ant Script with Build File Properties
Run/Debug Configuration: Android Application
Edit Subversion Options Related to Network Layers Dialog
Viewing Definition
Setting Up a Local Git Repository
Activating and Deactivating Maven Profiles
Compiler: Android DX Compiler
Project Library and Global Library Pages
Command Line Tools Input Pane
DSM Analysis
Analyzing Cyclic Dependencies
Creating a Command Line Tool
Defining Ant Execution Options
Navigating to Action
Browsing Subversion Repository
ActionScript, Flex and AIR
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Excluding Files and Folders from Deployment
Edit Android Platform Dialog
Inferring Nullity
Reviewing Compilation and Build Results
Viewing TODO Items
Git Branches in Multirooted Projects
Integrating Files and Changelists from the Changes Tool Window
Designing Layout of Android Application
Using PHP Code Sniffer Tool
Login to IntelliJ Configuration Server Dialog
Clone Repository Dialog
Opening and Reopening Files in the Editor
Annotating Source Code Directly
Getting Local Working Copy of the Repository
Navigating to Issues
Debugging with Logcat
Associating Ant Target with Keyboard Shortcut
Configuring Triggers for Ant Build Target
IntelliLang Configuration
Checking Out Files from CVS Repository
Folding and Expanding Code Blocks
Running and Debugging
Structural Search and Replace Examples
Browsing CVS Repository
Adding Node Elements to Diagram
Adding WS Libraries to a Web Service Client Module Manually
Adding WS Libraries to a Web Service Module Manually
Generate Ant Build
Commander Tool Window
Dependency Viewer
Roo Console Tool Window
Inline Android Style Dialog
Adding, Editing and Removing Watches
Setting Labels to Variables, Objects and Watches
Navigating to Source Code from the Debug Tool Window
Copy and Paste Between %product% and Explorer/Finder
Adding, Deleting and Moving Lines
Testing Android Applications
Creating Groovy Classes, Interfaces, Enumerations and Annotations
Creating Groovy Tests and Navigating to Tests
Adding a GWT Facet to a Module
Writing and Executing SQL Commands in the Database Console
Adding Data Structure Definition Files to a DDL Data Source
Adding a Struts 2 Facet to a Module
Viewing Siblings and Children
Checkout from TFS Wizard: Choose Source and Destination Paths
Unwrapping and Removing Statements
Assigning an Active Changelist
Managing Plugins
Importing Eclipse Project to %product%
Accessing the Database Tool Window
Creating and Editing Relationships
Mapping to EJB
Mapping to Hibernate
Create Mercurial Repository Dialog
@NonNls Annotation
Monitoring and Managing Tests
Specifying Actions to Confirm
Specifying a Version to Work With
Applying a Branch Entirely on Top of Master
Pushing Changes to the Upstream (Push)
Generating a Signed APK Through an Artifact
Generating Ant Build File
Defining Additional Ant Classpath
Plugin Configuration Wizard
Dependencies Analysis
Accessing DSM Analysis
Creating Folders and Grouping Run/Debug Configurations
Generating and Updating Copyright Notice
Speed Search in the Tool Windows
Running %product% as a Diff or Merge Command Line Tool
Managing Tasks and Context
Creating Ant Build File
Build File Properties
Find and Replace in Path
Java EE: App Tool Window
Applying Patches
Adding Tags
Stashing and Unstashing Changes
Checking Out Files from Subversion Repository
Integrating Changes to Branch
Refactoring Android XML Layout Files
Escaping Characters in Velocity Variables and Directives
Guided Tour Around %product% User Interface
Choose Actions to Add Dialog
Debug Tool Window. Watches
DSM Tool Window
Clone Mercurial Repository Dialog
New Android Component Dialog
Convert Contents To Attribute
Navigating from Stacktrace to Source Code
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Creating Branches and Tags
Exporting %product% Project to Eclipse
Defining Bean Class and Package
Running and Debugging Groovy Scripts
Analyzing XDebug Profiling Data
Analyzing Zend Debugger Profiling Data
Run/Debug Configuration: Android Test
XPath and XSLT Support
Cloning a Repository from GitHub
Configuring Subversion Branches
Creating Android Application Components
Running and Debugging Node.js
JSF Tool Window
Create Android Virtual Device Dialog
Using TODO
Checking Out from TFS Repository
Defining Ant Filters
Structural Search and Replace Dialogs
Schemas and DTDs
JSTestDriver Server Tool Window
Test Runner Tab
Integrate to Branch
Generate Signed APK Wizard. Specify Key and Keystore
Creating and Editing Search Templates
Browsing Contents of the Repository
Resolving Conflicts
Building, Running and Debugging Flex Applications
Code Duplication Analysis Settings
Package and Class Migration Dialog
Specify Code Duplication Analysis Scope
New Project from Scratch. Project Name, Location and Format
Creating and Editing File Templates
Creating and Editing Live Templates
Code Quality Tools
Exporting and Importing Settings
Web, EJB and Java EE Application Facet Pages
Opening, Reopening and Closing Projects
Hibernate Console Tool Window
JPA Console Tool Window
Rollback Actions With Regards to File Status
Login to GitHub Dialog
Project and IDE Settings
Iterating over an Array. Example of Applying Parameterized Live Templates
Analyzing Module Dependencies
Navigating to Line
Splitting and Unsplitting Editor Window
Choosing a Method to Step Into
Convert to Instance Method
Navigating to Source Code
Undoing and Redoing Changes
Fetching Changes from a Remote Git Repository
Generating an Unsigned APK
Creating Local and Remote Interfaces
Migrating to EJB 3.0
Creating Modules with Groovy and Groovy-Based Frameworks Support
Updating a Running Java EE Application
Binding a Form to a New Class
Generating Accessor Methods for Fields Bound to Data
Framework MVC Structure Tool Window
Connecting to or Creating Jabber Account
Toggling Writable Status
Deleting Files from the Repository
Working with Tags and Branches
Working With Subversion Properties for Files and Directories
Using JavaScript Code Quality Tools
Creating Elements in Persistence Units
Insert, Delete and Navigation Keys
Grails Tool Window
Configuring Folders Within a Content Root
Reverting to a Previous Version
Viewing and Fast Processing of Changelists
Enabling Integration with an Issue Tracking System
Uploading and Downloading Files
Libraries and Global Libraries
Debug Tool Window. Frames
Debug Tool Window. Dump
Event Log
Basic Code Completion. Completing Names and Keywords
Analyzing Inspection Results
Running JavaScript Unit Tests in Browser
Code Analysis
Navigating from .feature File to Step Definition
Analyze Stacktrace Dialog
Debug Tool Window. Variables
Integrate to Branch Info View
Rebasing a Branch to a Specific Commit
Creating and Deleting Tasks
Compiler and Builder
Specifying the Servlet Name and the Target Package
Move Inner to Upper Level Dialog for ActionScript
Update Directory / Update File Dialog (CVS)
SVN Repositories
Generate Signed APK Wizard
Analyzing External Stacktraces
Structural Search and Replace - General Procedure
Checking In Files
Generating an APK in the Debug Mode
Configuring Libraries and Dependencies in Grails Applications
Navigating Between Actions and Views
Preparing Plugins for Publishing
Navigating to Underlying Code
Creating and Configuring Web Application Elements
Creating and Deleting Web Application Elements - General Steps
Enabling an Extra WS Engine (Web Service Client Module)
Enabling an Extra WS Engine in a Web Services Module
Browse Repositories Dialog
Running and Debugging
Griffon Tool Window
Commit Changes Dialog
Adding Frameworks Support
Viewing Differences Between the Local and Remote Files
Creating Tapestry Pages, Componenets, and Mixins
Tapestry Tool Window
Specifying the Appearance Settings for Tool Windows
Navigating to File Path
Navigating to Next/Previous Error
Stopping and Pausing Applications
Copying, Renaming and Moving Files
Moving Items Between Changelists in the Changes Tool Window
Joining Lines and Literals
Merging, Deleting, and Comparing Branches
Authenticating to Subversion
Folding and Expanding Custom Blocks
Exporting Information From Subversion Repository
Defining the Set of Changelists to Display
Viewing and Managing Integration Status
Creating and Managing TFS Workspaces
Attaching the Debugger to a Running Process
Build Tools
Creating and Editing Assembly Descriptors
Editing Module with EJB Facet
Creating and Editing Relationships Between Domain Classes
Running and Debugging Grails Applications
Creating an Entry Point
Object-Relational Mapping (EJB, Hibernate and JPA)
Creating and Editing Faces Configuration
Viewing Table Data from the Data Sources Tool Window
Creating and Opening Forms
Breakpoints Icons and Statuses
Bean Validation Tool Window
Import into Subversion
Select Accessor Fields to Include in Transfer Object
Creating Hibernate Elements in a Session Factory
Generate equals() and hashCode() wizard
Configuring Keyboard Shortcuts
Check Out From Subversion Dialog
Navigating to Recent File
Building ActionScript and Flex Applications
Configuring and Managing Application Server Integration
Viewing Styles Applied to a Tag
Configuring Zend Debugger
Managing Spring Configuration Files
Working with Diagrams
Run/Debug Configuration: Flash App
Creating and Editing Template Variables
Hibernate and JPA Facet Pages
Debug Tool Window. Console
Analyzing Dependencies Using DSM
Viewing and Exploring Test Results
Locking and Unlocking Files and Folders
Resolving Text Conflicts
Configuring JavaScript Libraries
Simple, Parameterized and Surround Live Templates
Creating Node Elements and Members
Viewing Changes as Diagram
Generating Call to Web Service
Import Project from Existing Sources. Project Name and Location
Temporary and Permanent Run/Debug Configurations
Choose Local Paths to Upload Dialog
Export to HTML
Convert to Instance Method Dialog
Move Inner to Upper Level Dialog for Java
Rename Dialog for a Class or an Interface
Run/Debug Configuration: Tomcat
Run/Debug Configuration: TomEE
Structural Search and Replace. Edit Variable Dialog
Create Module from Scratch. Module Name, Location and Type
Configuring Colors and Fonts
Maven. Repositories
Browser Toolbar Debug Mappings
Accessing Default Project Settings and Structure
Creating and Managing Projects
Android tab
Keyboard Shortcuts and Mouse Reference
Debug Tool Window. Threads
Creating and Managing Modules
Configuring Global, Project and Module SDKs
Android Reference
Configuring Artifacts: Adding Resources
Generating equals() and hashCode()
Generating Getters and Setters
Implementing Methods of an Interface
Creating and Optimizing Imports
Analyzing Applications
Saving and Reverting Changes
Closing an Editor for a Language Injection
Internationalization and Localization Support
Creating and Editing Properties Files
Navigating Between Methods and Tags
Navigating to Braces
Navigating to Custom Region
Pinning and Unpinning Tabs
Navigating to Next/Previous Change
Navigating to Navigated Items
Creating and Saving Temporary Run/Debug Configurations
Enabling, Disabling and Removing Breakpoints
Navigating Back to Source
Creating TODO Items
Move Refactorings
Specifying Actions to Run in the Background
Shelving and Unshelving Changes
Filtering Out and Removing Unshelved Changes
Accessing the Authentication to Server Dialog
Enabling and Configuring Perforce Integration
Showing Revision Graph and Time-Lapse View
Saving and Clearing Contexts
Creating and Editing Flex Application Elements
Toggling Case
Selecting Files and Folders
Uploading Application to Google App Engine
Compare Files and Folders
Creating Grails Views and Actions
Comparing Folders
Working with Lists and Maps
Creating Event and Event Handler Classes
Analyzing GWT Compiled Output
Reporting Issues and Sharing Your Feedback
Installing an AMP Package
Managing File Sets
Binding Groups of Components to Fields
Creating and Disposing of a Form's Runtime Frame
Adding Mnemonics
Grouping and Ungrouping Components
Testing RESTful Web Services
Output Layout Tab
DB Data Source Properties
Components Properties
Change Method Signature in Java
Rebasing Branches
Checking Perforce Project Status
Resolving Dependencies
Creating Relationships in Entities
RESTful WebServices
Add Module. Main Settings
Differences Viewer
Output Filters Dialog
Play Framework (Play Console)
Pull Changes Dialog
Update Project Dialog (Subversion)
Play Framework
Check Out From CVS Dialog
Code Inspection
Running Inspections
Generating a Signed APK Using a Wizard
Testing PHP Applications
Enabling PHPUnit Support
Configuring a DB Data Source
Accessing Data Sources via the Database Console
Struts Tab
Familiarize Yourself with %product% Editor
Viewing Changes Made by Other Team Members
Preparing for ActionScript, Flex or AIR application development
Using the Push ITDs In refactoring
Running Grails Targets
Debugging JavaScript
Configuring PHP Development Environment
Configuring XDebug
Using Framework Model View Controller
Running Cucumber Tests
Configuring Browsers
Push Dialog
File Status Highlights
Spring Dependencies Diagram
Creating Files from Templates
Using Language Injections
Creating Method Breakpoints
Examining Suspended Program
Running with Coverage
Familiarize Yourself with IDE Navigation
Local Tab
Excluding Files from Project
Usage Examples
XPath Expression Evaluation
Integrating SVN Projects or Directories
Plugin Development Guidelines
Configuring a DDL Data Source
Unified Version Control Functionality
Navigating with Structure Views
Configuring Compiler Settings
Stepping Through the Program
Performing Tests
Comparing File Versions
Integrating Project
Viewing Details of Changes
Viewing File Status
Using CVS Watches
Change Method Signature in ActionScript
Generating PHPUnit Test Class
Data Sources
Mapping by Database Schema
Defining Seam Components
Enabling Spring Support
Bookmarks Dialog
Run/Debug Configuration: PHPUnit on Server
Authentication Required
Create Branch or Tag Dialog (Subversion)
Status Bar
Regular Expression Syntax Reference
Exchanging Instant Messages
Unwrap Tag
OSGi Bundles
Using Suggestion List
Remove Middleman
Creating Fields in Persistence Entities
Using JPA Console
Creating Fields in Hibernate Elements
Using Hibernate Console
New Project. Main Settings
New Project from Scratch. Technologies Page
Code Style. Java
Language Injections
Associating a Copyright Profile with a Scope
Revert Changes Dialog
Viewing Files Opened by Others
Import Eclipse Workspace
Viewing Hierarchies
Validating Dependencies
Creating Own Inspections
Search Templates
Configuring Code Coverage Measurement
Rename Refactorings
Safe Delete
Configuring Ignored Files
Working Offline
Integrating Changes To/From Feature Branches
Sharing Directory
Managing Resources
Creating Aspects
Generating XML Schema From Instance Document
Creating Persistence Units
GUI Designer Files
Customizing the Component Palette
Select Path Dialog
Grouping Modules
Import Database Schema / Import Mappings
Table Editor
Configuring Artifacts: Layout Structure
Configuring Inspection Severities
Creating Resources
Executing Maven Goal
Change Signature in JavaScript
Configuring JavaScript Debugger
Creating TestNG Test Classes
Viewing Diagram
Viewing Members in Diagram
Local History
Move File Dialog
Framework Integration
Application Servers
File Templates
Log Tab
Dependency Validation dialog
Merge Branches Dialog
Overriding Methods of a Superclass
Disabling Inspections
Viewing Inline Documentation
Managing Bookmarks
Navigating Between IDE Components
Evaluating Expressions
Rerunning Tests
Refreshing Status
Browsing Changes
Switching Between Working Directories
Opening a GWT Application in the Browser
Generating Java Code from XML Schema
Generating Xml Schema From Java Code
Enabling PHP support
Defining Seam Navigation Rules
Managing Struts 2 Elements
Enabling Web Application Support
Run/Debug Configuration: PHPUnit
Copyright Profiles
Framework Settings
Debugger. Data Views
Add / Edit Pattern Dialog
Phing Settings Dialog
History Tab
Import into CVS
Share Project on GitHub Dialog
Deleting Modules
Pull Dialog
Web Module Editor - Servlet Initialization Parameters
Generate Signed APK Wizard. Specify APK Location
Components Treeview
Quick Edit Language
Error Highlighting
Run Configurations
Code Coverage
Handling Differences
Resolving Commit Errors
Updating Local Information in CVS
Publishing a Project on GitHub
Pulling Changes from the Upstream (Git Pull)
Resolving Property Conflicts
Creating JSDoc Comments
Unit Testing Node.JS
PHP-Specific Guidelines
PHP Built-In Web Server
Configuring a Debugging Engine
Working with Spring Roo Console
Configuring Default Settings for Diagrams
Import Project from Gradle. Page 2
Directory-Based Versioning Model
Run/Debug Configuration: Node JS
Language Injection Settings Dialog: Java Parameter
Code Sniffer
Configuring Copyright Profiles
Live Templates
Paths Tab
Importing Project from Existing Source Code
Database Console Properties Dialog
Hibernate Console Properties Dialog
JPA Console Properties Dialog
Integrate Project Dialog (Subversion)
Create Patch Dialog
EJB Module Editor - EJB Relationships
Generate Java from Xml Schema using JAXB Dialog
Create HTML Wrapper for Flex Application Dialog
Package AIR Application Dialog
Set Up a New Project
XPath Inspections
Navigating with Breadcrumbs
Reviewing Results
Managing Code Coverage Suites
Generating Code Coverage Report
Change Class Signature
Updating Local Information
Creating Patches
Using Git Integration
Handling Passwords for Git Remote Repositories
Interactive Rebase
Pulling Changes from the Upstream (Pull)
Integrating Perforce Files
Using Visual SourceSafe Integration
Creating Grails Application Elements
Enabling JSF Support
Generating Instance Document From XML Schema
Using Distributed Configuration Files (.htaccess)
Enabling Phing Support
Navigating Within a Conversation
GUI Designer Basics
Configuring Web Application Deployment
Developing RESTful Web Services
Change Signature Dialogs
Extract Constant Dialog
Accessing the IDE Settings
Skeleton Generator
Mobile Module Settings Tab
Function Keys
Basic Editing
Checkout Dialog
Git Push Dialog
Rebase Branches Dialog
Shelve Changes Dialog
Faces Config Structure
File Associations
Finding Usages in Project
Extract Delegate
Extract Parameter Object
Running the Build
Using Productivity Guide
CoffeeScript Support
Working with Application Servers
Managing Struts Elements
Viewing Class Hierarchy as a Class Diagram
Navigating Through a Diagram Using Structure View
Generating Client-Side XML-Java Binding
Build Process
Web Services
Generate Skeleton PHPUnit Test Case Dialog
Type Migration Preview
Run/Debug Configuration: Grails
Sharing Settings
Add Filter Dialog
Optional MIDP Settings Dialog
Pre-Processing Tab
Update Info Tab
Configure CVS Root Field by Field Dialog
Switch Working Directory Dialog
Generate Java Code from WSDL or WADL Dialog
Create AIR Application Descriptor Dialog
Form Workspace
Apache Felix Framework Integrator
Optimizing Imports
Configuring Encoding for Properties Files
Ignoring Hard-Coded String Literals
Creating Line Breakpoints
Creating Tests
Encapsulate Fields
Extract Include File
Extract Interface
Extract Method Object
Extract Constant
Introduce Parameter in Java
Resetting Head Commit
Using Mercurial Integration
Handling Modified Without Checkout Files
Filtering Out Extraneous Changelists
Viewing Differences in Properties
TFS Check-in Policies
Introduce Parameter in ActionScript
Using the AspectJ Compiler (ajc)
Linking Gradle Project
Filtering Dependencies
Keyboard Shortcuts You Cannot Miss
Viewing Inline Documentation
Extract Parameter in JavaScript
Monitoring Code Coverage for JavaScript
Defining Navigation Rules
Supported Module Types
Debugging a PHP HTTP Request
Running Injected SQL Statements from the Editor
Enabling JPA Support
Path Variables
Viewing Seam Components
Struts Framework
Managing Tiles
Populating Your GUI Form
Supported Compilers
Add Archetype Dialog
Run/Debug Configuration: Maven
Ignored Files
Debugger. Data Type Renderers
Usage Statistics
Navigation Between IDE Components
Navigation Bar
Enable Version Control Integration Dialog
Web Module Editor - Filter Mappings
Generate Instance Document from Schema Dialog
Table Editor Properties Dialog
Sending Stacktraces
Delete Attribute
Changing Default Facet Settings
Changing the Settings for All Facets of the Same Type
Wrap Tag
Configuring Artifacts: Arranging Elements
Creating Empty Files
Creating Imports
Building Class Hierarchy
Viewing Offline Inspections Results
Navigating with Bookmarks
Navigating Between Editor Tabs
Viewing Usages of a Symbol
Working With Search Results
Setting Log Options
Reloading Classes
Finding the Current Execution Point
Viewing Current Caret Location
Make Class Static
Make Method Static
Deleting a Changelist
Resolving Conflicts with Perforce Integration
Viewing Merge Sources
Using TFS Integration
Using Macros in the Editor
Configuring Triggers for Maven Goals
Associating Maven Goals with Keyboard Shortcuts
Creating EJB
Creating CMP Bean Fields
Testing Grails Applications
Introduce Parameter in Groovy
Launching Groovy Interactive Console
Enabling JavaScript Unit Testing Support
Referencing DTD or Schema
Creating a PHP Web Application Debug Configuration
Monitoring Code Coverage for PHP Applications
Profiling with XDebug
Profiling with Zend Debugger
Viewing Structure of a Database or Table
Creating Session Factory
Generating Persistence Mappings
Opening JPA or Hibernate ER Diagram
Supported Languages
Managing Struts Elements - General Steps
Managing Validators
Struts 2
Enabling Struts 2 Support
Creating Form Initialization Code
Placing GUI Components on a Form
Placing Non-Palette Components or Forms
Enabling Cucumber Support in Project
Viewing HTML Source Code of a Web Page in the Editor
Exposing Code as Web Service
Add Module Wizard
Color Picker
Refactoring Dialogs
Importing %product% Settings on First Launch
Resource Bundle Editor
Run/Debug Configuration: JSTestDriver
Run/Debug Configuration: PHP Script
New Project from Scratch. Maven Settings Page
Compiler. RMI Compiler
Add Server Dialog
Creating Copyright Profiles
Editor. Smart Keys
Editor. Appearance
Enter Keyboard Shortcut Dialog
Edit Template Variables Dialog
Custom Plugin Repositories Dialog
Add / Edit Filter Dialog
Sources Tab
JSF Facet Page
Module Page for a Flash Module
Working With Legacy Projects
Navigation In Source Code
Converting Project into Directory-Based Format
Saving Project as Template
Customize Data Views
Logs Tab
Importing Existing Modules
CVS Roots Dialog
Push Rejected Dialog (Git)
Reset Head Dialog
Tag Dialog
Update Project Dialog (Git)
Integrate File Dialog (Perforce)
Update Project Dialog (Perforce)
EJB Module Editor - Transaction Attributes
EJB Editor
Faces Config Structure - Referenced Bean
Rename Entity Bean
Managing Facets
GUI Designer Reference
File Types Recognized by %product%
Scope Language Syntax Reference
Replace Attribute With Tag
Replace Tag With Attribute
Add Attribute
Add Subtag
Move Attribute In
Move Attribute Out
Change Attribute Value
Delete Tag
Wrap Tag Contents
How It Works
Feedback Page
What's New
Completing Path
Hippie Completion. Expanding Words
Find Usages for Dependencies
Retaining Hierarchy Tabs
Defining Scope-Profile Combination
Resolving Problems
Running Inspections Offline
Intention Actions
Applying Intention Actions
Generating JavaDoc Reference for a Project
Navigating Through the Hierarchy of Methods
Navigating with Navigation Bar
Finding Word at Caret
Finding Usages
Viewing Recent Find Usages
Configuring Breakpoints
Starting the Debugger Session
Exploring Frames
Configuring Testing Libraries
Terminating Tests
Viewing Code Coverage Results
Generify Refactoring
Type Migration
Use Interface Where Possible
Using Local History
Handling Issues
Grouping Changelist Items by Folder
Shelving Changes
Viewing Changes History for a File or Selection
Configuring CVS Roots
Working Offline
Checking Git Project Status
Checking out (Switching Between Branches)
Checking SVN Project Status
Configuring Format of the Local Working Copy
Using Online Resources
Build Configuration
Configuring Device Layout
Editing Macros
Executing Build File in Background
Creating Maven Module
Creating Maven Run/Debug Configuration
Configuring Primary Key
Configuring Service Endpoint
Creating Message Listeners
Creating Grails Application Module
Creating Griffon Application Module
Configuring Groovy-Based Frameworks
Instantiating Java Interface in Groovy
Enabling GWT Support
Creating a GWT Module
Configuring Mobile Java SDK
Viewing JavaScript Reference
Generating DTD
Generating Marshallers
Generating Unmarshallers
Creating PHP Documentation Comments
Enabling Profiling with XDebug
Enabling Profiling with Zend Debugger
Using Phing
Creating a List of Phing Build Files
Viewing Query Results
Configuring Modules with Seam Support
Creating Groups
Moving Components
Optimize Imports Dialog
PSI Viewer
Change Signature Dialog for ActionScript
Change Signature Dialog for JavaScript
Move Package Dialog
Edit Log Files Aliases Dialog
Run/Debug Configuration: PHP Remote Debug
Run/Debug Configuration: PHP Web Application
Run/Debug Configuration: Query Language Console
Code Style Schemes
Advanced Options Dialog
XPath Viewer
Dependencies Tab
Code Folding
Navigation Between Bookmarks
Tiles Tab
Configure Subversion Branches
Apply Patch Dialog
EJB Module Editor - Method Permissions
Web Module Editor - Assembly Descriptor References
Generate Schema from Instance Document Dialog
Tapestry View
Customizing Views
Creating Run/Debug Configuration for Tests
Refactoring Source Code
Extract Method
Viewing Changes Information
Highlighting Braces
Developing GWT Components
Enabling Java EE Application Support
Unit Testing JavaScript
XML-Java Binding
Configuring %product% Plugin SDK
Generating a Data Structure Definition (DDL) File
New Project from Scratch. Maven Page
New Project from Scratch. Flash Page
Import Project from Maven. Page 1
New Filter Dialog
Types of Breakpoints
Evaluate Expression
Find Usages
Find Usages. Class Options
Find Usages. Package Options
IntelliJ Configuration Server Settings
New Action Dialog
Encapsulate Fields Dialog
Extract Method Dialog
Inline Dialogs
Run/Debug Configuration: Applet
Run/Debug Configuration: Node JS Remote Debug
Run/Debug Configuration: XSLT
File Types
Deployment: Connection Tab
File Colors
GUI Designer
Language Injection Settings Dialog: XML Tag
Language Injection Settings Dialog: XML Attribute
Configuring Project Settings
Version Control
Console Folding
Debugger. JavaScript
Editor. Editor Tabs
Macros Dialog
Live Edit
Library Bundling
Web Browsers
Project Structure Dialog
AspectJ Facet Page
GWT Facet Page
Spring Facet Page
General tab
Post-Processing Tab
SDKs. Mobile
Customize Threads View
IDETalk Options Dialog
Creating Module from Scratch
Deployment Console
Validator Tab
Stash Dialog
Unstash Changes Dialog
Select Branch
Accessing Module Settings
Visual SourceSafe Options Dialog
Apply EJB 3.0 Style
Configuring Content Roots
Faces Config Structure - Managed Beans
Choose Servlet Package
Choose Device Dialog
Documenting Source Code in %product%
Creating Documentation Comments
Compiling Target
Running Applications
Moving Breakpoints
Creating a New Changelist
Using ClearCase Integration
Downloading Libraries from Maven Repositories
Creating Google App Engine Project
JavaScript-Specific Guidelines
Content Root
Creating a Server Configuration
File Templates
Designing GUI. Major Steps
Testing Frameworks
Creating Step Definition
Specifying Assembly Descriptor References
Previewing Pages with Web Contents in a Browser
Enabling Web Service Client Development Support Through a Dedicated Facet
Run/Debug Configuration
Register %product%
Configure Library Dialog
Create Test
Find Usages. Method Options
Find Usages. Throw Options
Find Usages. Variable Options
Supported Version Control Systems
Productivity Guide
Change Class Signature Dialog
Extract Include File Dialog
Extract Interface Dialog
Extract Method Object Dialog
Extract Superclass Dialog
Generify Dialog
Make Static Dialogs
Move Class Dialog
Replace Constructor with Builder Dialog
Reformat Code Dialog
Run/Debug Configuration: FlexUnit
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: NodeUnit
Run/Debug Configuration: PHP Built-in Web Server
Show History for File / Selection Dialog
Type Migration Dialog
Code Style. HTML
Files/Folders Default Permissions Dialog
Maven. Importing
Changelist Conflicts
Zend Framework
Editor. Code Folding
Editor. Code Completion
File Types
Web Services
Edit Application Context Dialog
Tapestry Facet Page
Dependencies tab
SDKs. Java
SDKs. %product%
Advanced Editing
Groovy Shell
CVS Reference
Create Gist Dialog
Configuring Project Structure
Perforce Options Dialog
SVN Checkout Options Dialog
Mark Resolved Dialog (Subversion)
New Changelist Dialog
Configuring Module Roots
New Servlet Dialog
New Filter Dialog
New Listener Dialog
Generate WSDL from Java Dialog
Monitor SOAP Messages Dialog
Generate Java Code from XML Schema using XmlBeans Dialog
New Key Store Dialog
General Techniques of Using Diagrams
Project Settings
Syntax Highlighting
Creating Packages
Surrounding Blocks of Code with Language Constructs
Building Call Hierarchy
Viewing Structure of a Source File
Suppressing Inspections
Disabling Intention Actions
Opening Language Injections in the Editor
Properties Files
Resource Bundle
Highlighting Usages
Configuring Debugger Options
Inspecting Watched Items
Monitoring the Debug Information
Change Method Signature
Introduce Property
Selecting Text in the Editor
Enabling Version Control
Associating a Directory with a Specific Version Control System
Configuring Autofolding Behavior
Creating a Library for aspectjrt.jar
Binding Macros With Keyboard Shortcuts
Working with Maven Dependencies
Comparing Files
Running Gant Targets
Creating Run/Debug Configuration for Application Server
Managing Phing Build Targets
Running Builds
Customizing Build Execution by Configuring Properties Externally
Creating a Project for Plugin Development
Remote Hosts
Customizing Upload
Using Spring Bean Patterns
Enabling Struts Support
Defining the Validation File Set

Go to Web help home page.