Is it possible to implement an option that enables the paging of the Grid View?

For example:

@(Html.Kendo().FileManager()
    .Name("filemanager")
     .Views(gridView => gridView.Grid(grid => grid.Pageable()))
     ...
)

Currently, when dynamically appending menu items using the append() method, there is no built-in support to specify an icon via an icon, iconClass, or similar property — unlike other Kendo UI components such as kendo.ui.Button, which allow this directly.

To include an icon today, we must use inline HTML within the text property and set encoded: false, like so:

menu.append({
    text: '<span class="k-icon k-i-plus"></span> Add Item',
    encoded: false
});

While this workaround functions, it's not as clean or consistent as using a dedicated iconClass or icon option.

Please consider adding official support for an iconClass, icon, or similar property when using append() with kendo.ui.Menu, aligning it with how other Kendo components handle icons.

This would:

• Improve API consistency across Kendo components.
• Simplify code for dynamic menu updates.
• Eliminate reliance on raw HTML and manual encoding flags.

This just seems like a minor oversight since the Enable(bool) method exists on the DatePicker html helper and other Kendo taghelpers support the enable or enabled attribute, but there doesn't seem to be an enable-like attribute for the kendo-datepicker. Thanks!

<kendo-datepicker for="ReadOnlyDate" enable="false"></kendo-datepicker>

Currently, the ToCamelCase() method lowers only the first letter, as per the example below:

Is it possible to create another overload of the ToCamelCase() method that transforms the string to "randomStatusId"?

Dear Telerik

The feature is related to https://www.telerik.com/account/support-center/view-ticket/1594775 this thread.

It is related to a product environment.

Scenario:

1. Save grid options in persistent storage (i.e. DB).
2. Grid operates successfully and return visits operate well with stored options being loaded with the grid.
3. Then the grid column structure or some other feature is amended during a maintenance and development request - the feature setting is contained within the stored options which are loaded with the grid. The grid functions without some of the changes because the options override the changes.
4. Behavior is unwanted so we would have to merge the new options and the old options.

Request:

Please can Telerik create functionality along the lines of:

$("#SomeGrid").data("kendoGrid").setOptions($("#SomeGrid").data("kendoGrid").mergeOptions(OptionsSaved, OptionsNew));

KR

David

It would be useful to have a grid operator for "IN" conditions. Right now we only have 2 options for an OR without having to use a custom filtering and custom clearing functions.

We have a lot of data that needs to be filtered that is not sequential.  For example purposes:

Given that a customer has a standing purchase order for parts over time.

Given that serial numbers on said parts will not be sequential and may not be even be similar enough for wildcards (if that feature is provided.)

Given that we need to filter grid data to retrieve customer number, purchase order and a set of serial numbers, we need the equivalent of:

SELECT * FROM testdatatable WHERE customer = '#####' AND purchaseorder = '#####' AND serialnumber IN ('abciqwe', 'cid235', 'sn34087', 'hpk2679');

which would be WHERE WHERE customer = '#####' AND purchaseorder = '#####' AND (serialnumber  = 'abciqwe' OR serialnumber =  'cid235' OR serialnumber = 'sn34087' OR serialnumber 'hpk2679');

So basically I would like to have the ability to have multiple OR statements and the operand could be 'contains' or 'not contains' as that would probably work better than "equal".

Our immediate need is for the MaskedTextBox.

And have modified my program.cs to add:

// Add services to the container.

builder.Services.AddControllersWithViews()

                // Maintain property names during serialization. See:

                // https://github.com/aspnet/Announcements/issues/194

                .AddNewtonsoftJson(options => options.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver());

// Add Kendo UI services to the services container"

builder.Services.AddKendo();

I copied the code from your demo into the ASP.net 6.0 Page above.

I added data properties to the Index.cshtml.cs model and changed the Value property on each Kendo object to point them. That works fine

The issue is that the formatting is not applied:

Hi Team,

I'd like to request adding a configuration to the Kendo UI Grid or ExcelExport event which would be a setting to autofit the Excel sheet columns instead of changing the workbook.sheets.columns.autowidth. 

Thank you!

Hi,

In some of the mobile interfaces, we do see a feature where users slide the submit button to trigger the form submission.

However, in the desktop interfaces, we have yet to see such a feature.

The Slide to Submit feature may help developers and users to reduce the usage of reCaptcha in some of the Form submissions.

Please add an option so that is possible to set Deferred rendering default setting to either true or false globally.

Currently the default is false and can only be overwritten on a control basis and not globally.

This would benefit those customers that have decided that all/most of the controls are rendered as deferred(true). Currently they have to append the Deffered(true) to each of the helpers.

I`m working development and produced I4.0 devices as well app systems since 3 years.  Are Telerick involve in this applications. 

When you create a Grid using a TModel that inherits from DynamicObject, a type cast exception is thrown when setting the DataSource Model Id property.

public class Metadata : DynamicObject
{
    ...
}  

...
.DataSource(dataSource =>
{
    dataSource.Ajax()
      .Model(model =>
      {
          model.Id("Id");
      });
})

A type cast exception is thrown by the following line in Kendo\AspNet.Core\Kendo.Mvc\UI\DataSource\Fluent\DataSourceModelDescriptorFactoryBase.cs because ModelDynamicDataKey is not generic, so it cannot be cast to IDataKey<TModel>

dataKey = (IDataKey<TModel>)new ModelDynamicDataKey(fieldName, lambdaExpression);

The following code changes fix the issue:

DataSourceModelDescriptorFactoryBase.cs

namespace Kendo.Mvc.UI.Fluent
{
	using System.Reflection;
	using Extensions;

	/// <summary>
	/// Defines the fluent interface for configuring the <see cref="DataSource"/> Model definition.
	/// </summary>
	/// <typeparam name="TModel">Type of the model</typeparam>
	public abstract class DataSourceModelDescriptorFactoryBase<TModel> : IHideObjectMembers
        where TModel : class
    {
        protected readonly ModelDescriptor model;

        public DataSourceModelDescriptorFactoryBase(ModelDescriptor model)
        {
            this.model = model;
        }

        /// <summary>
        /// Specify the member used to identify an unique Model instance.
        /// </summary>
        /// <param name="fieldName">The member name.</param>
        protected void Id(string fieldName)
        {
            IDataKey<TModel> dataKey;
            if (typeof(TModel).IsDynamicObject())
            {
                var lambdaExpression = ExpressionBuilder.Expression<TModel, object>(fieldName);
                dataKey = new ModelDynamicDataKey<TModel>(fieldName, lambdaExpression);
            }
            else
            {
                dataKey = GetDataKeyForField(fieldName);
            }

            dataKey.RouteKey = dataKey.Name;

            model.Id = dataKey;
        }

        protected IDataKey<TModel> GetDataKeyForField(string fieldName)
        {
            var lambdaExpression = ExpressionBuilder.Lambda<TModel>(fieldName);
            var fieldType = typeof(ModelDataKey<,>).MakeGenericType(new[] { typeof(TModel), lambdaExpression.Body.Type });

            var constructor = fieldType.GetConstructor(new[] { lambdaExpression.GetType() });

            return (IDataKey<TModel>)constructor.Invoke(new object[] { lambdaExpression });
        }
    }
}

ModelDynamicDataKey.cs

namespace Kendo.Mvc.UI
{
    using System;
    using System.Linq.Expressions;
    using Microsoft.AspNetCore.Mvc.Rendering;

    internal class ModelDynamicDataKey<TModel> : IDataKey<TModel>
        where TModel : class
    {
        public ModelDynamicDataKey(string memberName, Expression<Func<TModel, object>> expression)
        {
            RouteKey = "id";
            Name = memberName;
            Expression = expression;
            Value = expression.Compile();
        }

        public string Name
        {
            get;
        }

        public string RouteKey
        {
            get;
            set;
        }

        public Func<TModel, object> Value
        {
            get;
        }

        public Expression<Func<TModel, object>> Expression
        {
            get;
        }

        public object GetValue(object dataItem)
        {
            try
            {
                return Value((TModel)dataItem);
            }
            catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException)
            {
                return null;
            }
        }

        public string HiddenFieldHtml(IHtmlHelper<TModel> htmlHelper)
        {
            return htmlHelper.Hidden(Name, null, new { id = "" }).ToString();
        }
    }
}

This is actually a request for ALL PivotGrid Controls across the Telerik family. Currently only numeric values can be used in a PivotGrid. There are many instances when it can be really useful to perform Pivots on string values. Currently Telerik does not support this feature and I need to use the DevExpress PivotGrid to accomplish my use case. I would like to see Telerik adopt this same functionality.