IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page new project from existing sources appears to be missing.

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

Project Tool Window
Accessing Project Settings
Accessing Project Structure
Project Structure Dialog
Creating New Project from Scratch
Maven Projects Tool Window
Opening Multiple Projects
Opening, Reopening and Closing Projects
New Project Wizard
Import Project from Existing Sources. Project Name and Location
Importing Project from Existing Source Code
New Project from Scratch. Project Name, Location and Format
Importing Adobe Flash Builder Projects
Creating Files from Templates
Configuring Project and Global Libraries
Importing Project from Gradle Model
New Project from Scratch. Android Page
New Project from Scratch. Flash Page
New Project from Scratch. Maven Page
New Project from Scratch. Technologies Page
New Project from Scratch. Sources Page
Database Tool Window
Importing Eclipse Project to %product%
New Project from Scratch. Grails Page
New Project from Scratch. Griffon Page
Import Project from Existing Sources. Source Roots Page
Import Project from Existing Sources. Module Structure Page
Sharing Android Source Code and Resources Using Library Projects
New Project from Scratch. Mobile SDK Specific Options Page
Import Project from Existing Sources. Libraries Page
New Project from Scratch. Maven Settings Page
Managing Your Project Favorites
Data Sources
Creating Project
Importing Project from Maven Model
Creating Modules
Accessing Default Project Settings and Structure
Git Branches in Multirooted Projects
Converting Project into Directory-Based Format
Configuring Global, Project and Module SDKs
Import Project from Existing Sources. Facets Page
Import Project from Existing Sources
New Servlet Dialog
Working With Legacy Projects
Excluding Files and Folders from Deployment
Sources Tab
Import Project from Gradle. Page 2
New Project from Scratch. SDK Page
Create Module from Existing Sources. Libraries Page
Create Module from Existing Sources. Module Structure Page
Create Module from Existing Sources. Source Roots Page
Enabling Spring Support
Import Project from Flash Builder. Page 1
New Key Store Dialog
Introduce Parameter in Java
Import Existing Sources. Project SDK
Project Library and Global Library Pages
Adding Build File to Project
Creating Google App Engine Project
Configuring Module Dependencies and Libraries
Configuring Project Compiler Output
Import Project from Maven. Page 1
Enabling JSF Support
Creating and Importing Data Sources
Create Module from Existing Sources
New Project from Scratch
Checking Out Files from CVS Repository
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Set Up a New Project
Preparing for ActionScript, Flex or AIR application development
Creating a Project for Plugin Development
Import Project from Eclipse. Page 1
Creating Grails Application from Existing Code
Import Project from Maven. Page 3
Checkout from TFS Wizard
Saving Project as Template
Populating Projects
Integrating Project
Generating a Signed APK Using a Wizard
Checking Out Files from Subversion Repository
Excluding Files from Project
Project. General Settings Page
Import Data Sources Dialog
Using Visual SourceSafe Integration
Import Project from Eclipse. Page 2
Import Project from Maven. Page 4
Linking Gradle Project
Import Project from Flash Builder. Page 2
Creating and Running Your First Java Application
Importing Project
New Filter Dialog
New Project. Main Settings
Import Project from Maven. Page 2
Project and IDE Settings
Change Method Signature in ActionScript
Exporting %product% Project to Eclipse
Creating Module from Existing Source Code
Import Project or Module Wizard
Using the AspectJ Compiler (ajc)
Play Framework
Import Project from Gradle. Page 1
Register New File Type Association Dialog
Share Project on GitHub Dialog
Check Out From Subversion Dialog
Update Project Dialog (Subversion)
Publishing a Project on GitHub
Path Variables
New Filter Dialog
Create Module from Scratch. Sources Page
New File Type
Enabling PHP support
Viewing Table Data from the Data Sources Tool Window
Creating Module from Scratch
Update Info Tab
Generate Java Code from WSDL or WADL Dialog
Generating JavaDoc Reference for a Project
Configuring Code Coverage Measurement
Setting Up a Local Mercurial Repository
Checking Out from TFS Repository
Configuring a DB Data Source
Binding a Form to an Existing Class
Configuring Project Settings
Code Inspection
Change Method Signature in Java
Associating a Project Root with Version Control System
Configuring JavaScript Libraries
Importing Existing Modules
What's New
New Action Dialog
Finding and Replacing Text in Project
Convert Project Dialog
Check Out From CVS Dialog
New Android Component Dialog
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Generate XML Schema From Java Using JAXB Dialog
Configuring CVS Roots
Downloading Libraries from Maven Repositories
Checkout from TFS Wizard: Checkout Mode
Dependencies Tab
New Listener Dialog
Introduce Property
Generate Java Code from XML Schema using XmlBeans Dialog
Pushing Changes to the Upstream (Git Push)
Generating Java Code from XML Schema
Configuring a DDL Data Source
Compiler: Flex Compiler
Creating Mobile Module
Project Settings
New Bean Dialogs
Generate WSDL from Java Dialog
Generate Java from Xml Schema using JAXB Dialog
Generate Instance Document from Schema Dialog
Generate Schema from Instance Document Dialog
Finding Usages in Project
Restoring a File from Local History
Creating a New Changelist
Integrating SVN Projects or Directories
Working with %product% Features from Command Line
Change Signature in JavaScript
Binding a Form to a New Class
Configuring Project Structure
Running Command Line Tool Commands
Building, Running and Debugging Flex Applications
Enabling Cucumber Support in Project
Checkout from TFS Wizard: Source Workspace
Visual SourceSafe Options Dialog
Running Injected SQL Statements from the Editor
New Changelist Dialog
New BMP Entity Bean Dialog
New CMP Entity Bean Dialog
Extract Delegate
Generating a Signed APK Through an Artifact
Extract Parameter in JavaScript
Compiler. Annotation Processors
Creating Copyright Profiles
JetGradle Tool Window
Configuring Content Roots
Project Settings
Excluding Classes from Auto-Import
Configuring Compiler Settings
Checking Perforce Project Status
Exporting Information From Subversion Repository
PHP-Specific Guidelines
Grouping Modules
Extract Interface
Extract Parameter Object
Accessing Data Sources via the Database Console
Managing Spring Configuration Files
Struts Data Sources
Import Project. Select Model
Checkout from TFS Wizard: Choose Source Path
Update Project Dialog (Perforce)
Running Inspections
Checking Git Project Status
Checking SVN Project Status
Viewing Merge Sources
Editing Maven Settings
Generating XML Schema From Instance Document
Using PHP Code Sniffer Tool
Enabling Phing Support
Add New Field or Constant
New Message Bean Dialog
Configuring Gradle Integration
Filtering Dependencies
Creating Run/Debug Configuration for Application Server
Generating Persistence Mappings
Deleting Node Elements from Diagram
Integrate Project Dialog (Subversion)
New Session Bean Dialog
Generate Signed APK Wizard. Specify Key and Keystore
Import Eclipse Workspace
Checkout from TFS Wizard: Choose Source and Destination Paths
Create New Constructor
Create New Method
Change Signature Dialogs
DB Data Source Properties
Update Project Dialog (Git)
DSM Analysis
Running Inspections Offline
Extract Field
Build Configuration
Enabling Android Support
Generating Xml Schema From Java Code
Navigating from .feature File to Step Definition
Generating WSDL Document from Java Code
Checkout from TFS Wizard: Source Server
Checkout from TFS Wizard: Summary
Create Jar from Modules Dialog
Import Module from External Model
Import Module from External Model. Select Model
Create Module from Scratch
Create Module from Scratch. Module Name, Location and Type
Import Project
Framework Integration
Creating and Managing Projects
Importing Existing Module
Designer Tool Window
Framework Definitions
Navigating from Stacktrace to Source Code
Making Project
Rebuilding Project
Annotation Processors Support
Navigating to Source Code from the Debug Tool Window
Extract Superclass
Deleting Files from the Repository
Fetching Changes from a Remote Git Repository
Cloning a Repository from GitHub
Creating a New Branch
Pulling Changes from the Upstream (Git Pull)
Pulling Changes from the Upstream (Pull)
Integrating Files and Changelists from the Changes Tool Window
Generating Instance Document From XML Schema
Comparing Data Sources
Running Cucumber Tests
Creating Node Elements and Members
Configuring Web Application Deployment
Welcome Screen
Libraries and Global Libraries
Inferring Nullity
Getting Local Working Copy of the Repository
Activating and Deactivating Maven Profiles
Editing Module with EJB Facet
Enabling JPA Support
Configuring Libraries of UI Components
Adding Node Elements to Diagram
Maven. Importing
IntelliLang Configuration
Changing Default Facet Settings
Changing the Settings for All Facets of the Same Type
Enabling and Configuring Perforce Integration
Managing Resources
Favorites Tool Window
Checkout Dialog
Configuring Folders Within a Content Root
Working with Tags and Branches
PHP Built-In Web Server
Edit Check-in Policies Dialog
Associating a Copyright Profile with a Scope
Extract Variable
Adding Files To a Local Mercurial Repository
Creating and Opening Forms
Extract Method Dialog
Configuring Copyright Profiles
Menus and Toolbars
Customizing Profiles
Configuring Inspection Severities
Importing a Local Directory to Subversion Repository
Working With Subversion Properties for Files and Directories
Creating CMP Bean Fields
Creating Elements in Persistence Units
Bound Class
Creating Step Definition
Add/Edit Palette Component
Creating Empty Files
Extract Constant
Copy and Paste Between %product% and Explorer/Finder
Adding Files to a Local Git Repository
Creating and Managing TFS Workspaces
TFS Check-in Policies
Creating Griffon Application Module
Creating Module with Groovy Support
Creating and Editing Faces Configuration
Compiler. Excludes
DDL Data Source Properties
Enable Version Control Integration Dialog
Configuring Auto-Detection of Facets
Generating and Updating Copyright Notice
Defining Scope-Profile Combination
Viewing Usages of a Symbol
Resolving Conflicts
Refreshing Status
Setting Up a Local Git Repository
Enabling Integration with an Issue Tracking System
Building ActionScript and Flex Applications
Creating Resources
JavaScript-Specific Guidelines
Adding a Struts Facet to a Module
Open Task Dialog
Extract Parameter Object Dialog
OSGi Facet Page
Output Layout Tab
Dependency Viewer
Apply Patch Dialog
%product% Tool Windows
Basic Code Completion. Completing Names and Keywords
Finding and Replacing Text in File
Configuring Ignored Files
Browsing CVS Repository
Creating Maven Run/Debug Configuration
Deploying PHP Applications
Using Phing
Creating a Server Configuration
Defining Mappings
Creating a Module with a Dedicated Struts Facet
Creating a Module with a Dedicated Struts 2 Facet
Adding GUI Components and Forms to the Palette
Directory-Based Versioning Model
Configuring Keyboard Shortcuts
Configuring Third-Party Tools
File Colors
Language Injections
Create Workspace
Generate Signed APK Wizard
Accessing DSM Analysis
Creating Own Inspections
Intention Actions
Configuring Encoding for Properties Files
Creating and Editing Search Templates
Viewing TODO Items
Generify Refactoring
Remove Middleman
Adding Files to Version Control
Creating Git Gists
Configuring Format of the Local Working Copy
Generating an Unsigned APK
Adding Data Structure Definition Files to a DDL Data Source
Enabling Hibernate Support
Managing File Sets
Wrap Return Value Dialog
Structural Search and Replace Dialogs
Creating and Registering File Types
Guided Tour Around %product% User Interface
Path Variables
Database Console Tool Window
Creating and Managing Modules
Git Push Dialog
Commit Changes Dialog
Apache Felix Framework Integrator
Creating Tapestry Pages, Componenets, and Mixins
Configuring Annotation Processing
Rename Refactorings
Updating Local Information
Browsing Changes
ActionScript, Flex and AIR
Creating Aspects
Enabling EJB Support
Introduce Parameter in Groovy
File Templates
Setting Text Properties
Specifying the Servlet Name and the Target Package
Defining the Filter Element
Enabling Web Service Development Support Through a Dedicated Facet
Class Filters Dialog
Unified Version Control Functionality
Replace Constructor with Builder Dialog
Configuring Colors and Fonts
Repository and Incoming Tabs
TODO Tool Window
Adding and Removing Facets
Iterating over an Array. Example of Applying Parameterized Live Templates
Processing Annotations
Replace Constructor with Builder
Enabling Version Control
Viewing File Status
Creating a Module with a GWT Facet
GWT Sample Application Overview
Referencing DTD or Schema
Writing and Executing SQL Commands in the Database Console
Comparing Deployed Files and Folders with Their Local Versions
Enabling Struts Support
Managing Struts 2 Elements
GUI Designer Output Options
Creating TestNG Test Classes
Viewing Changes as Diagram
Differences Viewer for Folders and DB Objects
Generate Skeleton PHPUnit Test Case Dialog
Encapsulate Fields Dialog
Extract Delegate Dialog
Local History
SQL Dialects
Live Templates
Android Facet Page
Changes Tool Window
Framework MVC Structure Tool Window
Deleting Modules
Wrap Tag
Configuring Artifacts
Run Configurations
Analyzing Backward Dependencies
Creating and Editing Properties Files
Navigating with Bookmarks
Toggling Writable Status
Importing a Local Directory to CVS Repository
Creating Android Application Components
Creating Maven Module
Associating Maven Goals with Keyboard Shortcuts
Configuring Mobile Java SDK
Configuring Include Paths
Using Framework Model View Controller
Plugin Development Guidelines
Customizing the Component Palette
Exposing Code as Web Service
Compilation Types
Groovy Page
Extract Constant Dialog
Run/Debug Configuration: JavaScript Debug
Run/Debug Configuration: Maven
Run/Debug Configuration: TestNG
Code Style. Java
Creating and Editing Live Templates
File Encodings
Language Injection Settings: Generic JavaScript
Version Control
External Tools
GWT Facet Page
JSF Facet Page
Cleaning System Cache
Import into CVS
Create Gist Dialog
Change EJB Classes Dialog
Choose Servlet Class
Managing Facets
Enabling Other Users to View Your Files
Merge Tags
Retaining Hierarchy Tabs
Using Language Injections
Defining TODO Patterns and Filters
Configuring Subversion Repository Location
Creating a Command Line Tool
Packaging AIR Applications
Introduce Parameter in ActionScript
Generating Ant Build File
Creating Grails Application Elements
Enabling Java EE Application Support
Generating Accessor Methods for Fields Bound to Data
Placing Non-Palette Components or Forms
Generate Ant Build
Extract Interface Dialog
Extract Superclass Dialog
Run/Debug Configuration: JUnit
Creating and Editing File Templates
Compiler. Java Compiler
GUI Designer
Hibernate and JPA Facet Pages
Web, EJB and Java EE Application Facet Pages
Compiler Options tab
Grails Tool Window
Phing Build Tool Window
Choose Class
Select Repository to Clone Dialog
Rebase Branches Dialog
Unshelve Changes Dialog
Wrap Tag Contents
External Annotations
Extracting Hard-Coded String Literals
Safe Delete
Creating Branches and Tags
Familiarize Yourself with IDE Navigation
Uploading and Downloading Files
Editing the Servlet Element
Developing RESTful Web Services
Copy Dialog
Extract Variable Dialog
Move Class Dialog
Importing %product% Settings on First Launch
Configuring Menus and Toolbars
Configuring Quick Lists
JavaScript. Libraries
JavaScript. Usage Scope
Ant Build Tool Window
Commander Tool Window
EJB Tool Window
Persistence Tool Window
Web Tool Window
Update Directory / Update File Dialog (CVS)
Stash Dialog
Accessing Module Settings
Create Patch Dialog
Usage Examples
Tapestry View
XPath Search
Analyzing Dependencies
Navigating Between IDE Components
Setting Configuration Options
Configuring Debugger Options
Starting the Debugger Session
Code Coverage
Change Class Signature
TODO Example
Convert to Instance Method
Extract Method
Move Refactorings
Push Members Down
Moving an Opened File to Another Changelist
Moving Items Between Changelists in the Changes Tool Window
Merging, Deleting, and Comparing Branches
Integrating Changes to Branch
Previewing Output of Layout Definition Files
Executing Maven Goal
Running Grails Targets
Analyzing GWT Compiled Output
Unit Testing Node.JS
PHP-Specific Command Line Tools
Enabling a Command Line Tool
Customizing Build Execution by Configuring Properties Externally
Configuring %product% Plugin SDK
Manipulating Table Data in the Table Editor
Defining Seam Navigation Rules
Configuring Static Content Resources
Supported Compilers
Add Module Wizard
Find and Replace in Path
Extract Parameter Dialog
Extract Parameter Dialog for Groovy
Run/Debug Configuration: Plugin
Settings Dialog
Add Server Dialog
Language Injection Settings Dialog: Java Parameter
Maven. Repositories
Template Data Languages
Web Contexts
Configuring Individual File Encoding
Macros Dialog
Specifying Template Data Languages for Templates
Enter Keyboard Shortcut Dialog
Enter Mouse Shortcut Dialog
Configuring Code Style
Copying Code Style Settings
Local Tab
Debug Tool Window. Watches
Struts Tab
Creating Java Module
Create Mercurial Repository Dialog
Navigation Bar
Create Android Virtual Device Dialog
Data Binding Wizard
Changing Facet Settings
%product% vs Eclipse Terminology
Delete Attribute
Unwrap Tag
Enabling Tapestry Support
Creating Packages
Completing Path
Dependencies Analysis
Analyzing Duplicates
Using External Annotations
Managing Bookmarks
Compiling Applications
Cutting, Copying and Pasting
Browsing Contents of the Repository
Shelving Changes
Using GitHub Integration
Viewing the GitHub Version of a File
Interactive Rebase
Cleaning Up Local Working Copy
Configuring HTTP Proxy
Using TFS Integration
Testing Flex and ActionScript Applications
Adding and Editing Layout Components Using Android UI Designer
Running and Debugging Android Applications
Choosing the Target Device Manually
Testing Android Applications
Creating a Library for aspectjrt.jar
Binding Macros With Keyboard Shortcuts
Creating Ant Build File
Executing Ant Target
Configuring Triggers for Maven Goals
Configuring Primary Key
Creating Local and Remote Interfaces
Creating Message Listeners
Defining Bean Class and Package
Creating Grails Application Module
Configuring Libraries and Dependencies in Grails Applications
Comparing Files
Configuring Groovy-Based Frameworks
Enabling GWT Support
Configuring Mobile-Specific Compiling Settings
Configuring JavaScript Debugger
Debugging JavaScript
Enabling JavaScript Unit Testing Support
Using JavaScript Code Quality Tools
Defining Navigation Rules
Validating Web Content Files
Configuring XDebug
Configuring Zend Debugger
Enabling PHPUnit Support
Generating PHPUnit Test Class
Monitoring Code Coverage for PHP Applications
Processing Order
Managing Phing Build Targets
Generating a Data Structure Definition (DDL) File
Mapping by Database Schema
Mapping to EJB
Mapping to Hibernate
Customizing Upload
Code Analysis
Enabling Struts 2 Support
Binding the Form and Components to Code
Creating Form Initialization Code
Creating .feature Files
Configuring Default Settings for Diagrams
Compiler and Builder
Temporary and Permanent Run/Debug Configurations
Bookmarks Dialog
Plugin Configuration Wizard
Change Signature Dialog for ActionScript
Change Signature Dialog for JavaScript
Extract Module Dialog
Type Migration Preview
Run/Debug Configuration: Applet
Run/Debug Configuration: XSLT
Select Path Dialog
Specify Inspection Scope Dialog
Code Style. HTML
Code Style Schemes
Add / Edit Color Label Dialog
Schemas and DTDs
Ignore Unversioned Files
Application Servers
Console Folding
Editor. Colors and Fonts
Edit Tool Dialog
File Templates
General tab
SDKs. Flexmojos SDK
Basic Editing
Griffon Tool Window
Hibernate Console Tool Window
JPA Console Tool Window
Phing Settings Dialog
Groovy Shell
Structure Tool Window
Struts Assistant Tool Window
History Tab
Tag Dialog
Authentication Required
Create Branch or Tag Dialog (Subversion)
Import into Subversion
SVN Repositories
Adding Frameworks Support
Import Database Schema / Import Mappings
Web Module Editor - General
Web Module Editor - Context Parameters
Class Diagram Toolbar and Context Menu
Form Workspace
%product% vs NetBeans Terminology
Regular Expression Syntax Reference
Scope Language Syntax Reference
Managing User Groups
Viewing Files Opened by Others
Set Up
XPath and XSLT Support
Feedback Page
Limiting DSM Scope
Analyzing Data Flow
Viewing Offline Inspections Results
Annotating Source Code
Internationalization and Localization Support
Editing Resource Bundle
Navigating with Navigation Bar
Structural Search and Replace
Reviewing Results
Using TODO
Adding, Editing and Removing Watches
Configuring Testing Libraries
Extract Method Object
Replace Constructor with Factory Method
Replace Inheritance with Delegation
Type Migration
Wrap Return Value
Using Local History
Putting Labels
Viewing Local History of a File or Folder
Viewing Recent Changes
Associating a Directory with a Specific Version Control System
Copying, Renaming and Moving Files
Applying Patches
Viewing Changes Made by Other Team Members
Using ClearCase Integration
Ignoring Files
Using CVS Watches
Using Git Integration
Registering GitHub Account in %product%
Using Mercurial Integration
Using Multiple Perforce Depots with P4CONFIG
Browsing Subversion Repository
Sharing Directory
Managing Tasks and Context
Updating a Command Line Tool
Reformatting Source Code
Increasing Memory Heap
Associating Ant Target with Keyboard Shortcut
Resolving Dependencies
Working in Offline Mode
Migrating to EJB 3.0
Generating Groovy Documentation
Launching Groovy Interactive Console
Creating a GWT Module
Generating DTD
Creating a List of Phing Build Files
Viewing PSI Structure
Relational Databases
Viewing Structure of a Database or Table
Viewing Query Results
Using JPA Console
Using Hibernate Console
Viewing Seam Components
Working with Spring Roo Console
Adding a Struts 2 Facet to a Module
GUI Designer Files
Populating Your GUI Form
Duplicating Components
Morphing Components
Enabling Web Application Support
Populating Web Module
Run/Debug Configuration
Build File Properties
I18nize Hard-Coded String
Extract Field Dialog
Extract Parameter Dialog for JavaScript
Extract Property Dialog
Run/Debug Configuration: Grails
Run/Debug Configuration: Node JS
Run/Debug Configuration: PHPUnit
Show History for File / Selection Dialog
Copyright Profiles
Deployment: Connection Tab
Issue Navigation
Editor. Smart Keys
File Types
OSGi: Framework Definitions
Library Bundling
AspectJ Facet Page
Tool Windows Reference
Customize Data Views
DSM Tool Window
REST Client Tool Window
Unstash Changes Dialog
Shelve Changes Dialog
EJB Relationship Properties
Choose Servlet Package
Web Module Editor - Servlet Initialization Parameters
Components Treeview
General Usage
Replace Attribute With Tag
Replace Tag With Attribute
Add Attribute
Add Subtag
Move Attribute In
Move Attribute Out
Change Attribute Value
Convert Contents To Attribute
Delete Tag
How It Works
Knopflerfish Framework Integrator
XPath Expression Evaluation
File Associations
Generating Delegation Methods
Opening and Reopening Files in the Editor
Creating and Editing Flex Application Elements
Refactoring Android XML Layout Files
Developing GWT Components
Content Root
PHP Debugging Session
Working with Diagrams
Configure Library Dialog
Create Test
Differences Viewer
Downloading Options dialog
Generate Groovy Documentation Dialog
Generate JavaDoc Dialog
Optimize Imports Dialog
Convert Anonymous to Inner Dialog
Extract Variable Dialog for SASS
Rename Dialogs
Run/Debug Configuration: Flash Remote Debug
Run/Debug Configuration: Google AppEngine Dev Server
Run/Debug Configuration: J2ME
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: OSGi Bundles
Run/Debug Configuration: PHP Built-in Web Server
Code Style. XML
Deployment: Mappings Tab
Skipped Paths
Skeleton Generator
Changelist Conflicts
Manage TFS Servers and Workspaces
XSLT File Associations
Framework Settings
Debugger. Data Views
Debugger. Data Type Renderers
Master Password / Reset Master Password Dialog
Paths Tab
Optional MIDP Settings Dialog
Google App Engine Facet Page
Dependencies tab
Pre-Processing Tab
Running and Debugging
Navigation In Source Code
Android Tool Window
JSTestDriver Server Tool Window
Play Framework (Play Console)
Thumbnails Tool Window
Push Rejected Dialog (Git)
Subversion Working Copies Information Tab
Revert Changes Dialog
Apply EJB 3.0 Style
EJB Module Editor - General
EJB Module Editor - EJB Relationships
Configuring Module Roots
Faces Config Structure - Managed Beans
Status Bar
Table Editor
Edit Android Platform Dialog
Select Android Virtual Device Dialog
Diagram Toolbar and Context Menu
Components Properties
File Types Recognized by %product%
Analyzing Module Dependencies
Viewing Reference Information
Resource Bundle
Navigating to Class, File or Symbol by Name
Searching Through the Source Code
Monitoring the Debug Information
Creating Run/Debug Configuration for Tests
Using Help Topics
Stashing and Unstashing Changes
Creating an Android Run/Debug Configuration
Working with Application Servers
Keyboard Shortcuts You Cannot Miss
Supported Module Types
Defining Pageflow
File Template Variables
Viewing Class Hierarchy as a Class Diagram
Groups of Live Templates
Register %product%
Choose Local Paths to Upload Dialog
Types of Breakpoints
Export to HTML
Find Usages
Find Usages. Class Options
Find Usages. Method Options
Find Usages. Package Options
Find Usages. Throw Options
Find Usages. Variable Options
Supported Version Control Systems
Override Server Path Mappings Dialog
Extract Parameter Dialog for ActionScript
Inline Dialogs
Move Package Dialog
Move Inner to Upper Level Dialog for ActionScript
Move File Dialog
Package and Class Migration Dialog
Replace Inheritance with Delegation Dialog
Safe Delete Dialog
Run/Debug Configurations
Run/Debug Configuration: Android Application
Run/Debug Configuration: Android Test
Run/Debug Configuration: NodeUnit
Run/Debug Configuration: PHP Script
Run/Debug Configuration: PHPUnit on Server
Run/Debug Configuration: Query Language Console
Type Migration Dialog
Compiler: Android DX Compiler
Compiler. Validation
File Types
Maven. Runner
Edit Subversion Options Related to Network Layers Dialog
Debugger. HotSwap
Editor. Editor Tabs
Output Filters Dialog
Menus and Toolbars
Change Master Password Dialog
Custom Plugin Repositories Dialog
Quick Lists
Module Page
Facet Page
Spring Facet Page
Edit Application Context Dialog
Struts 2 Facet Page
Module Page for a Flash Module
Build Configuration page for a Flash module
SDKs. Java
SDKs. %product%
SDKs. Mobile
Function Keys
Navigation Between Bookmarks
Log Tab
Database Console Properties Dialog
Debug Tool Window
Debug Tool Window. Variables
Hibernate Console Properties Dialog
Hierarchy Tool Window
IDETalk Options Dialog
Inspection Tool Window
Java EE: App Tool Window
JPA Console Properties Dialog
Module Dependencies Tool Window
Remote Host Tool Window
Roo Console Tool Window
Test Runner Tab
Tiles Tab
CVS Roots Dialog
Clone Repository Dialog
Clone Mercurial Repository Dialog
Integrate to Branch
Lock File Dialog (Subversion)
Select Branch
File Status Highlights
EJB Module Editor - Method Permissions
EJB Editor - General Tab - Entity Bean
Generate GWT Compile Report Dialog
Faces Config Structure
Faces Config Structure - Navigation Rule
Web Module Editor - Filter Mappings
Web Module Editor - Servlet Mappings
Choose Device Dialog
Documenting Source Code in %product%
Creating Documentation Comments
Viewing Definition
Viewing Method Parameter Information
Packaging a Module into a JAR File
Creating and Editing Run/Debug Configurations
Running Applications
Performing Tests
Refactoring Source Code
Change Method Signature
Extract Parameter
Configuring VCS-Specific Settings
Handling Differences
Comparing File Versions
Viewing Changes Information
Configuring Subversion Branches
Resolving Text Conflicts
Working with Maven Dependencies
Object-Relational Mapping (EJB, Hibernate and JPA)
Creating JavaScript Unit Tests
Running JavaScript Unit Tests in Browser
Monitoring Code Coverage for JavaScript
Creating a PHP Web Application Debug Configuration
Creating and Editing Relationships
Creating Hibernate Elements in a Session Factory
Remote Hosts
Accessing Files on Remote Hosts
Managing Struts Elements
Designing GUI. Major Steps

Go to Web help home page.