New in Vaadin 7

Google Web Toolkit built-in

Whole stack is built in one product.

Development of client-side applications is supported to enable offline mode.

Includes all features of GWT 2.5 like SuperDevMode, Elemental and UIBinder.

Redesigned forms

Field groups can bind fields on any layout to a data source.

Declarative validation with JSR-303 validators.

Generics and explicit converters make data formatting easily customizable.

Sass-based themes

Supports most important features of the leading Sass language.

Automatic compilation of SCSS to CSS on the fly.

Makes theme CSS structured and eases re-use.

HTML5

Redesigned layout use browsers' native layouting engine and minimizes reflows.

Full control with CSS to all layout properties.

Now uses HTML5 doctype.

New windowing API

Renewed windowing API that gives easier access to the web platform.

Built in support for multiple browser tabs.

Flexible URI fragment based Navigation API.

New JavaScript API

Publishing of JavaScript callbacks directly from server.

Use any JavaScript widgets with simple generic wrapper without GWT.

Simplified widget development

Statically typed 2-way Java-based RPC.

Automated component state synchronization.

More extension points

Any widget can be customized with client-side extensions.

Any part of the generated start-up page can be changed with extension.

Supports client-side extensions that have no visible parts.

Download Vaadin 7 »

All new features
Heartbeat
  • Optionally keeps session alive
  • Reliable browser window close monitoring
Redesigned layouts
  • Minimal or no layout calculations to maximize layout speed
  • Full control of layouts with CSS including borders and margins
  • Redesigned lighter DOM for vertical, horizontal and css layout
Modular Jars
  • Split to seven jars to allow deploying only what you need
Hierarchical error handling
  • Delegate component errors to parent components
Adding multiple components at once
  • All component containers now support addComponents(Component...)
  • Support adding multiple components in constructors
UI replaces Application
  • New architecture make writing Vaadin applications simpler
  • Supports multiple browser tabs by default
Closing UI programmatically both from background thread and in ui event handlers
  • Reliaable clean of UI when browser is closed
Multiple concurrent themes
  • Support showing components with different themes on one page at once
  • Theme names are included in CSS selectors
Browser and request details available in init
  • Direct access to request and session on UI init
  • Access detected browser details on UI init
RPC
  • Call server-side methods from clients-side in Java
  • Call client-side methods from server
  • Static typing allows compile time checking
  • Supports:
    • Primitive types
    • Boxed primitive types
    • String
    • Java beans as long as all property types are also supported
    • Connector
    • enum
    • Array
    • URLReference (used to transmit Resource)
    • List<SupportedType>
    • Map<SupportedType>
    • Set<SupportedType>
Delayed RPC
  • Allows piggybacking the next XHR call instead of calling to server immediately
  • Supports optional folding of RPC calls together preserving only last value
Connectors
  • Connectors provide a flexible communication channel between client and server
  • Separating communication code from widgets promotes reusability
Dynamic state generation
  • Allow calculating component state on the fly just before state is sent to client
Differential state synchronization
  • Only parts of the state that are modified are sent over the wire
  • Only parts that differ from default values are sent in initial state synchronization
  • Nothing is sent for unchanged components
Server-client shared state
  • Java objects can be shared between client and server for easy component development
  • State is automatically mirrored from server to client
  • Support both public fields and bean properties
  • Supports all types supported by the new RPC API
High level view navigation
  • Support for URI fragment based view management
  • Support for registering both views instances as well as view classes
  • Programmatic navigation with navigateTo()
  • Supports saving bookmarks to views
  • Supports parameterized views
  • Views can block navigation
ColorPicker component
  • Easy to use interface with clickable color gradients
  • RGB, HSV and swatches color modes
  • Color history
  • Color preview
  • CSS color code representation and handling
Fine-grained listeners
  • For any component and event type, write addFooListener() instead of generic addListener(FooEvent)
  • Supports code completion in IDE:s better
  • Makes it possible to use Java 8 Lambdas
Automated repaints
  • No more need to call requestRepaint() in your components
Renewed Vaadin Maven Plugin
  • Now includes features from GWT Maven Plugin
Renewed Eclipse Plugin
  • Adds Apache Ivy based dependency management
Page bootstrapping renewed
  • Simpler inclusion of Vaadin UIs to custom web pages
UIProvider
  • Default UI provider chooses UI based on servlet parameters
  • Allows providing a different UI based on request parameters, URI or browser
VaadinSession
  • Full control over session lifecycle
  • Abstract away from servlets and portlets
VaadinService
  • Access deployment information and HTTP requests easily
  • Abstract away from servlets and portlets
Generics in data model
  • Property getValue() returns expected type
Two phase commit support
  • Transactional properties support commit/rollback
Component extension API
  • Allow adding functionality and customizations to any component
  • Modify DOM and hook event listeners
JavaScript callbacks
  • Declare client-side JavaScript API from server
  • Eases integration with parts of the page not controlled with Vaadin
Relative paths on host page
  • More flexible deployment
  • Adds support to Apache ProxyPass and other similar proxies
Application architype
  • New Maven architype eases creation of Vaadin 7 applications
  • Supports widgetset compilation and precompiled widgetsets
HTML5
  • Vaadin 7 uses HTML5 doctype
  • Use any parts of HTML5 in your application
State change listeners
  • Client-side can listen to shared state changes to update just the changed parts of the widget
Page
  • Listen to page resizes
  • Control navigation
Loading custom JavaScript
  • Annotate server-side classes with @JavaScript to request loading of JavaScript files
  • Automated control of loading order and ensuring that files are loaded only once
Deprecated API removed
  • Cleaned by removing API deprecated in Vaadin 6 or before
Changed constants to enums
  • Provide enums everywhere where possible instead of constants
Image component
  • Specialized UI component for showing images
  • Replaces Embedded
BrowserFrame component
  • Specialized UI component for embedding web pages with iframes
  • Replaces Embedded
Flash component
  • Specialized UI component for embedding flash
  • Replaces Embedded
Support for Firefox ESR
  • Adds support for the latest Firefox extended support release in addition to latest stable Firefox release
Sass Compiler
  • Allows modularization of themes for better reuse and easier maintenance
  • Support the most important features of SCSS
  • Implemented in Java, no dependency to Ruby
  • Supports all of CSS
  • On the fly conversion of SCSS to CSS in servlet
  • Built in themes are now based on Sass
  • Can be used in client-side projects as well
State change delegation
  • State can be annotated to automatically delegate state changes to corresponding widgets
  • Removed need to implement state change listeners and calling widget methods
Google Web Toolkit included
  • A full copy of GWT is included in Vaadin Framework
  • Vaadin team maintains a branch of GWT that brings newest features and bug fixes early on
  • All functionality of GWT is included to enable writing of client side UI:s, stateless applications, offline functionality and custom widgets
  • Included Elemental library gives direct access to all cutting edge browser features
  • Both browser plugin based dev mode debugging as well as super dev mode are supported
ThreadLocal access helpers
  • Direct access to VaadinService, VaadinRequest, VaadinResponse, VaadinSession and UI from anywhere during HTTP request
  • Service and UI are accessible also from outside HTTP request
Component ID
  • Replaces debug ids to allow wider use possibilities for identifying corresponding widget elements in DOM
Range retrieval for indexed containers
  • API for retrieving a range of Item ids in Container.Indexed to optimize performance
Native support for percent sizes
  • Letting browser do the percent to pixel calculation speeds up rendering
Custom class loader
  • Allow specifying custom class loaders to better support Java EE, CDI and Spring
  • Supports both servlets and portlets
JavaScript Connector
  • Wrap around any existing JavaScript based widget to adapt it for use in Vaadin
  • No widgetset compilation needed
  • Write client-side connectors in JavaScript
  • Support for shared state and rpc
Bootstrap page API
  • Let add-ons modify the bootstrap page to remove need for complicated custom servlets
Bean Validation
  • Annotate beans with JSR-303 standard annotations to automatically create validators for the fields
Field group
  • Allow data binding of multiple fields together to item data source
  • Supports buffering
  • Supports two phase commit
  • Annotation based and field name based property mapping
Explicit data model converters
  • All fields support explicit conversion from presentation format to data source format
  • Conversions are bidirectional
  • Allow setting converters to components directly in components or for the whole application at once
Built-in default converters
  • Automated conversions beween String, Boolean, Long, Date, Double, Float, Integer and Number
  • Conversion direction reversion
  • Built in converters support internationalization
Custom field component
  • Build new fields as composition of existing components
Simplified validation API
  • No need to implement isValid() in validators any more
Unsupported browser detection
  • Really old browsers are detected and customizable instructions given on updating the browser
Nested bean properties
  • BeanItem supports nested properties to allow flattening complex datatypes
Preserving UI state on refresh
  • Default is now reinitializing UI from page reload
  • UI can be configured to preserve state over page reloads
Vaadin 6 compatibility layer
  • Set of helper classes are provided to ease migration from Vaadin 6
Explicit layouts for Window and Panel
  • Unification of API for component parents
  • Window and Panel components now require setting layout explicitly
Customized Table column formats
  • Converters can be set per Table column to customize column formatting
Layout manager
  • Allows building custom layout calculations for widgets when browser based layouts are not powerful enough
  • Optimizes number of reflows by batching layout calculations from multiple widgets together
Client-side component hierarchy
  • Access the components hierarchy enables optimizations
  • List connector hierarchy in debug console
Automatic injection of CSS files
  • Inject custom CSS with @StyleSheet annotation
Popup blocker support
  • Open popups and start downloads in a way not stopped by popup blockers
Client driven client-server mapping
  • Mapping between server-side and client-side components is defined in client-side annotations to avoid server-side classpath issues
ComputedStyle API
  • Access computed CSS styles on the client-side