It would be really useful to be able to modify request parameters in the RequestStart event of the dataSource; this would be consistent with the functionality of the Kendo Tooltip RequestStart Event.

Currently if i set filter on my remote data source it fetches the data immediately, so if i want a callback i have to call fetch which will talk to server again.
What be really good is to be able to set sorting/filter and receive a callback when data is retrieved from server. 
E.g.
dataSource.fetch({
  filter: {},
  sorting: {}
}) // returns a promise
  .done(function(e){})
  .fail(function(e){});

The HiearchicalDataSource should support XML data binding. If not, then the examples and documentation should be updated until that support is present.

Currently when I choose a column filter and click on the filter button, a request is sent to the server and data is bound. However, if I work with large data sources and I know in advance that I want to filter by FirstName and LastName, for example, I would like to choose both the filters first, and when filter settings are finalized, I would like to rebind the grid with a button click, for example.

This would enable to bind only once the grid, instead of n times, if the user chooses lazy filtering which would be very useful, especially in the case of large data sources

Would be good to have ability to to something like this on an observable object:
o.set({ a: 1 })
I.e. pass an object to the set function to update/add properties in o from that object.

Currently when there are any errors in data-bind attributes you usually get some array out of bound indexing error (in parseBinding()) or some other obscure error.  

This suggestion is to trap these errors more aggresively and provide better error messages.

Is there planned support for JSON-RCP for DataSource? At least something that does batches? Using REST is fine for example code, but otherwise can result in many connections, etc. While a bigger problem in mobile, it still makes a difference in desktop. ExtDirect and json-rcp both seem to fit the bill.

If my callback takes 10ms or 300ms I still get the control whiting itself out and showing a loading animation.  Problem though is if it takes 10ms it looks like the control is flickering. 

Let me set a min duration before the animation shows up.  So I could say only show the loading animation if it's taking longer than 100ms.

In the datasource can you give us a property which will tell the DS that it needs to stringify the parameters so I don't have to keep googling this syntax?
parameterMap: function (options) {
                return kendo.stringify(options); // kendo.stringify serializes to JSON string
            }

So just like read: { stringifyParams:true ...}

Visual Studio plugin to generate javascript proxy classes for communicating with web services. 

Normally in ASP.Net the .Net proxy classes would be generated for me, but since I am now moving towards building RIA applications most of the WS calls now take place client side. The process of manually setting up service calls is a bit cumbersome so if KendoUI could include a tool for this it would be great.

Make spreadsheet support virtual scrolling as the grid does in this example - https://demos.telerik.com/kendo-ui/grid/virtualization-remote-data

This allows handling of much larger datasets than other methods of data binding.

The DataSource Model including validation should come from the server and not defined within javascript where possible.  There should be two primary ways to populate the model using the DataSource widget.

1.) Retrieved from the DataSource call itself as a JSON property off of the data call.  You should be able to define a schema: { parseModel: function(data) { return data.model } } to retrieve the model directly from the data call.

2.) You should be able to specify the schema: { model: new DataSource({ ... }) }.  The model itself should be DataSourcable so you can retrieve (with ETag/Last-Modified and Cache-Control) the model as a separate request alongside the data.

Given that you should be able to retrieve the model as a separate request,  you should be given the opportunity to augment/modify the model within the client side using something like schema: { changeModel: function(model) { // Supplement Model here
} }

I would like to propose that GET handlers return values that can be returned to their callers.  This would allow for things like proxy objects that can return values from other objects, without having to override the get function.  It would also allow for modification, augmentation, or replacement of values.

For examples you might find this interesting: http://millionmunkeys.net/PiMunkey/1.5/Documentation/functions.cfm#filters

Signalr is a push technology, but your current implementation is not robust enough to allow data from an outside source to be pushed to your grid. A stop measure for this would be to include the ability to use a function in addition to a string for the server read function. This would enable a developer to chain a server call to refresh data when data changes are coming from a source outside your grids. A full implementation of signalr would be to code your grid to accept a signalr call from the server hub that directly updates client data from any source, as long as it conforms to the model for the grid. This could be possibly done through the use of a signalr grid group, that the server could push to. This group should be a group of one that maps to a specific grid. This would also allow multiple grids on a page/form to be independently updated. Currently your signalr grids interfere with each other if the calls are running at the same time on that same page/form, both synchronously and asynchronously. 

Add functionality that will allow adding shared datasource to multiple components with individual filters.

This way we will be able to have one data source and multiple grids showing different part od data.

With the current hierchical datasource, a simple file system type use case can not be supported... or an email service with nested folders.  e.g. a folder might have subfolders OR files... or and email folder might have emails OR subfolders.  Its is rare that you would ever know how many nestings there are ahead of time.


If the Node object provided some form of a type field/string/object/function to describe the corresponding model that would be very valuable. the library could instantiate the appropriate type at run time. This would also be useful for templating where a simple switch statement could be used to present templates based on the type. I imagine there would be challenges with the datasource fetch as there could be multiple service endpoints a cross the children of a node based on the number of child types. You might consider solving this by changes children from an array to an array of arrays. And you could populated children with the number o possible types, each type having its own endpoint. Anyway it's a pretty common use case so please forward to product management for roadmap consideration. I'd probably consider that #1 on my list.

As of today, it is possible to create custom "simple" bindings as per this code sample:

http://demos.kendoui.com/web/mvvm/custom.html

This works fine, but it would be appreciated to be able to create custom bindings with "complex" syntax, such as this:

data-bind="foo: {condition: somePropertyOnViewModel, option1: A, option2: B }"

Create a datasource with a schema that has number fields.

Try to filter by one of these fields using a "contains" and an ignorecase and kendoui creates an expression like

(function(d, __f, __o) {
return ((d.MyNumber || '').toLowerCase().indexOf('12') >= 0)
})

this errors because the number does not have a toLowerCase() method.

Our code is generic and we do not want to have to change ignorecase depending on the data-type, as sometime the filter will be on a string and sometimes on a number. Can a fix be put in place to allow this combination to run without error.

Thanks.

In the context of MVVM bindings, it would be great to have a way to evaluate certain conditions/expressions, especially within template bindings, by "navigating" to other properties of the ViewModel, or to other properties of the currently iterated object.

For example:

<ul data-role="listview" data-bind="source: anObservableObject" data-template="some-template"></ul>
<script id="some-template" type="text/x-kendo-template">
    <li data-bind="text: whatever, visible: $source.someProperty == $data.otherProperty"></li>
</script>

In this example, $data refers to the current iteration data, and $source refers to the source. So the visible binding would be true/false according to the expression which would evaluate an arbitrary property on the source and an arbitrary property on the iterated object.

This is similar to Knockout's mechanism and it allows for greater flexibility within templates.

The DataSource schema must be given a total value in order to page correctly. However, DataSource expects this value to come from a response body field. In some cases, we must work with systems that return the total value as a custom field in the response header. We need a way to read custom response header values. 

Yes, the DataSource transport uses jQuery.ajax, so we can implement a custom complete function to read the response headers from the jqXHR. However, complete fires AFTER schema.total is set so it does no good.