Sunday, December 8, 2013

Metadata Driven User Interface: Metawidget v3.7

Version 3.7 of Metawidget, the Metadata Driven UI generator is now available!

This release was focused on:
As always, the best place to start is the Reference Documentation:

http://metawidget.org/doc/reference/en/pdf/metawidget.pdf

Your continued feedback is invaluable to us. Please download it and let us know what you think.

Saturday, December 7, 2013

JQuery Mobile UI Generator

The next release of Metawidget (3.7) adds support for JQuery Mobile (JQM). This allows you to easily create dynamic User Interfaces for JQM applications. It supports the full Metawidget pipeline of pluggable Inspectors, WidgetBuilders, Layouts and more - so you can scale from simple UIs to complex, enterprise apps:

Here's a simple (but complete) example. It creates a JavaScript object, renders a UI, and saves it again (the result is printed in the console):

<!DOCTYPE html>
<html>
   <head>
      <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
      <link rel="stylesheet" href="lib/jquery.mobile/jquery.mobile-1.3.2.min.css" />
      <script src="lib/jquery/jquery-1.8.3.min.js"></script>
      <script src="lib/jquery.mobile/jquery.mobile-1.3.2.min.js"></script>
      <script src="lib/metawidget/core/metawidget-core.min.js"></script>
      <script src="lib/metawidget/jquery.mobile/metawidget-jquerymobile.min.js"></script>
      <script type="text/javascript">

         var person = {
            name: 'Homer Simpson',
            age: 36,
            retired: true
         };

         $( document ).on( 'pageinit', '#page', function( event ) {
            var page = $( event.target );
            var mw = $( "#metawidget" );
            mw.metawidget();
            mw.metawidget( "buildWidgets", person );

         } );

         save = function( event ) {

            var page = $( event ).parents( 'article' );
            var mw = page.find( '#metawidget' );

            var processor = mw.metawidget( "getWidgetProcessor", function( widgetProcessor ) {
               return widgetProcessor instanceof metawidget.widgetprocessor.SimpleBindingProcessor;
            } );
            processor.save( mw.data( 'metawidget' ) );

            console.log( person );
         }
      </script>
   </head>
   <body>
      <article id="page" data-role="page">
         <section data-role="content">
            <div id="metawidget" data-role="metawidget"></div>
         </section>
         <footer data-role="footer" data-position="fixed" data-tap-toggle="false" data-transition="none">
            <div id="footer-navbar" data-role="navbar">
               <ul>
                  <li><a data-icon="check" data-iconpos="top" onclick="save( this )">Save</a></li>
               </ul>
            </div>
         </footer>
      </article>
   </body>
</html>

Of course Metawidget can take this much, much further. To see how, the best place to start is the JavaScript tutorial. There's also a complete Address Book sample application included in the examples pack.

Wednesday, October 16, 2013

Angular Form Generator: third-party widgets

I've been asked about supporting date pickers in IE8 through Metawidget. There are two answers:

Answer #1: Metawidget only automates what you'd do manually

Metawidget tries hard not to introduce any 'magic' into your UI development. It only automates what you'd normally have to do manually. So by default if you have a property of type date it will generate:

<input type="date">

This is an HTML5-specific input type. It will only render as a date picker in HTML5-compliant browsers. And even then, only in some HTML5-compliant browsers (Chrome works, IE 10 and Firefox do not). IE8 will fall back to a text box.

Answer #2: Metawidget supports third-party widget libraries

Of course, there's no shortage of third-party widget libraries that can supply JavaScript-based date pickers. And these will work great in IE8. For this example, we'll pick Angular-UI Date. To use ui-date manually (outside of Metawidget) you have to do:

<input type="date" ui-date>

That's only a minor tweak over what Metawidget generates anyway, so we can plug-in a WidgetProcessor to process the generated widget and add ui-date. If the required HTML was radically different from what Metawidget usually generates (say some nested divs) we could plug-in a whole new WidgetBuilder.

Here's a complete example, tested in IE8:

<html ng-app="myApp">
   <head>
      <!--[if lte IE 8]>
      <script>
         document.createElement( 'metawidget' );
      </script>
      <![endif]-->
      <link rel="stylesheet" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.9.0/themes/base/jquery-ui.css" type="text/css" media="all" />
      <script src="jquery-1.8.3.js" type="text/javascript"></script>
<script src="jquery-ui-1.9.0.js" type="text/javascript"></script>
      <script src="angular-1.0.7.min.js" type="text/javascript"></script>
      <script src="ui-date.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.6/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.6/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget', 'ui.date' ] )
            .controller( 'myController', function( $scope ) {
               $scope.metawidgetConfig = {
                  addWidgetProcessors: [ function( widget, elementName, attributes, mw ) {

                     if ( attributes.type === 'date' ) {
                        widget.setAttribute( 'ui-date', '' );
                     }

                     return widget;
                  } ]

               };
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  date: new Date()
               };
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person" config="metawidgetConfig"/>
   </body>
</html>

Feedback welcome!

Thursday, September 5, 2013

AngularJS UI Generator: custom widgets

I've been asked to blog about "select boxes versus radio buttons versus checkboxes" in Metawidget. There are two answers:

Answer #1: WidgetBuilders

UIs often have exacting requirements about which widgets to use. Metawidget is designed for this. It has a pluggable WidgetBuilder architecture allowing you to plug-in (and chain together) custom WidgetBuilders to handle just your custom case, and fall back to built-in WidgetBuilders for more general cases. So if you find yourself needing a particular custom widget: write a little WidgetBuilder.

Here's an example:

<html ng-app="myApp">
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget' ] )
            .controller( 'myController', function( $scope ) {
               $scope.metawidgetConfig = {
                  widgetBuilder: new metawidget.widgetbuilder.CompositeWidgetBuilder( [
                     function( elementName, attributes, mw ) {
                        if ( attributes.name === 'hobby' ) {
                           var select = document.createElement( 'select' );
                           select.innerHTML = '<option/><option>Beer</option><option>TV</option><option>Eating</option>';
                           return select;
                        }
                     },

                     new metawidget.widgetbuilder.HtmlWidgetBuilder()
                  ] )
               };
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  age: 36,
                  hobby: 'Beer'
               };
               $scope.save = function() {
                  console.log( $scope.person );
               }
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
         #metawidget button {
            display: block;
            margin: 10px auto 0px;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person" config="metawidgetConfig">
         <button ng-click="save()">Save</button>
      </metawidget>
   </body>
</html>

Note that Metawidget's WidgetProcessors (in this case AngularWidgetProcessor) are still able to automatically data-bind your custom widget. And your widget choice can key off any piece of metadata, not just attributes.name.

Answer #2: The Default

Having said that, the built-in WidgetBuilders do a decent job. You may find them sufficient for your use case. Here's an example of using JSON Schema metadata to create the same dropdown:

<html ng-app="myApp">
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget' ] )
            .controller( 'myController', function( $scope ) {
               $scope.metawidgetConfig = {
                  inspector: new metawidget.inspector.CompositeInspector( [
                     new metawidget.inspector.PropertyTypeInspector(),
                     new metawidget.inspector.JsonSchemaInspector( {
                        properties: {
                           hobby: {
                              enum: [ 'Beer', 'TV', 'Eating' ]
                           }
                        }

                     } )
                  ] )
               };
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  age: 36,
                  hobby: 'Beer'
               };
               $scope.save = function() {
                  console.log( $scope.person );
               }
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
         #metawidget button {
            display: block;
            margin: 10px auto 0px;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person" config="metawidgetConfig">
         <button ng-click="save()">Save</button>
      </metawidget>
   </body>
</html>

Widget choice is often dictated by data type. If you want checkboxes instead of a dropdown, then your data type needs to be an array rather than a string, so that the user can select multiple values:

<html ng-app="myApp">
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget' ] )
            .controller( 'myController', function( $scope ) {
               $scope.metawidgetConfig = {
                  inspector: new metawidget.inspector.CompositeInspector( [
                     new metawidget.inspector.PropertyTypeInspector(),
                     new metawidget.inspector.JsonSchemaInspector( {
                        properties: {
                           hobby: {
                              enum: [ 'Beer', 'TV', 'Eating' ]
                           }
                     }
                  } )
                  ] )
               };
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  age: 36,
                  hobby: [ 'Beer' ]
               };
               $scope.save = function() {
                  console.log( $scope.person );
               }
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
         #metawidget button {
            display: block;
            margin: 10px auto 0px;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person" config="metawidgetConfig">
         <button ng-click="save()">Save</button>
      </metawidget>
   </body>
</html>

Sometimes widget choice purely is aesthetic, though. If you want radio buttons instead of a select box, the built-in WidgetBuilder recognises a componentType metadata:

<html ng-app="myApp">
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget' ] )
            .controller( 'myController', function( $scope ) {
               $scope.metawidgetConfig = {
                  inspector: new metawidget.inspector.CompositeInspector( [
                     new metawidget.inspector.PropertyTypeInspector(),
                     new metawidget.inspector.JsonSchemaInspector( {
                     properties: {
                        hobby: {
                              enum: [ 'Beer', 'TV', 'Eating' ],
                              componentType: 'radio'
                           }
                        }
                     } )
                  ] )
               };
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  age: 36,
                  hobby: 'Beer'
               };
               $scope.save = function() {
                  console.log( $scope.person );
               }
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
         #metawidget button {
            display: block;
            margin: 10px auto 0px;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person" config="metawidgetConfig">
         <button ng-click="save()">Save</button>
      </metawidget>
   </body>
</html>

Feedback welcome!

Tuesday, August 13, 2013

How to generate a UI from JSON Objects using AngularJS

My previous minimal post has been quite popular, so I thought I'd do an AngularJS version. As expected, all that Angular goodness makes it even cleaner:

<html ng-app="myApp">
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.7/angular.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js" type="text/javascript"></script>
      <script src="http://metawidget.org/js/3.5/metawidget-angular.min.js" type="text/javascript"></script>
      <script type="text/javascript">
         angular.module( 'myApp', [ 'metawidget' ] )
            .controller( 'myController', function( $scope ) {
               $scope.person = {
                  firstname: 'Homer',
                  surname: 'Simpson',
                  age: 36
               };

               $scope.save = function() {
                  console.log( $scope.person );
               }
            } );
      </script>
      <style>
         #metawidget {
            border: 1px solid #cccccc;
            width: 250px;
            border-radius: 10px;
            padding: 10px;
            margin: 50px auto;
            display: block;
         }
         #metawidget button {
            display: block;
            margin: 10px auto 0px;
         }
      </style>
   </head>
   <body ng-controller="myController">
      <metawidget id="metawidget" ng-model="person">
         <button ng-click="save()">Save</button>
      </metawidget>

   </body>
</html>

This will handily render:

Clicking the Save button will print the results to the console.

Of course Metawidget can extend this further to support form validation, alternate layouts, third-party components, and much more. To see how, the best place to start is the tutorial.

Thursday, August 8, 2013

NoSQL UI Generator

I did an experiment combining MongoDB, JAX-RS, AngularJS and Metawidget to show how Metawidget lets you render NoSQL objects straight to the client. The advantage of this is that your client can dynamically adapt to whatever data is in your NoSQL database, without having to duplicate definitions between client and server. It's a MongoDB UI Generator!

Of course, there's nothing MongoDB-specific (or NoSQL-specific) about Metawidget. But it was great to see how easily these technologies played together. The only real gotcha was this bug, which I worked around by 'unwrapping' the $oid field:

// MongoDB's built-in ObjectId uses an $oid field, which AngularJS doesn't like to serialize

contact.put( "_id", new ObjectId().toString() );

You can download complete sample source code here. You'll need to deploy it on a Java EE compatible server (I used JBoss 7.1.1.Final) for JAX-RS, and MongoDB should be installed.

Feedback welcome!

Sunday, July 28, 2013

Troubleshooting JSON UI Generation: nested properties

I was asked why the following piece of Metawidget code returns an unusual result:

<!DOCTYPE html>
<html>
   <head>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js"></script>
      <script type="text/javascript">
      var person = {
         name: "Homer Simpson",
         age: 40,
         retired: false
      };
      </script>
   </head>
   <body>
      <div id="metawidget"></div>
      <script type="text/javascript">
         var mw = new metawidget.Metawidget( document.getElementById( 'metawidget' ), {
            inspector: new metawidget.inspector.CompositeInspector( [
               new metawidget.inspector.PropertyTypeInspector(),
               function( toInspect, type, names ) {
                  return {
                     properties: {
                        last_name: {
                           type:"object",
                           required:false,
                           properties: {
                              prefix: {
                                 type:"string",
                                 required:false
                              },
                              suffix: {
                                 type:"number",
                                 required:false
                              }
                           }
                        }
                     }
                  };
               }

            ] )
         } );
         mw.toInspect = person;
         mw.buildWidgets();
      </script>
   </body>
</html>

The developer was trying to add a custom Inspector to declare a new property last_name. This should be rendered along with his normal JSON object (which contains name, age and retired). But the result looks strange:

Let's explain what Metawidget is doing. Metawidget uses its Inspectors to retrieve metadata about which properties to render. Then it iterates over those properties and chooses appropriate widgets for them. For simple types, like string and number, Metawidget chooses native widgets like input type="text" and input type="number". But for complex types, such as object, it creates a nested Metawidget and recurses into it.

For this to work, the Inspectors have to play along. They cannot return the same metadata for the nested Metawidget as for the top-level Metawidget. If they do, we'll just recurse infinitely. This is what we're seeing. Actually you can see Metawidget helpfully caps the recursions so that the browser doesn't crash completely!

To fix this, our custom Inspector has to understand what it's being asked for and return appropriate metadata. It can use the names array to do this. A complete example:

<!DOCTYPE html>
<html>
   <head>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js"></script>
      <script type="text/javascript">
         var person = {
            name: "Homer Simpson",
            age: 40,
            retired: false
         };
      </script>
   </head>
   <body>
      <div id="metawidget"></div>
      <script type="text/javascript">
         var mw = new metawidget.Metawidget( document.getElementById( 'metawidget' ), {
            inspector: new metawidget.inspector.CompositeInspector( [
               new metawidget.inspector.PropertyTypeInspector(),
               function( toInspect, type, names ) {
                  if ( names === undefined ) {
                     return {
                        properties: {
                           last_name: {
                              type:"object",
                              required:false,
                           }
                        }
                     };
                  }


                  return {
                     type:"object",
                     required:false,
                     properties: {
                        prefix: {
                           type:"string",
                           required:false
                        },
                        suffix: {
                           type:"number",
                           required:false
                        }
                     }
                  }
               }
            ] )
         } );
         mw.toInspect = person;
         mw.buildWidgets();
      </script>
   </body>
</html>

This will correctly render:

This is the 'native' way of doing things. Another way of thinking of it is: the 'native' result from an Inspector cannot contain nested properties. Of course, for more complex use cases your Inspector will have to consider which names it's being asked for and act accordingly.

However Metawidget can make things a little easier. It comes with a JsonSchemaInspector which understands how to navigate JSON Schemas for nested properties. So you can simply do:

<!DOCTYPE html>
<html>
   <head>
      <script src="http://metawidget.org/js/3.5/metawidget-core.min.js"></script>
      <script type="text/javascript">
         var person = {
            name: "Homer Simpson",
            age: 40,
            retired: false
         };
      </script>
   </head>
   <body>
      <div id="metawidget"></div>
      <script type="text/javascript">
         var mw = new metawidget.Metawidget( document.getElementById( 'metawidget' ), {
            inspector: new metawidget.inspector.CompositeInspector( [
               new metawidget.inspector.PropertyTypeInspector(),
               new metawidget.inspector.JsonSchemaInspector( {
                  properties: {
                     last_name: {
                        type:"object",
                        required:false,
                        properties: {
                           prefix: {
                              type:"string",
                              required:false
                           },
                           suffix: {
                              type:"number",
                              required:false
                           }
                        }
                     }
                  }
               } )

            ] )
         } );
         mw.toInspect = person;
         mw.buildWidgets();
      </script>
   </body>
</html>

Hope that helps!