IntelliJ IDEA 12 Web Help

Missing Web Help Page

Page create jar from modules appears to be missing.

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

Creating Modules
Creating Files from Templates
Creating New Project from Scratch
Create Jar from Modules Dialog
Creating and Editing Run/Debug Configurations
Creating EJB
Creating Run/Debug Configuration for Tests
New Project from Scratch. Technologies Page
New Project from Scratch. Project Name, Location and Format
Excluding Files and Folders from Deployment
Importing Project from Existing Source Code
Creating Step Definition
Create Module from Existing Sources. Module Structure Page
Import Project from Existing Sources. Project Name and Location
Enabling JSF Support
Checkout from TFS Wizard
Creating Tests
Creating Module from Scratch
Creating Patches
Enabling Web Service Development Support Through a Dedicated Facet
Grouping Modules
Check Out From Subversion Dialog
New Project from Scratch. Android Page
New Project from Scratch. Flash Page
Generate Java Code from WSDL or WADL Dialog
Create Workspace
Import Project from Existing Sources. Module Structure Page
Create Module from Scratch
Create Module from Scratch. Module Name, Location and Type
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 Project
Importing Project from Gradle Model
Enabling Web Application Support
Play Framework
Create Branch or Tag Dialog (Subversion)
Packaging a Module into a JAR File
Create Mercurial Repository Dialog
Create HTML Wrapper for Flex Application Dialog
Checking Out Files from CVS Repository
Setting Up a Local Mercurial Repository
Importing Adobe Flash Builder Projects
Creating Elements in Persistence Units
New Project from Scratch. Grails Page
New Project from Scratch. Griffon Page
Importing Existing Modules
Create CMP Field
Create Android Virtual Device Dialog
Creating Directories
Using the AspectJ Compiler (ajc)
Importing Project from Maven Model
Creating Modules with Groovy and Groovy-Based Frameworks Support
Managing Struts Elements
Import Project from Gradle. Page 2
Creating and Managing Modules
New Project from Scratch. Maven Page
New Project from Scratch. Mobile SDK Specific Options Page
Create Test
Create Patch Dialog
Configuring Module Dependencies and Libraries
Creating Node Elements and Members
Check Out From CVS Dialog
Generate Java Code from XML Schema using XmlBeans Dialog
Creating Griffon Application Module
Create Library dialog
New Project from Scratch. Maven Settings Page
Create Gist Dialog
Generate WSDL from Java Dialog
Generate Java from Xml Schema using JAXB Dialog
Generate XML Schema From Java Using JAXB Dialog
Generate Instance Document from Schema Dialog
Generate Schema from Instance Document Dialog
Restoring a File from Local History
Applying Changes from a Specific Commit to Other Branches (Cherry Picking)
Checking Out Files from Subversion Repository
Working with %product% Features from Command Line
Creating a Module with a Dedicated Struts Facet
Creating and Opening Forms
Creating Grails Application from Existing Code
Creating Tapestry Pages, Componenets, and Mixins
Creating CMP Bean Fields
Creating Persistence Units
Import Project from Eclipse. Page 1
Import Project from Flash Builder. Page 1
Import Project from Maven. Page 1
Configuring Project and Global Libraries
Build Configuration
Enabling Android Support
Creating Aspects
Preparing Plugins for Publishing
Managing File Sets
Enabling Web Service Client Development Support Through a Dedicated Facet
Enabling EJB Support
Generating Java Code from XML Schema
Viewing Table Data from the Data Sources Tool Window
Creating a Module with a Dedicated Struts 2 Facet
Creating and Editing Faces Configuration
Creating and Importing Data Sources
Import Project from Maven. Page 4
Checkout from TFS Wizard: Source Workspace
Create AIR Application Descriptor Dialog
Creating and Editing Properties Files
Checking Out from TFS Repository
GUI Designer Basics
Managing Your Project Favorites
Building, Running and Debugging Flex Applications
Developing RESTful Web Services
Preparing for ActionScript, Flex or AIR application development
Creating Mobile Module
Enabling Spring Support
Checkout from TFS Wizard: Checkout Mode
Set Up a New Project
Extract Interface
Creating Resources
Navigating from .feature File to Step Definition
Deleting Node Elements from Diagram
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 Eclipse. Page 2
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
Checkout from TFS Wizard: Source Server
Checkout from TFS Wizard: Choose Source and Destination Paths
Checkout from TFS Wizard: Choose Source Path
Checkout from TFS Wizard: Summary
Create New Constructor
Create New Method
Import Module from External Model
Import Module from External Model. Select Model
New Project from Scratch
New Project from Scratch. Sources Page
New Project from Scratch. SDK Page
Import Project from Existing Sources
Creating Module from Existing Source Code
Deleting Modules
Excluding Files from Project
Create EJB Local Reference
Create Environment Entry
Create EJB Reference
Create Web Service Reference
Create EJB Resource Reference
Create Message Destination Reference
Create Security Role
Create EJB Resource Environment Reference
Excluding Classes from Auto-Import
Navigating from Stacktrace to Source Code
Annotation Processors Support
Navigating to Source Code from the Debug Tool Window
Deleting Files from the Repository
Fetching Changes from a Remote Git Repository
Cloning a Repository from GitHub
Pulling Changes from the Upstream (Git Pull)
Pulling Changes from the Upstream (Pull)
Exporting Information From Subversion Repository
Integrating Files and Changelists from the Changes Tool Window
Downloading Libraries from Maven Repositories
Generating Instance Document From XML Schema
Generating XML Schema From Instance Document
Generating Xml Schema From Java Code
Running Injected SQL Statements from the Editor
Configuring Modules with Seam Support
Struts Framework
Running and Debugging Node.js
Creating a Project for Plugin Development
Creating and Running Your First Java Application
Testing Android Applications
Managing Tiles
Adding GUI Components and Forms to the Palette
Project Tool Window
Creating Maven Run/Debug Configuration
Creating Module with Groovy Support
Testing PHP Applications
Creating Relationships in Entities
File Templates
Analyzing Module Dependencies
Creating Hibernate Elements in a Session Factory
Enabling Struts Support
EJB Tool Window
Configuring Annotation Processing
Creating Run/Debug Configuration for Application Server
Populating Web Module
Web Services
Components Properties
Add/Edit Palette Component
How It Works
Creating Git Gists
Creating a Library for aspectjrt.jar
Exporting %product% Project to Eclipse
Creating TestNG Test Classes
Creating Examples Table in Scenario Outline
Creating and Editing Live Templates
Persistence Tool Window
Connecting to or Creating Jabber Account
Customizing Profiles
Extract Parameter Object
Managing Virtual Devices
Creating Groovy Tests and Navigating to Tests
Creating a Module with a GWT Facet
Creating Groups
Creating Listeners
Configuring Keyboard Shortcuts
Configuring Colors and Fonts
Seam Tool Window
Managing Facets
Import Eclipse Workspace
Creating Empty Files
Adding Tags
Enabling Java EE Application Support
Bound Class
Temporary and Permanent Run/Debug Configurations
Output Layout Tab
Generate Signed APK Wizard
Configuring Artifacts: Layout Structure
Code Inspection
Compiling Target
Generating a Signed APK Using a Wizard
Generating a Signed APK Through an Artifact
Creating Google App Engine Project
Creating Grails Application Module
PHP-Specific Guidelines
Running PHP Applications
Adding a Struts 2 Facet to a Module
Generating Accessor Methods for Fields Bound to Data
Compiler: Flex Compiler
Android Facet Page
OSGi Facet Page
CDI Tool Window
Database Tool Window
Creating Java Module
Managing User Groups
Intention Actions
Documenting Source Code in %product%
Managing Bookmarks
Creating an Android Run/Debug Configuration
Unit Testing Node.JS
Enabling Struts 2 Support
Open Task Dialog
Creating Copyright Profiles
Opening, Reopening and Closing Projects
Web Tool Window
Web Module Editor - General
Package AIR Application Dialog
Creating Test Methods
Extract Delegate
Testing Flex and ActionScript Applications
Running and Debugging Android Applications
Sharing Android Source Code and Resources Using Library Projects
Editing Module with EJB Facet
Creating Grails Application Elements
Debugging JavaScript
Monitoring Code Coverage for JavaScript
Enabling Hibernate Support
Managing Spring Configuration Files
Localizing Forms
Creating .feature Files
Extract Parameter Object Dialog
Dependencies Tab
DSM Tool Window
Checkout Dialog
Import Database Schema / Import Mappings
Generate Signed APK Wizard. Specify Key and Keystore
Run Configurations
Creating Own Inspections
TODO Example
Creating Branches and Tags
Creating Maven Module
Creating Grails Views and Actions
Configuring a DDL Data Source
Enabling JPA Support
Creating and Configuring Web Application Elements
Import Project or Module Wizard
Maven. Importing
File Templates
Working With Legacy Projects
Form Workspace
Editing Resource Bundle
Extract Superclass
Adding Files to Version Control
Configuring Format of the Local Working Copy
Creating and Editing Flex Application Elements
Editing Maven Settings
JavaScript-Specific Guidelines
Creating JSDoc Comments
Creating PHP Documentation Comments
Relational Databases
Creating and Editing Relationships
Generating Persistence Mappings
Defining Pageflow
Adding a Struts Facet to a Module
GUI Designer Files
Binding Groups of Components to Fields
Copy Dialog
Extract Method Dialog
Wrap Return Value Dialog
Run/Debug Configuration: JSTestDriver
Run/Debug Configuration: TestNG
Compiler. Annotation Processors
Issue Navigation
Mobile Module Settings Tab
Web, EJB and Java EE Application Facet Pages
Maven Projects Tool Window
Commit Changes Dialog
Generating Delegation Methods
Managing Resources
Generating an Unsigned APK
Enabling Cucumber Support in Project
Creating and Deleting Web Application Elements - General Steps
Configuring Web Application Deployment
Generating Client-Side XML-Java Binding
Encapsulate Fields Dialog
Run/Debug Configuration: JUnit
Copyright Profiles
Schemas and DTDs
Associating a Copyright Profile with a Scope
Mobile Build Settings Tab
AspectJ Facet Page
Hibernate and JPA Facet Pages
Libraries and Global Libraries
Customize Data Views
Select Repository to Clone Dialog
Enable Web Services Support Dialog
Configuring Artifacts
Generating and Updating Copyright Notice
DSM Analysis
Introduce Parameter in Java
Specifying Actions to Confirm
Moving an Opened File to Another Changelist
Moving Items Between Changelists in the Changes Tool Window
Committing Changes to a Local Git Repository
Publishing a Project on GitHub
Refactoring Android XML Layout Files
Introduce Parameter in Groovy
Creating a Serializable Class
Analyzing GWT Compiled Output
Configuring PHP Development Environment
Struts 2
Web Service Clients
New Action Dialog
Run/Debug Configuration: JSR45 Compatible Server
Run/Debug Configuration: Node JS
Run/Debug Configuration: Plugin
Run/Debug Configuration: XSLT
Creating and Editing File Templates
Ignored Files
Live Templates
Spring Facet Page
Struts 2 Facet Page
Repository and Incoming Tabs
Debug Tool Window. Watches
Java EE: App Tool Window
History Tab
Share Project on GitHub Dialog
Login to GitHub Dialog
Faces Config Structure
New Servlet Dialog
Enabling Tapestry Support
Completing Statements
Using External Annotations
Creating and Editing Search Templates
Configuring Compiler Settings
Performing Tests
Creating TODO Items
Rename Refactorings
Cutting, Copying and Pasting
Working with Tags and Branches
Stashing and Unstashing Changes
Working With Subversion Properties for Files and Directories
Creating and Managing TFS Workspaces
Using Command Line Tools
ActionScript, Flex and AIR
Designing Layout of Android Application
Choosing the Target Device Manually
Binding Macros With Keyboard Shortcuts
Working with Maven Dependencies
Importing Eclipse Project to %product%
Configuring Primary Key
Using EJB ER Diagram
Working with Lists and Maps
Creating a GWT UiBinder
GWT Sample Application Overview
Opening a GWT Application in the Browser
Deploying and Running
Updating a Running Java EE Application
Creating JavaScript Unit Tests
Monitoring Code Coverage for PHP Applications
Plugin Development Guidelines
Generating a Data Structure Definition (DDL) File
Mapping by Database Schema
Mapping to EJB
Mapping to Hibernate
Customizing the Component Palette
Grouping and Ungrouping Components
Configuring Default Settings for Diagrams
Creating Relationship Links Between Elements
Viewing Changes as Diagram
Compilation Types
New Project Wizard
Groovy Page
Add Module Wizard
Convert Project Dialog
Type Migration Preview
Run/Debug Configuration: Flash App
Run/Debug Configuration: Flash Remote Debug
Run/Debug Configuration: FlexUnit
Run/Debug Configuration: JavaScript Debug
Run/Debug Configuration: MXUnit
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
Add Server Dialog
Framework Integration
Accessing Default Project Settings and Structure
Framework Settings
Debugger. Data Type Renderers
Specifying Template Data Languages for Templates
Copying Code Style Settings
Plugin Deployment Tab
Bean Validation Facet Page
CDI Facet Page
GWT Facet Page
JSF Facet Page
Web Services Facet Page
Web Services Client Facet Page
Importing Project
SDKs. Flexmojos SDK
Converting Project into Directory-Based Format
Saving Project as Template
Import Data Sources Dialog
Debug Tool Window. Variables
New Changelist Dialog
Apply EJB 3.0 Style
EJB Module Editor - EJB Relationships
JSF Faces Config Editor
Faces Config Structure - Managed Beans
Configuring Project Compiler Output
Components of the GUI Designer
Changing Default Facet Settings
Replace Attribute With Tag
Replace Tag With Attribute
Convert Contents To Attribute
Merge Tags
Split Tags
Wrap Tag
Wrap Tag Contents
Framework Definitions
Populating Projects
Creating Packages
What's New
Generating Constructors
Generating main() method. Example of Applying a Simple Live Template
Implementing Methods of an Interface
Iterating over an Array. Example of Applying Parameterized Live Templates
Overriding Methods of a Superclass
Analyzing Backward Dependencies
Analyzing Data Flow
Validating Dependencies
External Annotations
Internationalization and Localization Support
Resource Files
Navigating to Custom Region
Splitting and Unsplitting Editor Window
Using TODO
Adding, Editing and Removing Watches
Configuring Testing Libraries
Encapsulate Fields
Generify Refactoring
Introduce Property
Replace Inheritance with Delegation
Wrap Return Value
Configuring Ignored Files
Ignoring Files
Using Git Integration
Browsing Subversion Repository
Resolving Text Conflicts
Sharing Directory
Enabling Integration with an Issue Tracking System
Creating Android Application Components
Creating Ant Build File
Adding Build File to Project
Linking Gradle Project
Creating Local and Remote Interfaces
Creating Transfer Objects
Running and Debugging Groovy Scripts
Working with Application Servers
Configuring and Managing Application Server Integration
Running/Debugging Mobile Application
Viewing Inline Documentation
Running JavaScript Unit Tests in Browser
PHP-Specific Command Line Tools
Creating a List of Phing Build Files
Running and Debugging Plugins
Data Sources
Creating Session Factory
Creating Fields in Hibernate Elements
Navigating to Underlying Code
Viewing Seam Components
Defining Seam Navigation Rules
Using Spring Bean Patterns
Struts Data Sources
Managing Struts Elements - General Steps
Managing Struts 2 Elements
Binding the Form and Components to Code
Populating Your GUI Form
Duplicating Components
Morphing Components
Live Template Abbreviation
New Project. Main Settings
Bookmarks Dialog
Generate Ant Build
Run/Debug Configuration: Applet
Deployment: Connection Tab
GUI Designer
Language Injections
Project Structure Dialog
Struts Facet Page
General tab
Function Keys
Dependency Viewer
Favorites Tool Window
Struts Tab
Update Directory / Update File Dialog (CVS)
Components Treeview
Data Binding Wizard
Project and IDE Settings
General Usage
Usage Examples
IntelliLang Configuration
Tapestry View
Error Highlighting
File Associations
Extracting Hard-Coded String Literals
Structural Search and Replace Examples
Extract Method
Push Members Down
Getting Local Working Copy of the Repository
Setting Up a Local Git Repository
Using Mercurial Integration
Integrating Changes To/From Feature Branches
Developing GWT Components
Path Variables
Creating Form Initialization Code
Working with Diagrams
Configuring Static Content Resources
Defining the Servlet Element
Enabling an Extra WS Engine in a Web Services Module
Testing RESTful Web Services
Generate Groovy Documentation Dialog
Login to IntelliJ Configuration Server Dialog
Change Signature Dialogs
Extract Delegate Dialog
Extract Method Object Dialog
Move Class Dialog
Replace Constructor with Builder Dialog
Run/Debug Configurations
Run/Debug Configuration: Grails
Run/Debug Configuration: Groovy
Run/Debug Configuration: Query Language Console
Exporting and Importing Settings
Configuring Project Settings
Editor. Colors and Fonts
Editor. Auto Import
Edit Template Variables Dialog
Project Library and Global Library Pages
Pre-Processing Tab
Android Tool Window
Log Tab
Hierarchy Tool Window
IDEtalk and IDEtalk Messages Tool Windows
Test Runner Tab
Play Framework (Play Console)
Tag Dialog
Unstash Changes Dialog
Push Dialog
Link Job to Changelist Dialog
Configuring Content Roots
Select Android Virtual Device Dialog
Regular Expression Syntax Reference
Creating Imports
Navigating Between Test and Test Subject
Compiling Applications
Code Coverage
Resolving Conflicts
Git Branches in Multirooted Projects
Running Command Line Tool Commands
CoffeeScript Support
Google App Engine
Supported Module Types
Processing Order
Managing Validators
File Template Variables
Testing Frameworks
Run/Debug Configuration
Build File Properties
Types of Breakpoints
Generate JavaDoc Dialog
Extract Field Dialog
Extract Include File Dialog
Extract Interface Dialog
Extract Parameter Dialog
Extract Parameter Dialog for Groovy
Extract Superclass Dialog
Package and Class Migration Dialog
Replace Constructor with Factory Method Dialog
Replace Inheritance with Delegation Dialog
Run/Debug Configuration: Google AppEngine Dev Server
Run/Debug Configuration: J2ME
Run/Debug Configuration: Maven
Select Path Dialog
Show History for File / Selection Dialog
Structural Search and Replace Dialogs
Code Style
Code Style. Java
Creating and Registering File Types
Code Style Schemes
JavaScript. Libraries
Guided Tour Around %product% User Interface
Edit Subversion Options Related to Network Layers Dialog
Manage TFS Servers and Workspaces
XSLT File Associations
Debugger. Data Views
New File Type
OSGi: Framework Definitions
Library Bundling
Path Variables
Browse Repositories Dialog
Quick Lists
Local Tab
Database Console Properties Dialog
Find Tool Window
Hibernate Console Properties Dialog
JPA Console Properties Dialog
JSF Tool Window
Module Dependencies Tool Window
Roo Console Tool Window
CVS Roots Dialog
Import into CVS
Clone Repository Dialog
Merge Branches Dialog
Git Push Dialog
Pull Changes Dialog
Stash Dialog
Clone Mercurial Repository Dialog
SVN Checkout Options Dialog
Import into Subversion
SVN Repositories
Apply Patch Dialog
Revert Changes Dialog
Visual SourceSafe Options Dialog
EJB Relationship Properties
EJB Editor - General Tab - Entity Bean
EJB Editor - Assembly Descriptor
Add Relationship
Faces Config Structure - Navigation Rule
New Bean Dialogs
New Session Bean Dialog
New Message Bean Dialog
New BMP Entity Bean Dialog
New CMP Entity Bean Dialog
Choose Servlet Package
New Filter Dialog
New Listener Dialog
Class Diagram Toolbar and Context Menu
Adding and Removing Facets
Quick Edit Language
Project Settings
Creating Code Constructs by Live Templates
Configuring Inspection Severities
Creating Documentation Comments
Viewing Inline Documentation
Properties Files
Navigating with Bookmarks
Starting the Debugger Session
Inspecting Watched Items
Extract Constant
Zooming in the Editor
Checking In Files
Managing Changelists
Using Patches
Viewing Changes Information
Registering GitHub Account in %product%
Managing Tasks and Context
Building ActionScript and Flex Applications
Enabling AspectJ Support Plugins
Enabling GWT Support
Creating Event and Event Handler Classes
Configuring JavaScript Libraries
PHP Built-In Web Server
Using PHP Code Sniffer Tool
Content Root
Configuring XDebug
Configuring Zend Debugger
Enabling a Command Line Tool
Accessing Data Sources via the Database Console
Using Hibernate Console
Defining Mappings
Placing Non-Palette Components or Forms

Go to Web help home page.