I'd love it if you would consider making a real office document editor for the web. Take a look at this editor from OnlyOffice which they use in their CRM system:

https://personal.teamlab.com

It's built on HTML5 and the canvas element. The way you get complete control of every pixel and can make a desktop-like editor is simply stunning! This must surely be something Telerik also considers? There simply is no comparison to a normal HTML 4 editor which fails at such basic features as header/footer.

Make the Kendo UI Dojo embeddable via an iframe. Exactly what jsfiddle.net offers. 

http://doc.jsfiddle.net/use/embedding.html

We recently implemented a bubble chart for our system. The users loved it but wanted to see custom markers that would indicate "direction" of the data value. We couldn't see a way to put custom markers on the bubble chart (hence the term bubble I guess) so we looked at the scatter chart. This did everything we needed (custom marker, relative sizes, etc) but did not allow us to click on a marker that was behind another (like the bubble chart). We would like one or the other.

Kendo Map - Auto-Center after loading the geojson file.

In the applications I work on we have multiple maps where there are shapes with different colors, tooltips with data, and various map markers. 

The Map widget would be greatly enhanced if it could support a legend!

The Release Notes page for the Kendo UI (http://www.telerik.com/support/whats-new/kendo-ui/release-history) does not contain the exact version each release is. It only says something like "Kendo UI Q2 2015".

Please use the Reportings Release Notes page (http://www.telerik.com/support/whats-new/reporting/release-history) as the example to be followed, so that it is clear for us which version exactly the Q1, Q2 etc is connected to.

On RadMap and other visual tools, it would be beneficial to have the ability to alter colors for specific data points or have each data point have the ability to define a color.  This would be similar to how series in RadCharts work in that I could define a color for a specific marker, or layer, etc.

Allow users to draw shapes and select markers on the maps to perform events.

See http://hammerjs.github.io/

It would be nice to have tooltips showing when the user hovers a shape on a map, basically the same funcionality that can be obtained for markers.

PDF Export required a new method which will open on new tab instead of downloading it.

eg:  kendo.drawing.pdf.open(group,"Invoice.pdf") 

We use your grids, combo boxes and such in highly customized way, and most of them use custom functionality to complete a feature we need.

In many cases these are some default features we would like to apply to all controls of a certain type.

For example, we use a script which forces the user when using a combo box to always select a value and not enter incomplete text. This through script works like a charm, but a big problem is that each and every combo in our application must have this applied.

Another example is responsive grids....we have a script in place which on a certain resolution transforms your grid into a responsive table. This also works like a charm. The problem is that we only now made the script...we now need to apply it manually to 120+ grids in our application.

It would also be great if you would make the global event handler chainable with the regular one (so for example first the global one first from queue, then the regular one).

Aslo it would be great if it would receive the affected grid in the arguments so that we can also make selector logic...for example all grids which have some css class...execute desired functionality.

This would help SO much!

When trying to swipe up/down a form or left and right for the drawer menus when there are several textboxes/labels it doesn't always work.

This happens when the user starts the swipe action over a textbox/label.  If the user starts to swipe over a grey area (background) it works perfectly every time.

Currently, DataViz charts allow you to set a valueAxis's tick mark increments (increments of 100 would give you 0, 100, 200, 300, etc). I suggest a way to set a specific amount of ticks that your chart will always load, and the data will use divisions to fit the tick amount you set. Example: I want my chart to always display 5 ticks. I have two users, one who has a max number of 100 and the other has a max of 500. For User 1, the chart would set a max of 100 divided by the 5 ticks (so increments of 20). User 2 would get increments of 100 to fit the 5 ticks. 

Why not zoom on just an canvas - for example with a photo then a whole page or tab

When sorting a foreign key column on grid, the sorting is performed using the value/id - which is wrong. The sorting should consider the text displayed to the user.

Hi,

1. It would be desirable if the properties described by “,” and “.” were renamed so as to be typescript compatible so that if access to them was required, it could be done via eg:

myCulture.numberFormat.groupThousandsSeparator

And not

myCulture.numberFormat[ “,” ]

Refer to the properties as shown here in the kendo.all.d.ts file:

declare namespace kendo {
    function culture(): {
        name: string;
        calendar: {
            AM: string[];
            PM: string[];
            "/": string;
            ":": string;
            days: {
                names: string[];
                namesAbbr: string[];
                namesShort: string[];
            };
            months: {
                names: string[];
                namesAbbr: string[];
            };
            patterns: {
                D: string;
                F: string;
                G: string;
                M: string;
                T: string;
                Y: string;
                d: string;
                g: string;
                m: string;
                s: string;
                t: string;
                u: string;
                y: string;
            };
            firstDay: number;
            twoDigitYearMax: number;
        };
        calendars: {
            standard: {
                AM: string[];
                PM: string[];
                "/": string;
                ":": string;
                days: {
                    names: string[];
                    namesAbbr: string[];
                    namesShort: string[];
                };
                months: {
                    names: string[];
                    namesAbbr: string[];
                };
                patterns: {
                    D: string;
                    F: string;
                    G: string;
                    M: string;
                    T: string;
                    Y: string;
                    d: string;
                    g: string;
                    m: string;
                    s: string;
                    t: string;
                    u: string;
                    y: string;
                };
                firstDay: string;
                twoDigitYearMax: number;
            };
        };
        numberFormat: {
            currency: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
            decimals: number;
            ",": string;
            ".": string;
            groupSize: number[];
            pattern: string[];
            percent: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
        };
    };

Hi,

We are using kendo (version 2020.2.617) from typescript. The current of the culture() function definition in kendo.all.d.ts looks like this:

declare namespace kendo {
    function culture(): {
        name: string;
        calendar: {
            AM: string[];
            PM: string[];
            "/": string;
            ":": string;
            days: {
                names: string[];
                namesAbbr: string[];
                namesShort: string[];
            };
            months: {
                names: string[];
                namesAbbr: string[];
            };
            patterns: {
                D: string;
                F: string;
                G: string;
                M: string;
                T: string;
                Y: string;
                d: string;
                g: string;
                m: string;
                s: string;
                t: string;
                u: string;
                y: string;
            };
            firstDay: number;
            twoDigitYearMax: number;
        };
        calendars: {
            standard: {
                AM: string[];
                PM: string[];
                "/": string;
                ":": string;
                days: {
                    names: string[];
                    namesAbbr: string[];
                    namesShort: string[];
                };
                months: {
                    names: string[];
                    namesAbbr: string[];
                };
                patterns: {
                    D: string;
                    F: string;
                    G: string;
                    M: string;
                    T: string;
                    Y: string;
                    d: string;
                    g: string;
                    m: string;
                    s: string;
                    t: string;
                    u: string;
                    y: string;
                };
                firstDay: string;
                twoDigitYearMax: number;
            };
        };
        numberFormat: {
            currency: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
            decimals: number;
            ",": string;
            ".": string;
            groupSize: number[];
            pattern: string[];
            percent: {
                decimals: number;
                ",": string;
                ".": string;
                groupSize: number[];
                pattern: string[];
                symbol: string;
            };
        };
    };

It would be desirable if this was declared as an interface so client code could use the interface type and assign the culture to a typed variable, eg:

let currentCulture: IKendoCulture = kendo.culture( );

Thanks and regards,

Lou

It would be nice to have a widget to display network map of all connected node and links.

The kendo core would benefit from having integration packaging systems other than npm, especially jamjs. Kendo already implements AMD which is what jam specializes in.  

http://jamjs.org/
http://bower.io/
http://volojs.org/