IntelliJ IDEA
What's New
Getting Help
Getting Started with IntelliJ IDEA
Register IntelliJ IDEA
Familiarize Yourself with IntelliJ IDEA User Interface
Welcome Screen
Menus and Toolbars
Navigation Bar
Status Bar
Editor
Tool Windows
Navigation Tool Windows
Output Tool Windows
Auxiliary Tool Windows
Using Tool Windows
Viewing Modes
Familiarize Yourself with IDE Navigation
Configure Your Working Environment
Create and Run Your First Project
Import Your Existing Projects
Set up Your Project JDK and Libraries
Top Twelve Keyboard Shortcuts
Concepts
Project
Project Files
Project Structure
Project and IDE Settings
Module
Absolute and Relative Paths
Contents
Dependencies
Facet
Facet Dependencies
Libraries
Processing Order
Supported Languages
Language Injections
Code Analysis
Dependencies Analysis
DSM Analysis
Code Inspection
Inspection Profile
Annotations
@Nullable and @NotNull Annotations
@NonNls Annotation
External Annotations
Intention Actions
Overview and Examples
Types of Intention Actions
Scope
Templates
File Templates
Live Templates
Search Templates
Modeling Support
Compiler and Builder
Build Process
Compilation Types
Supported Compilers
Ant Support
Maven Support
Running and Debugging
Breakpoints
Breakpoint Icons
Breakpoint Status
Types of Breakpoints
Run/Debug Configuration
Testing Support
Unit Testing Support
Basic Deinitions
JUnit Support
TestNG Support
Code Coverage
GUI Designer Basics
Bound Class
GUI Designer Files
GUI Designer Output Options
Internationalization and Localization Support
Encoding
Resource Files
Properties Files
Resource Bundle
Java EE and Web Development
Application Servers Support
Access to Data
Object-Relational Mapping (EJB, Hibernate and JPA)
EJB
FreeMarker and Velocity
Groovy and Grails
GWT
HTML, XHTML, XML and CSS
Java EE and Web Applications
JavaScript, AJAX and Flex
JSF
JSP and JSPX
Seam
Spring
Struts
Struts 2
Web Services
RESTful WebServices
Third-Party Tools and Plugins
External Tools
Plugins
Plugins Repositories
Version Control with IntelliJ IDEA
Changelist
Directory-Based Versioning Model
Local History
Local, Committed and Incoming Changes
Patches
Shelved Changes
Supported Version Control Systems
Unified Version Control Functionality
Procedures
Configuring the IDE
Accessing Settings Dialog
Configuring Keyboard Shortcuts
Configuring Quick Lists
Customizing Menus and Toolbars
Configuring Code Style
Customizing Colors and Fonts
Configuring Tool Windows and Their Layout
Switching Between Schemes
Exporting and Importing Settings
Exporting Settings
Importing Settings
Creating and Managing Projects
Configuring Projects
Configuring Template Project
Accessing Project Settings and Project Structure
Configuring Absolute and Relative Paths
Configuring Project Compiler Output
Configuring Project JDK
Configuring Project Libraries
Configuring Individual File Encoding
Exporting Project Code Style Settings
Creating New Project
Creating New Project from Existing Source Code
Creating New Project from Scratch
Importing Maven Project
Importing Eclipse Project to IntelliJ IDEA
Importing Jbuilder Project
Exporting IntelliJ IDEA Project to Eclipse
Opening Multiple Projects
Opening, Reopening and Closing Project
Working With Legacy Projects
Creating and Managing Modules
Configuring Modules
Accessing Module Settings
Configuring Module Compiler Output
Configuring Module Dependencies and Libraries
Configuring Module JDK
Configuring Module Roots
Creating Modules
Creating Java Module
Creating Maven Module
Deleting Modules
Grouping Modules
Managing Facets
Detecting Facets in a Module
Adding and Removing Facets
Changing Module Facet Settings
Configuring Auto-Detection and Default Facet Settings
Configuring Bulk Facet Settings
Creating Classes, Files and Packages in Modules
Creating a Directory
Creating a New File by Template
Creating a Package
Creating and Editing File Templates
Creating and Registering File Types
Common Editing Procedures
Opening and Reopening Files in the Editor
Closing Files in the Editor
Saving and Reverting Changes
Managing Tabs
Navigating Between Editor Tabs
Pinning and Unpinning Tabs
Splitting and Unsplitting Tabs
Editing Multiple Files Using Groups of Tabs
Adding Editors to Favorites
Selecting Text in the Editor
Cutting, Copying and Pasting
Undoing and Redoing Changes
Viewing Differences Between Files
Advanced Editing Procedures
Adding, Joining And Splitting Lines
Adding New Lines
Joining Lines And Literals
Splitting Lines With String Literals
Auto-Completing Code
Completing Class Names
Completing Names and Keywords
Completing Punctuation
Completing Statements
Completing Path
Completing Tag Names
Completing Code Based on Type Information
Expanding Words
Negating Expressions
Using Suggestion List
Creating Code By Template
Creating Code Constructs by Live Templates
Creating Code Constructs Using Surround Templates
Creating Main() Method. Example of Applying a Simple Live Template
Iterating Over An Array. Example of Applying Parameterized Live Templates
Wrapping a Tag. Example of Applying Surround Live Templates
Working with Suggestion List
Creating and Editing Live Templates
Generating Code
Commenting and Uncommenting Blocks of Code
Creating and Optimizing Imports
Generating Constructors
Generating Delegation Methods
Generating Equals() and Hashcode()
Generating Getters and Setters
Implementing Methods of An Interface
Overriding Methods of a Superclass
Surrounding Blocks of Code with Language Constructs
Unwrapping and Removing Statements
Generating Documentation
Creating JavaDoc Comments
Generating JavaDoc Reference for a Project
Improving Visibility of the Source Code
Code Folding
Highlighting Braces
Reformatting Source Code
Programming by Intention
Applying Intention Actions
Configuring Intention Actions
Disabling and Suppressing Intention Actions
Using Macros in the Editor
Binding Macros With Keyboard Shortcuts
Editing Macros
Playing Back Macros
Recording Macros
Viewing Reference Information in the Editor
Viewing Definition
Viewing Documentation
Viewing Method Parameter Information
XML, XHTML, HTML and CSS Specific Tasks
Generating DTD
Referencing DTD Or Schema
Validating Web Content Files
Viewing HTML Files in the Browser
Viewing Styles Applied to a Tag
Viewing Images
Changing Color Values in CSS Files
Inspecting Source Code
Accessing Profiles Settings
Creating Own Inspections
Customizing Profiles
Adding and Changing Profiles
Defining Scope-Profile Combination
Configuring Inspections Severities
Disabling Inspections
Exporting Inspection Results
Resolving Problems
Running Inspections and Analyzing Results
Running Inspections Offline
Suppressing Inspections
Viewing Offline Inspections Results
Using IntelliJ IDEA Annotations
Annotating Source Code Directly
Using External Annotations
Changing Highlighting Level
Navigating Through the Source Code
Navigating With Bookmarks
Managing Bookmarks
Navigating Between IDE Components
Navigating Back and Forward to the Navigated Items
Navigating Between Methods
Navigating From Stacktrace To Source Code
Navigating To Action
Navigating To Braces
Navigating To Class, File Or Symbol by Name
Navigating To Declaration Or Type Declaration of a Symbol
Navigating To Implemented/Overridden Or Implementing/Overriding Methods
Navigating to File Path
Navigating To Line
Navigating To Next/Previous Change
Navigating To Next/Previous Error
Navigating To Recent File
Navigating With Navigation Bar
Navigating With Structure Views
Navigating Between Test and Test Subject
Searching Through the Source Code
Finding And Replacing Text Across Project
Finding Text in File
Finding Word At Caret
Performing Speed Search in the Tool Windows
Replacing Text in File
Structural Search and Replace
Structural Search and Replace - General Procedure
Creating and Editing Search Templates
Structural Search and Replace Examples
Finding Usages
Finding Usages in Project
Finding Usages in the Current File
Highlighting Usages
Viewing Usages of a Symbol
Viewing Recent Find Usages
Working With Search Results
Compiling Applications
Compiling Target
Configuring Compiler Settings
Making Module
Making Project
Packaging a Module Into a JAR File
Rebuilding Project
Reviewing Compilation And Build Results
Building Applications
Building with Ant
Controlling Behavior Of Ant Script With Build File Properties
Defining Additional Ant Classpath
Defining Ant Execution Options
Defining Ant Filters
Defining Runtime Properties
Executing Build File in Background
Increasing Memory Heap
Running the Build
Associating Ant Target with Keyboard Shortcut
Configuring Triggers for Ant Build Target
Executing Ant Target
Adding Build File to Project
Creating Ant Build File
Generating Ant Build File
Building with Maven
Activating and Deactivating Maven Profiles
Associating Maven Goals with Keyboard Shortcuts
Configuring Triggers for Maven Goals
Creating Maven Dependencies
Creating Maven Run/Debug Configuration
Editing Maven Settings
Executing Maven Goal
Working in Offline Mode
Running
Creating And Editing Run/Debug Configurations
Creating And Saving Temporary Run/Debug Configurations
Running Applications
Rerunning Applications
Reviewing Results
Stopping And Pausing Applications
Setting Code Coverage Options
Setting Configuration Options
Setting Log Options
Debugging
Using Breakpoints
Configuring Breakpoints
Creating Exception Breakpoints
Creating Field Watchpoints
Creating Line/Flex/JavaScript Breakpoints
Creating Method Breakpoints
Enabling and Disabling Breakpoints
Moving Breakpoints
Navigating Back to Source
Beginning the Debugger Session
Configuring Debugger Options
Configuring Stepping Speed
Pausing and Resuming the Debugger Session
Reloading Classes
Examining Suspended Program
Exploring Frame
Customizing Views
Testing
Configuring Libraries for Unit Testing
Creating Test Cases Using Intention Action
Creating TestNG Test Class
Creating JUnit Test Cases
Creating JUnit Test Methods
Creating Run/Debug Configuration for a Test
Monitoring and Managing Tests
Performing Tests
Rerunning Tests
Terminating Tests
Viewing Test Results
Analyzing Applications
Analyzing Dependencies Using DSM
Expanding Dependencies
Exploring Dependencies
Find Usages for Dependencies
Invoking DSM
Limiting DSM Scope
Viewing Structure and Hierarchy of the Source Code
Building Call Hierarchy
Building Class Hierarchy
Building Method Hierarchy
Retaining Hierarchy Tabs
Viewing Hierarchies
Viewing Structure of a Source File
Analyzing Backward Dependencies
Analyzing Cyclic Dependencies
Analyzing Data Flow
Analyzing Dependencies
Analyzing Duplicates
Analyzing Module Dependencies
Analyzing External Stacktraces
Validating Dependencies
Modeling with UML Class Diagram
Opening UML Class Diagram
Selecting Nodes and Members in Diagram
Creating Classes in Class Diagram
Creating Members in Class Diagram
Creating Relationship Links in Class Diagram
Navigating to Source from a UML Class Diagram
Viewing Siblings and Children
Viewing Dependencies in Class Diagram
Refactoring Source Code
Change Class Signature
Change Method Signature
Convert Anonymous to Inner
Convert to Instance Method
Copy/Clone Class
Encapsulate Fields
Extract Class
Extract Include File
Extract Interface
Extract Method
Extract Method Object
Extract Superclass
Generify Refactoring
Inline Refactorings
Introduce Constant
Introduce Field
Introduce Parameter
Introduce Parameter Object
Introduce Variable
Invert Boolean
Make Class Static
Make Method Static
Migrate
Move Refactorings
Pull Members Up
Push Members Down
Remove Middleman
Rename Refactorings
Replace Constructor With Factory Method
Replace Inheritance With Delegation
Replace Method Code Duplicates
Replace Temp With Query
Safe Delete
Use Interface Where Possible
Type Migration
Wrap Return Value
Internationalizing Source Code
Configuring Encoding for Properties Files
Creating and Editing Properties Files
Editing Resource Bundle
Recognizing Hard-Coded String Literals
Extracting Hard-Coded String Literals
Ignoring Hard-Coded String Literals
Designing GUI
Customizing the Component Palette
Adding GUI Components and Forms to the Palette
Configuring Libraries of UI Components
Creating Groups
Designing GUI. Major Steps
Binding the Form and Components to Code
Binding a Form to a New Class
Binding a Form to An Existing Class
Binding Groups of Components to Fields
Creating and Opening Forms
Creating a Form from a File Template
Creating a GUI Form Or Dialog
Creating Snapshots
Opening a Form for Editing
Localizing Forms
General Localization Procedure
Suppressing I18N Hard-Coded String Quick Fix
Changing the Design-Time Locale
Making Forms Functional
Creating and Disposing of a Form's Runtime Frame
Creating Form Initialization Code
Creating Listeners
Generating Accessor Methods for Fields Bound to Data
Populating Your GUI Form
Adding Mnemonics
Deleting Components
Duplicating Components
Grouping and Ungrouping Components
Morphing Components
Moving Components
Placing GUI Components on a Form
Placing Non-Palette Components Or Forms
Selecting Components
Wrapping/Unwrapping Components
Setting Component Properties
Configuring Client Properties
Setting Text Properties
Previewing Forms
Using Local History
Enabling Local History
Putting Labels
Restoring a File from Local History
Viewing Local History of a Class, Method, Field Or Code Fragment
Viewing Local History of a File Or Folder
Viewing Recent Changes
Version Control with IntelliJ IDEA
Configuring Version Control Options
Configuring General VCS Settings
Configuring Ignored Files
Enabling Version Control
Associating a Project Root with a Specific Version Control System
Associating a Directory with a Specific Version Control System
Changing VCS Associations
Handling Differences
Comparing File Versions
Integrating Differences
Integrating Project
Resolving Conflicts
Handling Issues
Creating Issue Patterns
Navigating to Issues
Managing Changelists
Assigning An Active Changelist
Creating a New Changelist
Deleting a Changelist
Grouping Changelist Items by Folder
Moving Items Between Changelists
Navigating to Source Code
Renaming a Changelist
Performing Common Version Control Procedures
Changing Read-Only Status of Files
Using Change Markers
Checking In Files
Copying, Renaming and Moving Files
Deleting Files from the Repository
Refreshing Status
Reverting Local Changes
Reverting to a Previous Version
Updating Local Information
Putting Files To and Retrieving From the Repository
Adding Files to Version Control
Browsing Contents of the Repository
Getting Local Working Copy of the Repository
Performing VCS-Specific Procedures
Using CVS Integration
Browsing CVS Repository
Checking Out Files from CVS Repository
Configuring CVS Roots
Configuring Global CVS Settings
Ignoring Files
Importing a Local Directory to CVS Repository
Resolving Commit Errors
Updating Local Information in CVS
Using CVS Watches
Working Offline
Working with Tags and Branches
Using Perforce Integration
Enabling and Configuring Perforce Integration
Handling Modified Without Checkout Files
Integrating Perforce Files
Resolving Conflicts with Perforce Integration
Showing Revision Graph and Time-Lapse View
Using Multiple Perforce Depots with P4CONFIG
Working Offline
Using Subversion Integration
Authenticating to Subversion
Browsing Subversion Repository
Checking Out Files from Subversion Repository
Cleaning Up Local Working Copy
Comparing With Branch
Configuring Format of the Local Working Copy
Configuring HTTP Proxy
Configuring Subversion Repository Location
Creating Branches and Tags
Exporting Information From Subversion Repository
Importing a Local Directory to Subversion Repository
Integrating Changes to Branch
Integrating SVN Projects Or Directories
Locking and Unlocking Files and Folders
Resolving Text Conflicts
Sharing Directory
Working With Subversion Properties for Files and Directories
Viewing Differences in Properties
Viewing and Fast Processing of Changelists
Defining the Set of Changelists to Display
Filtering Out Extraneous Changelists
Viewing and Managing Integration Status
Viewing Merge Sources
Using Clearcase Integration
Using Starteam Integration
Using Visual Source Safe Integration
Viewing Changes Information
Browsing Changes
Viewing and Navigating Through Changes in the Editor
Viewing Annotations
Viewing Changes by the Other Team Members
Viewing Changes History for a File Or Selection
Viewing File Status
Shelving and Unshelving Changes
Shelving Changes
Unshelving Changes
Restoring Unshelved Changes
Filtering Out and Removing Unshelved Changes
Using Patches
Applying Patches
Creating Patches
Working with Collaboration and Communication Facilities
Using the IDETalk Plugin
Connecting to Or Creating Jabber Account
Customizing IDETalk Options
Enabling Other Users to View Your Files
Exchanging Instant Messages
Finding and Adding Users
Managing User Groups
Searching a User's Message History
Sending Code Pointers
Sending Stacktraces
Viewing Differences Between the Local and Remote Files
Viewing Files Opened by Others
Using Teamcity
Using TODO Lists
Working with Third-Party Tools and Plugins
Using Third-Party Tools
Updating, Installing and Uninstalling Plugins from IntelliJ IDEA Plugin Repository
Developing Plugins
Setting up IntelliJ IDEA for Writing Plugins
Creating Plugin Project
Launching Plugin
Preparing Plugin for Publishing
Adding Plugins to An Enterprise Repository
Managing Enterprise Repositories
Updating Plugins from An Enterprise Repository
Developing Java EE and Web Applications
Enabling Web Application Support
Enabling Java EE Application Support
Creating and Configuring Web Application Elements
Specifying Assembly Descriptor References
Deploying and Running
Previewing HTML and JSP Files
Developing Applications Using EJB
Enabling EJB Support
Creating and Editing EJB
Creating and Editing Assembly Descriptors
Editing Module with EJB Facet
Migrating to EJB 3.0
Using EJB ER Diagram
Working with Application Servers
Configuring and Managing Application Server Integration
Creating Run/Debug Configuration for Application Server
Data Access Procedures
Working with Data Sources
Creating Data Sources
Configuring JDBC Data Source
Configuring SQL Data Source
Accessing Data Sources Via JDBC Console
Changing Properties of a Data Source
Adding .sql Files to SQL Data Source
JPA
Enabling JPA Support
Creating Persistence Units
Creating Elements in Persistence Units
Creating Fields in Persistence Entities
Creating Relationships in Entities
Navigating to Underlying Code
Opening JPA ER Diagram
Hibernate
Enabling Hibernate Support
Creating Session Factory
Creating Hibernate Elements in a Session Factory
Creating Fields in Hibernate Elements
Creating and Editing Relationships
Opening Hibernate ER Diagram
Navigating to Underlying Code
Using HQL Console
Generating Persistence Mappings
Mapping by Database Schema
Mapping to EJB
Mapping to Hibernate
Using Web Frameworks
Developing Web Applications Using Flex
Enabling Flex Support
Creating and Editing Flex Application Elements
Building, Running and Debugging Flex Applications
Developing Applications Using GWT
Developing GWT Components
Creating a GWT Module
Creating An Entry Point
Creating a Remote Service
Creating a Serializable Class
GWT Sample Application Overview
Enabling GWT Support
Creating a Module with a GWT Facet
Adding a GWT Facet to a Module
JSF
Enabling JSF Support
Creating and Editing Faces Configuration
Defining Navigation Rules
Developing Applications Using Spring
Enabling Spring Support
Creating and Editing Configuration
Managing File Sets
Using Spring Bean Templates
Using Spring Bean Patterns
Developing Web Applications Using Struts
Enabling Struts Support
Creating a Module with a Dedicated Struts Facet
Adding a Struts Facet to a Module
Enabling Support of Additional Struts Features
Managing Struts Elements
Managing Struts Elements - General Steps
Managing Tiles
Managing Validators
Using the Web Flow Diagram
Web Services Server
Enabling Web Services Support
Generating Code
Web Services Client
Generating Code
Enabling Web Services Support
Developing Web Applications Using Seam
Configuring Modules with Seam Support
Defining Seam Components
Viewing Seam Components
Defining Seam Navigation Rules
Navigating Within a Conversation
Navigating Between An Observer and An Event
Defining Pageflow
Developing RESTful Web Services
Enabling REST Support
Creating a New Module with a Dedicated Facet
Adding Dedicated Facets to a RESTful Web Service Module
Adding Libraries to a RESTful Web Service Module
Testing RESTful Web Services
Developing Web Applications Using Struts 2
Enabling Struts 2 Support
Creating a Module with a Dedicated Struts 2 Facet
Adding a Struts 2 Facet to a Module
Defining the Validation File Set
Managing Struts 2 Elements
Developing Applications in Dynamic Languages
Using Groovy
Enabling Groovy Support
Creating Groovy Classes, Interfaces, Enumerations and Annotations
Creating Groovy Scripts
Instantiating Java Interface in Groovy
Working with Groovy Lists and Maps
Running and Debugging Groovy Scripts
Converting Parameters to Map Entries
Using Grails
Enabling Grails Support
Creating Grails Application from Existing Code
Creating Grails Application Elements
Creating and Editing Relationships Between Domain Classes
Dynamic Querying
Scaffolding
Running Grails Targets
Working with Grails Plugins
Running and Debugging Grails Applications
Testing Grails Applications
Building Groovy Applications
Enabling Gant Support
Creating Gant Script
Running Gant Targets
Developing J2ME Applications
Creating Mobile Module
Configuring Mobile Java SDK
Configuring Mobile-Specific Compiling Settings
Running/Debugging Mobile Application
Reference
Dialogs
New Project Wizard
New Project From Existing Code
New Project From Existing Code. Facets Page
New Project From Existing Code. Libraries Page
New Project From Existing Code. Module Structure Page
New Project From Existing Code. Name and Location Page
New Project From Existing Code. Source Roots Page
New Project From Scratch
New Project From Scratch. Sources Page
New Project From Scratch. Technologies Page
New Project From Scratch. SDK Page
New Project From Scratch. Mobile SDK Specific Options Page
New Project From Scratch. Flex Page
New Project From Scratch. Grails Page
New Project From Scratch. Maven Page
New Project. Import From External Model
New Project. Import From Eclipse. Page 1
New Project. Import From Eclipse. Page 2
New Project. Import From Jbuilder
New Project. Import From Jbuilder. Select Projects Page
New Project. Import From Jbuilder. Source Roots Page
New Project. Import From Maven. Page 1
New Project. Import From Maven. Page 2
New Project. Import From Maven. Page 3
Add Module
Refactoring Dialogs
Change Signature Dialogs
Convert Anonymous to Inner Dialog
Convert to Instance Method Dialog
Copy Class Dialog
Encapsulate Fields Dialog
Extract Dialogs
Extract Class Dialog
Generify Dialog
Inline Dialogs
Introduce Dialogs
Introduce Parameter Object Dialog
Invert Boolean Dialog
Make Static Dialogs
Move Dialogs
Package and Class Migration Dialog
Pull Members Up / Push Members Down Dialogs
Rename Dialogs
Replace Constructor With Factory Method Dialog
Replace Inheritance With Delegation Dialog
Replace Method Code Duplicates Dialog
Replace Temp with Query Dialog
Safe Delete Dialog
Use Interface Where Possible Dialog
Wrap Return Value Dialog
Extract Method Object Dialog
Run/Debug Configuration
Run/Debug Configuration: Applet
Run/Debug Configuration: Application
Run/Debug Configuration: Code Coverage
Run/Debug Configuration: Flex
Run/Debug Configuration. Gant
Run/Debug Configuration: Geronimo Server
Run/Debug Configuration: Glassfish Server
Run/Debug Configuration: Grails Application
Run/Debug Configuration: Grails Tests
Run/Debug Configuration: Groovy Script
Run/Debug Configuration: GWT
Run/Debug Configuration: JavaScript Debug
Run/Debug Configuration: J2ME
Run/Debug Configuration: JBoss Server
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: JUnit
Run/Debug Configuration: Logs Tab
Run/Debug Configuration: Maven
Run/Debug Configuration: Plugin
Run/Debug Configuration: Remote
Run/Debug Configuration: TestNG
Run/Debug Configuration: Tomcat
Run/Debug Configuration: Weblogic
Run/Debug Configuration: Websphere
Add/Edit Palette Component
Apply Patch
Analyze Stacktrace Dialog
Authentication Required
Breakpoints
Build File Properties
Build Jars
Code Duplication Analysis Scope
Commit Changes
Create Patch
Code Duplication Analysis Settings
Convert Project Dialog
Customize Threads View
Customize Data Views
Differences Viewer for Files
Differences Viewer for Folders
Editor Bookmarks Dialog
Evaluate Expression
Export Threads
Export to HTML
File Cache Conflict
Find And Replace In Path
Find Usages. Class Options
Find Usages. Method Options
Find Usages. Other Options
Find Usages. Package Options
Find Usages. Throw Options
Find Usages. Variable Options
Generate Ant Build
Generate Equals() and Hashcode() Wizard
I18nize Hard-Coded String
Print
Recent Changes Dialog
Productivity Guide
Replace Text
Specify Dependency Analysis Scope Dialog
Specify Inspection Scope Dialog
Structural Search and Replace Dialogs
Structural Search and Replace. Edit Variable Dialog
Show History for File Dialog
Show History for Folder Dialog
Optimize Imports Dialog
Reformat Code Dialog
Unshelve Changes
Shelve Changes
Show History for Selection
Resource Bundle Editor
Type Migration Dialog
Create Test
Select Path
GUI Designer Reference
Components of the GUI Designer
Components Properties
Components Treeview
Data Binding Wizard
Form Workspace
Inspector
Palette
Keyboard Shortcuts Reference
Keyboard Shortcuts By Category
Advanced Editing
Basic Editing
Code Folding
Compiling, Running And Debugging
General
GUI Designer Shortcuts
Search
Navigation Between Bookmarks
Navigation Between IDE Components
Navigation In Source Code
Refactoring
Keyboard Shortcuts By Keystroke
Alt
Alt+Shift
Ctrl
Ctrl+Alt
Ctrl+Shift
Ctrl+Alt+Shift
Function Keys
Navigation Keys
Shift
Settings Dialog
IDE Settings
Appearance
Application Servers
Code Completion
Debugger
Debugger. Data Views
Debugger. Stepping
Debugger. Data Type Renderers
Debugger. Hotswap
Debugger. Groovy
Debugger. JavaScript
Colors and Fonts
Editor
Editor. Smart Keys
Editor. Appearance
Editor. Colors and Fonts
Editor. Editor Tabs
Editor. Code Folding
Editor. Code Completion
Editor. Auto Import
External Tools
Edit Tool Dialog
Output Filters Dialog
External Diff Tools
File Templates
File Types
New File Types
General
HTTP Proxy
Images
Intention Settings
Keymap
Keymaps - Enter Keyboard Shortcut Dialog
Live Templates
Edit Live Template Dialog
Edit Template Variables Dialog
Local History
Menus and Toolbars
Path Variables
Plugins
Resources
TODO
Add \ Edit Pattern Dialog
Add \ Edit Filter Dialog
Updates
Quick Lists
Web Browsers
Web Services
Project Settings
Code Style
General
Code Generation
Alignment and Braces
Wrapping
Blank Lines
Spaces
Imports
JavaDoc
XML
HTML
CSS
Java EE Names
JavaScript/ECMAScript/ActionScript
Compiler
Compiler. Excludes
Compiler. Java Compiler
Compiler. RMI Compiler
Compiler. Validation
Errors
GUI Designer
Scopes
Version Control
Confirmation
Background
Ignored Files
Ignore Unversioned Files
Cache
Issue Navigation
Vcss
Clearcase
Git
Perforce
Subversion
File Encodings
Maven
Maven. Importing
Maven. Ignored Files
Maven. Downloading
Maven. Runner
Maven. Repository Indices
SQL Dialects
Template Data Languages
Web Contexts
Tool Windows Reference
Changes Tool Window
Local Tab
Repository and Incoming Tabs
Debug Tool Window
Console Tab
Frames Tab
Variables Tab
Watches Tab
Dependency Viewer
Dependency Validation Dialog
Project Tool Window
Favorites View
Java EE Structure View
Run Tool Window
Logs Tab
Test Results Tab
JDBC Console
Version Control Tool Window
History Tab
Update Info Tab
Integrate to Branch Info View
Ant Build Tool Window
Commander Tool Window
DSM Tool Window
Duplicates Tool Window
Find Tool Window
Type Migration Preview
Hierarchy Tool Window
IDETalk and IDETalk Messages Tool Windows
IDETalk Options Dialog
Inspection Tool Window
Maven Projects Tool Window
Messages Tool Window
Module Dependencies Tool Window
Structure Tool Window
TODO Tool Window
Database
Import Data Sources Dialog
JDBC Data Source Properties
SQL Data Source Properties
REST Client Tool Window
Struts Assistant Tool Window
Tiles Tab
Validator Tab
Struts Tab
Choose Class
Web Preview Tool Window
SVN Repositories Tool Window
Version Control Reference
CVS Reference
CVS Global Settings Dialog
CVS Options Dialog
CVS Root Dialog
CVS Tool Window
Import Into CVS
Check Out From CVS Dialog
Starteam Reference
Starteam Options Dialog
Starteam-Related UI Elements
File Status Highlights
Perforce Options Dialog
Integrate File Dialog (Perforce)
Visual Sourcesafe Options Dialog
Subversion Reference
Subversion Options Dialog
Check Out From Subversion Dialog
Create Branch Or Tag Dialog (Subversion)
Select Repository Location Dialog (Subversion)
Set Property Dialog (Subversion)
Update Dialog (Subversion)
Integrate Project Dialog (Subversion)
Import Into Subversion
Subversion Working Copies Information
Integrate to Branch
Changes Browser
Select Branch
Configure Subversion Branches
Enable Version Control Integration
Icons Reference
IntelliJ IDEA vs Eclipse Terminology
File Types Recognized by IntelliJ IDEA
Regular Expression Syntax Reference
Scope Language Syntax Reference
Java EE Reference
Apply EJB 3.0 Style
EJB Editor
EJB Editor General Tab - Common
EJB Editor - General Tab - Entity Bean
EJB Editor - General Tab - Message Bean
EJB Editor - General Tab - Session Bean
EJB Editor - Assembly Descriptor
Assembly Descriptor Dialogs
Edit Relationship
EJB Module Editor
EJB Module Editor - General
EJB Module Editor - EJB Relationships
EJB Relationship Properties
EJB Module Editor - Method Permissions
EJB Module Editor - Transaction Attributes
Import Database Schema / Import Mappings
Add Relationship
Web Module Editor
Web Module Editor - General
Web Module Editor - Assembly Descriptor
Web Module Editor - Servlet Mappings
Web Module Editor - Servlet Initialization Parameters
Web Module Editor - Context Parameters
Web Module Editor - Filter Mappings
Web Module Editor - Assembly Descriptor References
Environment Entry References
Create Environment Entry
EJB Local References
Create EJB Local Reference
EJB Remote References
Create EJB Reference
Web Service References
Create Web Service Reference
Resource References
Create EJB Resource Reference
Message Destination References
Create Message Destination Reference
Resource Environment References
Create EJB Resource Environment Reference
Security Roles
Create Security Role
JSF Faces Config Editor
Faces Config Structure
Faces Config Structure - Component
Faces Config Structure - Converter
Faces Config Structure - Managed Beans
Faces Config Structure - Navigation Rule
Faces Config Structure - Referenced Bean
Faces Config Structure - Render Kit
Faces Config Structure - Validator
New Bean / Change Bean Dialog
New Servlet
Choose Servlet Package
New Filter
New Listener
Select Accessor Fields to Include in Transfer Object
Create CMP Field
Spring Dependencies Diagram
Rename Entity Bean
Project Structure Dialog
Modules
Sources Tab
Paths Tab
Dependencies Tab
Plugin Deployment Tab
Mobile Modules Settings Tab
Mobile Build Settings Tab
Module Facets Settings
Flex Facet
Hibernate and JPA Facet
JSF Facet
Seam Facet
Spring Facet
Web, EJB and Java EE Application Facets
Java EE Build Settings
Web, EJB, Java EE Application Settings
Web Resource Directories
Struts Facet
GWT Facet
Struts 2 Facet
General Settings for Project
JDKs
Libraries
Facets
Diagram Reference
General Techniques of Using Diagrams
Diagram Preview
UML Class Diagram
Intellilang
Overview
Intellilang Configuration
General Usage
Code Inspections
Quick Edit Language
Usage Examples
Feedback Page
XPath and XSLT Support
XPath Expression Evaluation
XPath Search
XPath Expression Generation
Plugin Settings
XSLT Support
Completion
Refactoring
Error Highlighting
XPath Inspections
Navigation
Documentation
Run Configurations
File Associations
Intentions
Developing Web Services
Developing Web Services
Generating Java from WSDL
Generating WSDL from Java
Generating Java from Xml Schema Using JAXB
Generating Java from Xml Schema Using XmlBeans
Generating Xml Schema From Java Using JAXB
Generating Instance Document From Xml Schema
Generating Xml Schema From Instance Document
Working with JAXB
Working with XML Beans
Using Web Services
Monitor SOAP Messages
Enabling Web Services Support
Show Deployed Web Services
Undeploying Web Services
Deploying Web Services
FAQ
Refactor-X
Delete Tag
Delete Attribute
Unwrap Tag
Wrap Tag
Wrap Tag Contents
Replace Attribute With Tag
Replace Tag With Attribute
Add Attribute
Add Subtag
Move Attribute In
Move Attribute Out
Change Attribute Value
Convert Contents To Attribute
Expand Tag
Collapse Tag
Merge Tags
Split Tags
IntelliJ IDEA 8 Web Help
IntelliJ IDEA Overview
Features & Screensots
Plugins
Documentation
Demos & Tutorials
Community
Download
Licensing & Upgrade