IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page new project from existing sources module structure page appears to be missing.

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

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

Go to Web help home page.