Thursday, December 18, 2014

Winter Holiday

'tis the season again to thank You, dear readers and followers for the support and loyalty you demonstrated over the past year. 2014 will be history soon and as is the custom in this part of the world we slow down a bit, enjoy winter and relax (and finish a book).

We will be back in 2015 with some great news and (spoiler alert) a new home for all things Siebel Essentials.

So with all the best wishes for the holiday season, I remain

yours, essentially


Tuesday, December 16, 2014

Siebel CRM IP 2014: Wrap Your Plug-ins - Part 2

Welcome to the second - and final - part of our introduction to the new plug-in wrapper architecture for Siebel Open UI IP 2014.

Building upon what we discussed in part 1, we will today implement a custom plug-in wrapper that allows a user to use a slider control instead of a drop down menu. Here is a video of the user experience.

In the previous part we created a skeleton PW and associated it with the Application UI object. So let's fill it with life:


Here's the ShowUI method for our simple demo wrapper:

MyPW.prototype.ShowUI = function () {
   SiebelAppFacade.MyPW.superclass.ShowUI.apply(this, arguments);
   var pwEl = this.GetEl(); //get the jQuery object for the control
   //create a slider, using the control name to make it unique
   var mySlider = $("<div id='slider" + pwEl.attr("name") + "'></div>");
   var sliderOptions = { min:0, max:100, step:10, value:0 };
   mySlider.slider(sliderOptions);   //make slider
   mySlider.addClass("ouib-slider");  //add class for style
In the ShowUI method we take care of "showing" our slider. This is what the code does in prose:

  • Call the superclass' ShowUI method (as you would do in any PR)
  • Use the GetEl method ("Get Element") which actually returns the jQuery collection of the control, making it much easier to reference it.
  • Create a DIV for the slider using the element's name for uniqueness.
  • Set slider options, these could come from control user properties of course.
  • Append the slider to the current control (you could also replace it).
  • Add a class for style.

So once this code has run, we have a slider below the actual control. Now we have to define what happens when a user actually uses the slider.


Here's the BindEvents method for our demo slider PW:

MyPW.prototype.BindEvents = function () {
   var that = this;
   //define slider events
   $("#slider" +  this.GetEl().attr("name")).slider({
      change: function(e,ui){  //when user releases the slide handle
      //call focus and blur events to trigger event handling
         that.OnControlEvent(consts.get("PHYEVENT_CONTROL_FOCUS"), that.control);
         that.OnControlEvent(consts.get("PHYEVENT_CONTROL_BLUR"), that.control, String(ui.value));
      slide: function(e,ui){ //while user slides, show the value

The jQuery UI slider widget exposes events such as 'change' or 'slide' which you can handle with a function. This is what we do:

  • When the user slides the handle ('slide' event), we set the field value to the value defined by the slider. This results in a nice effect on the original field.
  • When the user releases the slider and has changed the value ('change' event), we call two events on the control's PM:
    • FOCUS: This ensures that the control gets the focus before it is updated.
    • BLUR: This actually updates the original control with the slider value and removes the focus.

Using the focus/blur events triggers all the right events in the framework and is the recommended approach to update a field in Siebel Open UI. It is not (yet) documented, but you sure know that in Open UI it's a "no, no" to mess with the BC etc.

Great, our slider now actually sets the field value. But what if a user (or workflow, script, etc.) changes the value of the original control (maybe in a different applet)? Read on...


The SetValue method is a PW method that is invoked every time the control gets updated. So overriding this method is obviously mandatory for a good PW. Here's a sample implementation for our slider scenario:

MyPW.prototype.SetValue = function (value, index) {
   //SetValue of the PW is called when the original control value changes, value, index);
   //set the slider value

As you can see, we don't do much apart from the following:

  • Call the superclass' SetValue method for good measure.
  • Set the slider value to what is being passed by the SetValue method.

Magic! Our slider now correctly displays the value of the field, independent where it has been set.

Attach the Custom PW

One more thang! A custom PW must be attached to a control using the AttachPW method of the PluginBuilder class. This is done in the same file after the custom class implementation, like this:

SiebelApp.S_App.PluginBuilder.AttachPW(consts.get("SWE_CTRL_COMBOBOX"), SiebelAppFacade.MyPW, function (control) {
   if (control.GetName() == "Probability2") {  //simple demo, we could be so much more clever here
      return true;  //make it so
   else {return false};

As discussed in our previous post, the AttachPW method is run for each control (in the current view) that is of the type specified by the first argument. The function (third argument) must return true or false depending on whether you want the attachment to happen or not. In our simplistic scenario, we only attach when the control name is 'Probability2' (which is actually the Opportunity Probability dropdown on the form applet).

In the 'evaluation function' you can be totally clever and for example use this new function to evaluate whether the current device has a touch screen or not:


(nice touch, isn't it?)

Style Sheet

Please refer to this file for a standard style (you will need to add the CSS rules to a custom style sheet, otherwise you will not see the slider in IP 2014, because it comes without the jQuery UI style sheet.

Full Code

For your convenience (and because it's christmas ;-) you can find the full PW file here. Once you have registered it as described in part 1, you should see the following when you open any view that exposes the probability control:


In this second part of our mini-series we have demonstrated an implementation of a custom plug-in wrapper. The result is that each control that matches the conditions now is extended by a jQuery UI Slider that is fully functional.

have a nice day


Monday, December 15, 2014

Siebel CRM Patchset 14 for Innovation Pack 2013 is Available

Last Friday, Oracle released patchset 14 for Siebel CRM Innovation Pack 2013. Don't confuse this with IP 2014 ;-)

Please refer to the readme document for details on this patchset.

have a nice day


Siebel CRM IP 2014: Wrap Your Plug-ins - Part 1

One of the new members of the Siebel Open UI family that arrived with Innovation Pack 2014 are plug-in wrappers. They are part of a renewed physical renderer architecture which enables developers (at Oracle and at customer sites) to focus on the appearance and functionality of controls.

Let's start with an example and consider a scenario where a Siebel architect decides to revolutionize the user experience by replacing (or augmenting) all numeric fields with sliders. Here is an example of such augmentation:

A custom plug-in wrapper (slider)
below a standard control (Opportunity Probability)
If you want to see the final example in action, here is a short screencast that demonstrates the end user perspective.

In IP 2013, you could do that but at the cost of having to implement a custom physical renderer for applets and put much work into identifying the numeric fields, creating the slider, handling the events and so on.

Enter plug-in wrappers. A plug-in wrapper (PW) is basically a renderer for controls. They have a documented API and you can create your own wrappers. So instead of going down the rabbit hole in a frenzy of JavaScript, you only have to deal with a simple file that handles all controls across the entire application.

Together with fellow Oraclean and author Duncan Ford, we put together an example PW which we are going to introduce in this and the next article. Those who have been around for a while here at Siebel Essentials might recognize the slider example from last year (which of course is implemented in 'old-school' style as it was IP 2013).

A PW Template

Let's start with the 'skeleton' of a PW. Don't be afraid, it looks very familiar:

Click to enlarge. Full code example here.
Looks familiar? If you spent a bit of time with Open UI you would be tempted to say that the above code is a physical renderer. It has ShowUI, BindData, BindEvents method etc.

But one thing is a bit different and that's this part of the code:

SiebelApp.S_App.PluginBuilder.AttachPW(consts.get("SWE_CTRL_COMBOBOX"), SiebelAppFacade.MyPW, function (control) {
   return true;

The above code calls the AttachPW method of the PluginBuilder class which serves as the 'registry' for plug-in wrappers. The AttachPW method has three input arguments:
  1. The type of control to evaluate (represented by a constant; e.g. SWE_CTRL_COMBO is holding the type for dropdown boxes).
  2. The extension class (MyPW)
  3. An 'evaluation' function which must return true or false. Within this function we can define the conditions when the custom PW should be 'attached' to the original control of the type defined by the first argument.
For example, you could verify that a specific application or applet is loaded or whether a touch screen is detected or not. When the function returns true, the attachment will happen and when it returns false, nothing will happen.

The types of standard controls that we can currently "attach to" are the following:
  • Generic Field
  • Button
  • Calculator
  • CheckBox
  • Radio Buttons
  • Date
  • DropDown
  • File Picker
  • Flip Switch
  • Link
  • Route
  • Plain Text
  • Image Control
  • Rich Text Editor
  • Rating
  • Signature Capture
For each of those control types, there is a constant for the internal "name" of the control and there is a base PW to extend. For example, to extend the DropDown control, you would use a line of code like the following to extend the DropDownPW class.

SiebelJS.Extend(MyPW, SiebelAppFacade.DropDownPW);

Manifest Administration

Once you have created the template, you save it in the siebel/custom folder as usual and register it using the Application/Common object in the manifest administration.

If you have not done so already, you must copy the existing PLATFORM DEPENDENT entry to create a custom (writeable) one. Then register expression(s) as usual and associate the custom PW file just as you would do with any other custom JavaScript file.

The Story so Far

Plug-in Wrappers are a great enhancement of the Siebel Open UI API. Now we can create custom renderers for each type of control and define when these renderers should be put in place. So far we have seen the scaffolding which is very similar to what we already know from physical renderers. The PluginBuilder class works in the background to attach the PW to the control. In the next part of this mini-series we will see an actual implementation of a slider control. So stay tuned.

have a nice day


Thursday, December 11, 2014

Siebel CRM IP 2014: Themes and Manifests

As indicated in a previous post, one of the changes that come with IP 2014 is the way we register custom themes. As you might know, until IP 2013 we have to implement a custom JavaScript file that uses the ThemeManager class to register .css files against a theme. Here's a bitmap that shows some of this code that we got used to write over the past two years.

Bye bye, ThemeManager
But things change, and today we're going to see how to register a custom theme for Siebel Open UI in Innovation Pack 2014. These are the high-level steps of the process in IP 2014:
  1. Create custom CSS file (unchanged)
  2. Register custom CSS file(s) in the manifest (new)
  3. Create a custom manifest expression (new)
  4. Register the theme for the application (new)
  5. Create LOV entries (unchanged)
So let's get started. Of course we will focus on the new steps but for the sake of consistency we also quickly cover the steps that remain unchanged.

1. Create Custom CSS File

Depending on what you want to achieve, you will spend hours to days with the creation of your custom CSS file (or files). However, you have to place the custom CSS files in the following folder before you can use it in Siebel Open UI.


For our example, we have created a file named theme-alta.css. IF the custom folder does not exist, create it.

2. Register Custom CSS File(s) in the Manifest

The first new step is actually very simple. Any custom .css file you want to use must be registered in the Manifest Files view just as you would do with any custom JavaScript files.

Note that the file path is relative (as always) and starts with the files folder.

3. Create a Custom Manifest Expression

In order to use your files only under certain conditions (such as the user has selected the theme in the User Preferences), we should create a new manifest expression to define these conditions. This is an optional step but makes much sense as it imitates the out-of-the-box behaviour.

In the next screenshot you can see the new expression in the Manifest Expressions view.

The good news is that we can simply query for the "Aurora Theme" expression and copy the record. The only change we need to make to the expression code is replace "AURORA_THEME" with the internal code for our new theme ("ALTA_THEME" in the example).

The expression actually uses the LookupName function to locate the internal code of the currently selected theme (returned by the Preferences function) and compares it to a string.

4. Register the Theme for the Application

Now we can go to the Manifest Administration view and bring all the pieces together.

First, we have to create a new record in the UI Objects list for Type=Application, Usage Type=Theme and Name=PLATFORM DEPENDENT. You will find an existing record that you can simply copy.

With your new record selected, add an Expression record as follows, of course picking your new expression.

Finally, in the Files list add the base theme (most probably the default Oracle theme) that you extend and your custom file(s).

In the example, we build on the OOB theme-aurora.css file. Note the clever use of the new Sequence column.

5. Create List of Values Entries

The final step is the same as in IP 2013 or earlier. To enable end users to select the theme in the Behavior view we must add LOV entries.

In IP 2014, the standard Aurora theme supports three navigation patterns (Tab, Tree or Side Menu). Depending on your theme requirements you might want to support all three or just one or two of them. In our example we copied the existing entries for the Aurora theme to create three new entries for our Alta theme.

6. Test

Because of the manifest changes we need to re-login. After doing so, we navigate to User Preferences - Behavior and select our new theme.

After saving the changes, we reload the page and...voilá.

Siebel Open UI in Alta UI style. Click to enlarge
Alta UI?

You might have been wondering about "Alta" being used for our example. Recently, Oracle announced a new UI style named Alta UI which was used to create the common look and feel for the latest versions of Oracle Cloud applications.

My colleagues John and Duncan found this intriguing so we decided to create a little demo how to make Siebel look like Alta UI (note that we didn't use any of the Alta CSS files, it's just mimicking Alta UI). One possible reason to do this is that you want to integrate Siebel Open UI with an Alta-enabled application and provide a consistent look and feel for your end users. Of course the above example process of registering a custom theme in IP 2014 applies to any custom style sheet, no matter what look and feel it produces.


With IP 2014, themes (custom and standard) are registered in the manifest. While this means a bit of migration effort for existing theme customizations, the change is welcome because it gets rid of at least one JavaScript file.

If you consider the concept further, there is nothing stopping us from using manifest expressions in a sophisticated manner to "switch" themes under certain conditions (think of organizations, countries, positions, time of day, etc...). In addition we can use the theme registration not only for applications but also for views so that you could create a custom style for a group of views.

have a nice day


Tuesday, December 09, 2014

C.U.T.E - Completely Unexpected Tools Enhancement

Well, I was just strolling around in Siebel Tools Innovation Pack 2014 when I found this c.u.t.e:

Click to enlarge
Seems that some libraries have been renewed for IP 2014. The eScript editor that comes with Siebel Tools now has line numbers and collapsible blocks.

Did I say it already? Cute.
And for those among you who remember Nombas, here's another link.

have a nice day


Monday, December 08, 2014

Siebel CRM IP 2014: Open UI API Changes

For almost two years, Siebel developers around the world have been brushing up their JavaScript, HTML and CSS skills. The triggering event was the release of Siebel Open UI in late 2012. Since then, we have witnessed the rapid evolution of Open UI and have gotten used to presentation models, physical renderers and manifests.

With Innovation Pack 2014, the Siebel Open UI JavaScript API has undergone some changes, albeit not too dramatic. In this post, we'll investigate important new features and enhancements for Open UI developers. Most of the information in this article is taken from the updated Configuring Open UI guide and this author didn't have time yet to validate and test all of the features. But there is plenty of time for that in future posts.

Bye bye ThemeManager

Let's start with a class that you will no longer be using in IP 2014: the SiebelApp.ThemeManager. While we used it in IP 2013 and earlier to register custom themes, in IP 2014 we use the manifest administration views to do that (more on that in one of our next articles).

New AddValidator PM Method

The PresentationModel class has a new documented method named AddValidator. Its purpose is to allow developers to register any event and return true or false depending on whether they want the event to execute or not. Here is an example:

this.AddValidator(siebConsts.get("PHYEVENT_COLUMN_FOCUS"), function(row, ctrl,val){
   if(ctrl.GetDisplayName() === "Account" && val === "Hibbing Mfg"){
      return true;

The above code defines a validation function that is executed before the "Column Focus" event is handled. The example returns true (and allows the remaining event handlers to be executed) when the Account column is selected and the current account is "Hibbing Mfg".

You could return false and prohibit any further event handling, similarly to "CancelOperation" in eScript.

Deriving Classes

This is not really a new feature but officially documented for the first time in IP 2014. If you are familiar with what the SiebelJS.Extend method does, you can of course use it to extend a custom class you created just as you can extend any other (Oracle provided) class. Here is an example:

SiebelJS.Extend(myCustomDerivedPM, SiebelAppFacade.myCustomBasePM);

Custom Error Messages

IP 2014 brings a new physical renderer (three of them actually) for error messages. The default renderer is errorobjectrenderer.js which offers a ShowError method that actually invokes a simple alert. In the new samples folder, Oracle provides two files - errorpopuprenderer.js and errorstatusbarrenderer.js - that can be added to the manifest and used as the base for custom display of error messages.

Samples Anyone?

Yes, there is a new sub-folder (samples) in the siebel folder which provides sample code. It includes the aforementioned error renderers as well as examples for injecting controls into a presentation model, a "plugin wrapper" (PW, see below) for drop-down fields, a Google Maps renderer and the infamous "Recycle Bin" example. I haven't tested the samples as of yet but will have a look definitely.

A sample PW, new in IP 2014

Plug-in Wrappers?

A PW (Plug-in Wrapper) is a new type of base class that you could imagine as a renderer for controls such as fields, buttons, radio groups or even a rich text editor or route display on a map. As indicated above, the new classes (for example DropDownPW) can be extended to customize the behavior and look of controls by their type rather than their location (in a specific applet). In this overview, we're not diving into this, but we can expect plenty of articles in the future.

Method White List

A new user property (for applets, business components and business services) named GETEnabledMethods must be used to provide a "white list" of methods that actually modify data. Only these methods can be called through HTTP GET (i.e. from the browser-side JavaScript).


For Siebel Open UI developers, it is a top priority task to read and understand the What's New chapters of the relevant bookshelf guides to get a grip on new features and enhancements. The Open UI API is evolving and we should keep pace.

have a nice day


Thursday, December 04, 2014

Siebel CRM IP 2014: Going Mobile

Siebel CRM Innovation Pack 2014 brings a lot of fresh design patterns, most notably Responsive Web Design (RWD). The new standard theme (Aurora) uses CSS media queries to discern the available viewport and allows the browser (be it on a classic laptop or desktop or a mobile device) to rearrange elements in the DOM.With this change, we can now start using any Siebel Open UI application on any device and we have seen this already in a previous post.

Siebel desktop application on a tablet
However, bringing crowded desktop-size applications to a small-screen device is maybe not enough. Users might still struggle with applets that are simply too big and navigation in general might become awkward.

Siebel Mobile Applications in IP 2014

So let's have a look at Siebel Mobile Applications in IP 2014. These applications are optimized for use on smaller (touch) screens by means of dedicated applets that expose fewer fields.

Until - and including - IP 2013, jQuery Mobile was used to manage the rendering of Siebel Mobile Applications. Here is a screenshot of an mobile application in IP 2013:

With IP 2014, jQuery Mobile is history (for Siebel Mobile Applications that is) and we have what could be described as a unified rendering framework.

Here is what Siebel Service Mobile looks like in IP 2014:

Because mobile applications and desktop applications share the same renderers, we can now use all the features of desktop applications on mobile devices as well. Examples are iHelp, Expression Designer or shuttle (MVG) applets. In addition, cross-application development is much easier because you don't have to create separate renderers or themes for desktop and mobile applications.

New Container Application

Beginning with IP 2014, Oracle ships the Siebel Mobile App. In it's first inauguration, it's only available for Apple devices (on the Apple App Store). The mobile app can be imagined as a wrapper for the web application and provides native access to the device.

Customers can obtain an .maa file and start creating their own mobile apps using the Oracle Mobile Application Framework.

What's New in Disconnected Mobile Applications?

Disconnected mobile applications have also undergone some changes. Besides the obvious new skin, there is a new server component group (Disconnected Mobile Synchronization) that not only includes the well-known Database Extract and Transaction Processor components but also a new Mobile Data Extraction component which is specific to the mobile application and handles - as the name suggests - the data extraction on the server.

For the end user, synchronizing offline data has become easier. The "satellite dish" icon is now replaced with an "airplane" icon and it is no longer necessary to provide a synchronization password.

And before you ask, yes there is also a "bug" icon on top of the screen which can be enabled and allows inspection of offline synchronization log data on the client side.

See it in action

Again, we have to bow deeply to Richard from On Demand Education who recorded some videos showcasing Siebel Mobile Applications in IP 2014 (Part 1, Part 2). Thanks Richard!


With the shift towards a "design once, use everywhere" strategy and the responsive Aurora theme, mobile applications in IP 2014 are no longer separated from the rest by a special renderer. In fact, they now share the same browser-side architecture as desktop applications, so the lines between desktop/laptop and mobile devices begin to blur significantly.

However, mobile applications are still worth investigating as they are optimized for touch screen devices and smaller screen estates. And let's not forget the mobile disco(nnected) applications and the new mobile container apps.

have a nice day


Monday, December 01, 2014

From the Archives: Inside iHelp

Time for another "blast from the past". With IP 2014 (and iHelp in Open UI!) just released, here is a piece I wrote five years ago. Let's celebrate iHelp's 10th birthday with this post from November 2009.


Since it's inauguration as part of Siebel CRM 7.7 in 2004, iHelp has gained a good standing in assisting end users with low to medium complexity tasks.

Creating and administering iHelp is well documented in the Siebel bookshelf but there are interesting features which are not covered in detail and maybe you wish to try them out. Here we go:

Related iHelp

The Related iHelp tab allows us to associate one or more other iHelp items with the parent iHelp item. The result is as follows:

Links to all related iHelp items are displayed as a list in the iHelp pane.

Related Task

The Siebel Task UI, introduced with Siebel 8.0, offers a much more precise/enforced/transactional approach to guide end users through medium to complex level business processes. So if you wish to combine iHelp and Task UI you can do so by associating a related task to the iHelp item which results in the following display in the iHelp pane:

A green link to the respective task is displayed below the iHelp link in the iHelp pane.

'Show Me' Location

Sometimes you have invested in online help documents, flash videos or even Oracle User Productivity Kit which allows consultants to create interactive online content to guide the user through complex tasks. If your iHelp item needs a link to this valuable online resources, you can use the Show Me field to store the URL of the online media.

If the user clicks the "Show me more..." link at the bottom of the iHelp, a new browser window opens, displaying the URL. You can choose between full path (starting with http://) or relative path (to the SWSE's public directory).

Anchor tag

Another way to point end users to specific information needed to complete a step, you can place an anchor tag (<a href="some URL">) inside the description text (just like the other tags - i for italic, b for bold ,u for underline and v for view links).

The result is a link within the iHelp text which serves a similar purpose as the show me link but is more closely aligned with the instructions.

One of the other benefits is that you can of course control the hyperlinked text which is not the case with the "show me more" option.

The anchor tag can take the href and target parameters.

Conditional Branching

One of the lesser known features of iHelp is its ability of applying decision logic to navigate different branches of the iHelp definition. The language used is the notorious Siebel Query Language and (as in several other views where you can enter conditional expressions) the java-based expression builder window is launched to assist you.

Below is an example using the "Create a new Account" iHelp available in the Siebel Sample Database. If the Account is of type "Business" then Details must be entered, else the iHelp should guide the end user directly to entering the Contact details.

The iHelp pane renders multiple branches like this: A link "Click for Additional Steps" is displayed indicating that the end user has to complete the preceding steps first and then click the link to see the next steps.


Siebel iHelp plays a key role in many Siebel CRM projects and the features introduced in versions after 7.7 help super users and administrators create a rich end user experience.

have a nice day


Thursday, November 27, 2014

Siebel CRM IP 2014: High Interactivity Features in Open UI

The brand new Siebel Innovation Pack 2014 was eagerly anticipated by many customers because of the expected 'feature parity' with the High Interactivity (HI) client.

In the feature set for IP 2014, we find indeed some features that we sorely missed in earlier releases and now shine in their ActiveX free glory. In this article, we will discuss the following new features for Siebel Open UI in IP 2014:
  • Inline editing for attachments
  • Expression editor
  • iHelp
  • Column sort/freeze
  • Flowchart editors (Marketing, Loyalty, SmartScripts, iHelp, etc.)
  • Hierarchy diagrams
  • Calendar enhancements
All exciting for sure but let's go one by one:

Inline Editing for Attachments

The ActiveX based HI client made it easy for end users to open an attachment (for example a PowerPoint file) and edit it 'inline'. That means the Siebel web client kept a connection to the file and uploaded the modified file automatically after closing it in the local application.

The lack of this functionality in previous versions of Siebel Open UI was considered a show-stopper in many projects, so it is good to see that the functionality is back.

The first thing you will notice when you click an attachment link is an 'open or save' dialog.

After clicking Open, the browser redirects the file to the associated application, such as MS PowerPoint. Now you can simply change the file, save and close it. The Open UI framework will detect any changes and upload the new file version automatically, overwriting the original one.

Expression Editor

IP 2014 is the first release where you can use the Expression Editor in Open UI. As you know it is used in quite a lot of places such as Personalization, Runtime Events or iHelp (see below). So welcome back.


Used by a large percentage of Siebel customers, iHelp is an important feature when it comes to user guidance and process documentation. Having it back in Open UI certainly feels good.

The above screenshot shows the iHelp pane in action along with some other features such as column sort/lock and the new Communications panel (more on that in a future post) that replaces the customer dashboard.

Columns Sort/Lock

As you can see in the above screenshot, list columns can now be locked (frozen). There is a difference in achieving the lock though. As double-clicks are not favoured by the developers, there is now a small menu that appears when you click on a column header. That menu allows you to sort or lock the column.

Once a column is locked, it (and its left neighbours) stay in place while you scroll horizontally. The popup menu then has of course an Unlock command.

Flowchart Editors

Speaking of iHelp a bit earlier, we have to talk about the flowchart editors (like the iHelp designer). If you do a full inventory, Siebel CRM has a variety of client-side flowchart editors such as the aforementioned iHelp designer. In addition there is the SmartScript designer, Marketing Program designer, Loyalty Program designer etc, all of which were based on ActiveX in HI.

The Open UI edition of flowchart (and hierarchy) designers is based on the open source jsplumb library. Here is a screenshot of the iHelp designer.

Hierarchy Diagrams

As mentioned above, there is now a single JavaScript framework for showing shapes and connectors. So for good measure, here is the Open UI version of the account organizational hierarchy (analysis) applet.

Calendar Enhancements

The calendar is not really new in IP 2014 but there are various enhancements mostly by courtesy of refurbished renderers.

See IP 2014 in Action

Fellow blogger and friend Richard has gone the extra miles to record truly useful and entertaining videos during which he showcases all the new features of IP 2014 and Open UI. Please visit his blog for the videos.


Innovation Pack 2014 brings many long-awaited HI features to Open UI. Along with the design flexibility gained with Open UI, they are expected to deliver an even better user experience.

have a nice day