IntelliJ IDEA 12 Web Help

Missing Web Help Page

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

Go to Web help home page.