How Dynamic Widgets improve the Smart View experience

If you’ve worked with Content Server’s Smart View before, you know it offers a newly redesigned structured way to present content, but it comes with some significant limitations—especially when it comes to customization, flexibility, and widget interactions.  

That’s where Ravenblack Dynamic Widgets come in. Our solution makes Smart View more dynamic, customizable, and efficient, but without the headaches of complex and burdensome development.  

The challenges with Smart View  

 Presumably you may be considering an increased use of the Smart View interface for your users. Obviously some functionality is not available in Smart View, but even for simple use cases,  you may  still be using classic Content Server to adapt to your business requirements. Do any of these statements resonate with your company experience? 

1. You need to modify and extend Smart View pages and widget functionality to meet business requirements, but you are still using classic Content Server because it is easier to configure to your needs.  In our experience, organizations almost always need some level of customization of the Smart View for it to be adopted successfully by its users. Over the years, customers have used tools such as WebReports to do this.  

2. You think (or have found) the Smart View SDK is difficult to learn. You’re not wrong—customization is difficult. While Smart View has a Software Development Kit (SDK), it’s complicated to set up a development environment, and difficult to learn unless you've already worked with similar Javascript frameworks. This makes tailoring widgets to specific business needs a challenge.

3. You try to use WebReports widgets to achieve your aims. Many customers turn to WebReports widgets as an easier alternative to the SDK, particularly as they are familiar to many of their developers or business users.

4. You find that you have to work around various limitations with WebReports widgets and that you typically settle for sub-standard interfaces, or you need elaborate kludgey workarounds to succeed. Many customers have existing skills with WebReports on classic Content Server so naturally the ability to surface custom content in widgets with WebReports seems like a good start, however, even that approach has some frustrating limitations as noted further on in this blog.

Perhaps you can answer no to some of these, but for most customers and companies who work with Content Server, you’ve most likely answered yes to all. 

The WebReports widget-based solution has become a very popular go-to for customers, but it was originally designed to be a relatively passive, non-interactive feature to allow custom content to be surfaced on a page. As such, it doesn't quite meet the rich functionality of WebReports (and ActiveViews) in a classic environment. Specifically, these are some of the limitations:

• Perspective layout is static – once a widget is placed in a perspective, it can’t be resized, moved, or updated dynamically.
• Cluttered views – widgets stay visible even when not needed, cluttering the interface, and often requiring large amounts of blank space for WebReports waiting to be used.
• Fixed content – once the WebReport is loaded, any content remains visible. Dynamically changing content typically requires complex workarounds. 
  
• Widget Interaction Problems – Smart View loads widgets independently and often unpredictably, making any interaction unpredictable and error prone. Additionally, there is no defined way for widgets to "communicate" with each other to form even a simple application. 
• Styling is complicated – Smart View provides many complex layers of CSS (style classes for HTML) that can make any unique styling very difficult without deep knowledge of the SmartView class structure. 
• Custom (Smart) views require multiple different frameworks to be created – every different view requires a unique "perspective" object to be created and managed. The rules for selecting different views are very limited. 
• The widget container header is static and container options can’t be added. 

Simple use case  

Here’s a typical use case that sums up many of these issues.  

Deliverable 

The customer wants to implement a fairly unique set of filters to initiate a custom search. The various filters are fed dynamically based on sub-tables. Having selected appropriate filters, the user wants to click a search button, and then see the results.  

Challenges 

Where will the widget display the results? The most common approach is to set the widget as a full page, with half of the page showing the filter screen and half of the page showing the results. This may require some nested iFrames or complex logic to manage the search and displaying the results. In addition, both the filter section and the results section are poorly implemented—either too large or too small, and if the user requires any other standard widgets to exist on the same page, these other widgets are likely not visible without significant scrolling. In summary, you can create unique, custom content, but you have no control over the framework/palette available to render that content, once the page is loaded.   

How Dynamic Widgets solve these issues  

Ravenblack Dynamic Widgets introduce a brand new widget type combined with a rich set of JavaScript functions built around a framework explicitly designed to work in the Smart View environment.

These features combined, remove all of these limitations, and actually add new development capability that is not available with conventional WebReport widgets.  

With very granular control, any developer can perform multiple actions in response to any application events or program functions. We’ve built a custom API that provides the ability to control the widget in several different ways at any time during and after the page loads. Specifically you can:

• Show or hide any widgets on the page.
• Resize any widgets on the page, including new 1/3 and 2/3 width options.
• Update widget content in real-time (without refreshing the entire page), from WebReports, external URLs, or directly writing content.
• Customize the widget header with icons, titles and unique option buttons.
• Sharing data between widgets.
• Easily implement rules to control the sizing and showing of any widget on the page to meet the requirements of every application event.  
• Control non-dynamic widgets on the page to meet each business requirement. 
• Isolate dynamic content from the Smart View CSS classes. 

And for the first time, widgets can communicate with each other seamlessly, thanks to a central registry that eliminates naming conflicts and loading order issues.  

Easy deployment & what’s next  

The best part? It’s simple to install and use.  

• Dynamic Widgets are packaged as a CS App, installable via Content Server’s Application Manager — no OScript modules! 
• They integrate seamlessly with the Perspectives Manager using drag-and-drop functionality. 
• No special JavaScript files have to be added; everything is automatically loaded in the background. 
• There are several built-in utility objects such as a feature to queue timed events.
• Minimal coding is required—just WebReports, HTML, and basic JavaScript. 
• Comprehensive online and PDF documentation, along with multiple commented examples. 

  And we’re not stopping there. Future updates will include:  

• Modals & overlays for pop-ups, alerts, and dialogs.  
• Dynamically created widgets.
• Expanded API features for even more customization.  

Conclusion  

So, if you’ve ever struggled with Smart View’s limitations, Ravenblack Dynamic Widgets are here to help. They make customization easier, interfaces cleaner, and widgets smarter. And best of all we provide detailed documentation and multiple packaged examples to help get you started. We’ll be publishing videos of these demos along with example use cases. In the meantime, here's a short overview if you'd like to see Dynamic Widgets in action:

We’re always improving our products based on user feedback, so let us know what you think, and please share some of your problem use cases!