123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656 |
- ---
- title: Migrating From Vaadin 6 To Vaadin 7
- order: 34
- layout: page
- ---
-
- [[migrating-from-vaadin-6-to-vaadin-7]]
- = Migrating from Vaadin 6 to Vaadin 7
-
- For migration to Vaadin 7.1, see
- <<MigratingFromVaadin7.0ToVaadin7.1#migrating-from-vaadin-7.0-to-vaadin-7.1,
- Migrating From Vaadin 7.0 To Vaadin 7.1>>
-
- [[getting-started]]
- Getting Started
- ~~~~~~~~~~~~~~~
-
- Most Vaadin 7 APIs are compatible with Vaadin 6, but there are some
- changes that affect every application.
-
- Moving to Vaadin 7 brings a number of features designed to make the
- lives of developers easier. It is a major version where we could improve
- (and break) some parts of the API that have been stagnant and in need of
- improvement for years.
-
- Fear not, though, as the vast majority of the API is unchanged or
- practically so - many parts even for the last 10 years apart for some
- package name changes. While every application requires some migration
- steps, the minimal steps needed for many applications are simple enough,
- although a few more changes can be useful to benefit from some of the
- new features such as improvements to data binding.
-
- The first step is to *update Vaadin libraries*. While Vaadin 6 had a
- single JAR and separate GWT JARs, Vaadin 7 is packaged as multiple JARs
- that also include GWT. The easiest way to get all you need is to use Ivy
- (see below in the section on updating an existing Eclipse project) or
- Maven (see below on updating a Maven project). If you are using the latest version of
- the Vaadin Eclipse plug-in, upgrading the facet version creates an Ivy
- configuration.
-
- The first code change that applies to every Vaadin 6 application
- concerns the *com.vaadin.Application* class - it *exists no more*. The
- main entry point to your application is now a *com.vaadin.ui.UI*, which
- replaces Application and its main window. When switching to UI, you also
- get multi-window support out of the box, so bye bye to any old hacks to
- make it work. On the flip side, a new UI is created on page reload. If
- you prefer to keep the UI state over page reloads in the same way Vaadin
- 6 does, just add *@PreserveOnRefresh* annotation on your UI class.
-
- For minimal migration, though, it is possible to replace Application
- with *LegacyApplication* and its main Window with *LegacyWindow* and
- postpone a little dealing with UIs, but when migrating to UIs, you get
- more out of the box. The class *Window* is now only used for
- "sub-windows" (windows floating inside the page) , not "browser level"
- windows or tabs (the whole web page).
-
- An example should clarify things better than lengthy explanations,
- so:Vaadin 6:
-
- [source,java]
- ....
- package com.example.myexampleproject;
-
- import com.vaadin.Application;
- import com.vaadin.ui.*;
-
- public class V6tm1Application extends Application {
- @Override
- public void init() {
- Window mainWindow = new Window("V6tm1 Application");
- Label label = new Label("Hello Vaadin!");
- mainWindow.addComponent(label);
- setMainWindow(mainWindow);
- setTheme("mytheme");
- }
- }
- ....
-
- Vaadin 7:
-
- [source,java]
- ....
- package com.example.myexampleproject;
-
- import com.vaadin.server.VaadinRequest;
- import com.vaadin.ui.*;
-
- @Theme("mytheme")
- public class MyApplicationUI extends UI {
-
- @Override
- protected void init(VaadinRequest request) {
- VerticalLayout view = new VerticalLayout();
- view.addComponent(new Label("Hello Vaadin!"));
- setContent(view);
- }
- }
- ....
-
- In addition, replace `com.vaadin.terminal.gwt.server.ApplicationServlet`
- with com.vaadin.server.*VaadinServlet* in web.xml and its parameter
- "application" with "*UI*" pointing to your UI class, and the application
- is ready to go. Likewise, *ApplicationPortlet* has become *VaadinPortlet*.
-
- Some package names have also been changed, but a simple import
- reorganization in your IDE should take care of this.
-
- If you have a custom theme, import e.g.
- "../reindeer/*legacy-styles.css*" instead of "../reindeer/styles.css".
- The theme is now selected with an *@Theme* annotation on your UI class
- rather than a call to *setTheme()*, the usage should be clear from the
- example above.
-
- Most remaining issues should show up as compilation errors and in most
- cases should be easy to fix in your IDE.
-
- Now you should be ready to compile your widgetset (if any) and take the
- application for a first test drive. If you have customized themes, they
- will probably also need other updates - see the section on themes below.
-
- Note that support for some older browser versions - including IE6 and
- IE7 - has been dropped in Vaadin 7. If you absolutely need them, Vaadin
- 6 will continue to support them until its planned end of life (June
- 2014, five years from release of 6.0).
-
- If you have problems with specific topics, see the related sections of
- the migration guide.
-
- In case you need more help with the migration, the Vaadin team also
- provides https://vaadin.com/services#professionalservices[professional
- services].
-
- [[converting-an-eclipse-project]]
- Converting an Eclipse project
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- If you have an existing Vaadin 6 Eclipse project, the easiest way to get
- up and running with Vaadin 7 is to switch to *Ivy for dependency
- management*. In the project properties, select Project Facets and change
- the Vaadin plug-in version to 7.0. If necessary, upgrade also the Java
- and Dynamic Web Module facets. _Make sure you use the latest version of
- the *Eclipse plug-in* from the update site
- https://vaadin.com/framework/get-started#eclipse for this, and note that currently
- installing it also requires that the IvyDE update site is configured. We
- will attempt to eliminate this additional complication soon._
-
- Ivy dependency management can also be configured by hand by adding the
- files ivy.xml and ivysettings.xml to the root of the project and using
- them from Eclipse (with the IvyDE plug-in), Ant or other build system.
- For examples of the two files, see e.g.
- http://dev.vaadin.com/svn/integration/eclipse/plugins/com.vaadin.integration.eclipse/template/ivy/[here]
- and update VAADIN_VERSION in the file ivy.xml.
-
- Note that Vaadin 7 requires *Java version 6* or higher and *servlet
- version 2.4* or higher (or portlet 2.0 or higher). If your project is
- set up for older versions, update the corresponding facets.
-
- [[converting-a-maven-project]]
- Converting a Maven project
- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- Converting a *Maven* project is usually quite straightforward: replace
- the Vaadin dependency with dependencies to the needed Vaadin artifacts,
- remove any dependencies on GWT JARs, replace the GWT plug-in with the
- Vaadin plug-in and recompile everything. The easiest way to get the
- required sections and dependencies is to create a new project from the
- vaadin-application-archetype and copy the relevant sections from it to
- your project.
-
- Note that Vaadin 7 requires Java version 6 or higher and servlet version
- 2.4 or higher (or portlet 2.0 or higher). If your project is set up for
- older versions, update the corresponding dependencies and compiler
- version.
-
- [[content-for-windows-panels-and-more]]
- Content for Windows, Panels and More
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- In Vaadin 6, Window, Panel and some other components had a *default
- layout* and addComponent() etc. As this often caused confusion and
- caused layout problems when unaware of the implicit layout or forgetting
- to set its layout parameters, Vaadin 7 now requires *explicitly setting
- the content*. See e.g.
- <<CreatingABasicApplication#creating-a-basic-application,Creating
- a basic application>>
-
- If you want to minimize the impact of this on the look and theme of an
- old application, you can reproduce the *old structure* simply by setting
- a `VerticalLayout` (with margins enabled) as the content and add your
- components to it rather than the Panel/UI/Window.
-
- Note that the class *Window* is now only used for sub-windows, not
- browser level windows.
-
- Information related to browser windows in now in *Page*, including
- browser window size, URI fragment and page title. Setting the browser
- location (redirecting to a URL) can also be performed via Page.
-
- The API for *Notifications* has also changed, static methods
- `Notification.show()` are now used instead of `Window.showNotification()`.
-
- The current *UI*, *Page*, *VaadinService*, *VaadinRequest* and *VaadinResponse*
- instances are easily accessible using *UI.getCurrent()*,
- *Page.getCurrent()* etc. The session can be obtained using
- *UI.getSession()* and the request and response are available from
- *VaadinService.getCurrent()*. Thus, no more need for an explicit
- *ThreadLocal* to keep track of them.
-
- VaadinSession also provides the new entry point for *locking* access to
- Vaadin components from *background threads*, replacing the old approach
- of synchronizing to the Application instance - see the javadoc for
- *VaadinSession.lock()* for more details.
-
- To customize the creation of UIs - for instance to create different UIs
- for mobile and desktop devices -
- <<CreatingAnApplicationWithDifferentFeaturesForDifferentClients#creating-
- an-application-with-different-features-for-different-clients,a
- custom UIProvider>> can be used.
-
- [[forms-and-data-binding]]
- Forms and Data Binding
- ~~~~~~~~~~~~~~~~~~~~~~
-
- What enterprise applications are all about is data, and the data entry
- side in Vaadin 6 has been lacking in customizability. While it has been
- possible to create arbitrary forms for data input, many situations have
- required either bypassing the Form mechanism or using complicated tricks
- to customize their layouts etc.
-
- Although *Form* is still there in Vaadin 7 and a lot of old code for
- data binding works mostly as is, version 7 brings something better:
-
- * *FieldGroup* supporting *automated data binding*, whether for a hand-designed
- form or
- <<AutoGeneratingAFormBasedOnABeanVaadin6StyleForm#
- auto-generating-a-form-based-on-a-bean-vaadin-6-style,creating the fields automatically>>
-
- * *<<CreatingATextFieldForIntegerOnlyInputWhenNotUsingADataSource#
- creating-a-textfield-for-integer-only-input-when-not-using-a-data-source,typed
- fields and properties>>*
-
- * *<<CreatingYourOwnConverterForString#creating-your-own-converter-for-string-mytype-conversion,
- converters>>*,
- both
- <<ChangingTheDefaultConvertersForAnApplication#changing-the-default-converters-for-an-application,
- automatic via ConverterFactory>> and
- <<CreatingATextFieldForIntegerOnlyInputWhenNotUsingADataSource#
- creating-a-textfield-for-integer-only-input-when-not-using-a-data-source,explicitly set>>
-
- * improved *validation* (performed on data model values after
- conversion) - see e.g.
- <<UsingBeanValidationToValidateInput#using-bean-validation-to-validate-input,bean validation example>>
-
- * and more
-
- If you want to keep using the old mechanisms, just note that e.g.
- *TextField* now has the type String, and automatic conversions are applied
- as well as *validation* performed on values converted to the *data model
- type*. You can migrate data entry views form by form.
-
- The ancient *QueryContainer* has been removed, so it is time to switch
- to *SQLContainer* or some other container implementation.
-
- If you are using a custom implementation of *Container.Indexed*, there
- is one more method to implement - see the javadoc of *getItemIds(int,
- int)* for details and a utility making implementing it easy.
-
- *Property.toString()* should not be used to try to get the value of the
- property, use *Property.getValue()* instead.
-
- [[add-ons]]
- Add-ons
- ~~~~~~~
-
- If your project relies on add-ons from Vaadin Directory, note that not
- all of them have been updated for Vaadin 7, and a few might only be
- compatible with older Vaadin 7 beta versions. *Check the add-ons* you
- use before committing to migration.
-
- You may need to click "*Available for 7*" on the add-on page to get the
- correct add-on version.
-
- You can see a list of add-ons with a version available for Vaadin 7 using https://vaadin.com/directory/search[the search],
- although some of them might only be compatible with older alpha and beta
- versions of Vaadin 7 at the moment.
-
- Note also that a handful of add-ons you might have used are now obsolete
- as e.g. *CustomField* is integrated in Vaadin 7.
-
- [[widgetset]]
- Widgetset
- ~~~~~~~~~
-
- As long as you use the *correct version of* the Eclipse or Maven
- *plug-in* to compile your widgetset and remove any old GWT libraries
- from your classpath, not much changes for widgetsets.
-
- The current default widgetset is *com.vaadin.DefaultWidgetSet* and
- should be inherited by custom widgetsets, although
- *com.vaadin.terminal.gwt.DefaultWidgetset* still exists for backwards
- compatibility. *DefaultWidgetSet* is also used on portals, replacing
- *PortalDefaultWidgetSet*.
-
- If you are compiling your widgetset e.g. with Ant, there are some
- changes to the class to execute and its parameters. The class and
- parameters to use are now "com.google.gwt.dev.Compiler -workDir (working
- directory) -war (output directory) (widgetset module name)" with
- optional additional optional parameters before the module name.
-
- If you have optimized your widgetset to limit what components to load
- initially, see
- <<OptimizingTheWidgetSet#optimizing-the-widget-set,this tutorial>> and the
- https://vaadin.com/directory/component/widget-set-optimizer[WidgetSet
- Optimizer add-on].
-
- [[themes]]
- Themes
- ~~~~~~
-
- The *HTML5 DOCTYPE* is used by Vaadin 7, which can affect the behavior
- of some CSS rules.Vaadin 7 brings a new option to create your themes,
- with SCSS syntax of *SASS* supporting *variables, nested blocks and
- mix-ins* for easier reuse of definitions etc.
-
- To get your old application running without bigger changes, just import
- e.g. "../reindeer/*legacy-styles.css*" instead of
- "../reindeer/styles.css" and take the application for a spin. There will
- most likely be some changes to be done in your theme, but the main parts
- should be there.
-
- The themes also support *mixing components from multiple themes* and
- using multiple applications with *different themes on the same page*,
- which can be especially useful for portlets. However, these depend on
- fully migrating your themes to the SCSS format with a theme name
- selector.
-
- To take advantage of the new features, see
- <<CreatingAThemeUsingSass#creating-a-theme-using-sass,Creating a theme using Sass>>
- and
- <<CustomizingComponentThemeWithSass#customizing-component-theme-with-sass,
- Customizing component theme with Sass>>.
-
- Note that the SCSS theme needs to be *compiled* to CSS before use - in
- development mode, this takes place automatically on the fly whenever the
- theme is loaded, but when moving to production mode, you need to run the
- theme compiler on it to produce a pre-compiled static theme.
-
- <<WidgetStylingUsingOnlyCSS#widget-styling-using-only-css,CSS can be used to style
- components>> somewhat more freely than in Vaadin 6.
-
- The DOM structure of several layouts has changed, which might require
- changes to themes for layouts. See also the section on layouts below.
-
- [[navigation]]
- Navigation
- ~~~~~~~~~~
-
- In addition to low-level support for handling URI fragments Vaadin 7
- also provides a higher level *navigation* framework, allowing you to
- focus on the content of your views rather than the mechanics of how to
- navigate to them.
-
- The best way to get acquainted with the new navigation features is to
- check the tutorials on
- <<CreatingABookmarkableApplicationWithBackButtonSupport#
- creating-a-bookmarkable-application-with-back-button-support,
- creating a bookmarkable application>>,
- <<UsingParametersWithViews#using-parameters-with-views,using parameters with views>>,
- <<AccessControlForViews#access-control-for-views,access control for views>> and
- <<ViewChangeConfirmations#view-change-confirmations,view change confirmations>>.
-
- When logging out a user, you can use *Page.setLocation()* to redirect
- the user to a suitable page.
-
- [[extending-the-servlet]]
- Extending the Servlet
- ~~~~~~~~~~~~~~~~~~~~~
-
- As ApplicationServlet moved to history and is replaced by
- *VaadinServlet*, many customizations you have made to it need a rewrite.
-
- The most common customizations:
-
- * <<CustomizingTheStartupPageInAnApplication#customizing-the-startup-page-in-an-application,
- Customizing the bootstrap page in an application>>: JavaScript, headers, ...
- * Add-ons using customized servlets for other purposes (e.g. customizing
- communication between client and server) probably need more extensive
- rework
-
- Note also that *TransactionListener*, *ServletRequestListener* and
- *PortletRequestListener* have been removed.
-
- Many things that used to be taken care of by *ApplicationServlet* are now
- distributed among *VaadinServletService*, *VaadinSession*, *VaadinService*
- etc. You can get a *VaadinSession* with *Component.getSession()* and
- *VaadinService* e.g. with *VaadinSession.getService()*.
-
- System messages that used to be configured by "overriding" a static
- method *Application.getSystemMessages()* are now set in *VaadinService*
- using a *SystemMessagesProvider*.
-
- [[client-side-widgets]]
- Client side widgets
- ~~~~~~~~~~~~~~~~~~~
-
- For add-on authors and creators of custom widgets, the biggest changes
- in Vaadin 7 have perhaps taken place on the client side and in
- client-server communication.
-
- The first big change is a separation of the client side UI *widgets* and
- the code handling communication with the server (*Connector*). The
- familiar VLabel is still the client side widget corresponding to the
- server side component Label, but the communication part has been split
- off into LabelConnector. The annotations linking the client side and the
- server side have also changed, now the LabelConnector has an *@Connect*
- annotation linking it to the server side component Label.
- https://vaadin.com/book/vaadin7/-/page/architecture.client-side.html[The
- book] provides some background and the tutorial on
- <<CreatingASimpleComponent#creating-a-simple-component,creating a simple
- component>> shows an example.
-
- The connector communicates with the server primarily via shared
- state from the server to the client and **RPC
- calls **<<SendingEventsFromTheClientToTheServerUsingRPC#
- sending-events-from-the-client-to-the-server-using-RPC,from
- client to server>> and
- <<UsingRPCToSendEventsToTheClient#using-rpc-to-send-events-to-the-client,
- from server to client>>, with a larger set of supported data types. For
- component containers,
- <<CreatingASimpleComponentContainer#creating-a-simple-component-container,
- the hierarchy of the contained components is sent separately>>.
-
- The old mechanism with UIDL, *paintContent()* and *changeVariables()* is
- still there for a while to ease migration, but it is recommended to
- update your components to the new mechanisms, which also tend to result
- in much cleaner code. Using the old mechanisms requires implementing
- *LegacyComponent*.
-
- There are also new features such as support for *Extensions* (components
- which
- <<CreatingAUIExtension#creating-a-ui-extension,extend the UI>> or
- <<CreatingAComponentExtension#creating-a-component-extension,other
- components>> without having a widget in a layout) and
- <<UsingAJavaScriptLibraryOrAStyleSheetInAnAddOn#
- using-a-javascript-library-or-a-style-sheet-in-an-addon,support for
- JavaScript>>, also for
- <<IntegratingAJavaScriptComponent#integrating-a-javascript-component,
- implementing components>> and
- <<IntegratingAJavaScriptLibraryAsAnExtension#
- integrating-a-javascript-library-as-an-extension,extensions>>,
- which might simplify the implementation of some components. Shared state
- and RPC can also be used from JavaScript, and there are other techniques
- for client-server communication.
-
- *Package names* for the client side have changed but a simple import
- reorganization by the IDE should be able to take care of that, the new
- packages are under *com.vaadin.client.ui*.
-
- If you have implemented a *component that contains other components*
- (HasComponents, ComponentContainer) or have client side widgets which do
- size calculations etc, see the layouts chapter - these should now be
- much simpler to implement than previously, although much of custom
- layout widgets will probably need to be rewritten.
-
- A final note about client side development:
- *https://vaadin.com/blog/vaadin-and-superdevmode[SuperDevMode]*
- has been integrated to Vaadin 7, eliminating the need for browser
- plug-ins in many cases when debugging client side code.
-
- [[migration-steps-quick-and-dirty]]
- Migration steps (quick and dirty)
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
- * Create a connector class for the add-on
- * Extend *LegacyConnector*, override the *getWidget()* method, change its
- signature to return *VMyWidget* and implement it as return *(VMyWidget)
- super.getWidget();*
- * Replace the *@ClientWidget(VMyWidget.class)* annotation (on the
- server-side component) with *@Connect(MyServerSideComponent.class)* on the
- connector class
- * Remove the call to *super.updateFromUIDL(...)* in
- *VMyWidget.updateFromUIDL(...)* if no such method exists in the
- superclass.
- * If the widget has implemented *setHeight* and *setWidth*, make the
- connector implement *SimpleManagedLayout* and move the layout logic to the
- *layout()* method.
- * The actual sizes of the widget is available through
- *getLayoutManager().getOuterHeight(getWidget().getElement())* and similar
- for the width.
- * If the widget implements *ContainerResizedListener*, make the connector
- implement *SimpleManagedLayout* and call *getWidget().iLayout()* from the
- *layout()* method.
- * Be prepared for problems if you are doing layouting in *updateFromUIDL*
- as the actual size of a relatively sized widget will most likely change
- during the layout phase, i.e. after *updateFromUIDL*
-
- The connector class should look like
-
- [source,java]
- ....
- @Connect(MyComponent.class)
- public class MyConnector extends LegacyConnector {
- @Override
- public VMyWidget getWidget() {
- return (VMyWidget) super.getWidget();
- }
- }
- ....
-
- * Implement the interface *LegacyComponent* in the server side class
- * If your widget has not delegated caption handling to the framework
- (i.e. used *ApplicationConnection.updateComponent(..., ..., false)* you
- should override *delegateCaptionHandling()* in your connector and return
- false. Please note, however, that this is not recommended for most
- widgets.
-
- [[basic-widget-add-on-using-vaadin-7-apis]]
- Basic widget add-on using Vaadin 7 APIs
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
- Note: migration to new communication mechanisms etc. should be performed
- step by step.These instructions continue from where the quick and dirty
- migration ended.
-
- * Intermediate step: move *updateFromUIDL(...)* implementation from the
- widget to the connector
- * Change the visibility of any methods and fields it accesses in the
- widget to "package"
- * Intermediate step: design an API for the widget that does not access
- Vaadin communication mechanisms directly
- * Use listeners for events from the widget to the server
- * Use setters and action methods for server to client modifications
- * Convert state variables and their transmission in
- *paintContent()*/*updateFromUIDL()* to use shared state
- * Convert one-time actions (events etc.) to use RPC
- * Remove "implements LegacyComponent" from the server-side class and the
- methods *paintContent()* and *changeVariables()*
- * Remove "implements Paintable" or "extends LegacyConnector" and
- *updateFromUIDL()* from the client-side connector class (extend
- *AbstractComponentConnector* instead of *LegacyConnector*)
-
- [[layouts-and-component-containers]]
- Layouts and Component Containers
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- While the server side API of various layouts has not changed much, the
- implementations on the client side have. With the currently supported
- browsers, much more can now be calculated by the browser, so Vaadin
- layouts often do not need to measure and calculate sizes.
-
- Most of the differences are only relevant to those who develop client
- side component containers, but a few can also affect other developers.
-
- Among the changes affecting others than layout developers, *CssLayout*
- now consists of a single DIV instead of three nested elements, and
- <<WidgetStylingUsingOnlyCSS#widget-styling-using-only-css,CSS
- can be used to do more customization>> than in previous Vaadin versions.
- Also other layouts have changed in terms of their *DOM structure* on the
- client, which might require changes to themes. The interface
- *MarginHandler* is now only implemented by layouts that actually support
- it, not in *AbstractLayout*, and *margins* should be set in CSS for
- *CssLayout*.
-
- When implementing components that are not full-blown layouts (with
- *addComponent()*, *removeComponent()* etc.) but should contain other
- components, the simpler interface *HasComponents* should be used instead
- of *ComponentContainer*.
-
- For those implementing new component containers or layouts, see the
- related tutorials
- <<CreatingASimpleComponentContainer#creating-a-simple-component-container,
- Creating a simple component container>> and
- <<WidgetStylingUsingOnlyCSS#widget-styling-using-only-css,
- Widget styling using only CSS>>.
-
- [[migration-steps-for-componentcontainers]]
- Migration steps for ComponentContainers
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
- These continue from where the add-on migration steps above left off
-
- * Component containers (e.g. layouts) require more changes as the
- underlying layout mechanisms and updates have changed
- * Client-side child connectors are now created by the framework
- * Hierarchy change events. Guaranteed to run before child calls
- *updateCaption*. Create any child slots here and attach the widget.
- * Don't paint children
- * Don't call *child.updateFromUidl*
- * Update caption management (called before *updateFromUidl*, from state
- change event listener)
-
- [[miscellaneous-changes]]
- Miscellaneous Changes
- ~~~~~~~~~~~~~~~~~~~~~
-
- Many overloaded *addListener()* methods have been deprecated. Use
- *addClickListener()*, *addValueChangeListener()* etc. instead of them,
- reducing ambiguity and the need for explicit casts.
-
- Many *constants* have been replaced with enums, although in most cases
- the old names refer to enum values to ease migration.
-
- If using *background threads, locking* has changed: there is no longer
- an *Application* class to synchronize to, but *getSession().lock()* etc.
- should be used - see the javadoc for details on its correct use, using a
- correct try-finally is crucial for building reliable multi-threaded
- Vaadin applications.
-
- *ApplicationResource* has been replaced with *ConnectorResource*, taking
- different parameters.
-
- *URIHandler* has been replaced with *RequestHandler*. See also the related
- class *DownloadStream*.
-
- *JavaScript* can now be executed using *JavaScript.execute()*.
-
- Various methods that were *deprecated* until 6.8 etc. have been removed,
- and some classes and methods have been deprecated. In most of those
- cases, the deprecation comment or javadoc indicates what to use as a
- replacement.
-
- AbstractComponent.*isEnabled()* and *isVisible()* do not take the state
- of the parent component into account, but only inquire the state set for
- the component itself. A component inside a disabled component still is
- disabled, and one inside an invisible component is not rendered on the
- browser.
-
- No information is sent to the browser about components marked as
- *invisible* - they simply do not exist from the point of view of the
- client.
-
- [[components]]
- Components
- ~~~~~~~~~~
-
- *Button* is no longer a Field and does not have a constructor that takes
- a method name to call, use anonymous inner class instead. Because of
- this, *CheckBox* is no longer a Button and uses a *ValueChangeListener*
- instead of a *ClickListener*.
-
- *DateField* no longer supports milliseconds and its default resolution
- is day.
-
- *Label* now supports converters.
-
- *RichTextArea* custom formatting methods removed, use a
- *PropertyFormatter* or a *Converter* instead of overriding formatting
- methods.
-
- [[need-help]]
- Need help?
- ----------
-
- If you need any advice, training or hands on help in migrating your app
- to Vaadin 7, please be in touch with sales@vaadin.com. Vaadin team would
- be happy to be at your service.
|