Quantcast
Channel: Orbeon Forms Blog
Viewing all 231 articles
Browse latest View live

Review and PDF improvements

$
0
0

With Orbeon Forms 4.5, we are introducing several improvements to the Review mode and the PDF output.

Selection controls

We used to output all selection controls like this:

  • Single selection: output the selected item’s label.
  • Multiple selection: output all selected items’ labels with separators.
  • Boolean input: output “true” or “false”.

But this was not ideal for checkboxes and radio buttons. In these cases, you probably want all options visible in your review or PDF as well. Also, this opens the door to amending printed forms by checking options by hand.

The boolean input was worse, because nobody really wants to see “true” or “false” printed!

So here is how things look like in 4.5:

Review mode
Review mode
PDF output
PDF output

You notice that both checkboxes and radio buttons appear as boxes. That’s because on paper forms, unlike web UIs, there is more often than not no distinction between the two: you just check the boxes that apply, and explanatory text clarifies whether multiple choices are allowed. So for now we have decided on a unified appearance for both.

Highlighting of fields

We now also better highlight fields, for two reasons:

  • It was not always clear where a control’s label stopped and a control’s value started.
  • There is a use case for blank fields to be filled later on paper, in which case the field’s area must be clearly indicated.

This applies not only to input fields, but also to other types of controls which take more of a “field” appearance in review mode and PDF, such as date pickers and dropdown menus.

Highlighting of control fields
Highlighting of control fields

Page breaks before sections

Form Builder now has a built-in option to add a PDF page break before a section. One use case is forms that have a signature section, where there are legal requirements to make sure that certain fields stay together and on the same page.

Page Break Before option
Page Break Before option

Other improvements

Along the way, we also made the following improvements:

  • The “[Select…]” dropdown title no longer appears in Review mode and PDF files (see Fun with dropdown menu titles).
  • We place the form title in the header and the footer of the PDF, alongside page numbering.

With all this, the Review mode and PDF output are looking pretty good! These enhancements will be available in Orbeon Forms 4.5.


Configure the URL of your services in properties

$
0
0

Rationale

A few weeks ago, we've seen how you can store Orbeon Forms configurations, in particular the properties-local.xml, outside of the Orbeon Forms war file. We've seen how this allows you to have a single war you deploy on all your environments, and keep differences in configurations between these environments outside of the war file.

This is all good for the Orbeon Forms configurations. Here we'll see that you can use the same mechanism to define custom properties to specify which on what server your services run, or to what server you want data to be posted on submission.

The xxf:property() XPath function

Say you have forms you created with Form Builder, those forms use services, and in the service URL you want a different host name depending on the environment you're in. But of course, you don't want to change the forms as you run them on different environments. You can do this by defining a property, say:

<property as="xs:string"  
          name="com.example.service.host"
          value="prod.example.com"/>

Then, in Form Builder, in the HTTP Service Editor dialog, you refer to the value of the property with:

http://{xxf:property(com.example.service.host)}/your/service

Submission server

When users submit a form, you can setup Orbeon Forms to POST the data captured by the form to one of your servers. You do this with the send action, e.g.:

send(uri = "http://prod.example.com/your/service")

However, if you'd like, you can also move the server URL to its own property:

<property as="xs:anyURI"
          name="com.example.send.uri"
          value="http://prod.example.com/your/service"/>

And refer to that property in the send action (note that there is .uri at the end of the value passed to send, as the parameter to send is only a prefix, to which send can add different suffixes; for more on this, see the send action):

send(property = "com.example.send")

Orbeon Forms 4.5

$
0
0
Today we released Orbeon Forms 4.5!

Major features

This release is rich in new features features and enhancements:
  • IE11 support. Both Form Builder and deployed forms now work with with IE11.
  • Versioning of form definitions. Publishing a form definition doesn't overwrite the previously published form definition, but creates a new version of it. Orbeon Forms associates the version of the form definition used for creating and editing data. This is supported with relational databases (Oracle, MySQL, and DB2 at this time). (blog post)
  • Improved fields, checkboxes and radio buttons in preview and PDF. Automatic PDF output now shows all radio buttons and checkboxes, nicely highlights fields, supports optional page breaks before sections, and shows the form's title in the page's header and footer. (blog post)
  • Inserting and reordering of grid rows. Repeated grids now have the ability to reorder grid rows and to specify exactly where to insert a new row. (blog post)
  • Repeated sections. Form Builder and Form Runner now support repeated section content. This is very similar to repeating a group of grid rows, except that the entire content of a section can be repeated, including nested grids and subsections. (blog post)
  • Improved help messages appearance and positioning. Help messages have a fresher, more modern look, and are now more lightweight and better positioned. (blog post)
  • Hints for checkboxes and radio buttons. You can now associate hint messages with specific radio button or checkboxes. They appear as tooltips upon hover. (blog post)
  • Form definitions and form data duplication. The summary pages for both Form Builder and your own forms now can have a Duplicate button which allows you to duplicate form definitions (in Form Builder) and form data, including attachments. (blog post)
  • Improved dropdown menus. Dropdown menus are now a bit smarter! (blog post)
  • Improved Form Builder Choices editor. The Form Builder Choices editor allows you to reorder items and to directly localize labels and hints. (blog post)
  • Improved Form Builder variable resolution. We have fixed a long-standing issue which prevented the use of variables in repeated grids. (doc)
  • Detecting login pages in Ajax requests. Administrators can now tell Orbeon Forms which pages are login pages, to help with error recovery. (blog post)
    Internationalization:
    • This version features full Spanish localization, courtesy of Bruno Buzzi of AGESIC.
    • This version also features Swedish localization for Form Runner.
    See Localizing Orbeon Forms for more details about supported languages.
      Other bug-fixes and features

      Including the major features and enhancements above, we closed over 110 issues since Orbeon Forms 4.4. We should mention these notable bug-fixes and features:
      • XForms 2.0 bind() function (#1423)
      • Service request or response cannot target control in subsection (#1465)
      • Support repeats in actions (#1105)
      • PDF: Option to output a page break before a section (#1556)
      • FB: UI to edit control, grid and section classes (#1555)
      • PDF: Ability to set form title in header and/or footer (#1558)
      • Processes: reusable confirmation dialog (#1570)
      • XML Schema xs:import doesn't support relative paths (#1340)
      Current browser support
      • Form Builder (creating forms):
        • Chrome (latest versions, both in the stable and dev channels)
        • Firefox (latest released version and current Firefox ESR)
        • IE10 and IE11
        • Additional support for Form Runner (accessing form):
          • IE7 (deprecated), IE8, and IE9
          • Safari Mobile on iOS 6 and iOS 7
          • Chrome for Android (stable channel)
        Compatibility notes
        • Date picker. The Date Picker control has been removed from Form Builder. It was similar to the normal Date control, except the date was shown as text in the page, not in a text field. The Date Picker didn't have much of a benefit over the regular Date control, but had a big drawback: it wasn't usable on mobile devices, which expect a text field to enable the native date picker. Note that while the control isn't available in the Form Builder sidebar anymore, the underlying implementation is still there, so your existing forms that use a Date Picker can still be edited in Form Builder, and will still function properly. (#1364)
        • Datatable. The fr:datatable component, deprecated in 4.0, has been completely removed.
        • Deployment. Integrated deployment, consisting in combining your Java/JSP applications with Orbeon Forms within the same WAR, is now deprecated. We recommend using separate deployment instead.
        • Oracle flat view. The truncation of section/control column names has changed. If the section or control name is 14 characters or less, it is kept as is, and the other part is truncated if needed. A numerical suffix is used instead for those columns which would introduce duplicates. (doc)
        You can download the latest version of Orbeon Forms from the downloads page.
          Don't forget to grab a trial license for the PE version.

          Please send feedback:
          We hope you enjoy this release!

          Solving the observer problem

          $
          0
          0

          Abstract

          As most sophisticated web apps, Orbeon Forms has to deal with lots of asynchronous events in the browser, like Ajax requests, timers, and user interactions. We'll go over a real-life example of logic involving several asynchronous events, see the difficulty involved in implementing it with observers, and explore 3 alternatives: state machines, await, and Functional Reactive Programming (FRP). We'll see why, based on our experience, we don't consider state machines to be a good solution, and through an example explore the two remaining alternatives, await and FRP.

          Example of the loading indicator

          Orbeon Forms can show on the page a "loading indicator" to inform users that something is happening: data was sent to the server, and we're waiting for a response, maybe because we need to validate user input, save data, or call a service. Its logic works is as follows:

          1. In essence, when a request is in progress, we want the loading indicator to show.
          2. However, if the request takes very little time, we don't want to show the loading indicator.
          3. Also, when a request comes back, we don't want to hide the indicator if we already know we'll right away send another request to the server.

          Stated in plain English, this is quite simple.

          The problem with observers

          The browser gives us events, and we can run code when those events happen. Code running upon some event is called an observer. For the loading indicator, we would have an observer when an Ajax request starts, and another one when it ends. Since we don't want to show the indicator right away, the observer on the "Ajax request started" starts a timer for say 200 ms. So we would have an observer on that timer, which on completion shows the indicator if the request is still in progress. But to know that, we need to have state (isRequestInProgress), shared between the two observers.

          But a boolean isn't enough. Say you start a first request at t = 0 ms. At that point, you also start a timer for 200 ms. Say that first request ends at t = 100 ms. Now say a second request starts at t = 150 ms. At t = 200 ms, the first timer ends: a request is still in progress, so it shows the loading indicator. Bug! At that point the request has been going on for only 50 ms, so we shouldn't show the loading indicator just yet. One way to solve this problem is to use a counter, instead of a boolean, an increment/decrement that counter at the right time.

          I won't go here through all the details of the implementation, but the end result is that the above logic is spread across a number of observers that share and update some global state. Logic written this way is surprisingly hard to maintain, and subtle bugs can lead to a loading indicator that stays "stuck", i.e. shown even if there no Ajax request in progress, or that doesn't show anymore.

          Possible solutions

          We're aware of 3 alternatives to observers:

          1. State machines
          2. await
          3. Functional reactive programming (FRP)

          State machines

          In Form Builder, we started using a state machine about 2 years ago, and had a mixed experience with that approach. A state machine solves part of the observer problem, by putting the high level logic in a single place, in a fairly declarative form. However, we found that complex state machines are hard to debug, as you can't debug the declaration of the state machine itself, but instead have to debug the generic implementation of the state machine.

          Experimenting with await and FRP

          Before going for await or FRP in production code, we wanted to do some experimentation. For this, we took the example described in the excellent paper Deprecating the Observer Pattern. The example uses the canvas and the mousedown, mousemove, and mouseup events to let the user draw on the canvas. You'll find below the CoffeeScript code for 3 implementations:

          1. With observers, using plain jQuery.
          2. With await, using IcedCoffeeScript.
          3. With FRP, using Bacon.js.

          For each case, you can click on the link after the code to view the full source and run that example.

          With observers

          isDown = false
          
          canvas.on 'mousedown', (e) -> 
              isDown = true
              startLine(e)
          
          canvas.on 'mousemove', (e) -> 
              if isDown
                  continueLine(e)
          
          canvas.on 'mouseup', (e) -> 
              isDown = false
          

          See and run the code

          With await

          while true
          
            await canvas.one('mousedown', defer(e))
            startLine(e)
          
            until e.type == 'mouseup'
                rv = new iced.Rendezvous
                canvas.one('mousemove', rv.id().defer(e))
                canvas.one('mouseup'  , rv.id().defer(e))
                await rv.wait(defer())
                continueLine(e)
          

          See and run the code

          With FRP

          downStream         = canvas.asEventStream('mousedown')
          upStream           = canvas.asEventStream('mouseup')
          moveStream         = canvas.asEventStream('mousemove')
          
          isDownProp         = downStream.map(true)
                                         .merge(upStream.map(false))
                                         .toProperty(false)
          moveWhenDownStream = moveStream.filter(isDownProp)
          
          downStream         .onValue(startLine)
          moveWhenDownStream .onValue(continueLine)
          

          See and run the code

          Conclusion

          We believe that both await and FRP are significant improvement over observers or a state machine. At this point, we have a slight preference for await, as we think that:

          • Most developers will find it easier to understand code using await than code using FRP, and we believe in Erik Meijer's mantra: "write baby code".
          • We think that code using await will be easier to debug than code using FRP, as it will be easier to put breakpoints in the right place, and follow the code execution.

          Smarter dates and times

          $
          0
          0

          Orbeon Forms prior to version 4.4 used to display full dates and times in the Summary page:

          Full dates
          Full dates

          We didn’t like this because the resulting dates and times took a lot of precious space on screen.

          One way to solve this is to indicate relative dates such as “3 hours ago”, “20 days ago”, or “1 year ago”. [1] But we don’t like this either because the resulting information is often rounded to the point of being meaningless.

          Instead, we chose a very simple method inspired by applications such as Google Drive. [2] We use exactly 3 date and time formats:

          • if the instant is at most one day in the past, show hours and minutes only
          • if the year is the same as the current year, show the month and day only
          • otherwise, show year, month and day in a compact format

          The result is as follows:

          Short dates
          Short dates

          These shorter dates present enough meaningful information and always in a compact way. Of course this remains a tradeoff: for example if you want to save a screenshot for further reference, it would better to have full dates and times. But for most common uses, we think this is a pretty good approach. Let us know what you think!

          This change is available in Orbeon Forms 4.4 and newer.


          1. As GitHub does, for example.  ↩

          2. Formerly Google Docs.  ↩

          SQL Server support in Orbeon Forms

          $
          0
          0

          Starting with version 4.6, Orbeon Forms will support SQL Server. This is in addition to Oracle, MySQL, and DB2, which have been supported for a while now.

          Adding support for SQL Server was not as large an endeavor as one might think, this mostly thanks to the work we have done in 2013 to have one unified implementation of the persistence API for all relational databases. Having a unified implementation helps not only with supporting additional databases, but also creates cross-pollination between databases: an improvement we make for a specific database, is very likely to also improve things for all the other supported databases.

          For more on this, see how to create the tables in your SQL Server for Orbeon Forms, and how to setup your app server running Orbeon Forms with SQL Server.

          Inline property values

          $
          0
          0

          A small change coming in Orbeon Forms 4.6 is the ability to set inline configuration property values.

          Orbeon Forms uses properties for a lot of its configuration. For example, to set which standard buttons appear in a form:

          <property
            as="xs:string"
            name="oxf.fr.detail.buttons.orbeon.controls"
            value="refresh pdf wizard-prev wizard-next review"/>

          When a property value is not too long, and using proper indentation, this format is acceptable. But some property values are longer or require multiple lines, and placing them in an XML attribute becomes less than ideal.

          So starting with Orbeon Forms 4.6 you can place long property values inline instead. For example the following is identical to the above:

          <property as="xs:string" name="oxf.fr.detail.buttons.orbeon.controls">
              refresh pdf wizard-prev wizard-next review
          </property>

          This is even better for multi-line properties, such as the whitespace stripping configuration:

          <property as="xs:string" name="oxf.xforms.whitespace.html.preserve">
              xh|pre,
              xh|textarea,
              xh|script,
              xh|style,
              xh|template
          </property>

          or simple processes associated with buttons:

          <property as="xs:string" name="oxf.fr.detail.process.save-final.*.*">
              require-uploads
              then validate-all
              then save
              then success-message("save-success")
              recover error-message("database-error")
          </property>

          or the Form Builder toolbox configuration:

          <property as="xs:string"  name="oxf.fb.toolbox.group.typed.uri.*.*">
              oxf:/forms/orbeon/builder/xbl/typed-controls.xbl
              oxf:/xbl/orbeon/us-phone/us-phone.xbl
              oxf:/xbl/orbeon/number/number.xbl
              oxf:/xbl/orbeon/currency/currency.xbl
              oxf:/xbl/orbeon/us-state/us-state.xbl
          </property>

          See the documentation for more on configuration properties.

          Orbeon Forms 4.5.1

          $
          0
          0
          Today we released Orbeon Forms 4.5.1 PE. This is a bug-fix update for Orbeon Forms PE only. We recommend this update for all Orbeon Forms 4.5 users. For more details about the 4.5 release in general, see Orbeon Forms 4.5.

          This release includes the following fixes:
          • Form Builder
            • Control/section settings add empty class attribute (#1659)
            • FB: Dropdown has duplicate empty item if not "[Select...]" (#1708)
          • Form Runner
            • Caching of form definition is influenced by document id (#1681)
            • Make substring search case insensitive with MySQL (#1608)
            • If you're using MySQL 4.5, and the data in your summary page looks garbled, you should follow these instructions ((#1607)).
            • Wizard misses gray border (#1666)
            • PDF: Misaligned required checkboxes/radio buttons (#1677)
            • PDF attached to email has missing checkboxes (#1682)
            • Some forms fail to load and show empty (#1687)
          • XForms
            • Error when referring to nested bind with a variable (#1662)
            • Assertion error when xf:output used in XBL LHHA (#1707)
            • JavaScript error when opening help for control with no label (#1713
          You can download the latest version of Orbeon Forms from the downloads page.
            Don't forget to grab a trial license for the PE version.

            Please send feedback:
            We hope you enjoy this release!

            Automated database testing with RDS

            $
            0
            0

            Starting with version 4.6, Orbeon Forms will support SQL Server, in addition to Oracle, MySQL, and DB2. That's a lot of databases to test for. To make testing easier, we've started using Amazon RDS. RDS does for databases what Sauce did for browsers: it allows us to run on every commit all our tests against different databases, and this without us having to worry about maintaining servers running all the different databases we want to support.

            Since RDS doesn't (yet?) support DB2, at this point we're running automated tests on every commit against Oracle, MySQL, and SQL Server, but not DB2. For DB2, we're planning to do this by leveraging an EC2 instance.

            Improved Form Runner Home page usability

            $
            0
            0

            Orbeon Forms 4.6 improves the performance and usability of the Form Runner Home page.

            The Form Runner Home page
            The Form Runner Home page

            As a reminder, the Form Runner home page has two purposes:

            • For regular users, it is a start page which lists the forms available to the user and allows navigation to the Summary or New page.
            • For administrators, it provides a range of administrative functions such as publish/unpublish, moving forms to a remote server, and more.

            Recently, while using the Home Page with databases containing large numbers of published forms, we noticed performance issues, especially when loading form definition metadata from both a local and a remote server. So we fixed the following for Orbeon Forms 4.6:

            • We made joining local and remote form metadata much faster.
            • We addressed a few inefficiencies common to all databases.
            • We made retrieval of form metadata much faster with the Oracle database (which should help with other relational databases as well).
            • We added paged navigation to make the HTML page smaller and faster.

            With these changes, the Home page shows good responsiveness even with hundreds or a few thousands of published form definitions!

            The Form Builder summary page and Form Runner home page

            $
            0
            0

            We often get questions that result from a confusion between the roles of the Form Builder summary page, and the Form Runner home page. The confusion comes from both pages listing forms you've created with Form Builder. To put it simply:

            • The Form Builder summary page shows form you can edit.
              • This page is for form authors. It is the place to go to if you want to see what forms you can currently edit, or want to create a new form.
            • The Form Runner summary page shows form that have been published.
              • It can be useful to end users who want to see which forms they have access to. From there, they could fill out a new form (e.g. fill out a new "Child registration" form), and see what forms they have filled out in the past (e.g. all the previously filed out "Child registration" forms). Of course, whether end users can access that page is subject to how you configured the system.
              • It can be useful to administrators who want to perform management tasks on published forms. For instance, they can set whether a form is available to end users, or move published forms between servers, for instance push published forms from an integration server to a production server.

            Finally, keep in mind that both pages don't necessary display the same set of forms:

            • Obviously, forms a form author is currently working on, but that haven't been published yet will show on the Form Builder summary page, but not the Form Runner home page.
            • Maybe more surprisingly, the opposite is also possible: you can have, on a given Orbeon Forms server, published forms that are not available on the Form Builder summary page. This can happen in a number of situations, for instance when you have multiple environments, say a development and test server. If form authors always edit forms on the development server, publish them locally, and then publish them to the test server for testing, on the test server, those forms will only be available in the "published state", and won't be available for editing. Thus, on the test server, they will show on the Form Runner home page, but not the Form Builder summary page.

            Orbeon Forms 4.6

            $
            0
            0
            Today we released Orbeon Forms 4.6!

            Major features and enhancements
            • Lower memory usage for compiled forms. Orbeon Forms has a sophisticated system of caches, including for compiled form definitions. In previous versions, several compiled form definition were created for different modes of the same form (creation, edition, view, PDF, email, noscript). In this version, we create a single compiled form definition for creation and edition on one hand, and view, PDF and email on the other hand. When the wizard view is not used, a single form definition is created for all those modes. The benefit is that less memory is used per form you create, and that the first access to a given mode of a form can be faster. (#1143)
            • Faster large forms. This version fixes a bottleneck which slowed down very large forms, sometimes by a factor of two. (#1737)
            • SQL Server support. In addition to Oracle, DB2, and MySQL, Orbeon Forms can now store form definitions and data in SQL Server. (#697) (blog post)
            • Improved Form Runner Home page. The Form Runner Home page is now faster, in particular with relational databases, and supports paging. (blog post)
            • Improved versioning options when publishing. When versioning is enabled, publishing a form now gives the form author the option to create a new form version or to override the previous version. (#1669)
            • Upgrade form definitions. Form Builder, when loading forms from older versions of Orbeon Forms, has a mechanism to upgrade the form definition to the new version. Until now, you had to open all those forms in Form Builder and republish them, which could be time consuming. You can  now do this as a batch operation from the Form Runner Home page with the new "Upgrade form definitions" function. (#1695)
            Internationalization

            This version introduces the following new languages:
            • Portuguese (Form Runner and Form Builder)
            • Dutch (Form Runner)
            In addition, the Finnish resources have been brought up to date (Form Runner and Form Builder).

            See Localizing Orbeon Forms for the latest localization support. Localization depends on volunteers, so please let us know if you want to help!

            Other new features and bug-fixes

            Including the major features and enhancements above, we closed about 60 issues since Orbeon Forms 4.5.1 (over 70 since 4.5). We should mention these notable bug-fixes and features:
            • Form Builder
              • You can configure whether services/actions are present in toolbox (#1722), which Publish dialog actions are available (#1721), and which buttons and processes are used in Form Builder (#1416)
            • Form Runner
              • URLs in text fields and textareas are automatically hyperlinked (#1694)
              • The "navigate" action properties can be XPath value templates (#1226) (doc)
              • Attached images are properly resized in PDF files (#872)
              • Focusing out of all fields dispatches a DOMFocusOut event (the Form Runner error summary show errors as expected when this happens) (#619)
              • When paging in the Summary or Home pages, full updates are used and increase UI responsiveness (#1685)
              • The Dynamic Data Dropdown can now be hidden if its itemset is empty (#1621)
              • The min and max attributes on fr:grid are now AVTs (#1665)
            • XForms
              • Required and type MIPs now count as failed validations (#1533)
              • xf:case supports AVT on the selected attribute (#1683)
              • The recalculate and revalidate actions are now unified (#1650)
            • Other
              • Properties support inline values for enhanced readability (#1257) (blog post)
              • Orbeon now uses jQuery version 1.10.2 (#1349)
              Current browser support

              This is unchanged since Orbeon Forms 4.5:
              • Form Builder (creating forms):
                • Chrome (latest versions, both in the stable and dev channels)
                • Firefox (latest released version and current Firefox ESR)
                • IE10 and IE11
                • Additional support for Form Runner (accessing form):
                  • IE7 (deprecated), IE8, and IE9
                  • Safari Mobile on iOS 6 and iOS 7
                  • Chrome for Android (stable channel)
                Compatibility notes
                • If you use Oracle, MySQL or DB2, you need to upgrade your database schemas. (doc)
                • With XForms, the xxf:sequence element child of xf:var is deprecated. Instead, use xxf:value. (#1710)
                You can download the latest version of Orbeon Forms from the downloads page.
                  Don't forget to grab a trial license for the PE version.

                  Please send feedback:
                  We hope you enjoy this release!

                  Orbeon Forms 4.6.1

                  $
                  0
                  0
                  Today we released Orbeon Forms 4.6.1 PE. This update to Orbeon Forms 4.6 PE contains bug-fixes and a couple of minor features. We recommend this update for all Orbeon Forms 4.6 PE users. For more details about the 4.6 release in general, see Orbeon Forms 4.6.

                  This release includes the following:
                  • Form Builder
                    • FB: Order of apps in new dialog is random (#1794)
                    • Copy/paste of control doesn't copy LHHA references correctly (#1820)
                  • Form Runner
                    • ORA-24816 when saving large form (#1797)
                    • fr:fields-date/fr:dropdown-date: use oxf.xforms.format.input.date (#1803)
                    • Propagate request parameters between edit/review/pdf (#1736)
                    • Don't use spinner for Edit/Review buttons (#1814)
                    • Ability to pass custom parameters to persistence layers (#1735)
                  • XForms
                    • Filter returns blank page navigating to .xhtml page (#1796)
                    • Email validation is too lax (#1347)
                    • Spinner doesn't show properly in Liferay (#1804)
                    • Standard Orbeon error dialog not read out (#1724)
                  • Other
                    • Option to remove Orbeon version number everywhere (#1720)
                    • Flickr examples fail because Flickr APIs moved to SSL (#1805)
                  Compatibility notes:
                  • The oxf.fr.version property has been removed. Use the global oxf.show-version property instead.
                  You can download the latest version of Orbeon Forms from the downloads page.
                    Don't forget to grab a trial license for the PE version.

                    Please send feedback:
                    We hope you enjoy this release!

                    Multiple remote servers

                    $
                    0
                    0
                    Orbeon Forms 4.4 introduced the ability to connect Orbeon Forms to a remote server to publish, unpublish, and transfer form definitions back and forth.

                    It is now possible to configure more than one server, for example a staging and a production server. You choose to which server to connect when loading the Form Runner Home page.

                    Multiple remote servers
                    See the documentation for the details, including the change in configuration. This feature will be available in Orbeon Forms 4.7.

                    Orbeon Forms 4.6.2

                    $
                    0
                    0
                    Today we released Orbeon Forms 4.6.2 PE. This update to Orbeon Forms 4.6.1 PE contains bug-fixes and localization improvements. We recommend this update for all Orbeon Forms 4.6 PE users. For more details about the 4.6 release in general, see Orbeon Forms 4.6.

                    This release includes the following bug fixes:
                    • Form Builder
                      • Incorrect copy/paste of control with warning constraint (#1785)
                    • Form Runner
                      • Alert for constraint shows instead of alert for required (#1829)
                      • Required validation must win over other constraints (#1830)
                      • Comma-separated roles fail in persistence layer (#1690)
                      • Remove Explanation control from the toolbox unless ready (#1825)
                      • Versioned resources have expiration date in the past (#1837)
                    • XForms
                      • XForms inspector doesn't support copy/paste anymore (#1841)
                    This release also adds:
                    • Swedish localization for Form Builder
                    • Updated translations for German and Italian (#1832)
                    Compatibility notes:
                    You can download the latest version of Orbeon Forms from the downloads page.
                      Don't forget to grab a trial license for the PE version.

                      Please send feedback:
                      We hope you enjoy this release!

                      Fail to handle the session properly, and make your site useless

                      $
                      0
                      0

                      I was recently on vacation abroad. Just before taking the flight back home, I embarked on the mundane task of doing the online check-in for my return flight. The process started nicely, on what looked like a modern and well designed site; it was obvious that a lot of care went into creating that site.

                      Then, I arrived at the page where you need to enter information about yourself and family members traveling with you: passport number, expiration date, address of residence, information about the green card when it applies, and so on. In my case, with 4 family members, that was a pretty long page. I had all the passports handy, but it still took me maybe 10 minutes to enter that information. Apparently, I wasn't fast enough: upon pressing the Next button, I got that dreadful your session has expired message.

                      I ended up preparing all the information required for the form in a text file, so I could just copy-paste it very quickly, and fill out the form before the session could expire. Check-in done. But I seriously doubt that many people manage to get through this process. See such a nicely designed site completely fail because of a session issue is a shame.

                      The thing is that doing it right isn't as easy as it seems. You have to deals with competing requirements:

                      1. Having a session last for a longer time is worse for security and uses more resources on your servers.
                      2. But of course, the session should last long so the site is actually usable, and users don't get a session expired while filling out a form.

                      Say you setup your server to have the session last only 10 minutes, favoring security and lower resource usage on your server. The issue is that the "counter" typically gets reset every time users submit a form, e.g. click on the next button in a wizard. This means that if you have a long form, you're saying your users must fill it out in less than 10 minutes, which might not be possible. But of course, you can do better:

                      1. Why not "reset the counter" every time users fill out a field? This way, whatever the length of the form is, the session will only expire after 10 minutes of true inactivity.
                      2. If you want to be more aggressive about keeping the session alive, why not prevent it from expiring as long as users have a tab open pointing to your site?

                      Orbeon Forms does both. Out-of-the-box1. And we think every site should do the same. (Especially if those I use to check-in before an international flight with 4 family members.)


                      1 In Orbeon Forms, the feature that keeps the session alive as long as users have a tab open is called session heartbeat. Since doing this does put more strain on your servers, you have the option of disabling session heartbeat.

                      Embedding support in Orbeon Forms 4.7

                      $
                      0
                      0
                      So far there have been a couple of ways to integrate Orbeon Forms with existing applications:
                      • Side by side: linking or posting data from other applications to Orbeon Forms pages, and linking or posting data from Orbeon Forms to other applications.
                      • Embedded in a portal: using the full portlet or the proxy portlet within Liferay.
                      Orbeon Forms 4.7 introduces a new way to integrate forms within Java (and other Java Virtual Machine-based languages) applications: server-side embedding.

                      Your application simply includes a small JAR file, adds some configuration parameters, and then each page which needs to embed a form simply calls the API to tell which form to embed. You control where in your page the form must show, which means that your page can include your own header, footer, sidebars, and other content in addition to the form.

                      A form embedded in a simple page with a top banner
                      See the documentation for more details.

                      Control required values with formulas in Orbeon Forms 4.7

                      $
                      0
                      0
                      Up to Orbeon Forms 4.6, Form Builder only lets you determine whether a field is required or not once and for all, by saying "Yes" or "No.

                      With the upcoming Orbeon Forms 4.7, you can also choose to use a formula, which means that the choice can be dynamic: for example, a field might be required only if another field is set to a specific value.

                      As usual, you express the formula with an XPath expression, which gives you access to all of the form's data as well as the Orbeon Forms XPath function library.




                      For more details, see the documentation.

                      Internationalization in actions used to populate selection controls

                      $
                      0
                      0

                      When you create a form in Form Builder, if you have selection controls (dropdowns, checkboxes, radio buttons, lists, and the like), in most cases you know in advance what choices you want to offer your users. For instance, this is the case if you have a field allowing users to select a state, or marital status, or age bracket.

                      But in other cases you don't want to hard-code the choices in the form; maybe you don't know ahead of time what the choices are, or they are likely to change, or you don't want to duplicate that list across several forms. In all those cases, you'll want to rely on a list returned by a service (a database query or a REST/web service).

                      Starting with the upcoming 4.7 release, if your form is available in several languages, you can also define how the labels in those different languages is to be extracted from what is returned by the service. For more on this, see the documentation on internationalization in actions.

                      Orbeon Forms 4.7

                      $
                      0
                      0
                      Today we released Orbeon Forms 4.7!

                      Major features and enhancements
                      • Server-side embedding API. Orbeon Forms 4.7 introduces a new way to integrate forms within Java (and other Java Virtual Machine-based languages) applications: server-side embedding. (doc, blog)
                      • Internal service requests. Orbeon Forms often needs to perform requests to itself, such as calling its own persistence layer implementations, as well as for internal page navigation. In previous versions, Orbeon Forms performed HTTP requests on itself. This could cause problems, such as using more servlet container threads, slower performance, and interference with servlet filters. Internal requests no longer use actual HTTP connections, which addresses these issues.
                      • Improved Liferay proxy portlet support.
                        • The proxy portlet uses a better and more configurable HTTP client to connect to Form Runner. In particular, this means that gzip compression can be supported between Form Runner and the portlet.  (doc)
                        • The WAR file is much smaller than before (1.7 MB).
                        • The portlet supports dynamic form selection from URL parameters. Note that this is disabled by default for security reasons. (doc)
                      • Form Builder improvements.
                        • Support internationalization of itemsets in actions. (docblog)
                        • You can control required values with formulas. (docblog)
                      • Multiple remote servers. The Form Runner Home page supports multiple remote servers. You can, for example, configure a staging and a production server. (docblog)
                      • Flat view support with DB2. Previously, the flat view was supported with Oracle only. It is now also supported with DB2. (doc)
                      • Improvements to simple processes.
                        • New set-data-status action. (doc)
                        • New setvalue action. (doc)
                        • Support XVT in success-message and error-message actions. (doc)
                        • Ability to set and clear fields with the duplicate action. (doc)
                        • Ability to send form metadata to a service. (doc)
                      • New APIs.
                        • Service API to duplicate form data. (doc)
                        • Service API to list form data attachments. (doc)
                      Internationalization

                      See Localizing Orbeon Forms for the latest localization support. Localization depends on volunteers, so please let us know if you want to help!

                      Other new features and bug-fixes

                      Including the major features and enhancements above, we closed about 40 issues since Orbeon Forms 4.6.2 (and over 60 since 4.6).
                        Current browser support
                        • Form Builder (creating forms):
                          • Chrome (latest versions, both in the stable and dev channels)
                          • Firefox (latest released version and current Firefox ESR)
                          • IE11
                          • Additional support for Form Runner (accessing form):
                            • IE8 and IE9
                            • Safari Mobile on iOS 6, iOS 7 and iOS 8
                            • Chrome for Android (stable channel)
                          Compatibility notes
                          • Browser support
                            • For end-users (when accessing forms, e.g. through Form Runner) – Support for IE7 was deprecated in Orbeon Forms 4.5, and isn't supported anymore started with Orbeon Forms 4.7.
                            • For form authors (using Form Builder) – In Orbeon Forms 4.7, we used to support both IE10 and IE11; since in most cases IE10 auto-updates to IE11, the share of IE10 dropped very quickly after IE11 was released in October 2013. So, in Orbeon Forms 4.7, we decided to drop support for IE10. Going forward, for Form Builder, we plan to only support the latest release of IE.
                            • Portlets. Support for loading portlet content asynchronously has been removed. This had been introduced to improve portlet loads with slower browsers such as IE 7, which is no longer supported.
                            • Property deprecation. The oxf.fr.production-server-uri property is deprecated and replaced with the new oxf.fr.home.remote-servers property.  If oxf.fr.production-server-uri is set and not empty, it takes precedence over the new oxf.fr.home.remote-servers property, for backward compatibility.
                            You can download the latest version of Orbeon Forms from the downloads page.
                              Don't forget to grab a trial license for the PE version.

                              Please send feedback:
                              We hope you enjoy this release!
                              Viewing all 231 articles
                              Browse latest View live