Update README.md

Author: muten84

README.md

@@ -33,7 +33,7 @@ Appify was developed mainly for Java Web developers. If you have skills on HTML5
 <inherits name="it.appify.App" />
 ``` 
 
-####@WebApp
+#### @WebApp
 Now your are ready to use all Appify features. First of all you have to declare your web app inteface. Appify offers some annotations to make the development of your web app fast and easy. Infact the webapp interface can be annotated with some web app capabilities and inject them in your webapp such as: Geolocation, Storage, Application Cache, Notification, Offline support, and many others.
 
 ``` java
@@ -56,9 +56,9 @@ In this first example we have declared a webapp with no particular features but
 myApp.startApp(new AppModel());
 ``` 
 
-##Controller annotations:
+## Controller annotations:
 
-####@Controller
+#### @Controller
 Developing a controller with Appify is very simple. Controller is a  class annotated with @Controller annotation. The controller can be bound to a View (in Appify a view is a page) by its name. So if you want to bind a MenuController to your main page you have yo annotate your MainPage class with a @Controller and pass the page name to page parameter.
 
 ``` java
@@ -88,7 +88,7 @@ Now suppose we have this HTML code for our menu view, controller can intercept a
 	</div>
 </div>
 ``` 
-####@ViewHandler
+#### @ViewHandler
 So if you want to intercept the click event on the button with id "checkInBtn" contained in the "mainPage" page you have to write this simple code in your controller class:
 
 ``` java
@@ -99,7 +99,7 @@ So if you want to intercept the click event on the button with id "checkInBtn" c
 ``` 
 Classes annotated with @Controller annotation MUST have a constructor with a WebApp type parameter. This constructor will enables the framework to inject the WebApp skeleton. Webapp skeleton enable you to develop your controllers to trigger a page transition, obtain your current app state, get current visualized page reference, change some view behavior like CSS toggles, show modals, show tooltips and popovers, and to read and write the persistent storage. For all WebApp API skeleton you can see at the WebApp API. 
 
-####@ViewElement
+#### @ViewElement
 Appify can inject the desired view element in your controller. If you have the need to get a reference to an input text element you can declare it as a field of your controller class:
 
 ``` java
@@ -108,7 +108,7 @@ Appify can inject the desired view element in your controller. If you have the n
 ``` 
 Note that you have to provide at least some getters and setters of your private fields. Getters and Setters will enable Appify to correctly inject your view element in your controller. Alternatively you can use the public modifier for your UI fields. Note that all ViewElement (ui fields) are simply DOM elements. GWT offers its Element class and a great mechanism that wraps an HTML DOM Element in a Java Object.
 
-####@ViewModelHandler
+#### @ViewModelHandler
 If you need to intercpet the data behind the user interaction with a view you have to use the @ViewModelHandler annotation. @ViewModelHandler is a special @ViewHandler for intercept events from a @ViewElement and its related model data. This annotation is useful for List, Combo or Radio Button HTML elements. In general all user interactions with a UI field bound with a model can be intercepted trough a @ViewModelHandler. The example above shows how you can get the described behavior in a few lines of code:
 
 ``` java
@@ -121,10 +121,10 @@ If you need to intercpet the data behind the user interaction with a view you ha
 ``` 
 The onItemReceived method will receive the data behind a list of items when the user will click on an item in the list. The viewId MUST correspond simply to the id of our HTML list. Note that ViewModelHandler need to know the model type in terms of fields bound to our views, in this case the HTML list and the "code" and "name" fields wrapped in the Item class. The declaration of the binding between View and Model is made trough special attributes that can be used in your HTML page. We will call this attributes directives. For all supported directives see the relative Appendix 'Appify supported Directives'.   
 
-##Service annotations:
+## Service annotations:
 Services are simple classes delegated to some kind of background logic execution with singleton scope. To make a class an Appify Service you need to use the related annotations set.
 
-####@Service
+#### @Service
 Service annotation is the main annotation for service discovering. Appify will inject your app in a Service class and will start your service calling the method annotated with the Start annotation. 
 So if you want to create a service you just need to do this:
 
@@ -140,7 +140,7 @@ public class MyService {
 }
 ```
 
-####@Start
+#### @Start
 @Service annotation is strictly related with #Start annotation. A service class will be started by Appify if there is at least one public method annotated with the @Start annotation.
 
 ``` java
@@ -160,8 +160,8 @@ public class MyService {
 }
 ```
 
-##Appify WebApp annotations:
-####@Geolocation
+## Appify WebApp annotations:
+#### @Geolocation
 You can enable Geolocation support by adding this simple annotation. You can use annotation parameter to configure your geolocation behavior.
 
 ``` java
@@ -192,7 +192,7 @@ app.getGeolocationService().getCurrentPosition(
 				});
 ```
 
-####@Battery
+#### @Battery
 Battery service enables your app to obtain the Battery service for reading battery level and get charging information from your device.
 
 ``` java
@@ -223,7 +223,7 @@ app.getBatteryService().getBatteryStatus(
 					}
 				});
 ```
-####@Offline
+#### @Offline
 Offline annotation makes your app offline-first enabling your app to access the HTML5 Application Cache receive events and get connection status informations:
 
 ``` java
@@ -248,7 +248,7 @@ app.getApplicationCacheService().getConnetionStatus(
 					}
 				});
 ```
-####@Storage
+#### @Storage
 If you need to persist application state in the storage you can annotate your web app with this annotation. Using Storage annotation will enable you to get a Storage Service and to obtain a great Appify behavior. Once Storage was activated your application state will be persisted every time you call the updateAppState method of your app. Without the Storage feature the updateAppState method will affect only the view but changes will not be persisted so a simple refresh of your page will reset all your application state.
 
 ``` java
@@ -271,7 +271,7 @@ model.setBatteryStatus(currentStatus);
 /*persist only in the local storage your app state*/
 app.getStorageService().store(AppModel.class.toString(), model);
 ``` 
-#Javascript API
+# Javascript API
 If you prefer, you can use the Javascript Api version of Appify:
 ``` javascript
 //construct your appify object
@@ -290,7 +290,7 @@ myapp.moveTo('childPage');
 mymodel.title='New Title';
 myapp.updateAppState(mymodel);
 ```
-#Updates:
+# Updates:
 Actually Appify rely on these modules:
   - App.Js for the View and the Page transition.
   - VueJs for the MVVM pattern.
@@ -301,10 +301,10 @@ Actually Appify rely on these modules:
 
 These modules (except of GWT) are not mandatory and you can use what you prefer, for example for the MVVM instead of VueJs you can use AngularJs. This is not a priority requirement, but it's planned in the road-map and will be provided in the next future.
 
-#License 
+# License 
 GNU GPLv3
 
-#Appendix
+# Appendix
 
-##Appify supported Directives
+## Appify supported Directives
 TODO