IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page new project from existing sources project name and location 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
Maven Projects Tool Window
Project
Opening Multiple Projects
Creating New Project from Scratch
Opening, Reopening and Closing Projects
Importing Adobe Flash Builder Projects
New Project from Scratch. Project Name, Location and Format
Import Project from Existing Sources. Project Name and Location
New Project Wizard
Configuring Project and Global Libraries
Rename Refactorings
New Project from Scratch. Android Page
Importing Project from Existing Source Code
Sharing Android Source Code and Resources Using Library Projects
Importing Project from Gradle Model
Accessing Default Project Settings and Structure
Importing Eclipse Project to %product%
Project Library and Global Library Pages
Creating Files from Templates
Git Branches in Multirooted Projects
Configuring Module Dependencies and Libraries
Managing Your Project Favorites
New Project from Scratch. Flash Page
Editor. Colors and Fonts
Converting Project into Directory-Based Format
Configuring Global, Project and Module SDKs
Creating Project
New Project from Scratch. Technologies Page
New Project from Scratch. Maven Page
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Working With Legacy Projects
Node.js
Importing Project from Maven Model
Import Project from Gradle. Page 2
New Project from Scratch. Mobile SDK Specific Options Page
New Project from Scratch. Sources Page
Adding Build File to Project
Creating Google App Engine Project
Configuring Project Compiler Output
Excluding Files and Folders from Deployment
New Project from Scratch. Grails Page
New Project from Scratch. Griffon Page
Import Project from Existing Sources. Module Structure Page
Import Project from Existing Sources. Libraries Page
New Project from Scratch. Maven Settings Page
Enabling Android Support
Creating and Running Your First Java Application
Android Facet Page
Project and IDE Settings
Import Project from Existing Sources. Source Roots Page
Creating a Project for Plugin Development
Finding and Replacing Text in Project
Import Project from Flash Builder. Page 1
Integrating Project
Scope
Project. General Settings Page
Import Project from Existing Sources. Facets Page
Database Tool Window
Populating Projects
Manage TFS Servers and Workspaces
Data Sources
Markup Languages and Style Sheets
Configuring Subversion Repository Location
Saving Project as Template
Import Project from Maven. Page 1
Import Project from Eclipse. Page 1
Linking Gradle Project
Import Project from Existing Sources
Enabling Spring Support
Creating and Editing Run/Debug Configurations
New Project from Scratch. SDK Page
Enabling JSF Support
Exporting %product% Project to Eclipse
Path Variables
Using the AspectJ Compiler (ajc)
Preparing for ActionScript, Flex or AIR application development
Maven
Update Project Dialog (Subversion)
Android Tab
Set Up a New Project
Creating Modules
Import Project from Maven. Page 3
Import Project from Maven. Page 4
Importing Project
Excluding Files from Project
Adding and Editing Layout Components Using Android UI Designer
New Project. Main Settings
Import Existing Sources. Project SDK
Play Framework
Import Project from Eclipse. Page 2
Setting Up a Local Mercurial Repository
Creating and Importing Data Sources
Import Project from Flash Builder. Page 2
Enabling and Disabling Plugins
Share Project on GitHub Dialog
New Servlet Dialog
Create Module from Existing Sources. Libraries Page
Create Module from Existing Sources. Module Structure Page
IntelliLang Configuration
Generating a Signed APK Using a Wizard
Create Module from Scratch. Module Name, Location and Type
New Project from Scratch
Sources Tab
Publishing a Project on GitHub
Update Info Tab
Basic Code Completion. Completing Names and Keywords
Generating JavaDoc Reference for a Project
Configuring JavaScript Libraries
Configuring Project Settings
Navigating to Class, File or Symbol by Name
Associating a Project Root with Version Control System
Create Module from Existing Sources. Source Roots Page
Import Project from Maven. Page 2
Enabling PHP support
Checking Out Files from Subversion Repository
Import Project or Module Wizard
Checking Out Files from CVS Repository
Select Repository Location Dialog (Subversion)
New Android Component Dialog
Creating and Registering File Types
Build Configuration
Creating Tapestry Pages, Componenets, and Mixins
Code Inspection
Change Method Signature in ActionScript
Creating Grails Application from Existing Code
Import Project from Gradle. Page 1
Convert Project Dialog
New Key Store Dialog
Structural Search and Replace
Introduce Parameter in Java
Comparing Deployed Files and Folders with Their Local Versions
Check Out From Subversion Dialog
Testing Flex and ActionScript Applications
Import Data Sources Dialog
Finding and Replacing Text in File
Configuring Annotation Processing
Checkout from TFS Wizard: Choose Source and Destination Paths
Create Module from Existing Sources
Creating and Managing Projects
Menus and Toolbars
Integrating SVN Projects or Directories
Running and Debugging Android Applications
Project Settings
Finding Usages in Project
Configuring Gradle Integration
Adding and Removing Facets
Commenting and Uncommenting Blocks of Code
Installing, Updating and Uninstalling Repository Plugins
Deploying and Running
Configuring a DB Data Source
Differences Viewer for Folders and DB Objects
Android Tool Window
Configuring Project Structure
Designer Tool Window
Creating and Managing TFS Workspaces
Using Visual SourceSafe Integration
Creating Local and Remote Interfaces
Checkout from TFS Wizard
Compiler: Flex Compiler
Introduce Property
Enabling and Configuring Perforce Integration
Creating Mobile Module
Enabling Cucumber Support in Project
Libraries and Global Libraries
Change Method Signature in Java
Specifying the Servlet Name and the Target Package
Select Android Virtual Device Dialog
Project Settings
Activating and Deactivating Maven Profiles
New Filter Dialog
Generate Signed APK Wizard. Specify Key and Keystore
SDK
Available Facets and Their Dependencies
New Filter Dialog
Configuring Menus and Toolbars
Checking Out from TFS Repository
Generating Instance Document From XML Schema
Configuring Compiler Settings
Pushing Changes to the Upstream (Git Push)
Checking Perforce Project Status
Running Command Line Tool Commands
OSGi
Filters and Ordering Dialog
Edit Android Platform Dialog
Generating XML Schema From Instance Document
Copy and Paste Between %product% and Explorer/Finder
Navigating Between Test and Test Subject
Pausing and Resuming the Debugger Session
Language and Framework-Specific Guidelines
Building, Running and Debugging Flex Applications
Rename Dialogs
JetGradle Tool Window
Update Project Dialog (Perforce)
Configuring Content Roots
Framework Definitions
Running Inspections
Checking Git Project Status
Checking SVN Project Status
ActionScript, Flex and AIR
Downloading Libraries from Maven Repositories
Using PHP Code Sniffer Tool
Enabling Phing Support
What's New
Generating and Updating Copyright Notice
Completing Tag Names
Configuring Ignored Files
Creating Android Application Components
Generating Signed and Unsigned Android Application Packages
Change Signature in JavaScript
Run/Debug Configuration: Android Application
Dependencies Tab
Annotation Processors Support
Filtering Dependencies
Extract Variable in JavaScript
Extract Variable for SASS
Structural Search and Replace Dialogs
Framework Integration
Creating Copyright Profiles
Creating Module from Existing Source Code
Generate Java Code from WSDL or WADL Dialog
Testing Android Applications
Binding a Form to an Existing Class
Import Project. Select Model
Integrate Project Dialog (Subversion)
New BMP Entity Bean Dialog
New CMP Entity Bean Dialog
Import Eclipse Workspace
Reviewing Compilation and Build Results
Configuring Code Coverage Measurement
Android
Editing Maven Settings
Running Cucumber Tests
Creating Node Elements and Members
Configuring Web Application Deployment
Register New File Type Association Dialog
Check Out From CVS Dialog
Diagram Toolbar and Context Menu
Creating Resources
Running and Debugging Node.js
Run/Debug Configuration: Android Test
Creating and Editing File Templates
New File Type
Favorites Tool Window
Update Project Dialog (Git)
DSM Analysis
Opening and Reopening Files in the Editor
Running Inspections Offline
Managing Tasks and Context
Building ActionScript and Flex Applications
Generating a Signed APK Through an Artifact
Generating Java Code from XML Schema
PHP-Specific Guidelines
Code Style. Java
Output Layout Tab
Repository and Incoming Tabs
Importing Existing Modules
Creating and Editing Search Templates
Configuring CVS Roots
Working with Tags and Branches
Working With Subversion Properties for Files and Directories
New Action Dialog
Create Module from Scratch. Sources Page
Import Project
Compiler: Android DX Compiler
Maven
Creating Module from Scratch
Settings
Making Project
Rebuilding Project
Integrating Files and Changelists from the Changes Tool Window
Viewing Table Data from the Data Sources Tool Window
Viewing Siblings and Children
Viewing Ancestors, Descendants, and Usages
Running and Debugging
Inline Android Style Dialog
Unwrapping and Removing Statements
Excluding Classes from Auto-Import
Using Change Markers to View and Navigate Through Changes in the Editor
Defining Bean Class and Package
Creating and Editing Faces Configuration
Compiler. Annotation Processors
Grouping Modules
Visual SourceSafe Options Dialog
Generate Instance Document from Schema Dialog
Create Android Virtual Device Dialog
Structural Search and Replace Examples
Extract Delegate
Extract Variable
Creating Branches and Tags
Configuring Libraries of UI Components
Creating and Editing Live Templates
Schemas and DTDs
DB Data Source Properties
Managing Resources
Refactoring Android XML Layout Files
Creating and Opening Forms
SourceSafe
Creating an Android Run/Debug Configuration
Library
Adding GUI Components and Forms to the Palette
Creating and Managing Modules
Rename Servlet
Generate WSDL from Java Dialog
Generate XML Schema From Java Using JAXB Dialog
Generate Schema from Instance Document Dialog
Checkout from TFS Wizard: Checkout Mode
Configuring Colors and Fonts
Web, EJB and Java EE Application Facet Pages
New Listener Dialog
%product% Tool Windows
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Creating Event and Event Handler Classes
Creating Run/Debug Configuration for Application Server
PHP Built-In Web Server
Configuring a DDL Data Source
Edit Check-in Policies Dialog
Configuring Folders Within a Content Root
New Message Bean Dialog
XPath and XSLT Support
Writing and Executing SQL Commands in the Database Console
Enabling Web Service Development Support Through a Dedicated Facet
Generate Java Code from XML Schema using XmlBeans Dialog
Generate Signed APK Wizard
Stashing and Unstashing Changes
Artifact
Creating and Deleting Web Application Elements - General Steps
Generating WSDL Document from Java Code
Find and Replace in Path
Maven. Importing
Associating a Copyright Profile with a Scope
Internationalization and Localization Support
Defining TODO Patterns and Filters
Copying, Renaming and Moving Files
Importing a Local Directory to Subversion Repository
Directory-Based Versioning Model
Package and Class Migration Dialog
Menus and Toolbars
Welcome Screen
Migrate
Applying Patches
Adding Files To a Local Mercurial Repository
Escaping Characters in Velocity Variables and Directives
Exporting and Importing Settings
Hibernate and JPA Facet Pages
New Bean Dialogs
New Session Bean Dialog
Generate Java from Xml Schema using JAXB Dialog
Viewing Structure and Hierarchy of the Source Code
@Nullable and @NotNull Annotations
Creating and Editing Properties Files
Splitting and Unsplitting Editor Window
Extract Interface
Restoring a File from Local History
Cutting, Copying and Pasting
Getting Local Working Copy of the Repository
Creating a New Changelist
Undoing and Redoing Changes
Creating a New Branch
Folding and Expanding Code Blocks
Configuring Libraries and Dependencies in Grails Applications
Creating Modules with Groovy and Groovy-Based Frameworks Support
Running and Debugging Groovy Scripts
Working with %product% Features from Command Line
Running and Debugging Plugins
Running Injected SQL Statements from the Editor
Managing Spring Configuration Files
Binding a Form to a New Class
Class Filters Dialog
Modules
New Changelist Dialog
Rename Entity Bean
Run Configurations
Inferring Nullity
Viewing Current Caret Location
Working with Annotations
TFS Check-in Policies
Creating Maven Run/Debug Configuration
Accessing Data Sources via the Database Console
Uploading and Downloading Files
Managing File Sets
Compiler and Builder
Temporary and Permanent Run/Debug Configurations
Checkout from TFS Wizard: Source Workspace
Generate Skeleton PHPUnit Test Case Dialog
Structural Search and Replace. Edit Variable Dialog
Adding, Editing and Removing Watches
Adding Files to a Local Git Repository
Generating Xml Schema From Java Code
Enabling Web Service Client Development Support Through a Dedicated Facet
Configuring Copyright Profiles
Enable Version Control Integration Dialog
Configuring Auto-Detection of Facets
Generating Getters and Setters
Viewing Usages of a Symbol
Extract Superclass
Extract Field
Generating an Unsigned APK
JavaScript-Specific Guidelines
Extract Parameter in JavaScript
Spring
Creating Step Definition
Copyright
OSGi Facet Page
Choose Servlet Class
Class Diagram Toolbar and Context Menu
XPath Expression Evaluation
File Associations
Merging, Deleting, and Comparing Branches
Exporting Information From Subversion Repository
Add New Field or Constant
Create New Method
Change Signature Dialogs
Run/Debug Configuration: Flash App
Generate Signed APK Wizard. Specify APK Location
Customizing Profiles
Configuring Inspection Severities
Saving and Reverting Changes
Monitoring and Managing Tests
Extract Parameter Object
Debugging with Logcat
Creating Grails Views and Actions
Working with Lists and Maps
Referencing DTD or Schema
Using Phing
Struts Data Sources
Binding the Form and Components to Code
Simple, Parameterized and Surround Live Templates
Deleting Node Elements from Diagram
Checkout from TFS Wizard: Choose Source Path
Checkout from TFS Wizard: Summary
Breakpoints Icons and Statuses
Unified Version Control Functionality
Replace Constructor with Builder Dialog
Run/Debug Configuration: TestNG
General
Edit Template Variables Dialog
Running and Debugging
Android Layout Preview Tool Window
Choose Class
SVN Repositories
Iterating over an Array. Example of Applying Parameterized Live Templates
Running Inspection by Name
Setting Up a Local Git Repository
Viewing Merge Sources
Designing Layout of Android Application
ColdFusion
Enabling a Command Line Tool
Enabling JPA Support
Defining Mappings
Adding Node Elements to Diagram
Create New Constructor
Open Task Dialog
Extract Method Dialog
Scopes
Changing Default Facet Settings
Changing the Settings for All Facets of the Same Type
Configuring Artifacts: Layout Structure
Accessing DSM Analysis
Configuring Encoding for Properties Files
Viewing TODO Items
Extract Constant
Remove Middleman
Resolving Conflicts
Refreshing Status
Viewing File Status
Enabling Integration with an Issue Tracking System
Creating and Editing Flex Application Elements
Creating Aspects
Generating Persistence Mappings
Bound Class
Compiler. Excludes
Guided Tour Around %product% User Interface
Defining Scope-Profile Combination
Navigating Between Methods and Tags
Attaching and Detaching Perforce Jobs to Changelists
Manipulating Table Data in the Table Editor
Setting Text Properties
Create Jar from Modules Dialog
Wrap Return Value Dialog
Run/Debug Configuration: JUnit
GWT Facet Page
Dependency Viewer
Import into CVS
Import into Subversion
Apply Patch Dialog
Change EJB Classes Dialog
Navigating with Bookmarks
Joining Lines and Literals
Updating Local Information
Browsing Changes
Locking and Unlocking Files and Folders
Creating CMP Bean Fields
Navigating Between Actions and Views
Object-Relational Mapping (EJB, Hibernate and JPA)
Deploying PHP Applications
Creating and Editing Relationships
Customizing Upload
Navigating from .feature File to Step Definition
Creating and Configuring Web Application Elements
Checkout from TFS Wizard: Source Server
Generate equals() and hashCode() wizard
Local, Repository, and Incoming Changes
Import Module from External Model
Import Module from External Model. Select Model
Create Module from Scratch
Creating and Editing Template Variables
Path Variables
Compiler Options tab
Android tab
Keyboard Shortcuts and Mouse Reference
Insert, Delete and Navigation Keys
IDEtalk and IDEtalk Messages Tool Windows
Importing Existing Module
Checkout Dialog
Commit Changes Dialog
Android Reference
Add/Edit Palette Component
Finding and Adding Users
Viewing Differences Between the Local and Remote Files
Refactoring
Generating equals() and hashCode()
Creating and Optimizing Imports
Navigating Between Files and Tool Windows
Navigating from Stacktrace to Source Code
Pinning and Unpinning Tabs
Structural Search and Replace - General Procedure
Creating and Saving Temporary Run/Debug Configurations
Creating Folders and Grouping Run/Debug Configurations
Stopping and Pausing Applications
Enabling, Disabling and Removing Breakpoints
Setting Labels to Variables, Objects and Watches
Navigating to Source Code from the Debug Tool Window
Viewing and Exploring Test Results
Deleting Files from the Repository
Adding, Deleting and Moving Lines
Shelving and Unshelving Changes
Filtering Out and Removing Unshelved Changes
Browsing CVS Repository
Fetching Changes from a Remote Git Repository
Cloning a Repository from GitHub
Pulling Changes from the Upstream (Git Pull)
Pulling Changes from the Upstream (Pull)
Showing Revision Graph and Time-Lapse View
Folding and Expanding Custom Blocks
Viewing and Fast Processing of Changelists
Viewing and Managing Integration Status
Creating and Deleting Tasks
Saving and Clearing Contexts
Creating and Editing Assembly Descriptors
Selecting Files and Folders
Compare Files and Folders
Creating and Editing Relationships Between Domain Classes
Running and Debugging Grails Applications
Creating Groovy Classes, Interfaces, Enumerations and Annotations
Creating Groovy Tests and Navigating to Tests
Configuring and Managing Application Server Integration
Reporting Issues and Sharing Your Feedback
Comparing Data Sources
Creating Elements in Persistence Units
Navigating Between an Observer and an Event
File Template Variables
Creating and Disposing of a Form's Runtime Frame
Grouping and Ungrouping Components
Placing Non-Palette Components or Forms
Exposing Code as Web Service
Extract Parameter Object Dialog
Configuring Third-Party Tools
Language Injection Settings Dialog: XML Attribute
External Tools
Phing Build Tool Window
TODO Tool Window
Scope Language Syntax Reference
Apache Felix Framework Integrator
Creating Empty Files
Processing Annotations
Safe Delete
Enabling Version Control
Editing Module with EJB Facet
Creating Griffon Application Module
Creating Module with Groovy Support
Using Distributed Configuration Files (.htaccess)
Mapping by Database Schema
Managing Struts 2 Elements
GUI Designer Output Options
Run/Debug Configuration: Maven
File Colors
General tab
Git Push Dialog
Create Branch or Tag Dialog (Subversion)
Configuring Format of the Local Working Copy
Viewing Changes as Diagram
Local History
Run/Debug Configuration: Applet
Language Injections
SQL Dialects
Servers
Changes Tool Window
Framework MVC Structure Tool Window
Deleting Modules
Faces Config Structure - Component
Usage Examples
Delete Attribute
Move Attribute In
Wrap Tag
Configuring Artifacts
Analyzing Backward Dependencies
Creating Own Inspections
Toggling Writable Status
Setting Configuration Options
Importing a Local Directory to CVS Repository
Creating Git Gists
Previewing Output of Layout Definition Files
Creating Maven Module
Associating Maven Goals with Keyboard Shortcuts
Configuring Mobile Java SDK
Unit Testing Node.JS
Configuring Include Paths
Using Framework Model View Controller
File Templates
Customizing the Component Palette
Configuring Static Content Resources
Breakpoints
Changelist
Version Control
Facets
Select Repository to Clone Dialog
Creating Imports
External Annotations
Enabling EJB Support
Adding Data Structure Definition Files to a DDL Data Source
Compilation Types
Extract Constant Dialog
Extract Delegate Dialog
File Encodings
StarTeam
Create Workspace
JSF Facet Page
DDL Data Source Properties
Cleaning System Cache
EJB Editor - Assembly Descriptor
Palette
Enabling Other Users to View Your Files
Completion
Analyzing Duplicates
Adding Files to Version Control
Using Git Integration
Creating a Command Line Tool
AspectJ
Generating Ant Build File
Configuring XDebug
Extract Interface Dialog
Extract Superclass Dialog
Configuring Keyboard Shortcuts
Run/Debug Configuration: PHPUnit
Ignore Unversioned Files
Perforce
Struts Tab
Components Properties
Navigating Between Editor Tabs
Creating a Module with a GWT Facet
GWT Sample Application Overview
Debugging JavaScript
Mapping to EJB
Mapping to Hibernate
Creating TestNG Test Classes
Defining the Filter Element
Adding WS Libraries to a Web Service Client Module Manually
Adding WS Libraries to a Web Service Module Manually
Encapsulate Fields Dialog
Run/Debug Configuration: JavaScript Debug
Select Path Dialog
Compiler. Java Compiler
Copyright Profiles
Edit Tool Dialog
Paths Tab
Grails Tool Window
%product% vs Eclipse Terminology
Replace Attribute With Tag
Replace Tag With Attribute
Add Attribute
Add Subtag
Move Attribute Out
Change Attribute Value
Delete Tag
Unwrap Tag
Wrap Tag Contents
Using Language Injections
Creating Tests
Copy
Ant
Gradle
Familiarize Yourself with IDE Navigation
Creating Grails Application Elements
Validating Web Content Files
Plugin Development Guidelines
Using JPA Console
Using Hibernate Console
Creating a Server Configuration
Adding a Struts Facet to a Module
Register %product%
Generate Ant Build
Run/Debug Configuration: PHPUnit on Server
Deployment: Connection Tab
Inspections
Language Injection Settings Dialog: Java Parameter
Git
Live Templates
Ctrl
Database Console Tool Window
Authentication Required
Create AIR Application Descriptor Dialog
Intention Actions
Extracting Hard-Coded String Literals
Creating a Module with a Dedicated Struts Facet
Creating a Module with a Dedicated Struts 2 Facet
Editing the Servlet Element
Add Module. Main Settings
Plugin Configuration Wizard
Move Class Dialog
Run/Debug Configuration: XSLT
Compiler
JavaScript. Libraries
JavaScript. Usage Scope
Language Injection Settings Dialog: XML Tag
Language Injection Settings: Generic JavaScript
ClearCase
TFS
Plugins
Artifacts
SDKs
Ant Build Tool Window
Commander Tool Window
Logs Tab
Accessing Module Settings
Faces Config Structure - Converter
Faces Config Structure - Managed Beans
Managing Facets
%product% vs NetBeans Terminology
Managing User Groups
Merge Tags
Tapestry View
Error Highlighting
Navigation
Analyzing Dependencies
Analyzing Data Flow
Editing Resource Bundle
Navigating Between IDE Components
Configuring Debugger Options
Change Class Signature
TODO Example
Convert to Instance Method
Extract Method
Generify Refactoring
Moving an Opened File to Another Changelist
Moving Items Between Changelists in the Changes Tool Window
Using Drag-and-Drop in the Editor
Using Mercurial Integration
Using Multiple Perforce Depots with P4CONFIG
Browsing Subversion Repository
Packaging AIR Applications
Executing Maven Goal
Eclipse
EJB
Creating Transfer Objects
Running Grails Targets
Customizing Build Execution by Configuring Properties Externally
Configuring %product% Plugin SDK
Enabling Hibernate Support
Defining Seam Navigation Rules
Generating Accessor Methods for Fields Bound to Data
Supported Compilers
PHP
Interpreters
Subversion
File Templates
Module Page for a Flash Module
Basic Editing
EJB Tool Window
Persistence Tool Window
Phing Settings Dialog
Web Tool Window
CVS Roots Dialog
Faces Config Structure
Spellchecking
Introduce Parameter in Groovy
Servlets
I18nize Hard-Coded String
Copy Dialog
Importing %product% Settings on First Launch
Run/Debug Configuration: Plugin
Settings Dialog
GUI Designer
JavaScript
Phing
Template Data Languages
Mercurial
Web Contexts
Configuring Individual File Encoding
Macros Dialog
Specifying Template Data Languages for Templates
Configuring Code Style
Copying Code Style Settings
Debug Tool Window. Watches
Test Runner Tab
Create Mercurial Repository Dialog
Navigation Bar
Create Patch Dialog
Import Database Schema / Import Mappings
Changing Facet Settings
Overview
Convert Contents To Attribute
Dependencies Analysis
Using External Annotations
Managing Bookmarks
Compiling Applications
Code Coverage
Move Refactorings
Replace Constructor with Builder
Browsing Contents of the Repository
Shelving Changes
Using GitHub Integration
Viewing the GitHub Version of a File
Cleaning Up Local Working Copy
Configuring HTTP Proxy
Configuring Subversion Branches
Using TFS Integration
Creating a Library for aspectjrt.jar
Creating Ant Build File
Executing Ant Target
Configuring Triggers for Maven Goals
Creating EJB
Grails
Creating Grails Application Module
Comparing Files
J2ME
Configuring Mobile-Specific Compiling Settings
Configuring JavaScript Debugger
Enabling JavaScript Unit Testing Support
Using JavaScript Code Quality Tools
Defining Navigation Rules
Configuring Zend Debugger
PHP Debugging Session
Generating PHPUnit Test Class
Dependencies
Monitoring Code Coverage for PHP Applications
Analyzing XDebug Profiling Data
Analyzing Zend Debugger Profiling Data
Managing Phing Build Targets
Generating a Data Structure Definition (DDL) File
Enabling Struts Support
Code Analysis
Configure Library Dialog
Downloading Options dialog
Change Signature Dialog for ActionScript
Change Signature Dialog for JavaScript
Move Inner to Upper Level Dialog for ActionScript
Run/Debug Configuration: Node JS
Run/Debug Configuration: OSGi Bundles
Maven. Repositories
Application Servers
Debugger. Data Type Renderers
Diagrams
Tag Dialog
Unshelve Changes Dialog
EJB Relationship Properties
XPath Search
Starting the Debugger Session
Defining the Servlet Element
Defining the Filter Mapping Element
Groovy Page
Bookmarks Dialog
Extract Module Dialog
Extract Variable Dialog
Run/Debug Configuration: J2ME
Show History for File / Selection Dialog
Specify Inspection Scope Dialog
Advanced
VCSs
CVS
XSLT File Associations
SDKs. Flexmojos SDK
Griffon Tool Window
Hibernate Console Tool Window
JPA Console Tool Window
Groovy Shell
Structure Tool Window
Struts Assistant Tool Window
Thumbnails Tool Window
History Tab
Update Directory / Update File Dialog (CVS)
Create Gist Dialog
Faces Config Structure - Validator
Resource References
Create HTML Wrapper for Flex Application Dialog
Package AIR Application Dialog
Data Binding Wizard
File Types Recognized by %product%
IDEtalk
Viewing Files Opened by Others
Set Up
Tapestry
Tapestry Tool Window
XPath Expression Generation
Retaining Hierarchy Tabs
Viewing Offline Inspections Results
Navigating to Declaration or Type Declaration of a Symbol
Navigating with Navigation Bar
Search Templates
Reviewing Results
Using TODO
Configuring Testing Libraries
Type Migration
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
Using ClearCase Integration
Registering GitHub Account in %product%
Sharing Directory
Reformatting Source Code
Introduce Parameter in ActionScript
Increasing Memory Heap
Associating Ant Target with Keyboard Shortcut
Resolving Dependencies
Scaffolding
Groovy
Generating Groovy Documentation
Launching Groovy Interactive Console
Developing GWT Components
Enabling Java EE Application Support
Enabling PHPUnit Support
Creating a List of Phing Build Files
Viewing PSI Structure
Viewing Seam Components
Working with Spring Roo Console
Build File Properties
Create Test
Extract Property Dialog
Run/Debug Configuration: Grails
Code Style. HTML
Code Style Schemes
Coverage
Options
Add Server Dialog
Editor. Smart Keys
Editor. Editor Tabs
Mobile Module Settings Tab
AspectJ Facet Page
Navigation In Source Code
Local Tab
Debug Tool Window
Customize Data Views
Rebase Branches Dialog
Stash Dialog
Running %product% as a Diff or Merge Command Line Tool
Generating Maven Dependencies
Configuring Browsers
Developing RESTful Web Services
Add Module Wizard
Breakpoints
Differences Viewer
Extract Parameter Dialog
Extract Parameter Dialog for Groovy
Edit Log Files Aliases Dialog
Run/Debug Configuration: JSTestDriver
Run/Debug Configuration: PHP Script
Configuring Quick Lists
File Types
Debug
Servers
Confirmation
Ignored Files
Changelist Conflicts
Edit Subversion Options Related to Network Layers Dialog
OSGi: Framework Definitions
Web Services
Module Page
Optional MIDP Settings Dialog
Dependencies tab
Alt
DSM Tool Window
Creating Java Module
Faces Config Structure - Navigation Rule
Web Module Editor - General
Message Destination References
Web Module Editor - Context Parameters
Form Workspace
General Usage
How It Works
Creating Packages
Completing Path
Resource Bundle
Running with Coverage
Change Method Signature
Make Method Static
Push Members Down
Integrating Changes to Branch
Testing Grails Applications
Griffon
Configuring Groovy-Based Frameworks
Analyzing GWT Compiled Output
Supported Module Types
Creating PHP Documentation Comments
Enabling Profiling with XDebug
PHP-Specific Command Line Tools
Processing Order
Creating Relationships in Entities
Listeners
Find Usages. Package Options
Generate JavaDoc Dialog
Optimize Imports Dialog
Move Inner to Upper Level Dialog for Java
Replace Inheritance with Delegation Dialog
Run/Debug Configuration: PHP Built-in Web Server
Code Style. XML
Add / Edit Color Label Dialog
Node.js
Skeleton Generator
Framework Settings
Debugger. Data Views
Editor. Auto Import
Enter Keyboard Shortcut Dialog
Enter Mouse Shortcut Dialog
TODO
Updates
Ctrl+Shift
Ctrl+Alt+Shift
Tool Windows Reference
Log Tab
Command Line Tools Console Tool Window
Inspection Tool Window
Clone Repository Dialog
Unstash Changes Dialog
Clone Mercurial Repository Dialog
Link Job to Changelist Dialog
Shelve Changes Dialog
Add Relationship
Faces Config Structure - Referenced Bean
Select Accessor Fields to Include in Transfer Object
Web Service References
Create Web Service Reference
Create EJB Resource Reference
Create EJB Resource Environment Reference
Web Module Editor - Servlet Initialization Parameters
Expose Class As Web Service Dialog
Choose Device Dialog
Enabling Tapestry Support
XPath Inspections
Using Suggestion List
Familiarize Yourself with %product% Editor
Documenting Source Code in %product%
Creating Line Breakpoints
Creating Method Breakpoints
Monitoring the Debug Information
Creating Run/Debug Configuration for Tests
Reverting Local Changes
Reverting to a Previous Version
Interactive Rebase
Choosing the Target Device Manually
Generating an APK in the Debug Mode
Binding Macros With Keyboard Shortcuts
Configuring Primary Key
Creating Message Listeners
Enabling GWT Support
Keyboard Shortcuts You Cannot Miss
Seam
Enabling Struts 2 Support
Creating Form Initialization Code
Creating .feature Files
Working with Diagrams
Configuring Default Settings for Diagrams
Groups of Live Templates
Populating Web Module
Specifying General Application Settings
Run/Debug Configuration
Create Library dialog
Edit Library dialog
Export to HTML
Convert Anonymous to Inner Dialog
Extract Field Dialog
Extract Parameter Dialog for JavaScript
Extract Variable Dialog for SASS
Type Migration Preview
Run/Debug Configuration: FlexUnit
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: NodeUnit
ColdFusion
Deployment: Mappings Tab
Console Folding
Editor
File Types
Library Bundling
Web Browsers
XSLT
Mobile Build Settings Tab
Google App Engine Facet Page
Tapestry Facet Page
Pre-Processing Tab
Shift
General
Customize Threads View
Debug Tool Window. Variables
JSTestDriver Server Tool Window
Run Tool Window
Push Rejected Dialog (Git)
Adding Frameworks Support
Apply EJB 3.0 Style
EJB Module Editor - Method Permissions
Faces Config Structure - Render Kit
EJB Local References
Create EJB Local Reference
Regular Expression Syntax Reference
Split Tags
Feedback Page
Hippie Completion. Expanding Words
Limiting DSM Scope
Analyzing Module Dependencies
Annotating Source Code
Searching Through the Source Code
Detaching Editor Tabs
Convert Anonymous to Inner
Extract Method Object
Replace Constructor with Factory Method
Replace Inheritance with Delegation
Wrap Return Value
Changing Read-Only Status of Files
Assigning an Active Changelist
Viewing Changes Made by Other Team Members
Configuring Global CVS Settings
Ignoring Files
Using CVS Watches
Authenticating to Subversion
Updating a Command Line Tool
Configuring Device Layout
Attaching the Debugger to a Running Process
Using Macros in the Editor
Using the Push ITDs In refactoring
Working in Offline Mode
Migrating to EJB 3.0
Creating a GWT Module
Creating a Remote Service
Working with Application Servers
Generating DTD
Content Root
Facet
Relational Databases
Viewing Structure of a Database or Table
Viewing Query Results
Defining Pageflow
Adding a Struts 2 Facet to a Module
GUI Designer Files
Live Templates
Populating Your GUI Form
Duplicating Components
Morphing Components
Setting Component Properties
Enabling Web Application Support
Types of Breakpoints
Find Usages. Class Options
Find Usages. Method Options
Move Members Dialog
Move File Dialog
Replace Constructor with Factory Method Dialog
Gradle
JSLint
Skipped Paths
Issue Navigation
Add Team Foundation Server
Command Line Tool Support
Editor. Appearance
HTTP Proxy
Keymap
Browse Repositories Dialog
Quick Lists
Plugin Deployment Tab
Edit Application Context Dialog
Ctrl+Alt
Function Keys
Command Line Tools Input Pane
REST Client Tool Window
Tiles Tab
Set Property Dialog (Subversion)
Subversion Working Copies Information Tab
EJB Module Editor - EJB Relationships
EJB Editor - General Tab - Entity Bean
Configuring Module Roots
EJB Editor General Tab - Common
Choose Servlet Package
Create EJB Reference
Create Message Destination Reference
Resource Environment References
Monitor SOAP Messages Dialog
Components Treeview
Symbols
Tuning %product%
Knopflerfish Framework Integrator
Generating Delegation Methods
Viewing Reference Information
Viewing Method Parameter Information
Viewing Class Hierarchy as a Class Diagram
Choose Local Paths to Upload Dialog
Generate Groovy Documentation Dialog
Login to IntelliJ Configuration Server Dialog
Print
Extract Include File Dialog
Extract Parameter Dialog for ActionScript
Inline Dialogs
Invert Boolean Dialog
Make Static Dialogs
Move Package Dialog
Replace Temp with Query Dialog
Safe Delete Dialog
Run/Debug Configuration: Flash Remote Debug
Run/Debug Configuration: Google AppEngine Dev Server
Code Style. CSS
Compiler. Validation
Formatting
JSHint
Maven. Runner
Spelling
Zend Framework
Symfony
Debugger. Stepping
Debugger. HotSwap
Editor. Code Completion
Add Filter Dialog
Passwords
Master Password / Reset Master Password Dialog
Add / Edit Filter Dialog
XPath Viewer
Facet Page
Build Configuration page for a Flash module
CDI Tool Window
Duplicates Tool Window
Java EE: App Tool Window
Module Dependencies Tool Window
Play Framework (Play Console)
Configure CVS Root Field by Field Dialog
Merge Branches Dialog
Pull Changes Dialog
Configure Subversion Branches
Select Branch
File Status Highlights
Revert Changes Dialog
Create CMP Field
Edit File Set
EJB Module Editor - General
Create Environment Entry
EJB Remote References
Create Security Role
Web Module Editor - Servlet Mappings
Status Bar
Table Editor
Inspector
Exchanging Instant Messages
Creating Documentation Comments
Viewing Definition
Packaging a Module into a JAR File
Running Applications
Performing Tests
Using Help Topics
Refactoring Source Code
Configuring VCS-Specific Settings
Handling Differences
Viewing Changes Information
Resolving Text Conflicts
Working with Maven Dependencies
GWT
Creating JavaScript Unit Tests
Running JavaScript Unit Tests in Browser
Monitoring Code Coverage for JavaScript
Module
Creating a PHP Web Application Debug Configuration
Remote Hosts
Accessing Files on Remote Hosts
Analyze Stacktrace Dialog
Find Usages
Find Usages. Throw Options
Find Usages. Variable Options
Supported Version Control Systems
Override Server Path Mappings Dialog
Change Class Signature Dialog
Extract Method Object Dialog
Run/Debug Configurations
Run/Debug Configuration: Groovy
Run/Debug Configuration: GWT
Run/Debug Configuration: Query Language Console
Type Migration Dialog
General
Code Style. PHP
Code Style. SQL
Deployment
Deployment: Excluded Paths Tab
Advanced Options Dialog
DBGp Proxy
Code Sniffer
XML Catalog
Tasks
Background
Appearance
Debugger
Output Filters Dialog
GitHub
Notifications
Change Master Password Dialog
Custom Plugin Repositories Dialog
Spring Facet Page
Struts 2 Facet Page
Web Resource Directory Path Dialog
SDKs. Java
SDKs. %product%
SDKs. Mobile
Advanced Editing
Search
Navigation Between Bookmarks
Database Console Properties Dialog
Debug Tool Window. Frames
Export Threads
Hibernate Console Properties Dialog
Hierarchy Tool Window
IDETalk Options Dialog
JPA Console Properties Dialog
Remote Host Tool Window
Roo Console Tool Window
Export Test Results
Validator Tab
Login to GitHub Dialog
Reset Head Dialog
Edit Jobs Linked to Changelist Dialog
SVN Checkout Options Dialog
Integrate to Branch
Lock File Dialog (Subversion)
Edit Relationship
EJB Module Editor - Transaction Attributes
Generate GWT Compile Report Dialog
Environment Entry References
Security Roles
Web Module Editor - Filter Mappings
Show Deployed Web Services Dialog
Table Editor Properties Dialog
Auto-Completion
Configuring Artifacts: Adding Resources
Generating Constructors
Viewing Structure of a Source File
Analyzing External Stacktraces
Properties Files
Stepping Through the Program
Extract Include File
Extract Parameter
Comparing File Versions
Adding Tags
Plugins
Creating Hibernate Elements in a Session Factory
Managing Struts Elements
Designing GUI. Major Steps

Go to Web help home page.