IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page Creating Module from Scratch.xml appears to be missing.

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

Creating New Project from Scratch
Accessing Module Settings
Configuring Module Dependencies and Libraries
Creating Files from Templates
Creating Module from Scratch
Grouping Modules
Module Page
Web Module Editor
Creating Module with Groovy Support
Module Dependencies Tool Window
Creating Griffon Application Module
Creating a Module with a GWT Facet
Creating Grails Application Module
Creating Java Module
Creating Maven Module
Add Module Wizard
Creating Modules
Preparing for ActionScript, Flex or AIR application development
Add Module. Main Settings
Create Jar from Modules Dialog
Creating and Editing Run/Debug Configurations
Using the AspectJ Compiler (ajc)
Creating a Module with a Dedicated Struts Facet
Creating Mobile Module
Import Project from Existing Sources. Module Structure Page
Importing Existing Modules
Creating Modules with Groovy and Groovy-Based Frameworks Support
Creating and Running Your First Java Application
Enabling JSF Support
Creating Module from Existing Source Code
Creating a Module with a Dedicated Struts 2 Facet
Create Module from Existing Sources. Module Structure Page
Creating a GWT Module
Configuring Project and Global Libraries
Creating and Registering File Types
Editing Module with EJB Facet
Excluding Files and Folders from Deployment
Enabling Android Support
New Project from Scratch. Android Page
Creating and Opening Forms
Analyzing Module Dependencies
Importing Project from Gradle Model
Import Project from Existing Sources. Project Name and Location
New Project from Scratch. Project Name, Location and Format
Creating and Managing Modules
How It Works
Module Page for a Flash Module
Checkout from TFS Wizard
New Project from Scratch. Maven Page
Configuring Module Compiler Output
Generate Java Code from WSDL or WADL Dialog
Build Configuration
Deleting Modules
Enabling Spring Support
Sharing Android Source Code and Resources Using Library Projects
New Project from Scratch. SDK Page
EJB Module Editor - EJB Relationships
New Project from Scratch. Flash Page
Build Configuration page for a Flash module
Creating Google App Engine Project
Configuring Modules with Seam Support
Adding a Struts Facet to a Module
Import Project from Gradle. Page 2
Create Module from Scratch. Module Name, Location and Type
Creating Tests
Supported Module Types
New Project. Main 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
Create Module from Existing Sources. Source Roots Page
Create Module from Existing Sources. Libraries Page
Creating Grails Application from Existing Code
Play Framework
Check Out From Subversion Dialog
Creating Documentation Comments
Creating JSDoc Comments
Creating and Importing Data Sources
New Project from Scratch. Technologies Page
Creating and Editing File Templates
Importing Project from Existing Source Code
Populating Web Module
Packaging a Module into a JAR File
Testing Android Applications
Enabling EJB Support
Creating and Configuring Web Application Elements
EJB Module Editor - General
Creating Hibernate Elements in a Session Factory
New Project from Scratch. Mobile SDK Specific Options Page
Exporting %product% Project to Eclipse
Creating a Project for Plugin Development
Enabling JPA Support
Adding a Struts 2 Facet to a Module
Configuring Module Roots
Adding a GWT Facet to a Module
Creating Elements in Persistence Units
Project Tool Window
Generate Java from Xml Schema using JAXB Dialog
Enabling Hibernate Support
Creating and Deleting Web Application Elements - General Steps
Extract Module Dialog
New Project from Scratch. Maven Settings Page
Check Out From CVS Dialog
Generate Java Code from XML Schema using XmlBeans Dialog
Creating a Library for aspectjrt.jar
Creating EJB
New Project from Scratch. Grails Page
New Project from Scratch. Griffon Page
EJB Module Editor - Transaction Attributes
Generate WSDL from Java Dialog
Generate XML Schema From Java Using JAXB Dialog
Generate Instance Document from Schema Dialog
Generate Schema from Instance Document Dialog
Creating %language% %symbols%
Creating Code Constructs by Live Templates
Creating Imports
Creating and Editing Search Templates
Making Module
Creating Test Methods
Restoring a File from Local History
Creating Issue Patterns
Checking Out Files from CVS Repository
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Checking Out Files from Subversion Repository
Creating Resources
Creating an Android Run/Debug Configuration
Importing Project from Maven Model
Working with %product% Features from Command Line
Creating PHP Documentation Comments
Creating Session Factory
Creating Form Initialization Code
Enabling Web Service Development Support Through a Dedicated Facet
Editing Module Dependencies on Diagram
Enabling Web Application Support
Enabling an Extra WS Engine in a Web Services Module
Creating and Editing Flex Application Elements
Creating an Entry Point
Creating a Remote Service
Enabling Java EE Application Support
Creating Persistence Units
Import Project from Maven. Page 1
Dependencies Tab
Available Facets and Their Dependencies
Creating Relationships in Entities
Enabling an Extra WS Engine (Web Service Client Module)
Import Project from Eclipse. Page 1
Paths Tab
Generating Java Code from XML Schema
Adding WS Libraries to a Web Service Client Module Manually
Adding WS Libraries to a Web Service Module Manually
Import Project or Module Wizard
Import Project from Flash Builder. Page 1
EJB Module Editor
Configuring Global, Project and Module SDKs
Creating Run/Debug Configuration for Tests
Creating and Editing Faces Configuration
Processing Order
Struts Framework
Struts 2
Creating TestNG Test Classes
Creating Relationship Links Between Elements
Mobile Module Settings Tab
Creating Own Inspections
Creating Patches
Downloading Libraries from Maven Repositories
Creating Grails Application Elements
Creating and Editing Relationships Between Domain Classes
Set Up a New Project
Compiling Target
Content Root
Android Facet Page
Import Project from Eclipse. Page 2
DSM Tool Window
Creating Directories
Creating and Saving Temporary Run/Debug Configurations
Creating Maven Run/Debug Configuration
Creating Run/Debug Configuration for Application Server
Creating .feature Files
Creating Step Definition
Navigating from .feature File to Step Definition
Creating Examples Table in Scenario Outline
Creating Node Elements and Members
Deleting Node Elements from Diagram
Enabling Web Service Client Development Support Through a Dedicated Facet
Generating WSDL Document from Java Code
Import Project from Existing Sources. Source Roots Page
Import Project from Existing Sources. Libraries Page
Import Project from Existing Sources. Facets Page
Import Project from Flash Builder. 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
Checkout from TFS Wizard: Checkout Mode
Checkout from TFS Wizard: Source Server
Checkout from TFS Wizard: Choose Source and Destination Paths
Checkout from TFS Wizard: Source Workspace
Checkout from TFS Wizard: Choose Source Path
Checkout from TFS Wizard: Summary
New Project from Scratch
New Project from Scratch. Sources Page
Import Project from Existing Sources
Creating and Editing Live Templates
Creating and Editing Template Variables
Creating Copyright Profiles
Creating and Managing Projects
Creating Project
EJB Tool Window
Importing Existing Module
EJB Module Editor - Method Permissions
Excluding Files from Project
Web Module Editor - General
Web Module Editor - Assembly Descriptor References
Web Module Editor - Assembly Descriptor
Web Module Editor - Servlet Initialization Parameters
Web Module Editor - Filter Mappings
Web Module Editor - Context Parameters
Web Module Editor - Servlet Mappings
Connecting to or Creating Jabber Account
Creating Tapestry Pages, Componenets, and Mixins
Creating Packages
Creating Empty Files
Creating Code Constructs Using Surround Templates
Creating and Optimizing Imports
Excluding Classes from Auto-Import
Creating and Editing Properties Files
Navigating from Stacktrace to Source Code
Creating Folders and Grouping Run/Debug Configurations
Creating Exception Breakpoints
Creating Field Watchpoints
Creating Line Breakpoints
Creating Method Breakpoints
Navigating to Source Code from the Debug Tool Window
Creating TODO Items
Deleting Files from the Repository
Creating a New Changelist
Fetching Changes from a Remote Git Repository
Cloning a Repository from GitHub
Creating Git Gists
Creating a New Branch
Pulling Changes from the Upstream (Git Pull)
Pulling Changes from the Upstream (Pull)
Creating Branches and Tags
Exporting Information From Subversion Repository
Integrating Files and Changelists from the Changes Tool Window
Creating and Managing TFS Workspaces
Checking Out from TFS Repository
Creating and Deleting Tasks
Creating a Command Line Tool
Creating Android Application Components
Creating Aspects
Creating Ant Build File
Creating and Editing Assembly Descriptors
Creating CMP Bean Fields
Creating Local and Remote Interfaces
Creating Message Listeners
Creating Transfer Objects
Creating Grails Views and Actions
Creating Groovy Classes, Interfaces, Enumerations and Annotations
Creating Groovy Scripts
Creating Groovy Tests and Navigating to Tests
Creating a Serializable Class
Creating a GWT UiBinder
Creating Event and Event Handler Classes
Creating JavaScript Unit Tests
Generating Instance Document From XML Schema
Generating XML Schema From Instance Document
Generating Xml Schema From Java Code
Creating a PHP Web Application Debug Configuration
Creating a List of Phing Build Files
Viewing Table Data from the Data Sources Tool Window
Running Injected SQL Statements from the Editor
Creating Fields in Persistence Entities
Creating and Editing Relationships
Creating Fields in Hibernate Elements
Creating a Server Configuration
Creating Groups
Creating and Disposing of a Form's Runtime Frame
Creating Listeners
Run/Debug Configuration: JUnit
Run/Debug Configuration: TestNG
Enabling Tapestry Support
Developing RESTful Web Services
Output Layout Tab
Annotation Processors Support
Path Variables
Configuring Groovy-Based Frameworks
Enabling Struts 2 Support
Build Process
Framework Integration
Web Tool Window
Run Configurations
Configuring Compiler Settings
Seam Tool Window
GWT Facet Page
Managing Facets
TODO Example
File Templates
Generating Client-Side XML-Java Binding
Sources Tab
Configuring Project Compiler Output
Import Eclipse Workspace
Developing GWT Components
Viewing Seam Components
Compiler: Flex Compiler
OSGi Facet Page
CDI Tool Window
Java EE: App Tool Window
Building ActionScript and Flex Applications
Importing Adobe Flash Builder Projects
Enabling Struts Support
Specifying Assembly Descriptor References
Web Services
Saving Project as Template
Adding and Removing Facets
File Associations
Configuring Annotation Processing
Managing Spring Configuration Files
Enabling Cucumber Support in Project
Run/Debug Configuration: Grails
Compiler Options tab
Persistence Tool Window
Basic Code Completion. Completing Names and Keywords
Enabling GWT Support
Preparing Plugins for Publishing
Defining Seam Navigation Rules
Defining Pageflow
RESTful WebServices
Compilation Types
Run/Debug Configuration: XSLT
Language Injection Settings: Generic JavaScript
Bean Validation Facet Page
CDI Facet Page
JSF Facet Page
Struts 2 Facet Page
Web Services Facet Page
Web Services Client Facet Page
Scope Language Syntax Reference
Analyzing Backward Dependencies
Compiling Applications
Compiler. Annotation Processors
Mobile Build Settings Tab
AspectJ Facet Page
Web, EJB and Java EE Application Facet Pages
Finding and Replacing Text in Project
Generating an Unsigned APK
GWT Sample Application Overview
Run/Debug Configuration: Applet
Maven. Importing
Welcome Screen
DDL Data Source Properties
Dependency Viewer
Generate GWT Compile Report Dialog
Tapestry View
What's New
DSM Analysis
External Annotations
Using External Annotations
Building, Running and Debugging Flex Applications
Managing Virtual Devices
Running Grails Targets
JavaScript-Specific Guidelines
Managing File Sets
Web Applications
Compiler and Builder
Web Service Clients
Run/Debug Configuration: GWT
Run/Debug Configuration: J2ME
Plugin Deployment Tab
DB Data Source Properties
Edit File Set
Generating equals() and hashCode()
Managing Your Project Favorites
Configuring Testing Libraries
ActionScript, Flex and AIR
Synchronizing Changes in Gradle Project and IntelliJ IDEA Project
Working with Maven Dependencies
Importing Eclipse Project to %product%
Introduce Parameter in Groovy
Working with Application Servers
Configuring a DDL Data Source
Configuring Libraries of UI Components
Running Cucumber Tests
Viewing Changes as Diagram
Configuring Web Application Deployment
Enabling Web Service Client Development Support
Enabling Web Service Development Support
Copy Dialog
Type Migration Preview
Run/Debug Configuration: Android Test
Run/Debug Configuration: Plugin
Configuring Third-Party Tools
Compiler. Java Compiler
External Tools
Configuring Code Style
Web Resource Directory Path Dialog
Menus and Toolbars
Struts Assistant Tool Window
Create Branch or Tag Dialog (Subversion)
Adding Frameworks Support
Enable Web Services Support Dialog
Edit Android Platform Dialog
Generate Signed APK Wizard
%product% vs Eclipse Terminology
%product% vs NetBeans Terminology
Regular Expression Syntax Reference
Adding Auto-Detected Facets
Populating Projects
Analyzing Duplicates
Familiarize Yourself with %product% Editor
Intention Actions
Using Language Injections
Editing Resource Bundle
Applying Patches
Configuring Global CVS Settings
Generating a Signed APK Through an Artifact
Generating Ant Build File
Testing Grails Applications
Working with Grails Plugins
Running and Debugging Groovy Scripts
Object-Relational Mapping (EJB, Hibernate and JPA)
Configuring Mobile Java SDK
Viewing PSI Structure
Relational Databases
Using JPA Console
Using Hibernate Console
Mapping to EJB
Navigating to Underlying Code
Managing Struts Elements
Managing Tiles
Managing Struts 2 Elements
GUI Designer Basics
Binding the Form and Components to Code
Generating Accessor Methods for Fields Bound to Data
Generate Ant Build
Run/Debug Configuration: Android Application
Run/Debug Configuration: Groovy
Run/Debug Configuration: OSGi Bundles
Code Style Schemes
Project Structure Dialog
Libraries and Global Libraries
Function Keys
Find Tool Window
Update Directory / Update File Dialog (CVS)
Configuring Project Structure
Package AIR Application Dialog
XPath Search
Extracting Hard-Coded String Literals
Search Templates
Starting the Debugger Session
Google App Engine
Configure Library Dialog
Extract Constant Dialog
Move Class Dialog
Run/Debug Configuration: Flash Remote Debug
Run/Debug Configuration: Node JS
Select Path Dialog
Manage TFS Servers and Workspaces
Google App Engine Facet Page
Hibernate and JPA Facet Pages
Edit Application Context Dialog
General tab
Dependencies tab
Repository and Incoming Tabs
Maven Projects Tool Window
Import into CVS
Create Patch Dialog
Configuring Content Roots
Viewing External Documentation
Properties Files
Browsing CVS Repository
Using Git Integration
Git Branches in Multirooted Projects
Generating Signed and Unsigned Android Application Packages
Supported Languages
Working with Diagrams
Configuring Static Content Resources
Defining the Servlet Element
Defining the Filter Element
Defining the Filter Mapping Element
Testing RESTful Web Services
Temporary and Permanent Run/Debug Configurations
Build File Properties
Create Test
Downloading Options dialog
Generate equals() and hashCode() wizard
Play Configuration Dialog
Copyright Profiles
XSLT File Associations
File Templates
Tool Windows Reference
JSF Tool Window
Play Framework (Play Console)
TODO Tool Window
Apply EJB 3.0 Style
Change EJB Classes Dialog
EJB Relationship Properties
Import Database Schema / Import Mappings
Faces Config Structure - Navigation Rule
Expose Class As Web Service Dialog
Monitor SOAP Messages Dialog
Class Diagram Toolbar and Context Menu
Components Properties
File Types Recognized by %product%
XPath and XSLT Support
Dependencies Analysis
Annotating Source Code
Documenting Source Code in %product%
Navigating Between Test and Test Subject
Commenting and Uncommenting Blocks of Code
Handling Issues
Undoing and Redoing Changes
Enabling Integration with an Issue Tracking System
Designing Layout of Android Application
Configuring and Managing Application Server Integration
Configuring %product% Plugin SDK
Configuring a DB Data Source
Struts Data Sources
Managing Struts Elements - General Steps
Designing GUI. Major Steps

Go to Web help home page.