IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page add reference dialog appears to be missing.

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

Select Path Dialog
Project Structure Dialog
Adding and Removing Facets
Specifying Assembly Descriptor References
Settings Dialog
Accessing Module Settings
Adding Build File to Project
Play Framework
Edit Application Context Dialog
Defining Additional Ant Classpath
Add Module Wizard
Adding and Editing Layout Components Using Android UI Designer
Web Module Editor - Assembly Descriptor References
Add Server Dialog
Enabling Support of Additional Struts Features
Managing Your Project Favorites
Make Static Dialogs
Add / Edit Pattern Dialog
Add Team Foundation Server
Adding GUI Components and Forms to the Palette
Change Signature Dialogs
Choose Actions to Add Dialog
Add Archetype Dialog
Add / Edit Color Label Dialog
Add / Edit Filter Dialog
Refactoring Android XML Layout Files
Adding Node Elements to Diagram
Edit Subversion Options Related to Network Layers Dialog
Configuring Global, Project and Module SDKs
Finding and Adding Users
Adding Files to Version Control
Add Filter Dialog
Browse Repositories Dialog
Configuring Module Dependencies and Libraries
Preparing for ActionScript, Flex or AIR application development
Adding a Struts 2 Facet to a Module
Add Frameworks Support dialog
Configure Library Dialog
Run/Debug Configurations
Configuring Project and Global Libraries
New Bean Dialogs
Inline Dialogs
Import Data Sources Dialog
Filters and Ordering Dialog
Table Editor Properties Dialog
Adding a Struts Facet to a Module
CVS Roots Dialog
Extract Constant Dialog
Application Servers
Custom Plugin Repositories Dialog
EJB Local References
Dependency Validation dialog
Web Service References
Edit Tool Dialog
Create Web Service Reference
Structural Search and Replace Dialogs
Resource References
Resource Environment References
Add/Edit Palette Component
Viewing Reference Information
Specifying Additional Connection Settings
Resolving References with Maven
Copy Dialog
Login to IntelliJ Configuration Server Dialog
Update Project Dialog (Subversion)
Add Relationship
Adding Files To a Local Mercurial Repository
Adding a GWT Facet to a Module
Creating and Opening Forms
EJB Remote References
Change Signature Dialog for ActionScript
Create EJB Local Reference
Add Attribute
Add Subtag
Pushing Changes to the Upstream (Git Push)
Find and Replace in Path
Play Configuration Dialog
Create EJB Reference
Message Destination References
Adding Files to a Local Git Repository
Extract Variable Dialog
IDETalk Options Dialog
Commit Changes Dialog
Assembly Descriptor Dialogs
Adding, Editing and Removing Watches
Extract Parameter Dialog
Create EJB Resource Environment Reference
Database Console Properties Dialog
Managing Enterprise Plugin Repositories
Managing Spring Configuration Files
Downloading Options dialog
Extract Method Dialog
Create Message Destination Reference
Select Android Virtual Device Dialog
Class Filters Dialog
Extract Field Dialog
Master Password / Reset Master Password Dialog
Scope Language Syntax Reference
CVS Global Settings Dialog
Edit File Set
Generate Java Code from WSDL or WADL Dialog
Creating EJB
Bookmarks Dialog
Change Class Signature Dialog
Specify Dependency Analysis Scope Dialog
New Key Store Dialog
Attaching and Detaching Perforce Jobs to Changelists
Package AIR Application Dialog
Change Method Signature in ActionScript
Enabling Web Service Development Support Through a Dedicated Facet
Choose Local Paths to Upload Dialog
Extract Parameter Dialog for JavaScript
Move File Dialog
Reformat Code Dialog
Version Control
Optional MIDP Settings Dialog
Check Out From CVS Dialog
Edit Jobs Linked to Changelist Dialog
Check Out From Subversion Dialog
Sharing Android Source Code and Resources Using Library Projects
Adding WS Libraries to a Web Service Module Manually
Optimize Imports Dialog
Override Server Path Mappings Dialog
Change Signature Dialog for JavaScript
Edit Check-in Policies Dialog
Output Filters Dialog
Generate Java Code from XML Schema using XmlBeans Dialog
Create HTML Wrapper for Flex Application Dialog
Adding Auto-Detected Facets
Configuring Subversion Branches
Build Configuration
Add Module. Main Settings
Extract Parameter Dialog for ActionScript
Extract Variable Dialog for SASS
Move Inner to Upper Level Dialog for ActionScript
Move Members Dialog
Push Members Down Dialog
Advanced Options Dialog
Language Injection Settings Dialog: Java Parameter
Edit Template Variables Dialog
Change Master Password Dialog
Keyboard Shortcuts and Mouse Reference
Phing Settings Dialog
Switch Working Directory Dialog
Faces Config Structure - Referenced Bean
Generate Java from Xml Schema using JAXB Dialog
Viewing JavaScript Reference
Managing File Sets
New Filter Dialog
Edit Log Files Aliases Dialog
Create EJB Resource Reference
Choose Device Dialog
Regular Expression Syntax Reference
Accessing Breakpoint Properties
Creating a PHP Web Application Debug Configuration
Generate JavaDoc Dialog
Files/Folders Default Permissions Dialog
Enter Keyboard Shortcut Dialog
DB Data Source Properties
Hibernate Console Properties Dialog
JPA Console Properties Dialog
Configure CVS Root Field by Field Dialog
Push Rejected Dialog (Git)
Rebasing Commits Dialog
Link Job to Changelist Dialog
Create Android Virtual Device Dialog
Using the AspectJ Compiler (ajc)
Excluding Files and Folders from Deployment
Wrap Return Value Dialog
Project Library and Global Library Pages
Create Patch Dialog
New BMP Entity Bean Dialog
New CMP Entity Bean Dialog
Generate XML Schema From Java Using JAXB Dialog
Generate Instance Document from Schema Dialog
Generate Schema from Instance Document Dialog
Writing and Executing SQL Commands in the Database Console
Enabling Web Service Client Development Support Through a Dedicated Facet
Create Library dialog
Edit Library dialog
Generate Skeleton PHPUnit Test Case Dialog
Convert Anonymous to Inner Dialog
Generify Dialog
Replace Constructor with Factory Method Dialog
Show History for File / Selection Dialog
Struts Tab
Version Control Reference
Integrate Project Dialog (Subversion)
Lock File Dialog (Subversion)
Apply Patch Dialog
Change EJB Classes Dialog
Generate WSDL from Java Dialog
Diagram Reference
Configuring Artifacts: Additional Settings
Adding Plugins to Enterprise Repositories
Enabling EJB Support
Register New File Type Association Dialog
Show History for Folder Dialog
Creating and Running Your First Java Application
Language Injection Settings Dialog: XML Tag
Web Resource Directory Path Dialog
Update Directory / Update File Dialog (CVS)
SVN Checkout Options Dialog
Create Branch or Tag Dialog (Subversion)
Enable Version Control Integration Dialog
Enable Web Services Support Dialog
Edit Android Platform Dialog
Designer Tool Window
Generating JavaDoc Reference for a Project
Change Method Signature in Java
Introduce Parameter in Java
Manipulating Table Data in the Table Editor
Move Class Dialog
Macros Dialog
Enter Mouse Shortcut Dialog
DDL Data Source Properties
Git Push Dialog
Pull Changes Dialog
Update Project Dialog (Perforce)
Expose Class As Web Service Dialog
GUI Designer Reference
Configuring Inspection Severities
Enabling Spring Support
New Action Dialog
Language Injection Settings Dialog: XML Attribute
Web Browsers
Customize Data Views
Create Gist Dialog
Update Project Dialog (Git)
Revert Changes Dialog
New Message Bean Dialog
Extract Parameter Dialog for Groovy
Run/Debug Configuration: PHPUnit
Structural Search and Replace. Edit Variable Dialog
Path Variables
Checkout Dialog
Merge Branches Dialog
Perforce Options Dialog
Shelve Changes Dialog
New Session Bean Dialog
New Servlet Dialog
Inline Android Style Dialog
Accessing the Authentication to Server Dialog
Keymap Reference
Adding WS Libraries to a Web Service Client Module Manually
Open Task Dialog
Manage TFS Servers and Workspaces
Clone Repository Dialog
Select Repository to Clone Dialog
Stash Dialog
Unstash Changes Dialog
Clone Mercurial Repository Dialog
Create Mercurial Repository Dialog
Pull Dialog
Push Dialog
Mark Resolved Dialog (Subversion)
New Changelist Dialog
Create AIR Application Descriptor Dialog
Code Inspection
Installing, Updating and Uninstalling Repository Plugins
Updating a Running Java EE Application
Enabling PHP support
Convert Project Dialog
Refactoring Dialogs
Move Package Dialog
Move Inner to Upper Level Dialog for Java
Pull Members Up Dialog
Rename Dialogs
Safe Delete Dialog
Specify Inspection Scope Dialog
Sharing Settings
Tool Windows Reference
Share Project on GitHub Dialog
Login to GitHub Dialog
Rebase Branches Dialog
Reset Head Dialog
Tag Dialog
Integrate File Dialog (Perforce)
Set Property Dialog (Subversion)
Adding Frameworks Support
Select Target Changelist Dialog
Unshelve Changes Dialog
Visual SourceSafe Options Dialog
Generate GWT Compile Report Dialog
Monitor SOAP Messages Dialog
Show Deployed Web Services Dialog
New Android Component Dialog
IntelliLang Configuration
Accessing the CVS Roots Dialog Box
Adding Tags
Controlling Behavior of Ant Script with Build File Properties
Change Signature in JavaScript
Creating a Server Configuration
Add New Field or Constant
Encapsulate Fields Dialog
Configuring Quick Lists
CVS Reference
Creating and Editing Search Templates
Importing Adobe Flash Builder Projects
Enabling JSF Support
Generating Java Code from XML Schema
Build File Properties
Package and Class Migration Dialog
Run/Debug Configuration: OSGi Bundles
Output Layout Tab
Import Database Schema / Import Mappings
New Filter Dialog
New Listener Dialog
Environment Entry References
Validating Dependencies
Creating and Editing Run/Debug Configurations
Configuring Ignored Files
Creating and Editing Relationships
Analyze Stacktrace Dialog
Generate Groovy Documentation Dialog
Extract Include File Dialog
Extract Interface Dialog
Extract Parameter Object Dialog
Extract Superclass Dialog
Replace Constructor with Builder Dialog
Web Services
Compiler Options tab
Configuring Artifacts: Adding Resources
Using External Annotations
Specifying Actions to Confirm
Configuring JavaScript Libraries
Running JavaScript Unit Tests in Browser
Create Jar from Modules Dialog
Find Usages Dialogs
Recent Changes Dialog
Convert to Instance Method Dialog
Extract Dialogs
Extract Delegate Dialog
Extract Method Object Dialog
Extract Module Dialog
Extract Property Dialog
Invert Boolean Dialog
Move Dialogs
Move Instance Method Dialog
Rename Dialog for a Class or an Interface
Rename Dialog for a Directory
Rename Dialog for a Field
Rename Dialog for a File
Rename Dialog for a Method
Rename Dialog for a Package
Replace Inheritance with Delegation Dialog
Replace Method Code Duplicates Dialog
Replace Temp with Query Dialog
Use Interface Where Possible Dialog
Run/Debug Configuration: PHPUnit on Server
Type Migration Dialog
Mouse Reference
Favorites Tool Window
Git Reference
GitHub Integration Reference
Mercurial Reference
Perforce Reference
Subversion Reference
Select Repository Location Dialog (Subversion)
Subversion Options Dialog
Configure Ignored Files Dialog
Java EE Reference
Web Services Reference
XML-Java Binding Reference
Android Reference
Flex Reference
Icons Reference
Adding, Deleting and Moving Lines
Updating Local Information in CVS
Debugging JavaScript
Adding Data Structure Definition Files to a DDL Data Source
Adding Mnemonics
Run/Debug Configuration: JSTestDriver
Configuring Menus and Toolbars
SQL Dialects
Live Templates
Web, EJB and Java EE Application Facet Pages
Select Branch
Creating Folders and Grouping Run/Debug Configurations
Creating and Managing TFS Workspaces
Exposing Code as Web Service
New Project from Scratch. Technologies Page
Configuring Keyboard Shortcuts
Setting Log Options
Defining TODO Patterns and Filters
Run/Debug Configuration: Android Application
File Types
XPath Expression Evaluation
Rebasing a Branch to a Specific Commit
Generating a Signed APK Using a Wizard
Creating a Library for aspectjrt.jar
Editing Maven Settings
Customizing the Component Palette
Run/Debug Configuration: XSLT
Creating Copyright Profiles
Debug Tool Window. Variables
Find Tool Window
Apply EJB 3.0 Style
Running Inspections
Make Method Static
Cutting, Copying and Pasting
Enabling Integration with an Issue Tracking System
Configuring and Managing Application Server Integration
Configuring Third-Party Tools
Ignore Unversioned Files
Editor. Auto Import
Repository and Incoming Tabs
Export Threads
Phing Build Tool Window
Project Tool Window
File Associations
Analyzing Duplicates
Finding and Replacing Text in Project
Configuring Breakpoints
Creating CMP Bean Fields
Referencing DTD or Schema
PHP-Specific Command Line Tools
Run/Debug Configuration: Grails
Create Workspace
Android Facet Page
Configuring Module Compiler Output
Code Inspections
Set Up a New Project
Error Highlighting
Finding and Replacing Text in File
Configuring %product% Plugin SDK
Creating Elements in Persistence Units
Defining Pageflow
Code Duplication Analysis Settings
Find Usages
Specify Code Duplication Analysis Scope
File Encodings
New File Type
Creating Modules
Creating Files from Templates
What's New
Rename Refactorings
Changing Read-Only Status of Files
Setting Up a Local Mercurial Repository
Checking Out from TFS Repository
Enabling Android Support
Defining Runtime Properties
Configuring Include Paths
Defining Seam Navigation Rules
Setting Text Properties
Run/Debug Configuration: Node JS
Run/Debug Configuration: PHP Built-in Web Server
Code Style. HTML
Creating and Registering File Types
Issue Navigation
Zend Framework
Menus and Toolbars
OSGi Facet Page
Dependencies tab
Extracting Hard-Coded String Literals
Defining Ant Execution Options
Creating Griffon Application Module
Configuring a DDL Data Source
Enabling JPA Support
Enabling Web Application Support
Configuring Static Content Resources
Run/Debug Configuration: PHP Script
Code Style. Java
Framework Settings
Authentication Required
Choose Servlet Package
General Usage
Configuring Artifacts: Layout Structure
Configuring Annotation Processing
Setting Labels to Variables, Objects and Watches
Configuring Testing Libraries
Handling Passwords for Git Remote Repositories
Merging, Deleting, and Comparing Branches
Rebasing Branches
Importing Eclipse Project to %product%
Enabling Java EE Application Support
Multiuser Debugging via XDebug Proxies
Customizing Build Execution by Configuring Properties Externally
Creating Fields in Persistence Entities
Creating Fields in Hibernate Elements
Path Variables
Creating a Module with a Dedicated Struts 2 Facet
Grouping and Ungrouping Components
Register %product%
Run/Debug Configuration: Android Test
Run/Debug Configuration: JUnit
Run/Debug Configuration: TestNG
External Tools
File Templates
Configure Subversion Branches
SVN Repositories
Choose Servlet Class
Edit Relationship
Configuring Project Compiler Output
Configuring Auto-Detection of Facets
Basic Code Completion. Completing Names and Keywords
Completing Path
Creating Own Inspections
Navigating with Bookmarks
Change Class Signature
Introduce Property
Building, Running and Debugging Flex Applications
Creating Ant Build File
Importing Project from Maven Model
Comparing Folders
Creating and Editing Faces Configuration
Creating and Importing Data Sources
Defining the Validation File Set
Differences Viewer
Run/Debug Configuration: Flash App
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: NodeUnit
Run/Debug Configuration: PHP Web Application
Configuring Colors and Fonts
General tab
Importing Project from Existing Source Code
Opening, Reopening and Closing Projects
Database Console Tool Window
Creating Module from Scratch
Maven Projects Tool Window
Create CMP Field
EJB Relationship Properties
Faces Config Structure
Opening and Reopening Files in the Editor
Navigating to Declaration or Type Declaration of a Symbol
Managing Code Coverage Suites
Refactoring Source Code
Deleting Files from the Repository
Checking Out Files from Subversion Repository
Defining the Set of Changelists to Display
Using Visual SourceSafe Integration
Running Grails Targets
Introduce Parameter in Groovy
Configuring Mobile Java SDK
Extract Parameter in JavaScript
Monitoring Code Coverage for JavaScript
Using Distributed Configuration Files (.htaccess)
Generating PHPUnit Test Class
Managing Phing Build Targets
Creating Relationships in Entities
Enabling Hibernate Support
Mapping by Database Schema
Enabling Struts 2 Support
Creating TestNG Test Classes
Creating Examples Table in Scenario Outline
Generating Client-Side XML-Java Binding
Enabling Web Service Development Support
Testing RESTful Web Services
Find Usages. Package Options
Unified Version Control Functionality
PSI Viewer
Run/Debug Configuration: FlexUnit
Run/Debug Configuration: PHP HTTP Request
Run/Debug Configuration: Remote
Language Injection Settings: Generic JavaScript
Debugger. Data Views
Quick Lists
Importing Existing Modules
Rename Entity Bean
Create Environment Entry
Customizing IDEtalk Options
Run Configurations
Creating Imports
TODO Example
Extract Interface
Make Class Static
Copying, Renaming and Moving Files
Using CVS Watches
Configuring Subversion Repository Location
Enabling AspectJ Support Plugins
Creating Maven Run/Debug Configuration
Selecting Files and Folders
Using PHP Code Sniffer Tool
Defining Seam Components
Compilation Types
Import Project or Module Wizard
I18nize Hard-Coded String
Productivity Guide
Run/Debug Configuration: JavaScript Debug
Run/Debug Configuration: PHP Remote Debug
Code Style. XML
Compiler. Java Compiler
Deployment: Connection Tab
JavaScript. Usage Scope
Ignored Files
Console Folding
Debugger. Data Type Renderers
Debug Tool Window. Watches
Changes Browser
Integrate to Branch
Faces Config Structure - Managed Beans
Rename Servlet
Create Security Role
Web Module Editor - Filter Mappings
Managing Facets
Components Properties
Framework Definitions
Editing Templates
Intention Actions
Creating and Saving Temporary Run/Debug Configurations
Navigating Back to Source
Move Refactorings
Viewing Local History of a File or Folder
Creating Issue Patterns
Ignoring Files
Using Command Line Tools
Updating a Command Line Tool
Managing Resources
Associating Ant Target with Keyboard Shortcut
Downloading Libraries from Maven Repositories
Activating and Deactivating Maven Profiles
Relational Databases
Creating Hibernate Elements in a Session Factory
GUI Designer Basics
GUI Designer Files
Bound Class
Configuring Libraries of UI Components
Placing Non-Palette Components or Forms
Find Usages. Class Options
Find Usages. Method Options
Run/Debug Configuration: Applet
Run/Debug Configuration: Maven
JavaScript. Libraries
Language Injections
Schemas and DTDs
Command Line Tool Support
OSGi: Framework Definitions
Dependencies Tab
Pre-Processing Tab
Ant Build Tool Window
Database Tool Window
Remote Host Tool Window
Choose Class
Import into Subversion
Completing Tag Names
Defining Scope-Profile Combination
Using Help Topics
Stashing and Unstashing Changes
Generating Maven Dependencies
Creating Module with Groovy Support
Creating Run/Debug Configuration for Application Server
Enabling Struts Support
Navigating from .feature File to Step Definition
Viewing Changes as Diagram
Configuring Web Application Deployment
Generating WSDL Document from Java Code
New Project from Scratch. Maven Page
Create New Method
IntelliJ Configuration Server Settings
Run/Debug Configuration: Flash Remote Debug
Run/Debug Configuration: Node JS Remote Debug
Code Style Schemes
Deployment: Excluded Paths Tab
Mobile Module Settings Tab
GWT Facet Page
Importing Project
Validation Tab
Event Log
Integrate to Branch Info View
EJB Editor - Assembly Descriptor
Web Module Editor - Servlet Initialization Parameters
Table Editor
Form Workspace
Quick Edit Language
Managing User Groups
Viewing Files Opened by Others
Import Eclipse Workspace
Generating and Updating Copyright Notice
Smart Type Code Completion. Completing Code Based on Type Information
Familiarize Yourself with %product% Editor
Annotating Source Code
Structural Search and Replace - General Procedure
Enabling, Disabling and Removing Breakpoints
Creating Tests
Configuring Code Coverage Measurement
Extract Include File
Extract Constant
Resolving Conflicts
Publishing a Project on GitHub
Creating Git Gists
Setting Up a Local Git Repository
Authenticating to Subversion
Integrating Changes to Branch
Integrating SVN Projects or Directories
Introduce Parameter in ActionScript
Creating an Android Run/Debug Configuration
Editing Module with EJB Facet
Zen Coding Support
Running and Debugging Node.js
PHP-Specific Guidelines
PHP Built-In Web Server
Configuring XDebug
PHP Debugging Session
Debugging a PHP HTTP Request
Analyzing Zend Debugger Profiling Data
Creating a Project for Plugin Development
Configuring a DB Data Source
Creating Persistence Units
Binding a Form to an Existing Class
Populating Your GUI Form
Enabling Cucumber Support in Project
Running Cucumber Tests
Viewing Ancestors, Descendants, and Usages
Populating Web Module
Enabling Web Service Client Development Support
RESTful WebServices
Import Project from Existing Sources. Project Name and Location
Import Project from Flash Builder. Page 1
Checkout from TFS Wizard: Source Server
Create New Constructor
Differences Viewer for Folders and DB Objects
Evaluate Expression
Find Usages. Throw Options
Find Usages. Variable Options
Run/Debug Configuration: MXUnit
New Project from Scratch. Maven Settings Page
Compiler: Flex Compiler
Creating and Editing Template Variables
File Colors
Exporting and Importing Settings
XML Catalog
Changelist Conflicts
XSLT File Associations
Editor. Smart Keys
Configuring Individual File Encoding
Copying Code Style Settings
Paths Tab
Module Page for a Flash Module
Post-Processing Tab
Dependency Viewer
Importing Existing Module
Run Tool Window
Play Framework (Play Console)
History Tab
Creating Module from Existing Source Code
Grouping Modules
Subversion Working Copies Information Tab
File Status Highlights
EJB Module Editor - Method Permissions
Configuring Module Roots
Changing Facet Settings
Changing Default Facet Settings
Changing the Settings for All Facets of the Same Type
Enabling Tapestry Support
Implementing Methods of an Interface
Iterating over an Array. Example of Applying Parameterized Live Templates
Overriding Methods of a Superclass
Excluding Classes from Auto-Import
Analyzing Backward Dependencies
Analyzing Cyclic Dependencies
Exporting Inspection Results
Inferring Nullity
Using Language Injections
Resource Files
Recognizing Hard-Coded String Literals
Highlighting Usages
Working With Search Results
Inspecting Watched Items
Convert Anonymous to Inner
Generify Refactoring
Extract Field
Push Members Down
Replace Constructor with Builder
Replace Constructor with Factory Method
Wrap Return Value
Specifying Actions to Run in the Background
Checking In Files
Shelving and Unshelving Changes
Using Change Markers to View and Navigate Through Changes in the Editor
Checking Out Files from CVS Repository
Configuring CVS Roots
Viewing Merge Sources
Enabling and Disabling Plugins
Packaging AIR Applications
Testing Flex and ActionScript Applications
Configuring Device Layout
Using Macros in the Editor
Generating Ant Build File
Executing Ant Target
Configuring Gradle Integration
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Working in Offline Mode
Exporting %product% Project to Eclipse
Creating Local and Remote Interfaces
Creating Message Listeners
Defining Bean Class and Package
Migrating to EJB 3.0
Creating Grails Application Module
Configuring Libraries and Dependencies in Grails Applications
Configuring Mobile-Specific Compiling Settings
Running/Debugging Mobile Application
Extract Variable in JavaScript
Markup Languages and Style Sheets
XML-Java Binding
Extract Variable for SASS
Creating PHP Documentation Comments
Processing Order
Running and Debugging Plugins
Generating a Data Structure Definition (DDL) File
Creating Session Factory
Configuring Modules with Seam Support
Working with Spring Roo Console
Managing Struts Elements
Localizing Forms
Setting Component Properties
Editing Module Dependencies on Diagram
New Project from Scratch. Android Page
New Project from Scratch. Mobile SDK Specific Options Page
Temporary and Permanent Run/Debug Configurations
Checkout from TFS Wizard: Source Workspace
Checkout from TFS Wizard: Summary
Color Picker
Export to HTML
Generate Ant Build
Directory-Based Versioning Model
Importing %product% Settings on First Launch
Run/Debug Configuration: Application
Run/Debug Configuration: Cucumber Java
Run/Debug Configuration: Plugin
Code Style. ActionScript
Language Injection Settings: Generic PHP
Language Injection Settings: Groovy
Switching Between Schemes
Web Contexts
Editor. Colors and Fonts
External Diff Tools
Library Bundling
Usage Statistics
Sources Tab
Hibernate and JPA Facet Pages
JSF Facet Page
Libraries and Global Libraries
Keyboard Shortcuts By Keystroke
Opening Multiple Projects
Keyboard Shortcuts By Category
Android Tool Window
Debug Tool Window
Customize Threads View
Menus and Toolbars
Duplicates Tool Window
Module Dependencies Tool Window
Roo Console Tool Window
Seam Tool Window
Tiles Tab
Validator Tab
Import into CVS
Creating Java Module
EJB Module Editor
Select Accessor Fields to Include in Transfer Object
Web Module Editor
Web Module Editor - General
Data Binding Wizard
Project Settings
XPath and XSLT Support
Plugin Settings
Feedback Page
Using Suggestion List
Running Inspections Offline
Configuring Intention Actions
Viewing Inline Documentation
Managing Editor Tabs
Closing an Editor for a Language Injection
Internationalization and Localization Support
Managing Bookmarks
Search Templates
Structural Search and Replace Examples
Reviewing Compilation and Build Results
Setting Configuration Options
Monitoring and Managing Tests
Running with Coverage
Remove Middleman
Replace Temp With Query
Configuring General VCS Settings
Configuring History Cache Handling
Configuring VCS-Specific Settings
Handling Differences
Assigning an Active Changelist
Reverting Local Changes
Using ClearCase Integration
Assembling a CVS Root String
Using Git Integration
Using Mercurial Integration
Working Offline
Browsing Subversion Repository
Comparing With Branch
Resolving Text Conflicts
Sharing Directory
Viewing and Fast Processing of Changelists
Filtering Out Extraneous Changelists
Creating a Command Line Tool
Choosing the Target Device Manually
Using the Push ITDs In refactoring
Executing Build File in Background
Associating Maven Goals with Keyboard Shortcuts
Creating and Editing Relationships Between Domain Classes
Configuring Groovy-Based Frameworks
Instantiating Java Interface in Groovy
Generating Groovy Documentation
Creating a Module with a GWT Facet
Creating a GWT Module
Object-Relational Mapping (EJB, Hibernate and JPA)
JavaScript-Specific Guidelines
Creating JSDoc Comments
Configuring JavaScript Debugger
Defining Navigation Rules
Changing Color Values in Style Sheets
Validating Web Content Files
Expanding Zen Coding Templates with User Defined Templates
Enabling a Command Line Tool
Using Framework Model View Controller
Enabling Phing Support
Navigating to Underlying Code
Struts Framework
Creating a Module with a Dedicated Struts Facet
Struts 2
Binding Groups of Components to Fields
Making Forms Functional
New Project. Main Settings
Import Project from Gradle. Page 1
Types of Breakpoints
Local History
Run/Debug Configuration: Google AppEngine Dev Server
Run/Debug Configuration: Query Language Console
Deployment: Mappings Tab
Skipped Paths
Skeleton Generator
Struts 2 Facet Page
Navigation In Source Code
Command Line Tools Console Tool Window
Hibernate Console Tool Window
Hierarchy Tool Window
JPA Console Tool Window
JSF Tool Window
Structure Tool Window
TODO Tool Window
Web Module Editor - Servlet Mappings
Generate Signed APK Wizard. Specify Key and Keystore
Components Treeview
Configuring Artifacts
Tapestry View
XPath Search
Creating Documentation Comments
Viewing Usages of a Symbol
Code Coverage
Extract Superclass
Associating a Directory with a Specific Version Control System
Changing VCS Associations
GWT Sample Application Overview
Documentation Look-up in External JavaScript Libraries
Remote Hosts
File Template Variables
#parse Directive
Web Services
New Project from Scratch. Flash Page
Import Project from Maven. Page 1
Run/Debug Configuration: Groovy
Run/Debug Configuration: GWT
Run/Debug Configuration: J2ME
Code Style
Compiler. Excludes
Compiler. RMI Compiler
Compiler: Android DX Compiler
Copyright Profiles
Framework Integration
GUI Designer
Maven. Repositories
Play Configuration
Debugger. JavaScript
Plugin Deployment Tab
AspectJ Facet Page
Spring Facet Page
Function Keys
Running and Debugging
Local Tab
Debug Tool Window. Console
DSM Tool Window
IDEtalk and IDEtalk Messages Tool Windows
Inspection Tool Window
JSTestDriver Server Tool Window
Test Runner Tab
CVS Tool Window
Configuring Content Roots
EJB Module Editor - General
EJB Editor - General Tab - Entity Bean
EJB Editor - General Tab - Message Bean
Faces Config Structure - Component
Web Module Editor - Context Parameters
Status Bar
Class Diagram Toolbar and Context Menu
Exchanging Instant Messages
XPath Inspections
Completing Punctuation
Analyzing External Stacktraces
Annotating Source Code Directly
Viewing External Documentation
Properties Files
Ignoring Hard-Coded String Literals
Navigating Between Methods and Tags
Navigating to Class, File or Symbol by Name
Navigating to Recent File
Finding Usages in the Current File
Evaluating Expressions
Viewing Details of Changes
Configuring Global CVS Settings
Git Branches in Multirooted Projects
Creating Resources
Creating Google App Engine Project
Working with Grails Plugins
Generating Instance Document From XML Schema
Generating XML Schema From Instance Document
Viewing Images
Available Facets and Their Dependencies
Accessing Files on Remote Hosts
File Templates
Web Service Clients
Import Project from Existing Sources. Libraries Page
Import Project from Existing Sources. Module Structure Page
Import Existing Sources. Project SDK
Import Project from Eclipse. Page 1
Import Project from Eclipse. Page 2
Import Project from Flash Builder. Page 2
Import Project from Gradle. Page 2
Import Project from Maven. Page 3
Checkout from TFS Wizard: Choose Source and Destination Paths
Create Test
Supported Version Control Systems
Plugin Configuration Wizard
Resource Bundle Editor
Run/Debug Configuration: ColdFusion
Create Module from Existing Sources. Libraries Page
Create Module from Existing Sources. Module Structure Page
New Project from Scratch. SDK Page
Code Style. CSS
Compiler. Groovy Compiler
Maven. Importing
Code Sniffer
Guided Tour Around %product% User Interface
Debugger. Groovy
HTTP Proxy
XPath Viewer
Project. General Settings Page
Module Page
Facet Page
Build Configuration page for a Flash module
Basic Editing
GUI Designer Shortcuts
Navigation Between Bookmarks
Navigation Between IDE Components
Bean Validation Tool Window
Coverage Tool Window
Debug Tool Window. Frames
JetGradle Tool Window
Deployment Console
Update Info Tab
Configuring Project Structure
EJB Module Editor - EJB Relationships
EJB Editor General Tab - Common
JSF Faces Config Editor
Faces Config Structure - Navigation Rule
Security Roles
Generate Signed APK Wizard. Specify APK Location
Diagram Toolbar and Context Menu
File Types Recognized by %product%
Apache Felix Framework Integrator
Creating Code Constructs by Live Templates
Auto-Completing Code
Dependencies Analysis
Analyzing Dependencies Using DSM
Analyzing Module Dependencies
Suppressing Inspections
Documenting Source Code in %product%
Creating and Editing Properties Files
Pinning and Unpinning Tabs
Finding Usages in Project
Running Applications
Creating Field Watchpoints
Stepping Through the Program
Choosing a Method to Step Into
Change Method Signature
Extract Parameter
Shelving Changes
Applying Patches
Creating Patches
Checking out (Switching Between Branches)
Interactive Rebase
Handling Modified Without Checkout Files
Configuring Format of the Local Working Copy
Integrating Changes To/From Feature Branches
ActionScript, Flex and AIR
Building ActionScript and Flex Applications
Testing Android Applications
Keyboard Shortcuts You Cannot Miss
Enabling JavaScript Unit Testing Support
Creating JavaScript Unit Tests
Supported Module Types
Enabling PHPUnit Support
Mapping to EJB
Mapping to Hibernate
Defining Mappings
Supported Languages
GUI Designer Output Options
Designing GUI. Major Steps
Creating Listeners

Go to Web help home page.