IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page importing grails or griffon applications from existing source appears to be missing.

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

Database Tool Window
Importing Project from Existing Source Code
Creating and Importing Data Sources
Sources Tab
DB Data Source Properties
Import Project from Existing Sources. Project Name and Location
Data Sources
Import Project from Existing Sources. Source Roots Page
Filters and Ordering Dialog
Grails Tool Window
Creating New Project from Scratch
Processing Order
Import Data Sources Dialog
Configuring a DB Data Source
Creating Grails Application from Existing Code
DDL Data Source Properties
Create Module from Existing Sources. Source Roots Page
Creating Files from Templates
Importing Project from Gradle Model
Using Visual SourceSafe Integration
Griffon Tool Window
Generate Java Code from WSDL or WADL Dialog
Checkout from TFS Wizard: Source Workspace
Excluding Files and Folders from Deployment
Viewing Changes History for a File or Selection
Running Grails Targets
New Project from Scratch. Grails Page
New Project from Scratch. Griffon Page
Importing Adobe Flash Builder Projects
Sharing Android Source Code and Resources Using Library Projects
Configuring a DDL Data Source
New Project from Scratch. Sources Page
Testing Flex and ActionScript Applications
Creating Module from Existing Source Code
Running and Debugging Grails Applications
Viewing Table Data from the Data Sources Tool Window
Importing Project from Maven Model
Preparing for ActionScript, Flex or AIR application development
Working with Grails Plugins
Import Project from Existing Sources. Libraries Page
Import Project from Existing Sources. Module Structure Page
Import Project from Existing Sources. Facets Page
Create Module from Existing Sources
Create Module from Existing Sources. Libraries Page
Create Module from Existing Sources. Module Structure Page
Import Project from Existing Sources
Checkout from TFS Wizard: Source Server
Checkout from TFS Wizard: Choose Source and Destination Paths
Maven. Importing
Searching Through the Source Code
Testing Grails Applications
Content Root
Referencing DTD or Schema
Accessing Data Sources via the Database Console
Checkout from TFS Wizard: Choose Source Path
Creating Griffon Application Module
Checkout from TFS Wizard
Viewing Local History of a File or Folder
Struts Data Sources
Checking Out from TFS Repository
Creating Grails Application Elements
Importing Existing Modules
New Project from Scratch. Project Name, Location and Format
Importing Eclipse Project to %product%
New Project from Scratch. Technologies Page
Building ActionScript and Flex Applications
Testing PHP Applications
Creating Module from Scratch
Importing Project
Configuring Libraries and Dependencies in Grails Applications
Navigating from Stacktrace to Source Code
Reformatting Source Code
Building, Running and Debugging Flex Applications
Checking Out Files from CVS Repository
Checking Out Files from Subversion Repository
New Project from Scratch. Android Page
New Project from Scratch. Flash Page
Run/Debug Configuration: Grails
Navigating Through the Source Code
Import Existing Sources. Project SDK
Create Module from Scratch. Sources Page
Creating and Running Your First Java Application
Importing Existing Module
Running Applications
Navigating to Source Code from the Debug Tool Window
Exporting and Importing Settings
Check Out From Subversion Dialog
Navigating to Class, File or Symbol by Name
Importing a Local Directory to CVS Repository
Binding a Form to an Existing Class
Running Injected SQL Statements from the Editor
Import Project from Maven. Page 1
Create Branch or Tag Dialog (Subversion)
Annotating Source Code
Creating Grails Application Module
Generate Java from Xml Schema using JAXB Dialog
Generate XML Schema From Java Using JAXB Dialog
Viewing Structure and Hierarchy of the Source Code
Annotating Source Code Directly
Navigating to Declaration or Type Declaration of a Symbol
Adding Data Structure Definition Files to a DDL Data Source
New Project from Scratch. Maven Page
Generate Java Code from XML Schema using XmlBeans Dialog
Import Project or Module Wizard
Generate Instance Document from Schema Dialog
ActionScript, Flex and AIR
Generating XML Schema From Instance Document
Generating Java Code from XML Schema
Check Out From CVS Dialog
Generate Schema from Instance Document Dialog
New Project from Scratch. Mobile SDK Specific Options Page
Run/Debug Configuration. Griffon
New Project from Scratch. Maven Settings Page
Generate WSDL from Java Dialog
Connecting to or Creating Jabber Account
Introduce Parameter in Java
Restoring a File from Local History
Navigating to Source Code
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Working with %product% Features from Command Line
Changing Properties of a Data Source
Viewing Structure of a Database or Table
Viewing HTML Source Code of a Web Page in the Editor
Import Project from Flash Builder. Page 1
Grails Procedures
Packaging AIR Applications
Running and Debugging Android Applications
Testing Android Applications
Generating Instance Document From XML Schema
Deploying PHP Applications
Import Project from Eclipse. Page 1
Compiling Applications
Exporting Information From Subversion Repository
Integrating SVN Projects or Directories
Checkout from TFS Wizard: Checkout Mode
Using Language Injections
Downloading Libraries from Maven Repositories
Creating Grails Views and Actions
Import Project from Flash Builder. Page 2
Checkout from TFS Wizard: Summary
Importing %product% Settings on First Launch
Excluding Files from Project
Documenting Source Code in %product%
Running %product% as a Diff or Merge Command Line Tool
Viewing Merge Sources
Improving Visibility of the Source Code
Build Configuration
JavaScript-Specific Guidelines
Placing Non-Palette Components or Forms
Compilation Types
Import Project from Gradle. Page 2
Resource Files
Structural Search and Replace
Extract Interface
Generating Persistence Mappings
Deleting Node Elements from Diagram
Database Console Tool Window
Visual SourceSafe Options Dialog
Apache Felix Framework Integrator
Manipulating Table Data in the Table Editor
Navigation In Source Code
Viewing Local History of Source Code
Fetching Changes from a Remote Git Repository
Importing a Local Directory to Subversion Repository
PHP-Specific Guidelines
Running PHP Applications
Navigating from .feature File to Step Definition
Web Applications
Generating WSDL Document from Java Code
Import Project from Eclipse. Page 2
Import Project from Gradle. Page 1
Import Project from Maven. Page 2
Import Project from Maven. Page 3
Import Project from Maven. Page 4
Add New Field or Constant
Create Jar from Modules Dialog
Rename Dialog for a Class or an Interface
Import Module from External Model
Import Module from External Model. Select Model
Create Module from Scratch
Create Module from Scratch. Module Name, Location and Type
New Project from Scratch
New Project from Scratch. SDK Page
Project Tool Window
Excluding Classes from Auto-Import
Analyzing Applications
Viewing Structure of a Source File
Rerunning Applications
Stopping and Pausing Applications
Navigating Back to Source
Refactoring Source Code
Deleting Files from the Repository
Cloning a Repository from GitHub
Pulling Changes from the Upstream (Git Pull)
Pulling Changes from the Upstream (Pull)
Integrating Files and Changelists from the Changes Tool Window
Generating Xml Schema From Java Code
Debugging PHP Applications
Monitoring Code Coverage for PHP Applications
Comparing Data Sources
Opening JPA or Hibernate ER Diagram
Compiler. Annotation Processors
Opening, Reopening and Closing Projects
Generating a Signed APK Using a Wizard
Defining Seam Navigation Rules
Creating and Opening Forms
Editing Module with EJB Facet
Creating and Editing Relationships
Refactoring Android XML Layout Files
Creating Aspects
GUI Designer Files
Dependencies Tab
Creating and Editing Search Templates
Creating Modules
Configuring Module Dependencies and Libraries
Internationalization and Localization Support
Writing and Executing SQL Commands in the Database Console
Defining Pageflow
Managing Spring Configuration Files
Configuring Global, Project and Module SDKs
Bound Class
Adding Node Elements to Diagram
Local History
External Tools
Welcome Screen
Maven Projects Tool Window
Changing the Settings for All Facets of the Same Type
Inferring Nullity
Move Refactorings
Defining the Set of Changelists to Display
Multiuser Debugging via XDebug Proxies
Mapping by Database Schema
Adding a Struts Facet to a Module
Creating Listeners
Compiler and Builder
Run/Debug Configuration: Flash App
Output Layout Tab
Duplicates Tool Window
Test Runner Tab
IntelliLang Configuration
Running Inspections
External Annotations
Monitoring and Managing Tests
Viewing and Fast Processing of Changelists
Enabling JSF Support
Play Framework
Relational Databases
Enabling Spring Support
Code Style. Java
Select Repository to Clone Dialog
Generate Signed APK Wizard. Specify Key and Keystore
Scope Language Syntax Reference
Generify Refactoring
Working with Tags and Branches
Integrating Changes To/From Feature Branches
Creating and Editing Relationships Between Domain Classes
Creating Run/Debug Configuration for Application Server
Configuring JavaScript Libraries
Navigating to Underlying Code
Creating a Server Configuration
Generating Accessor Methods for Fields Bound to Data
Differences Viewer for Folders and DB Objects
Run/Debug Configuration: J2ME
OSGi Facet Page
Integrate Project Dialog (Subversion)
Extract Superclass
Enabling Android Support
Creating Persistence Units
Creating Step Definition
Run/Debug Configuration: Flash Remote Debug
Creating Project
Android Facet Page
Changing Default Facet Settings
Creating Own Inspections
Starting the Debugger Session
Extract Parameter Object
Getting Local Working Copy of the Repository
Exporting %product% Project to Eclipse
Supported Module Types
Enabling JPA Support
Build Process
PSI Viewer
Run/Debug Configuration: JavaScript Debug
TODO Tool Window
Creating Java Module
Generate Signed APK Wizard
Import Eclipse Workspace
Creating Folders and Grouping Run/Debug Configurations
Push Members Down
Using CVS Watches
Previewing Output of Layout Definition Files
Supported Languages
Enabling Struts Support
Creating Form Initialization Code
Import Project. Select Model
Change Signature Dialogs
Extract Parameter Object Dialog
Run/Debug Configuration: OSGi Bundles
Configuring Third-Party Tools
Creating and Editing File Templates
Creating and Editing Live Templates
Creating and Editing Template Variables
Application Servers
Add / Edit Pattern Dialog
Hibernate and JPA Facet Pages
Web, EJB and Java EE Application Facet Pages
Module Page for a Flash Module
Project Library and Global Library Pages
Menus and Toolbars
Find Tool Window
Run Tool Window
Groovy Shell
Checkout Dialog
Add Relationship
Faces Config Structure
Resource Environment References
Designer Tool Window
Package AIR Application Dialog
General Techniques of Using Diagrams
Components Properties
Familiarize Yourself with %product% Editor
Analyzing Data Flow
Resolving Problems
Configuring Compiler Settings
Creating Line Breakpoints
Examining Suspended Program
Change Class Signature
Wrap Return Value
Refreshing Status
Applying a Branch Entirely on Top of Master
Folding Custom Regions with Line Comments
Debugging with Logcat
Generating a Signed APK Through an Artifact
Navigating Between Actions and Views
Creating and Editing Faces Configuration
Customizing the Component Palette
Copy Dialog
Extract Superclass Dialog
Structural Search and Replace Dialogs
Hierarchy Tool Window
Phing Build Tool Window
Import Database Schema / Import Mappings
%product% Tool Windows
Analyzing Duplicates
Change Method Signature in Java
Extract Field
Rename Refactorings
Creating and Editing Flex Application Elements
Markup Languages and Style Sheets
Creating Elements in Persistence Units
Uploading and Downloading Files
Working with Diagrams
Enabling Web Application Support
New Project. Main Settings
Add Module. Main Settings
Bookmarks Dialog
Open Task Dialog
Extract Interface Dialog
Wrap Return Value Dialog
Reformat Code Dialog
Run/Debug Configuration: PHP Built-in Web Server
Run/Debug Configuration: PHP Remote Debug
Run/Debug Configuration: PHP Web Application
Configuring Menus and Toolbars
File Colors
GUI Designer
Language Injections
Creating Copyright Profiles
JSF Facet Page
Compiler Options tab
Opening Multiple Projects
Android Tool Window
Messages Tool Window
Persistence Tool Window
Structure Tool Window
Web Tool Window
Table Editor
Add/Edit Palette Component
How It Works
Analyzing External Stacktraces
Customizing Profiles
Saving and Reverting Changes
Using External Annotations
Navigating Between Methods and Tags
Customizing Views
Creating Tests
TODO Example
Extract Delegate
Make Method Static
Creating Git Gists
Merging, Deleting, and Comparing Branches
Pushing Changes to the Upstream (Git Push)
Integrating Changes to Branch
Running Command Line Tool Commands
Creating Android Application Components
Enabling EJB Support
Configuring Groovy-Based Frameworks
Enabling Java EE Application Support
Enabling PHP support
Managing File Sets
Defining the Filter Mapping Element
Enabling Web Service Development Support Through a Dedicated Facet
Types of Breakpoints
Encapsulate Fields Dialog
Type Migration Preview
Configuring Keyboard Shortcuts
Compiler. Excludes
Guided Tour Around %product% User Interface
Path Variables
Working With Legacy Projects
Share Project on GitHub Dialog
Rebasing Commits Dialog
Change EJB Classes Dialog
Configuring Folders Within a Content Root
Security Roles
Set Up a New Project
Generating and Updating Copyright Notice
Defining Scope-Profile Combination
Viewing Definition
Creating and Editing Properties Files
Managing Bookmarks
Finding and Replacing Text in File
Reviewing Compilation and Build Results
Setting Log Options
Reloading Classes
Replace Constructor with Builder
Viewing Changes Information
Accessing the CVS Roots Dialog Box
Setting Up a Local Mercurial Repository
Using Perforce Integration
Creating Branches and Tags
Working With Subversion Properties for Files and Directories
Change Method Signature in ActionScript
Choosing the Target Device Manually
Linking Gradle Project
Executing Maven Goal
Working with Maven Dependencies
Activating and Deactivating Maven Profiles
CoffeeScript Support
Working with Lists and Maps
Enabling GWT Support
Object-Relational Mapping (EJB, Hibernate and JPA)
Change Signature in JavaScript
Configuring PHP Development Environment
Creating PHP Documentation Comments
Creating Fields in Persistence Entities
Creating Relationships in Entities
Creating Fields in Hibernate Elements
File Templates
GUI Designer Output Options
Binding Groups of Components to Fields
Setting Text Properties
Creating .feature Files
Creating Relationship Links Between Elements
Creating and Configuring Web Application Elements
Specifying Assembly Descriptor References
Exposing Code as Web Service
Groovy Page
Breakpoints Icons and Statuses
Find Usages. Package Options
Generate Skeleton PHPUnit Test Case Dialog
Optimize Imports Dialog
Override Server Path Mappings Dialog
Productivity Guide
Extract Method Dialog
Move Package Dialog
Shelved Changes
Register New File Type Association Dialog
Run/Debug Configuration: Android Application
Run/Debug Configuration: Android Test
Run/Debug Configuration: Application
Run/Debug Configuration: ColdFusion
Run/Debug Configuration: Node JS
Run/Debug Configuration: Node JS Remote Debug
Run/Debug Configuration: NodeUnit
Run/Debug Configuration: PHPUnit
Run/Debug Configuration: PHPUnit on Server
Run/Debug Configuration: Remote
Specify Inspection Scope Dialog
DBGp Proxy
Create Workspace
Configuring Copyright Profiles
Configuring Code Style
Add / Edit Filter Dialog
Optional MIDP Settings Dialog
GWT Facet Page
General tab
Libraries and Global Libraries
Validation Tab
SDKs. Flexmojos SDK
Android Layout Preview Tool Window
Saving Project as Template
Debug Tool Window
Debug Tool Window. Variables
Debug Tool Window. Watches
Dependency Viewer
Hibernate Console Tool Window
JetGradle Tool Window
JPA Console Tool Window
Module Dependencies Tool Window
Struts Assistant Tool Window
CVS Tool Window
Merge Branches Dialog
Import into Subversion
Commit Changes Dialog
Adding Frameworks Support
Configuring Content Roots
Configuring Module Compiler Output
Configuring Project Compiler Output
Edit Android Platform Dialog
Managing Facets
Enabling Other Users to View Your Files
Managing User Groups
Merge Tags
Split Tags
Framework Definitions
Run Configurations
Tapestry Tool Window
Syntax Highlighting
Creating Packages
Creating Empty Files
Generating Code
Creating Code Constructs by Live Templates
Overriding Methods of a Superclass
Hippie Completion. Expanding Words
Using Suggestion List
Find Usages for Dependencies
Analyzing Dependencies
Exporting Inspection Results
Recognizing Hard-Coded String Literals
Navigating Through the Hierarchy of Methods
Navigating with Breadcrumbs
Splitting and Unsplitting Editor Window
Annotation Processors Support
Reviewing Results
Using TODO
Configuring Debugger Options
Defining TODO Patterns and Filters
Finding the Current Execution Point
Creating Run/Debug Configuration for Tests
Viewing Code Coverage Results
Extract Variable
Putting Labels
Cutting, Copying and Pasting
Handling Differences
Commenting and Uncommenting Blocks of Code
Applying Patches
Working with Annotations
Code Folding
Interactive Rebase
Browsing Subversion Repository
Managing Resources
Configuring Device Layout
Managing Virtual Devices
Generating an APK in the Debug Mode
Using the AspectJ Compiler (ajc)
Adding Build File to Project
Defining Additional Ant Classpath
Executing Ant Target
Configuring Gradle Integration
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Configuring Primary Key
Configuring Service Endpoint
Creating and Editing Assembly Descriptors
Creating Message Listeners
Creating Transfer Objects
Defining Bean Class and Package
Migrating to EJB 3.0
Google App Engine
Creating Google App Engine Project
Dynamic Finders
Launching Groovy Interactive Console
Developing GWT Components
Java EE
Deploying and Running
Working with Application Servers
Updating a Running Java EE Application
Creating JSDoc Comments
Running JavaScript Unit Tests in Browser
Generating DTD
Running and Debugging Node.js
Unit Testing Node.JS
Enabling PHPUnit Support
Profiling the Performance of a PHP Application
Plugin Development Guidelines
Viewing PSI Structure
Using JPA Console
Using Hibernate Console
Mapping to EJB
Remote Hosts
Navigating Within a Conversation
Working with Spring Roo Console
Struts Framework
Struts 2
Enabling Struts 2 Support
Adding a Struts 2 Facet to a Module
GUI Designer Basics
Creating Groups
Live Templates
Live Template Abbreviation
Build File Properties
Generate Groovy Documentation Dialog
Change Class Signature Dialog
Move Class Dialog
Run/Debug Configuration: JSTestDriver
Live Templates
Edit Template Variables Dialog
Mobile Module Settings Tab
Coverage Tool Window
Customize Data Views
DSM Tool Window
Favorites Tool Window
Inspection Tool Window
Import into CVS
Pull Changes Dialog
Tag Dialog
Integrate to Branch
Create Patch Dialog
Knopflerfish Framework Integrator
XPath Search
Run Configurations
Code Inspection
Search Templates
Extract Constant
Stashing and Unstashing Changes
Viewing Pages with Web Contents
Running and Debugging
Analyze Stacktrace Dialog
Differences Viewer
Downloading Options dialog
Find Usages
I18nize Hard-Coded String
Replace Constructor with Builder Dialog
Run/Debug Configuration: JSR45 Compatible Server
Show History for File / Selection Dialog
Code Style. HTML
Editor. Editor Tabs
Library Bundling
Browse Repositories Dialog
Code Folding
Bean Validation Tool Window
Local Tab
Repository and Incoming Tabs
Log Tab
Customize Threads View
Subversion Working Copies Information Tab
Update Project Dialog (Subversion)
Apply Patch Dialog
Unshelve Changes Dialog
Configuring Module Roots
Faces Config Structure - Navigation Rule
Status Bar
Data Binding Wizard
Form Workspace
File Types Recognized by %product%
Structural Search and Replace - General Procedure
Using Help Topics
Code Coverage
Resolving Conflicts
Configuring CVS Roots
Publishing a Project on GitHub
Setting Up a Local Git Repository
Generating Signed and Unsigned Android Application Packages
Simple, Parameterized and Surround Live Templates
Enabling Cucumber Support in Project
Navigating Through a Diagram Using Structure View
Populating Web Module
Testing RESTful Web Services
Run/Debug Configuration
Register %product%
Configure Library Dialog
Create Test
Generate equals() and hashCode() wizard
Supported Version Control Systems
Extract Include File Dialog
Extract Module Dialog
Extract Parameter Dialog
Extract Parameter Dialog for Groovy
Extract Variable Dialog for SASS
Move Members Dialog
Use Interface Where Possible Dialog
Resource Bundle Editor
Run/Debug Configuration: Google AppEngine Dev Server
Run/Debug Configuration: PHP Script
Run/Debug Configuration: Query Language Console
JavaScript. Libraries
Debugger. Data Views
Debugger. Data Type Renderers
Debugger. Groovy
Editor. Colors and Fonts
Editor. Code Completion
Edit Tool Dialog
Output Filters Dialog
File Templates
Quick Lists
Mobile Build Settings Tab
Edit Application Context Dialog
Struts Facet Page
Android Tab
SDKs. Java
SDKs. %product%
SDKs. Mobile
Function Keys
Navigation Between Bookmarks
Navigation Between IDE Components
Tool Windows Reference
Debug Tool Window. Frames
Debug Tool Window. Dump
Creating and Managing Modules
EJB Tool Window
Java EE: App Tool Window
JSF Tool Window
Roo Console Tool Window
Tiles Tab
Validator Tab
Struts Tab
Thumbnails Tool Window
Update Info Tab
SVN Checkout Options Dialog
Lock File Dialog (Subversion)
Revert Changes Dialog
Shelve Changes Dialog
EJB Relationship Properties
New BMP Entity Bean Dialog
New CMP Entity Bean Dialog
Select Accessor Fields to Include in Transfer Object
Choose Device Dialog
Select Android Virtual Device Dialog
Diagram Reference
Diagram Toolbar and Context Menu
Class Diagram Toolbar and Context Menu
Regular Expression Syntax Reference
XPath and XSLT Support
Creating Directories
Generating Constructors
Analyzing Inspection Results
Disabling Intention Actions
Creating Documentation Comments
Viewing Reference Information
Viewing Method Parameter Information
Working With Search Results
Creating and Editing Run/Debug Configurations
Adding, Editing and Removing Watches
Performing Tests
Rerunning Tests
Managing Changelists
Undoing and Redoing Changes
Committing Changes to a Local Git Repository
Configuring Autofolding Behavior
Configuring Format of the Local Working Copy
Creating an Android Run/Debug Configuration
Familiarize Yourself with IDE Navigation
Creating CMP Bean Fields
Extract Parameter in JavaScript
Viewing Styles Applied to a Tag
Viewing Images
PHP Debugging Session
Enabling a Command Line Tool
Enabling Hibernate Support
Navigating to Underlying Code
Defining Mappings
Code Analysis
Managing Struts Elements
Adding GUI Components and Forms to the Palette
Designing GUI. Major Steps
Binding the Form and Components to Code

Go to Web help home page.