Enterprise Architect 12 - ÊÊÓÃÓÚÈí¼þ¿ª·¢, ÒµÎñ·ÖÎöºÍϵͳ¹¤³Ì

Portals window

A major new feature in Enterprise Architect 12. Provides rapid and focused access to many common and many advanced features.

• Access to open and recently closed documents
• Searches
• Common functions
• Workspaces
• Perspectives
• Working sets
• and much more...

A new and indispensable tool for navigating and building models. Access to Portal pages is also available by clicking on the Start Page icons associated with each page. (View/Portals)

Providing rapid access to common commands, to searches, to recent documents, user interface themeing, workspace layouts and more

• Fast, simple list of actions that you can perform based on current area of interest
  • Accessible from View/Portals
  • Also accessible from the Start Page (portal icons are arranged on Start Page for quick access)
  • Portals bar is also available from the drop menu of the new Navigator bar and from the toolbar context menu

Start:

• Commands for creating a model or connecting to an existing one
  • Access recently opened models
  • Connect to a server or the cloud
  • Access your current tasks, the current model calendar and model mail
• Find recent changes in your model
• Find what needs to be done next
• Get Help from the many resources provided by Sparx Systems
  • Search in the model or in files
  • Access Help

Viewpoint:

• Choose how to view a package - as a list, Gantt chart or requirements specification
• Switch view for a diagram. Supports list, Gantt and graphical modes
• Configure the Visual style of Enterprise Architect
• Save and manage Workspace Layouts
• Save and Manage Working Sets
• Save and Manage user interface Perspectives
• Open a working set based on the current model (list of defined working sets shown)
• Switch to a defined perspective
• Switch to a defined workspace layout

Model:

• Explore the model using the Project Browser, the Package Browser (list, Gantt or specification view) or find a package by name
  • Add new models, packages, diagrams and elements.
  • Add new packages and models based on predefined patterns
  • Access custom modeling tools such as:
    • The Specification Manager for requirements
    • The Scenario Builder for defining detailed use case scenarios
    • The Decision Table Editor to define business and logic rules
    • The Database Builder to create, access, manage, difference and query modeled databases
    • The Schema Composer to rapidly build XSD and other target outputs from selected elements and properties within a model
  • Trace relationships using a number of different mechanisms. Find, access and visualize related elements easily
  • Run model transforms on elements or packages
• Display both core windows for modeling and the large list of additional windows to help create your model

Verify:

• Includes Simulation, Testing and Testpoint management
• Quickly locate simulations and 'active' elements and diagrams in your model
  • Access the Simulation workspace layout
• Access tools and windows relevant to running and controlling simulations
• Run a range of searches designed to quickly locate recent work, failures, successes, not run and recently run tests
  • Find deferred tests, tests not checked and create Testing Reports
  • Access Testpoint tools and Testpoint layouts
• Access the Testing layout
  • Run model validation

Execute:

• Access the full set of Visual Analysis tools to debug, profile, record and build your software systems
• Manage build scripts, build, run, test and deploy
• Access advanced recording tools that allow you to create diagrams and call graphs from executing code
• Profile your executing software to identify optimization 'hot spots' and to build call graphs
  • Access the fully featured integrated debugger to:
    • Set and manage Breakpoints
      • Set and manage Tracepoints
      • Set and Manage Action points
      • View the call stack
      • Inspect local variables
      • Inspect memory
      • List loaded modules
      • Manage watches
      • Use the object workbench
• Apply the debugging workspace to quickly move into software construction mode

Publish:

• Generate documentation in HTML or in rich text (RTF and DOCX) format
  • Publish your model in a variety of specific formats, such as XMI, OWL, ECore, BPMN, XPDL and MOF
• Import a range of target information
  • Source code files in a wide range of languages
  • Database schema using ODBC
  • Binary files created in .NET
  • WSDL
  • XSD
• Generate code from your model
  • Generate source code in a variety of languages
    • Generate DDL from your data model
    • Generate XSD from your XSD model
    • Generate WSDL from a suitable WSDL model
• Exchange model information (import and export)
  • Connect to a RAS (Reusable Asset Service) server and import models
    • Import model information in XMI format
    • Import model reference data
    • Export model information as XMI
    • Export model reference data
  • Edit templates
    • Edit Document templates (for RTF and DOCX generation)
    • Edit code templates
    • Edit Transformation templates

Manage:

• Access tools to manage a shared model and a team of modelers
  • Access Project and Package based Gantt charts
  • Access, edit and examine resource allocations
  • Check on high level project tasks and status
  • Assign tasks
  • Track tasks and resource allocations in various states with new searches
    • Recently completed
    • Starting today
    • Overdue
    • Ending today
    • Active
    • Find Kanban diagrams
  • Tools
    • Find baselines
    • Access auditing information
    • Access the scripting tools
  • Package control
    • Configure package control and load and save package to XMI
    • View XMI
    • Compare current model to previously exported XMI (difference)
    • Merge package with XMI (requires Merge file)
  • Version Control
    • Configure package version control settings
    • Validate settings
    • Set up overall version control for a model
• Access a variety of Element based tools such as resources, Maintenance, Testing and Properties

Navigator bar

Provides Windows Explorer like access to your current position within the model. A minimalistic alternative to using the Project Browser or simply to keep track of your current location. Also includes a Package Finder, Portals shortcut menu and menu access to many common package based functions. (View/Navigator)

• Provides persistent indication of model context
• Easily navigate a model structure
• Context menu provides convenient actions based on the current context
  • Display package contents as a list, specification or Gantt chart
  • Add a new Package or Diagram
    • Insert a new Model Pattern
  • Copy the package path or navigate to a previously copied path
  • Find and jump to any package in the model
• Run a search for any named package with the dedicated search box
• Jump directly to the start page
• Commonly used tools directly available from menu button located at right end of bar

Database Engineering toolset

Database Engineering toolset, including Database Builder window and new Datamodel pattern. Supports construction, exploration, differencing, query, DDL generation, Alter DDL, import and merge in a database centric fashion. (Tools/Database Builder) and (Package/New.../Database::Database Engineering)

Database Builder - Provides a data centric view of the model

• Provides a list of all Data models in the current project
• Expand a database to see its contents, categorized by type of object (tables, view, procedures, functions, sequences & packages)
• Maintain a list of connections for each modeled database, thereby allowing modeled changes to be propagated to multiple physical databases easily
• Connect to any database easily using database connection Artifact objects
• Create an MS Access database or Firebird database directly without needing any additional tools
• Create and maintain the columns and constraints for a table within the Database Builder view
• Create and maintain the definition of modeled Views, Procedures, Sequences and Functions within the Database Builder view
• Run queries to view the contents of your database
• Compare the database to the model and selectively generate sql to update the database at a granular level
• Generate an entire schema directly to the Execution Engine (in the database builder) to create a database entirely from within Enterprise Architect
• Database object maintenance, query and DDL execution and database comparisons can all be completed using a single database connection

Model Patterns now available for each supported DBMS:

• Automatically creates a structure that organises database objects into separate packages of each type
• Each database model consists of a stereotyped package ('DataModel') that contains a logical and physical sub-package, as well as a report specification artifact that easily generates a database report
• Each physical sub-package is stereotyped as 'Database' and stores DBMS, Default Owner & Default Connection properties (as tagged values)
• Each database creates the package types that are available in the selected DBMS
• Any database object created in one of these packages is automatically saved into the appropriate package
• Any ODBC import invoked from within the data model package structure automatically loads the data model diagram and saves the objects into their relevant package

Improved Foreign Key constraint editing:

• Associations between tables automatically show the Foreign Key dialog on creation and double click
• Standard connector properties dialog available from the context menu
• Simplified process for creating a foreign key, simply select a primary key or unique index on the parent table
• By default each column in the selected key is automatically linked to a column of the same name in the child table
• If the column doesn't exist a new column with the correct type will be added to the child table
• Alternatively select an existing column in child table by name
• Extended properties (like On Delete, On Update) of the foreign key are now directly visible on the window
• The name of the optionally created Foreign Key index is automatically shown

Improved Table Column properties dialog:

• List of columns is now the primary focus of the dialog
• Create a new column via a context menu item or hot key, Ctrl+N
• All column properties are editable directly within the list
• Reorder a column via the context menu items or hot keys, Ctrl+Up or Ctrl+Down
• Delete an existing column via the context menu item or hot key, Ctrl+D
• All properties relevant to the selected column's datatype are visible and accessible directly on the window
• Constraints, indexes, checks and triggers are available conveniently on second tab

Improved Table Constraints properties dialog:

• Conveniently located together with the column properties
• List of constraints (this includes Indexes, Primary and Foreign Keys, Check & Unique Constraints and table Triggers) are now primary focus and can be edited inline
• Create a new constraint via a context menu item or hot key, Ctrl+N
• All constraint properties are editable directly within the list
• Reorder a constraint via the context menu items or hot keys, Ctrl+Up or Ctrl+Down
• Delete an existing constraint via the context menu item or hot key, Ctrl+D
• All properties relevant to the selected constraint's stereotype are visible and accessible directly on the window
• Involved columns (both assigned and available) are shown directly on the window
• Adding assigned columns is done simply by either double clicking an available column, or using the context menu or hot key Ctrl+Left
• Unassigning columns is done simply by either double clicking an assigned column, or using the context menu or hot key Ctrl+Right

Visual representation of database objects improved:

• All database object types now have their own image
• Database objects are now represented by their image consistently in all views
• Function and Sequence objects now available on Data modeling toolbox

Maintenance window for Procedures, Sequences and Functions contained in a single object added:

• A custom designed property window that easily allows for the maintenance of database container objects, consisting of a list and simple, direct editing of the properties used by database engineering
• Syntax highlighting and intellisense available on the SQL definition editor

Maintenance window for database View objects improved:

• Notes field added to window, the entered text is generated as a comment to DDL
• The dependencies are now represented as a list of object names
• Syntax highlighting and intellisense improved in the SQL definition editor

Round-trip Database Engineering:

• Compare Difference and show the differences between EA and ODBC
• Set actions to synchronize: It's possible that some differences' action set as "EA -> ODBC" while some differences' action set as "ODBC -> EA"
• The database and EA model should be synchronized. You can validate it by running the Difference tool again.

Templates for DDL generation (Create or Alter) now available for all supported DBMS:

• Full customization of DDL generation now possible through new DDL generation templates
• Alter DDL generation support completely redesigned to use the new DDL generation templates
• Alter DDL allow selective generation (as part of the Database Builder)
• DDL can now be generated to a single file or to the Execution Engine (part of the Database Builder) for immediate execution
• Supported database: Oracle, mysql, MS Sql Server (2005/2008/2012), PostgreSql, sqlite, sybase asa, sybase_ase, access, DB2, Informix, Ingres, InterBase
• DDL Execute Engine
• Generated SQL Script to Execution Engine according to dependency order, then simply "Execute" each single one or "Execute All" in one go.
  • E.g. change a column's length will generate following statements in order(suppose the column is used in an index):
    1. Drop index
    2. alter the column (unless you drop and then add the column, so you never lose your data!)
    3. Create the index
• Duplicated script combined in one. E.g. in some databases, change column type or length will generate the same scripts, EA grouped the scripts for you.

Compare the database to the model

Actions on the difference (actions integrated in a combo box, which only filled with valid actions according to the context)

Schema Composer

Quickly and effectively build XSD and other schemas from a selection of elements within the model. Currently targets CIM, NIEM, UN/CEFACT - NDR and generic XSD, OWL and other formats. (Tools/Schema Composer)

• New powerful toolset to rapidly design and build XSD and similar data definitions from a model subset
• Rapidly define message schema using a subset of your class model
• Drag and drop elements into the source profile
• Specify properties (attributes) to expose in the final Schema
• Manage inheritance and association relationships as they effect the final schema
• Set and manage advanced properties relevant to the final export type
• View the hierarchy of the proposed new schema
• Save message definitions as artifact in model or on your file system
• Open schema composer directly to the message by double clicking the artifact
• Generate schemas in a number of built-in formats:
  • CIM XSD
    • CIM Augmented RDFS (same as generic RDFS, but includes both forward and inverse property for each bi-directional Association in message)
• Generic XML Schema (XSD)
• JavaScript Object Notation (JSON)
• NIEM schema definition and model transform (for creating NIEM model extensions and schemas)
  • Create a NIEM subset directly within your model ready to define extension and exchange schemas
• Resource Description Framework Schema (RDFS)
• Automation API support included to allow custom extensions for other frameworks and export formats
  • Add-ins can access the schema data and create their own custom outputs (E.g custom domain targetted XSD)
    • Generate additional formats through an API available to add-ins
  • API to define schema composer capabilities (eg. Allow adjusting multiplicity)
    • API to access the model data configured in the Schema Composer
    • API support to allow saving and loading custom profiles
    • Sample add-in included in Code Samples directory under the Enterprise Architect install directory

XML and XSD Editing and Validation

New support for viewing the structure of XML and related documents and for editing and navigating those documents. XSD intellisense support. Also includes new support for validating XML documents using XSD.

Code Editor updated to improve XML editing experience

• Intellisense for XML Schemas and XSL Stylesheets added
• Outlining support for XML documents added
• Syntax highlighting for XML documents improved

Structure (outline) tree for XML document editing improved

• Tree nodes display more useful information
  • Customized icons used for XSD, XSL and XML types
  • Relationship between code editor and structure tree improved
  • Toolbar Option to automatically synchronize document location to tree and vice versa

Extras

• Validation of the current XML document against a schema now available in context menu
• Formatting of the current XML document now available in context menu
• Edit documents from the local file systems as well as those attached to model document artifacts

Main menu

A major overhaul of the main menu structure to provide better and more effective access to both existing and to new tools. Also included is the ability to turn off main menu (and Portal) icons for a cleaner and less cluttered look (see View/Visual Style/Select Visual Style :: Show Menu Icons)

"Package" menu

Provides focused access to major functionality associated with Packages. Allows the Project menu to be more tightly focused on Project level functionality.

Support for XMI merge using Baseline Merge sets

Provide the ability to selectively merge sets of changes in a multi-user environment. Each user must supply both an XMI of their current work, plus a Baseline merge file detailing how their XMI differs from the original. Only the listed changes are merged and all other changes to the Master package remain untouched.

• Allows integrating work from multiple people working on the same package into the same model
• Import XMI dialog provides an option to immediately baseline a Package after importing an XMI file
• Export XMI dialog provides an option to automatically generate a Merge File based on the differences to the initial package Baseline
• Import XMI dialog provides an option to specify a Merge File (as created during export) when importing
  • Merge file specifies what has changed in the XMI file being imported
  • Only the elements and properties specified in the Merge File will be imported in the model

The basic workflow is as follows

1. Each modeler receives a copy of the original package
2. Each modeler imports and baselines the package
3. Each modeler makes their changes (additions, deletions and modifications)
4. Each modeler then exports their package creating an XMI file and a Merge file based on their changes
5. The original model is then updated with each modelers changes, using the Merge files
6. Changes not in the Merge Files (E.g other modelers additions, deletions and updates) are ignored
7. The resultant model accurately reflects the sum of the modelers work

Start Page

New more effective and attractive Start Page, including rapid access to principal Portal pages via specialized icons.

Start Page Updated

• Now provides a clearer and simpler list of models
• Simplified links for creating models or connecting to existing models/repositories
• New set of active icons provide links directly to Portals pages
• Fully themed to match current user interface style

Other Interface Changes

• Learning center now opens in the main tab view
• Model Mail now opens in the main tab view
• Added new floating window 'Summary View' to provide an overview of the context item
  • Provides a neat, simple and informative overview of an Element, Test, Resource, Attribute, Operation ( and more ) with out needing to view the properties or generate a report
  • Can also be a quick way to get an overview into a document/email and so on

Element Maintenance and Project Management

Element Maintenance and Project Management docked windows split into their component windows so they can be docked in a wide variety of layouts.

New Technology

• Added additional maintenance types: Decisions and Events. (Element/Maintenance)

Element Types

Including Checklist (Artifact) and Project Management Types (Backlog, Event, Milestone, Meeting, Phase, Risk, Sprint, Version) Available as a new diagram type "Project Management"

• Added Checklist note element (artifact)
• Edit and set individual items as checked or unchecked
• Show checked items with strike-thru appearance
• Includes new Project Management diagram.
• Backlog, Deliverable, Event, Meeting, Milestone, Phase, Sprint and Version element stereotypes

New Diagram Quick Keys

Instantly access Enterprise Architect features using shortcut keys:

• Q, Begin inplace editing.
• N, Display the Notes window
• P, Show the docked Properties Window.
• S, Select the current element ( Allows multi selection )
• O/A, Open the Operation and Attribute dialog
• G, Generate code
• Y, Sync code
• W, Add way point at the mouse position for the selected connector.
• F, Select the first editable feature of the item in focus
• Enter, Select the closest object to top left when no items have selection.
• Comma, Move selection to the parent of the selected child ( When no selection behaves as Enter key )
• Period, Move selection to the child closest to the parents top left corner ( When no selection behaves as Enter key)
• R, Display the docked relationship window
• I, Enable Snap to Grid on the current diagram
• M, Create new Diagram Element
• ?/, Toggle between the current element and connector ( always toggles from the connector to the source element )

New Technologies

Enterprise Architect 12 introduces a range of new technologies including:

• NIEM: National Information Exchange Model
• CIM: Common Information Model
• UMM2
• New Requirements Profile
• Database Engineer Toolset
• Risk Taxonomy

NIEM

NIEM provides a common framework which is used to define how information may be shared between systems, government agencies and departments.

Import the NIEM reference schemas into Enterprise Architect. Use the Schema Composer to define your own subset, automatically detecting inter-dependencies and use the resulting subset schema to build your own IEPD. Generate your IEPD from Enterprise Architect to produce all necessary exchange files, static artifacts, metadata and catalog files.