The following section describes the architecture provided by the SCC framework. The SCC provides developers with a robust object-oriented architecture for building powerful Windows-based applications. In addition to providing the low-level classes and services needed by developers (and provided at some level by numerous other frameworks) the SCC provides a highly extensible “add-in” architecture into which development teams can “plug in” new features and incorporate new functionality into the existing user interface container. Thus, unlike other “framework” products, the SSE SCC not only provides a sound set of developer “services”, or tools, which help provide capabilities and enforce best practices, but it also provides a user interface container that “hosts” new functionality.

The SCC container is a user interface “shell” that can host multiple “add-ins” (i.e. plug-ins). Each hosted add-in can incorporate its own user interface elements into the parent container in addition to providing its own views and functionality specific to its intended purpose. Each add-in targeting the SCC container is written as a separate Visual Studio.NET project in any .NET compatible language. To facilitate loading an add-in into the SCC container, an add-in must provide an add-in XML file which defines how the add-in will be loaded into the host container. Through this XML file, add-ins can specify any menu items, toolbars, docking windows, and or other UI elements they wish to incorporate into the parent container and specify how and where they wish them to display. This infrastructure also allows add-ins to extend the capabilities of other add-ins. In addition to user interface elements, each add-in can provide its own help files and localized resource files. This separation of functionality into separate add-ins also helps minimize the tightly coupled interactions usually found in software development. Different teams of developers can work on, and be responsible for, functionality isolated into individual add-ins with little fear of disrupting other teams.

While the add-in infrastructure defines how various pieces of functionality are loaded and interact with each other, the true advantage of the SCC container is the provided interface shell that hosts each add-ins capabilities. The SCC container provides a tabbed-MDI interface built with a Windows-standard look-and-feel. Taking advantage of the Infragistics NetAdvantage components, the entire UI and its components should “feel” much like many other standard Windows applications to your end-users.

The UI framework provides a consistent paradigm for developers to integrate and interact with UI elements such as the following:

• Menus
• Context Menus
• Toolbars
• Dock Windows
• Navigator Groups and Items
• Views
• Dialog Forms
• Administrative Panels
• Wizards
• MMC-Style Tree Views

Each of the above user interface elements can be declared and configured via the add-in XML definition files described above. In addition to the items listed above, development teams can build and integrate their own UI elements into the framework with very little effort.

Instead of just providing a “container” that allows development teams to incorporate their own UI, the SCC container also provides many of the Windows “standard” elements that are prevalent throughout so many of today’s applications. These consist of pre-defined menus and toolbars that provide teams a jumpstart on development by including some of the defaults pieces so many users come to expect. Some examples of these types of elements are:

• File menu - Streamlined paradigm for supporting “Save”, “Save All” functionality from all views
• Edit menu - Cut, Copy, Paste support for most built in controls
• Window menu - Switch between views and dock/hide all available dock windows

In addition to providing a consistent “feel” for the application, by taking advantage of the AppStyling™ capabilities of the Infragistics NetAdvantage™ suite of controls, the SCC container provides the ability to design new “skins” for an entire application without changing a line of code. This allows the look-and-feel of every UI element to be customized through an external file and consistently defined throughout every view.

The following screenshots provides an example of an application built as “add-ins” into the SCC container:

Figure 1 – Pretecht™ by SSE


Figure 2 - Lipper Insight™

One of the most attractive advantages of a “smart client” application is the ability to provide a “thick”, Windows-based user interface and to automatically deploy new features and updates from a centralized location. This capability greatly minimizes the cost of required maintenance and, if used correctly, can even streamline the overall development process. To provide this automatic updating capability, the SCC can be easily configured to deploy via Microsoft’s ClickOnce technology. SSE can work with you to identify the most streamlined deployment strategy to help get your SCC application to your end-users. This same capability can also be used to streamline the deployment of internal builds to a testing team.

The SCC container and the underlying framework both support a streamlined infrastructure for providing full localization support within an application. Using these features and some provided best-practice guidance; developers can easily build applications targeting multiple languages. End-users can flip between languages at ease and managers have the oversight into how much of an application’s text has actually been translated. SSE can work with your development teams to identify the most streamlined workflow for taking advantage of the SCC features and getting your localized software built and deployed. The SCC supports the localization of all text, icons, and images related to every UI element.