All these grids

clock January 30, 2012 20:39 by author Flexicious

A quick rundown for the those of you new to Flex/Flexicious:

The Flex SDK has 3 DataGrids provided by Adobe:
DataGrid
Advanced DataGrid
Spark DataGrid

Flexicious has extensions built on top of each of the above. Usually referred to as :
Classic (ExtendedDataGrid)
Advanced (ExtendedAdvancedDataGrid)
Spark (ExtendedSparkDataGrid – newly launched)
And finally, we have a grid that we built from the ground up – Flexicious Ultimate (FlexDataGrid) which is the most feature rich product in the list above.

A couple weeks ago, we launched the new Flexicious Spark Extension. This caused a number of questions, concerns and feedback. (Thanks and keep it coming). A number of our customers immediately brought up - “What does this mean for Ultimate”?

So, let’s answer that first, because it is an important question. Ultimate has and will continue to be the Superset of everything in terms of functionality for the foreseeable future.  It is the most powerful DataGrid component available for Flex today, and is by any measure, our most successful product. Our largest Enterprise customers use it almost exclusively, simply because it can do almost everything that the others can, and a lot more. It is where our innovation has and will continue to be born for the foreseeable future. DataGrids are often the workhorse components of most RIA applications. We understand the crucial role we play in this ecosystem and take your concerns very seriously.

Although we believe that the Spark architecture has advantages over the Halo architecture, from a purely functional perspective, the Spark DataGrid is nowhere close to Halo ADG or Ultimate. Seasoned Flex developers know that the Spark DataGrid is *still* quite primitive in terms of feature set, but it does what it does very well, i.e. display of flat data. However, the moment you need hierarchical data, or column groups, or locked columns and rows, and a number of other features, well, you better stick with Ultimate or Halo (and consequently, our AdvancedDataGrid Extension).

It’s always good to have options. A number of folks are using the Spark data grid exclusively in their apps, where there isn’t a requirement for complex functionality, and that is fine. For such applications, either our Spark or Classic product will be a good choice.

Finally, all our products share a lot of the codebase. The API’s are very consistent, property names and method signatures are usually consistent except when they have to support additional functionality, and moving from one product to another is usually quite trivial. 



Introducing Flexicious Spark DataGrid Extension with Paging, Filters, Footers, Print, Export, Preferences and a lot more!

clock January 15, 2012 23:15 by author Flexicious

It almost feels like dejavu. This time last year, we were hard at working finishing up Ultimate. Spark datagrid was very primitive at the time (and compared to Ultimate, still is). However, there has been significant progress in terms of feature parity with MX, and although not quite there yet, it certainly is on its way. The time was right for us to jump in and add a little bit of our Flexicious Sparkle  to the Spark DataGrid :-)

So, with no further ado, presenting... the all new.. Flexicious SPARK datagrid extension!! Check out the demo here.

With the addition of this new product, we're changing our pricing a little bit, in that we're eliminating the USD 299 option. It was very small percentage of our sales anyway. Now, for USD 799.99 you get all five of our products - Classic, Advanced, Spark, Ultimate, and SQLEDT.  You can purchase unlimited domains, and the entire Flexicious source code as add-ons as well. This opens up the opportunity for our Single Developer customers to have access to unlimited domains/source, something a lot of you have asked for.

For existing customers, there is an option to add the new Spark DataGrid Extension to your product portfolio by paying the difference, just use the request quote form.

 



Flexicious 2.6 Released!

clock January 15, 2012 23:14 by author Flexicious

As will be obvious from the previous post, 2.6 sees the release of a new product, the Flexicious Spark DataGrid Extension. If you are interested in adding this product to your license, please read this. There has been some reorganization of the codebase to account for the requirements of the Spark DataGrid, some of these are interface changes documented below. However, there have been many enhancements, a brand new feature (Row Spans and Columns Spans), numerous bug fixes, and performance improvements for Ultimate, and quite a few for Classic as well. We have been hard at work, and are continuing at a feverish pace with new features, new products, performance improvements.

We will be sending out subscription renewal notices moving forward. PLEASE, renew your subscription in time. We hate it when support is delayed because of an expired subscription that needs to be renewed. We pride ourselves in providing accurate and timely support. We want you to have access to help whenever you need it, so please renew in time. This enforces your commitment to the product and energizes our drive to add new features and improve existing ones.

 

Enhancement, Ultimate: Added rowSpanFunction and colSpanFunction. Added RowSpanExample and colSpanExample to demonsrate the new row and column span functionality.

New Example, Row Span and Col Span - Newly added example to demonstrate the row and column span abilities of Flexicious Ultimate

New Example, Remoting Backend - Ultimate working with a live backend, similar to the Classic Examples, with filterPageSortMode=server and one page of data loaded at any given time.

New Example, Trader View - Ultimate demonstrating how to quickly update the values of a specific cell, without causing a grid rebuild. This enables you to process high frequency updates from the backend.

New Example, Selection Options : Demonstration of the new Selection Exclusion mechanism (See blog post)

Enhancement, Ultimate: Added the getRowHeightFunction, which can be used to override the built in row height calculation functionality when variableRowHeight=true

Enhancement, Ultimate: Added enableSelectionexclusion

Enhancement, Ultimate: Added code so that if enableSelectionCascade, on lazy load setChildData call, automatically add to children next level selected objects

Enhancement, Ultimate: Added code so that if enableDynamicLevels=true, on lazy load setChildData call, automatically add next level if the current objects children have more children.

Enhancement, Classic and Ultimate: Added the properties filterCompareFunction and filterConverterFunction to convert data prior to filter comparision. See the XMLData example for details.

Enhancement, Classic and Ultimate: Added dateFormatString to DateComboBox to control the date format of the Custom date range popup. You can instantiate this on the column via: filterRenderer="{UIUtils.createRenderer(DateComboBox,{dateFormatString:'DD/MM/YYYY'})}"

Bug Fix, Classic : Fix for issue of preference persistence of grouped columns.

Bug Fix, Ultimate : Scenarios where there are editable cells widely spaced apart, tabbing results in NPE.

Bug Fix, Ultimate : Nested Data with level renderers and variable row height did not size correctly.

Bug Fix, Ultimate : When data is added dynamically to a previously drawn grid, some cells showed up empty even when there was text to show.

Bug Fix, Ultimate : Refresh operations, like sorting, rebuilding, expand collapse caused some cells to loose formatting information, and icon state.

Bug Fix, Ultimate : Footer Cells did not update on filter.

Bug Fix, Ultimate : Cells with a custom cellTextColorFunction defined did not retain color post scrolling.

Bug Fix, Ultimate : Under certain circumstances, vertical gridlines did not extend all the way down to the grid, or post resize, did not retract back into the grids viewport.

Bug Fix, Ultimate : Expand Collapse operations that happened in conjunction with the scrollbar appearing or disappearing resulted in weird state.

Bug Fix, Ultimate : Edit row highlight did not disappear until mouse over on another row.

Enhancement, Ultimate : variableRowHeight – for items where word wrap did not apply (text not long enough) we did not respect the rowHeight.

Enhancement, Ultimate : Item being edited, cell text showed through item editor. Cell text will now be hidden.

Enhancement, Ultimate Automation: Added support for automation of CheckBox Click Events

Enhancement, Ultimate Automation: Added support for Level Renderer Cell Automation

Bug Fix, Ultimate : RowDisabledFunction was being ignored, and such rows were participating in hover, selection and drag. This will now be prevented. Disabled Cells will not be editable, hoverable, selectable or draggable.

Bug Fix, Ultimate : Clicking checkbox header sometimes caused the rows to collapse.

Bug Fix, Ultimate : Re-position the no-data message on grid resize.

Bug Fix, Ultimate : Support for filterCompareFunction on Ultimate did not work.

Default Changed : The enableSelectionCascade now defaults to true.

Interface Changed : Changed IExtendedDataGrid to have get and setColumn method, and getDataProvider, renamed get dataProvider to getDataProvider. This was done because the Spark Datagrid has different return types for these properties and will not match the interface.

Method renamed : Renamed the selectAll method to selectAllCheckboxes, and clearSelection to clearCheckboxSelection. This was done because the Spark DataGrid already assigns a different meaning to these methods.

Deprecated : Row Number Column. This has been deprecated, since it is not applicable for hierarchical data. Also, causing performance issues.

Deprecated : FlexDataGridColumnLevel.widthDistributionMode. This has been removed. It was never used, and its place was taken by columnWidthMode. This property is defined on the column itself.

Bug Fix, Ultimate: Print failed in certain scenarios with preferences stored. Also, fix for scenarios where the container pushes the grid body to a negative height post print, the rows were disappearing. A sanity check has been added for this.

Bug Fix, Classic: Issue with preferences not being persisted for ICustomMatchFilterControls resolved.

Added Boolean flag autoRegister to interface IFilterControl. Just add the following to your FilterInclude:

/**

* Register with the container on creation complete

*/

public function get autoRegister():Boolean

{

return filterControlInterface.autoRegister;

}

 

/**

* @private

*/

public function set autoRegister(value:Boolean):void

{

filterControlInterface.autoRegister = value;

}

Also, since the Spark datagrid assigns a different type to the columns and dataprovider property on the grid, the IExtendedDataGrid has been modified to have getColumns, setColumns, getDataProvider, and setDataProvider methods. So in MyDocExporter, you will see this error:

Access of possibly undefined property columns through a reference with static type com.flexicious.grids.dependencies:IExtendedDataGrid. MyDocExporter.as /main/src/com/sample/examples/support/export line 31 Flex Problem

Just replace grid.columns with grid.getColumns()

 



Filtering with hierarchical data and selection across large lazy loaded datasets using Selection Exclusion

clock January 15, 2012 22:07 by author Flexicious

One of the things about support for hierarchical data, is that concepts that apply to flat data become significantly difficult to conceptualize and implement. To put this in context, imagine the good old filtering functionality. With flat data, you have a set of columns, and a filter will apply to one of the columns.

With hierarchical data, this concept becomes more difficult to implement, because now you have to filter out each item that matches a filter, keeping in perspective that its ascendants or descendants may or may not match the filter. So if a child matches a filter, but the parent does not, we would take out the parent, which in essence takes out the child as well. Then you have scenarios where the parent matches, but none of the children do. Even the concept of matching requires thought, because the field being searched on might exist on the parent, but not the child or vice versa, since they could potentially be different object types and might not share the property being searched on. Whew! That was a mouthful.

Since we have to account for these scenarios, we have the following properties:

  • enableRecursiveSearch: For Grouped datagrids(reusePreviousLevelColumns=true), searching on this column will cause match current item, as well as any of its children. If any children match, this item matches as well.
  • enableHideIfNoChildren: Flag to control whether or not an item that has no children is filtered out or not.
  • filterExcludeObjectsWithoutMatchField : By default, for hierarchical datagrids, when there is an object that does not have the property being searched for, these objects are included in the filter match. Set this flag to true to exclude such objects.

It is things like this that we consider to be the strength of Flexicious Ultimate. It’s the fact that we have already thought about scenarios like that so you don’t have to. There are literally hundreds of things like this.

That brings us to the topic of this blog post, the selection exclusion mechanism.

One of the things that we have built into the architecture of the product is the concept of lazy loaded hierarchical datagrids. Data is loaded on demand as the user scrolls (Virtual scroll) or as the item is expanded (Lazy Load, Full and Partial). This all works fine, but what do you do about selection cascade and bubble? So far, (up until 2.5) this was limited to eager loaded grids, so when you check a parent, we run through and automatically select the children, i.e. add them to the selectedObjects collection. The big assumption here is that children are already loaded when you select the parent. This assumption falls flat on its face when you have lazy load or virtual scroll. In scenarios like this, you could select a row, and then expand or scroll. It will also cause performance issues if you have large datasets and you end up selecting a lot of records that cascade selection. Well, say hello to enableSelectionExclusion. From the docs:

enableSelectionExclusion: Support for selection based on exclusion. In scenarios where you have lazy loaded grids, selection cascade and select all will simply set flags on the selectionInfo object. The selectedObjects and selectedKeys no longer contain references to data that is selected. Instead, they contain the items that the user explicitly selected. unSelectedObjects will contain items that the user explicitly unselected. This helps maintain selection across very large lazy loaded datasets. When you set the enableSelectionExclusion flag to true, use the selectionInfo object to access the selection (or build a query on the server) to identify the objects user selected.

The selectionInfo object is a simple list of LevelSelectionInfo objects, which contains explicitly selected and unselected objects, which can then be used to construct a query on the server as to what the selection on the client was.

See the VirtualScrollExample for this concept in action!