August 2010 - Posts - Gary's Blog

Multiselection Functionality in XAF Model Editor (coming in v2010 vol 2)

XAF Team is constantly working on improving the Model Editor usability. Recently we published the Model Editor Enhancements blog post, describing the Model Editor improvements that we rushed to you in v2010 vol 1.6 version. “But wait?!” I hear you cry, “what about 2010.2?!” Well, let’s take a look at what functionality will be available in the upcoming release.

Now you can select multiple nodes to perform various operations with them at once! Just select a bunch of nodes in the normal way – hold down SHIFT and click a node to select sequential nodes, or hold down CTRL and click a node to select individual nodes – then drag as normal. For instance, you can expand several Action Container nodes, select multiple Action Link nodes within them, and drag them all to another Action Container.

You can use the context menu commands, when several nodes are selected (except for Generate Content and Add commands). The command will be applied to each selected node. For instance, you can select several nodes and reset their differences at once.

This animation shows you what I mean:

Multi-selection functionality can also be used when sorting a certain node’s child nodes (navigation items, columns, layout items, etc.). You can select several nodes and drag this group up or down the list. The indexes of child nodes will automatically be modified to correspond to the new arrangement. You can use the context menus Up/Down commands, also available via the ALT+UP/ALT-DOWN shortcuts.

This animation shows you the UP command executed on several Navigation Item nodes are selected:

Note that when the top selected node reaches the top of the list, its index stops decrementing and equals zero. If you repeat the Up command again, this node stays on top, and other selected nodes will continue moving up (cool eh?). Obviously, the corresponding thing happens when doing the same thing with the Down command.

Of course, the multi-selection support is not the only improvement the Model Editor will get in the upcoming release. There are many enhancements to be announced later. But I don’t want to spoil it by telling you all the plot now! Winking smile

That’s all for this post, until next time, happy XAF’ing!

Posted Aug 26 2010, 03:59 PM by Gary Short (DevExpress) with 3 comment(s)

Filed under: XAF, v2010.2

Linq Server Mode and Entity Framework 4.0 (coming in V2010 Vol 2)

We’ve supported Server Mode for our controls for some time now and it’s worked, out-of-the-box, for almost any Language-Integrated Query (LINQ) provider. For example the LinqServerModeSource can be used together with our WPF and Windows Forms grids, and the LinqServerModeDataSource can be used with our ASP.NET grid. So far so good. Unfortunately, the LINQ implementation in Entity Framework had some specifics preventing it from building effective dynamic queries for those types that are not known at compile time. Worse, there were Entity Framework specifics which required workarounds which did not work in a medium trust environment.

Well it’s time to fix all that. As of the forthcoming V2010 Vol 2 release, we’ll be providing complete support for Entity Framework in our Data Library. Of course, when I say Entity Framework, I mean EF 4.0 and above – but then you knew that, ‘cos nobody would take a dependency on EF before the 4.0 release, right? There is one limitation though, the maximum number of total or group summaries allowed is 14, but I’m sure you can live with that. Smile

Okay, enough chit chat, let’s have an example. First thing to do is to create a storage model and mapping information. So, add the ADO.NET Entity Data Model item template and configure it using the Entity Data Model Wizard:

Select “Generate from Database”:

Select the Northwind database:

Select the “Products” table:

And we’re done!

Next, let’s add a grid to our window:

<Window x:Class="DXGrid_EF4_ServerMode.MainWindow" 
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        Title="MainWindow" 
        Height="350" 
        Width="525" 
        xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <dxg:GridControl Name="grid" AutoPopulateColumns="True">
            <dxg:GridControl.View>
    <dxg:TableView ShowTotalSummary="True" />
            </dxg:GridControl.View>
        </dxg:GridControl>
    </Grid>
</Window>

And then bind to the data:

public partial class MainWindow : Window {
    public MainWindow() {
        InitializeComponent();
        NorthwindEntities dataContext = new NorthwindEntities();
        grid.DataSource = new LinqServerModeSource() {
            ElementType = typeof(Product),
            KeyExpression = "ProductID",
            QueryableSource = dataContext.Products
        };
    }
}

For more information oh how Server Mode works, albeit with an OData twist, check out this post.

Oh, and the news just keeps getting better and better. Not only is this technology coming in V2010.2, but there was a beta version released in V2010.1.6, so you can start playing with it now!

Posted Aug 23 2010, 06:59 PM by Gary Short (DevExpress) with 7 comment(s)

Filed under: XPO, v2010.2

Technical Debt–Don’t Let it Kill Your Projects

Earlier this week I travelled to Newcastle to deliver a presentation on Technical Debt. The feedback from the audience was very positive and so I thought it was worth sharing the main points of my talk with you.

Technical Debt – a Definition or Two
Ward Cunningham defined technical debt as being analogous to financial debt. With financial debt you borrow money now in order to obtain some benefit that you could not otherwise obtain – the purchase of a car for example. In the future you are going to have to pay back the money you borrowed, along with some interest on the capital. Ward suggests that it is the same with technical debt. You borrow time now, in the form of taking engineering or architectural short cuts, in order to obtain some benefit that you could not otherwise obtain – meeting a project milestone for example. Just like with financial debt, in the future you are going to have to pay back the time you borrowed, along with some extra time (the interest) that is the cost of not doing the thing properly in the first instance.

I have taken the liberty of expanding this definition a little. Staying with the financial analogy, I further suggest that technical debt can be accrued if you do not take advantage of technical advancements and software components where possible. In much the same way, in financial terms, you can make a notional loss if you have your savings in an account that pays 2% interest, when you could have had it in an account that pays 5% interest.

Not All Debt is Bad
Of course, not all financial debt is bad. In fact, a certain about of financial debt is almost required to run a successful company. Used wisely, financial debt can be used to start companies. A company may borrow money in order to purchase raw materials, which they then make into widgets, which they sell for enough profit to pay off the original loan and purchase more raw goods. The same is undoubtedly true of technical debt. A company may borrow time in one iteration in order to hit an important milestone, and pay the debt off in the next iteration.

But Some is Deadly
Of course, no matter how well you think your financial debt is managed, there could always be something unexpected that comes along to mess it up for you. Witness the recent credit crunch, where banks demanded instant repayment of outstanding loans, forcing many companies to the wall. The same is true of technical debt, carry too much, or carry it for too long and something will come along and force your project to the wall.

A Safe Level of Technical Debt
That being the case, it is best if you have no technical debt in your projects, right? Okay, I know what you are thinking, having no technical debt is like having no bugs in your software, it’s something great to aim for but it’s not at all realistic, there are bugs in every system and there will be technical debt in every code base. Well that’s true, but here’s what I claim. I claim that if I provide you with an application and even although there are bugs in it, if the bugs are so hard to find that, even after months of use, you never hit them, then you’d be fair enough in saying that my application was bug free. Well I claim the same is true of technical debt. We know there will be technical debt in the code base, but if we drive it down to a level where it does not impact us, then to all intents and purposes, there is no technical debt. So what is that safe level? Well to be honest, it will depend on your project, but you’ll know what it is for yourself, as soon as you start to bump up against issues of technical debt then you are starting to “feel” that debt, then that is the time to start driving it down again.

Calculating Technical Debt
We need a system to put a financial value on the technical debt in our code base. We have to do this for two reasons. Firstly because you can’t drive down the amount of technical debt unless you have a way to quantify it, and secondly because you wont get sign off from your project manager to repay the debt unless you can show, in financial terms, how much money you are going to save in so doing. Why is this? Well, looking at things from a project management point of view, if you are going to spend an iteration driving down technical debt then what will happen is this. At the start of the iteration you may have 10 pieces of functionality coded in your application, at the end of the iteration you will still only have 10 pieces of functionality coded plus it will have cost you one development cycle (whatever that may cost your company). Now that is a tough sell for any project manager to make to the business. Of course if you can say something like, I’m going to spend one cycle – at a cost of £25K – but I’m going to remove £75k of technical debt from the code base, then that is a much easier sale to make.

To calculate technical debt is fairly straight forward. All you have to do is to sum the cost of each of the component parts of any fix required to drive down the technical debt. Things like, manpower costs, hardware costs and licencing costs. Not forgetting the hidden costs such as employer’s on costs and the cost to repair the damage to your brand of a late or shoddy release. There is a general formula and rate card in the presentation which you can use to get a feel for how to calculate the specific debt in your organisation.

Anti-Pattern: Not Invented Here
Just as there are patterns in good software design, there are anti-patterns in bad software design that can lead to the build up of technical debt. The first one we are going to look at is “Not Invented Here”. This anti-pattern is an example of the second class of technical debt we defined above. The class where savings against time were not made where possible by buying in a component to achieve non-core functionality in an application. The symptoms of this anti-pattern are that a team will insist on writing their own component – a charting control say – instead of buying one from a vendor, such as ourselves, for $250. The Technical Debt accrues from the cost of developing their own component plus the cost of maintaining it for the duration of the application lifecycle, a cost that far outweighs the purchase price of $250.

Anti-Pattern: Code That Plays Together Stays Together
This anti-pattern arises from an abuse of OO design principles. The symptoms are that an application has one or more “God” objects, objects which are stuffed full of properties and functions to the extent that no one developer on the team has a clear understanding of what they all do, and no one can define the responsibilities of the classes. This is an example of the first class of debt defined above, where time is borrowed in the form of an architectural shortcut (monolithic object models are easier to define than models where proper separation of concerns has taken place) but has to be paid back, with interest, in the form of the extra time it now takes to add new functionality to the model.

Metric: Decrease in Productivity
Being able to spot these anti-patterns is helpful, but it is also helpful to be able to use metrics to indicate that technical debt is building up in your project. One such metric is a decrease in productivity. If you graph items of functionality completed per iteration then you should see a variance from one iteration to another, after all not all pieces of functionality take equal time to complete and so some iterations will have more completed pieces than others. However the trend should be fairly constant across the iterations. If you see the trend declining this can indicate that there is technical debt in your codebase. The debt takes the form of code you have to “go around” in order to get things done. The more of it there is, the more of this code you have to write and so the less functionality you can get through per iteration.

Metric: Increase in Number of Tests Per Piece of Functionality
In the same way, if you graph number of tests versus pieces of functionality, again you will see a variance but the trend should be near constant. However, if you see rising tests/functionality then that too can be an indicator of technical debt. This is because that extra code you wrote in the example above has to be tested and so the number of tests rises.

Tools Can Help You Defeat Technical Debt
There are tools available which can help you combat technical debt. DevExpress has both a free tool and a paid for tool. The tools will help you both in analysing your code, to make you aware of potential technical debt and by helping you to refactor that code to eliminate the debt. Of course our competitors also sell tools in this area. Which is best? Well that’s not for me to say, you’ll just have to download, compare and decide! Smile

Posted Aug 20 2010, 03:29 PM by Gary Short (DevExpress) with 1 comment(s)

XAF – Model Editor Enhancements (Now Available in V2010 Vol 1.6)

Remember how we re-wrote the Model Editor for V2010 Vol 1? Remember how you loved all those new features: categories in property grids; the description panel, etc? Remember how you hated lack of usability features? Well we’ve made a start at fixing that with a few usability enhancements and, because of your input on the subject, we’ve decided to rush those new features to you in V2010 V1.6 which is available from the client centre now!

So, let’s take a look at what we added:

Nodes Tree Usability Improvements

You can now clone a detail view:

Doing so results in a copy of the current node, at the same hierarchy level. Note that the Id property is appended with “_Copy”, all the other properties remain the same as the original.

What’s this good for? Well, mainly for implementing view variants. Now you can quickly create several copies of the same view, and make minor changes in each of them, there is no need to scroll up to the parent node just to paste new node.

Drag-and-drop is now supported in the nodes tree:

You can move a child node from one parent node to another using drag-and-drop, convenient when moving an Action to another action container, moving navigation item to another group, modifying the Detail View layout etc.

When dragging, you can place a pointer over the target node, and it will be expanded automatically, after a small delay. To create a copy of the node instead of moving it, just hold down the CTRL key when dragging. If the target node already has a child with the same ID, the “_Copy” suffix will be added.

You can rearrange child items, of a certain parent node, using drag-and-drop, convenient when reordering list view columns or navigation items. Hold down the SHIFT key, and drag a child node up or down the list within the bounds of its parent node.

The indexes of child nodes will be automatically modified to correspond the rearrangement.

Search Panel Speed and Look and Feel

What have we changed with the Search Panel? Well, its performance is improved and a new smart search behavior is provided. Now you can type something in the search box and the search results will be updated while you type.

In the MainDemo, the delay between typing a character and updating the results is about half a second.

Custom Editors in the Property Grid

When creating complex XAF applications, you probably extend the Application Model with custom nodes and properties. Now you can bind custom editors to properties. To do this, implement the required UITypeEditor descendant and set it for the property via the EditorAttribute. If you have read the Pivot Grid & Chart List Editors post, you may notice that the PivotGridSettingsEditor is bound to the PivotSettings node's Settings property using this feature.

Well, that’s all for this post. Until next time, happy XAF’ing! :-)

Posted Aug 16 2010, 05:20 PM by Gary Short (DevExpress) with 4 comment(s)

Filed under: XAF, v2010.2

XAF – Pivot Grid & Chart List Editors (coming in V2010 Vol 2)

Data comes in all shapes and sizes and businesses want to look at it from all the different angles. Luckily DevExpress has a number of different components to help you do just that. Previously, I examined the difference between grouping versus pivoting with our grids. To make things even easier for you, in V2010 Vol 2 XAF will introduce two new ListEditors, they are: Chart and PivotGrid.

Previously, to show data in a PivotGrid, you had to create an Analysis module. Well not anymore! As of V2010.2 it will be possible to show any collection in a PivotGrid or Chart by changing the editor for a ListView and customizing it, if needed.

Let's create a view that will show us a collection of Order objects in a PivotGrid. We'll use the FeatureCenter application as an example.

Open the ModelEditor and navigate to the Order_ListView view. Select WinPivotGridListEditor in the EditorType dropdown:

Select the PivotSettings node, and open the wizard by clicking on the ellipsis button for Settings attribute:

The PivotGrid designer is opened. Using this designer, we are able to completely customize the PivotGrid. Let's create PivotGrid fields for the necessary properties by double clicking on a property name in the Field List. First, let’s add a Freight field:

We also need three more fields that are not listed in the Field List: Employee.FullName, Customer.Country, Customer.City and Customer.CompanyName. Let's create them manually, by clicking the Add button, and selecting FieldName:

Now we can layout the grid. Navigate to the layout and move the Freight field to the data area, Employee field to the Column area and Customer.Country, Customer.City and Customer.CompanyName to the RowArea:

Let's return to the Fields section and correct the captions to avoid dots in field names:

We can now close the wizard and save the model. Note that the Settings attribute contains the entire configuration we created, stored in XML format:

The FeatureCenter does not show this Orders view in the navigation by default, so let's add the corresponding navigation item:

Now we can see the view in action. Save the model and run the application. This is what our orders view looks like in the PivotGrid:

And sales in the as a chart:

And of course, this all works in ASP.Net XAF applications too:

That’s all for this post, until next time, happy XAFing! :-)

Posted Aug 12 2010, 01:58 PM by Gary Short (DevExpress) with 7 comment(s)

Filed under: XAF, v2010.2

XAF – Actions in Detail View Layout (coming in V2010 Vol 2)

Putting a few Actions into the toolbar is okay, but we’ve all been there where we add Action after Action and then we step back to look at our GUI and we think “Ahh, my eyes!”. You know what I’m talking about, right? So, what do we do then? Well we usually look to put some of our Actions directly into the detail form, near data editors or into floating panels. In the upcoming V2010 Vol 2 release, XAF will make it possible to put Actions into the DetailView layout. Let's walk through a simple example showing how to do this.

Suppose we have a License business object and we need to allow end-users to perform two operations (register a license and get a key by email) with a license in the detail form.
First, we will add a LicenseDetailViewController into the common module and target it to the License object and DetailView in the designer:

Then, we will add two SimpleActions from the Toolbox and type AddLicense in their Category property. This is just a custom category name, allowing us to logically group these Actions and also to map them to a corresponding ActionContainer:

After that, let's rebuild the solution and open the Model Editor for the common module. There we will navigate to the License_DetailView. Then, we will add an ActionContainerViewItem to the list of its items:

This new kind of item allows us to select an ActionContainer, whose actions will be shown within this item in the DetailView layout. Let's select our custom AddLicense container from the drop down list:

After that, we will go to the Layout node and customize the layout to add our new item into the layout:

Since all Actions from the selected ActionContainer will be shown within the ActionContainerViewItem, we may want to change the order that Actions appear. This can be done using the standard approach - go to the ActionsDesign | ActionToContainerMapping node in the Model Editor and change the Index property of Actions:

Let's run our Windows Forms application and see how the License_DetailView will look:

You may want to perform additional layout customizations to get the final look. For example, you can change the width, height and other options of the layout item containing our Actions.

Then let's run the ASP.NET part of our application to see how Actions look there:

Additionally, here are two more screenshots from the FeatureCenter demo, showing that all Actions types are supported:

When developing this feature, we considered that XAF developers will use a new ActionContainerViewItem to place custom Actions, although, you should note that standard Actions are also supported.
Currently, all of the Actions from the selected category will be placed within the item. You can't change the sizes of individual Action-controls, because a single layout item is created to host them. So, if you want to control Actions individually, map them to several categories and create several ActionContainerViewItems for them.

As always, we want to hear your feedback on this feature, so please feel free to leave a comment here, or email me directly (garys@devexpress.com).

Okay, that’s all for this post, until next time, happy XAFing! :-)

Posted Aug 11 2010, 01:44 PM by Gary Short (DevExpress) with 13 comment(s)

Filed under: XAF, v2010.2

XAF – New KPI Functionality Coming (coming in V2010 Vol 2)

Key Performance Indicators, or KPIs, are loved by businesses, which means XAF has to love them because our target market is developers working in teams who have been side tracked to build “that little app” for accounts; and we know, the faster you can get that done, the faster you can get back to your “proper” day job. So it’s great news then, that as of Vol 2, XAF will ship with a KPI module!

So what are KPIs? Well, these are quantitative measurements of dynamic business processes. For instance, an important performance indicator for a trading company is daily sales, for a developer team – the number of active bugs in their product, etc. For better visualization, KPI value ranges can be split to a “green zone” (everything is OK), “yellow zone” (warning), and “red zone” (things are bad). When the KPI is based on a time range, it can be useful to compare values of different periods (for instance, the current month against the previous one). If a deeper analysis (drilldown) is required, then the objects an indicator was calculated from can be listed.

It’s probably easier if I just show you:

When the KPI module is used in an XAF application, the “KPI” navigation group with the “Definition” and “Scorecard” navigation items is available:

Under the “Definition” item, a new KPI definition, represented by the KpiDefinition persistent object, can be created.

The KpiDefinition object’s properties are described below:
• Name – the KPI’s name.
• TargetObjectType – the type of object KPI is designed for.
• Criteria – criteria used to filter a set of objects to analyze. In KPI criteria, two extra parameters for DateTime properties can be used – RangeStart and RangeEnd. These parameters represent a measurement range specified by the Range property.
• Direction – “High is better”/”Low is better” enumeration value, specifying how to treat deviation from a previous measurement result.
• Expression – aggregation function used to evaluate KPI – Sum, Count, Avg, etc.
• Range – the period to analyze.
• Compare – the Boolean flag, which indicates if the KPI current values should be compared to previous values calculated using the RangeToCompare period.
• RangeToCompare – the past period compared with Range.
• MeasurementFrequency – the time span between measurements.
• GreenZone , RedZone – specifies KPI value ranges used for visualization.

In the Preview tab, the current KPI value and a collection of objects, used to calculate KPI, are available.
The best place to view the KPI results is the dashboard. Here, we will take a look at the Scorecards. A Scorecard is an object, exposing a collection of KPIs. Under the Scorecard navigation item, the Scorecards with linked KPIs can be created.

A drill-down list view can be invoked by double-clicking a KPI. It is a list of objects that were used to calculate the KPI result. This list view can be analyzed by grouping and sorting data, or by using our new features – ChartListEditor or PivotGridListEditor, representing this collection as a Chart or a PivotGrid:

To visualize KPIs on the scorecard or dashboard, the KpiInstance objects are used. KpiInstance is separated from the KpiDefinition. The KpiInstance object holds and manages KPI measurement history, retrieves Current and Previous values from the KPI history cache, creates a data source for sparkline and chart editors, and is responsible for cleaning outdated values from the cache. A KpiInstance object is created by a KpiDefinition object in its AfterConstruction method.
The ShowChart Action provides the capability to view KPI results as a chart:

The chart is customizable via the Chart Wizard, and can be printed – just like charts created with the PivotChart module.
The ability to visualize KPIs via the Gauges is currently in development.

That’s all for this post, ‘til next time, happy XAFing! :-)

Posted Aug 10 2010, 01:49 PM by Gary Short (DevExpress) with 8 comment(s)

Filed under: XAF, v2010.2

XAF – New Dashboard Functionality (coming in V2010 Vol 2)

Software dashboards – much like the dashboard in your car – provide you with instant, summary information on the “health” of a system. Of course the term “health” can mean many things. If you are Amazon, it can mean information on orders/minute, stock levels/category etc. If you are an ISP it can mean things like total uptime/server, memory usage/server, etc. Whatever it means to you, it is important that you know about changes to it immediately and that is where the software dashboard comes in.

New in V2010 Vol2, XAF will provide the ability to create a dashboard view. Let’s take a look at how that will be done.

Using the FeatureCenter application, open the ModelEditor and add a new DashboardView to the Views node:

Then, we need to add some items to our dashboard:

Next we can select a view, that we want to be shown as an item, and a criteria. Let's add the Employees list view.

KPIs (more on these in a future blog post) can also be easily placed on dashboards. Let's add another DashboardVIewItem, and select KpiInstance_Chart_DetailView as its View. We'll use a Criteria to select a particular KPI:

If we have a previously created customized view (for example a list view shown as a chart using ChartListEditor), it can be placed onto a dashboard in the same way:

Now we can layout our dashboard as required. Click on the layout node, then invoke the layout customization dialog:

Next, we need to create a navigation item which will open our dashboard:

Finally, run the application and look at the dashboard in action:

Runtime customization is also supported. Invoke the layout customization for the dashboard and click the “Add” button to create an item. In the opened View selector, you can choose an object type and a view. Let's choose the “Sales by Countries” list view:

After clicking OK it appears on the Customization form, and can be dropped onto the dashboard:

And, after some customization our dashboard looks like this:

Dashboards are supported for ASP.NET applications as well:

That’s all for this sneak peek, until next time, happy XAF'ing :-)

Posted Aug 09 2010, 12:29 PM by Gary Short (DevExpress) with 21 comment(s)

Filed under: XAF, v2010.2

XAF – Version 10.1 What’s New Redux

As development of 10.2 gets underway, and the wheels of engineering begin to spin faster and faster to produce the next great version of DevExpress products, it provides an opportunity for the technical writers to catch their breaths. Well it would, if it were not for their collective determination to improve the information available to our customers. So instead of kicking off their shoes and sitting back with a nice cup of tea, a couple of them have gone back and improved the information contained in our 10.1 what’s new. If you missed it first time round, or even if you didn’t and but you just wanted more information on what’s available in XAF in 10.1, now’s a good time to check it out.

Starting with the typed application model, which is significantly faster due to it’s use of lazy initialization and uses less memory due to holding references and not values, we then go on to look at the Domain Components Technology Preview.

This technology preview shows how Domain Components has been designed to dramatically simplify data reusability by providing a much more abstract approach to object design. To use Domain Components you define interfaces instead of regular business classes, where you specify the required properties and data fields, you also define special classes that describe how interface members behave when the object is constructed and properties are changed etc. The actual business classes are generated by XAF at runtime.

This model is much more flexible as domain logic and interfaces can be packaged together into an assembly and used as a domain library and, of course, since a class can implement any number of interfaces, but can only be derived from one base class, then this model let’s you combine domain logic in a more flexible manner.

Of course, it wasn’t only the code “under the hood” that received attention in 10.1, oh no, the UI got a more than a “lick of paint” too. Take the Ribbon UI for example, prior to 10.1 this was supported via a special module that required to to be configured manually. With the release of 10.1, the Ribbon is now automatically supported in all Windows Forms XAF applications. Enabling and disabling of the Ribbon is managed via a single Application Model property now.

Another UI capability that was improved in 10.1 was MDI with the creation of a new View strategy which enables MDI functionality with a single line of code, or via an option in the Model Editor, if you prefer.

But what about Web Forms I hear you cry? You were crying that, right? Well, if you were, don’t worry as we took good care of you there too. Firstly there was a new visual theme, in fact XAF’s core components were refactored so that the standard DevExpress ASP.Net visual themes could be used in XAF web form apps. 10.1 saw the release of the Aqua Theme, which became the default for all new applications, with the other themes to be available from 10.2 onwards.

Next we got rid of that annoying way the navigation items were duplicated at the bottom of the page, you know, using all the expensive real estate. Well not anymore, now we have a new navigation item container that allows you to show only the items you require!

We finished up by telling you about enhancements we’d made to the EasyTest Script Recorder and letting you know about a preview of the Conditional Appearance Module. So if you want to refresh your memory, or you just want to check out the new information, then now is a great time to review the 10.1 what’s new page.

That’s all for now, ‘til next time, happy XAFing! :-)

Posted Aug 05 2010, 05:12 PM by Gary Short (DevExpress) with no comments

Filed under: XAF

This Blog

Recent Posts

Archives

Gary's Blog