Test Enviroment :

IE Version : IE8

IIS Version : 5.0

RadControls Version : RadControls for Asp.Net Q2 2007(ASP.Net 2.X)

Issue one :

If a page used controls in assembly named RadAjax.Net2, there will be some Javascript errors caused when loading these pages. Please see picture "err1.jpg";

If I remove these ajax controls from this page , there will be no Javascript error.

Issue two:

I can’t select a Item from RadComBox. And RadComBox will always only display the last item if I click the left mouse button. Please see picture "err1.2pg";

My question is :
Can "RadControls for Asp.Net Q2 2007" work on .NET 4.0? If yes, what I should do to fix above two issues? If not, what I shall do if I have to use .NET 4.0?
I tried Telerik.Web.UI_2012_1_411_Dev.msi on .NET 4.0. There are big differences between RadControls for Asp.Net Q2 2007 in coding. If I use  

 <AjaxSettings>
<telerik:AjaxSetting AjaxControlID="btnViewUpdate">
<UpdatedControls>
<telerik:AjaxUpdatedControl ControlID="RadScheduler1" LoadingPanelID="RadAjaxLoadingPanel1" />
<telerik:AjaxUpdatedControl ControlID="lblViewName" />
</UpdatedControls>
</telerik:AjaxSetting>
</AjaxSettings>

protected override void Page_Init(object sender, EventArgs e)
        {
            base.Page_Init(sender, e);
            Grid = new RadGrid(); // actually this is not RadGrid but descendant class I created
            Grid.Initialize(ZSheet, ForceLoad, DataSourceProvider, this); // create columns runtime
            ZSheetContainer.Controls.Add(Grid); 
            GridFilter.Initialize(ZSheet, Grid.ZTable.TableNameUser); 
            if (IsPostBack)
                GridFilter.ApplyFilter(); // create and apply filter expressions obtained from different source, see below
        }

public void ApplyFilter()
        {
            if (string.IsNullOrWhiteSpace(_hf.Value)) return;
            List<GridFilterItem> filterItems =
                new JavaScriptSerializer().Deserialize<List<GridFilterItem>>(_hf.Value);
            foreach (GridFilterItem item in filterItems)
            {
                ZSheetItem zitem = _table.Structure.FirstOrDefault(t => t.f_name == item.Condition.ColumnID);
                Type columnType = GetColumnType(zitem);
                Type filterExpressionType;
                Type[] types = new[] { columnType };
 
                switch (item.Condition.Operator)
                {
                    case GridKnownFunction.Contains:
                        filterExpressionType = typeof(RadFilterContainsFilterExpression);
                        break;
                    case GridKnownFunction.DoesNotContain:
                        filterExpressionType = typeof(RadFilterDoesNotContainFilterExpression);
                        break;
                    case GridKnownFunction.StartsWith:
                        filterExpressionType = typeof(RadFilterStartsWithFilterExpression);
                        break;
                    case GridKnownFunction.EndsWith:
                        filterExpressionType = typeof(RadFilterEndsWithFilterExpression);
                        break;
                    case GridKnownFunction.EqualTo:
                        filterExpressionType = typeof(RadFilterEqualToFilterExpression<>);
                        break;
                    case GridKnownFunction.NotEqualTo:
                        filterExpressionType = typeof(RadFilterNotEqualToFilterExpression<>);
                        break;
                    case GridKnownFunction.GreaterThan:
                        filterExpressionType = typeof(RadFilterGreaterThanFilterExpression<>);
                        break;
                    case GridKnownFunction.LessThan:
                        filterExpressionType = typeof(RadFilterLessThanFilterExpression<>);
                        break;
                    case GridKnownFunction.GreaterThanOrEqualTo:
                        filterExpressionType = typeof(RadFilterGreaterThanOrEqualToFilterExpression<>);
                        break;
                    case GridKnownFunction.LessThanOrEqualTo:
                        filterExpressionType = typeof(RadFilterLessThanOrEqualToFilterExpression<>);
                        break;
                    case GridKnownFunction.Between:
                        filterExpressionType = typeof(RadFilterBetweenFilterExpression<>);
                        types = new[] { columnType, columnType };
                        break;
                    case GridKnownFunction.NotBetween:
                        filterExpressionType = typeof(RadFilterNotBetweenFilterExpression<>);
                        types = new[] { columnType, columnType };
                        break;
                    case GridKnownFunction.IsEmpty:
                        filterExpressionType = typeof(RadFilterIsEmptyFilterExpression);
                        break;
                    case GridKnownFunction.NotIsEmpty:
                        filterExpressionType = typeof(RadFilterNotIsEmptyFilterExpression);
                        break;
                    case GridKnownFunction.IsNull:
                        filterExpressionType = typeof(RadFilterIsNullFilterExpression);
                        break;
                    case GridKnownFunction.NotIsNull:
                        filterExpressionType = typeof(RadFilterNotIsNullFilterExpression);
                        break;
                    default:
                        filterExpressionType = typeof(RadFilterEqualToFilterExpression<>);
                        break;
                }
 
                Type genericType = filterExpressionType.MakeGenericType(types);
                RadFilterExpression expression = (RadFilterExpression)Activator.CreateInstance(genericType, item.Condition.ColumnID);
                _filter.RootGroup.AddExpression(expression);
             }            
            _filter.FireApplyCommand();

}