IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page configuring a module sdk appears to be missing.

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

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

Go to Web help home page.