IntelliJ IDEA 12 Web Help

Missing Web Help Page

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

Go to Web help home page.