Telerik Forums
UI for WPF Forum
or
Ask question
All Questions
Unanswered
Answered
25,593 questions
11 answers
290 views
Self-Referencing GridView in WPF
Hi,

I am using Self-Referencing GridView in my WPF project and I am getting the output correctly. But I need the below things to do

1. Make the Header and Panel group for the child gridview as FALSE. Note: I have done it for the Parent Gridview.
2. I am binding the List Collection property to the grid for the child and individual properties for the Parent. I want to make visible false for GUID columns in the child grid (guid is there in the List collection. if i remove from collection, self referencing is not working).

Please help me to solve these issues.

Thanks,
Ram
GridView
Ramasamy
Top achievements
Rank 1
 answered on 27 Sep 2011
1 answer
141 views
Prevent row from shrinking when entering edit mode on a cell
I have some cells that contain a lot of text content, and they have a set width, so the content gets split into multiple lines, which is what I want. However, when I click on one of these cells to edit it, the row height shrinks down to "single-line" height, so you have to scroll through all the cell text to get to the place you want to edit. Is there an easy way to prevent that from happening? I could calculate the desired height based on the length of the text and the width of the cell and then set it in the PreparedCellForEdit handler, but that seems like a very hackish solution.

GridView
Pavel Pavlov
Telerik team
 answered on 27 Sep 2011
2 answers
122 views
Telerik Rad Controls Integration with GoXam
Hi all,
We've been experiencing some problems with the content residing inside either the Rad Tab or Rad Pane. We believe the issue is possibly related to the "IsContentPreserved" property, as changing this to true in our initial set up, Rad Tabs, seemed to be a fix.
We've made some changes to the UI, namely hosting the Rad Tabs inside the Docking system, Rad Panes. The problem has reoccurred, although setting the "IsContentPreserved=true" on the Rad PaneGroup hasn't resolved the problem this time. 
Basically the problem we keep experiencing is that UI elements that're inside either the Rad Tabs or Rad Docking Rad Pane Groups which are bound loose the values or possibly the DataContext all together.

Note:
The DataContext is being set from the constructor in the code behind C#, DataContext not bound from the UI in Xaml.


Any help with this would be great, thanks in advance

Nick
Docking
Nick Sullivan
Top achievements
Rank 1
 answered on 27 Sep 2011
0 answers
308 views
Save and load gridview settings
Hello
I have seen quite a few examples to Save and Load the Gridview settings, but all of them use the IsolatedStorage which is only available for Clickonce applications.
My application is not a Clickonce, hence I cannot use that.
Is there another way to save/load settings?
I have got Telerik Q3 2010 version and am using .NET 3.5
I also tried modifying the RadGridViewSettings class and use IsolatedStorageFile.GetUserStoreForAssembly
as below, but when serializing, I get an error saying:
Type 'System.Windows.Input.Cursor' cannot be serialized. Consider marking it with the DataContractAttribute attribute, and marking all of its members you want serialized with the DataMemberAttribute attribute.  See the Microsoft .NET Framework documentation for other supported types.

Any ideas?
Regards
Apoorva
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.ComponentModel;
using System.Windows;
using System.Windows.Data;
using Telerik.Windows.Controls;
using Telerik.Windows.Data;
using Telerik.Windows.Controls.GridView;
using System.Windows.Controls;
using System.Runtime.Serialization;
using System.IO;
using System.IO.IsolatedStorage;
using System.ServiceModel;
 
namespace Groupcall.MessengerInvoice
{
    public class RadGridViewSettings
    {
        public RadGridViewSettings()
        {
            //
        }
        public class RadGridViewApplicationSettings : Dictionary<string, object>
        {
            private RadGridViewSettings settings;
 
            private DataContractSerializer serializer = null;
             
            string folderName = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
            string settingsFile;
 
            public RadGridViewApplicationSettings()
            {
                //
            }
 
            public RadGridViewApplicationSettings(RadGridViewSettings settings)
            {
                this.settings = settings;
                settingsFile = Path.Combine(folderName, "Groupcall\\GC Messenger Invoice\\UsageGridSettings.xml");
                List<Type> types = new List<Type>();
                types.Add(typeof(List<ColumnSetting>));
                types.Add(typeof(List<FilterSetting>));
                types.Add(typeof(List<GroupSetting>));
                types.Add(typeof(List<SortSetting>));
                types.Add(typeof(List<PropertySetting>));
                types.Add(typeof(TextBlock));
                types.Add(typeof(System.Windows.Media.MatrixTransform));
 
                this.serializer = new DataContractSerializer(typeof(RadGridViewApplicationSettings), types);
            }
 
            public string PersistID
            {
                get
                {
                    if (!ContainsKey("PersistID") && settings.grid != null)
                    {
                        this["PersistID"] = settings.grid.Name;
                    }
 
                    return (string)this["PersistID"];
                }
            }
 
            public int FrozenColumnCount
            {
                get
                {
                    if (!ContainsKey("FrozenColumnCount"))
                    {
                        this["FrozenColumnCount"] = 0;
                    }
 
                    return (int)this["FrozenColumnCount"];
                }
                set
                {
                    this["FrozenColumnCount"] = value;
                }
            }
 
            public List<ColumnSetting> ColumnSettings
            {
                get
                {
                    if (!ContainsKey("ColumnSettings"))
                    {
                        this["ColumnSettings"] = new List<ColumnSetting>();
                    }
 
                    return (List<ColumnSetting>)this["ColumnSettings"];
                }
            }
 
            public List<SortSetting> SortSettings
            {
                get
                {
                    if (!ContainsKey("SortSettings"))
                    {
                        this["SortSettings"] = new List<SortSetting>();
                    }
 
                    return (List<SortSetting>)this["SortSettings"];
                }
            }
 
            public List<GroupSetting> GroupSettings
            {
                get
                {
                    if (!ContainsKey("GroupSettings"))
                    {
                        this["GroupSettings"] = new List<GroupSetting>();
                    }
 
                    return (List<GroupSetting>)this["GroupSettings"];
                }
            }
 
            public List<FilterSetting> FilterSettings
            {
                get
                {
                    if (!ContainsKey("FilterSettings"))
                    {
                        this["FilterSettings"] = new List<FilterSetting>();
                    }
 
                    return (List<FilterSetting>)this["FilterSettings"];
                }
            }
 
            public void Reload()
            {
                try
                {
                    //using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
                    using (IsolatedStorageFile file=IsolatedStorageFile.GetUserStoreForAssembly())
                    {
                        using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(PersistID, FileMode.Open, file))
                        //using (FileStream stream=new FileStream(settingsFile,FileMode.Open))
                        {
                            if (stream.Length > 0)
                            {
                                RadGridViewApplicationSettings loaded = (RadGridViewApplicationSettings)serializer.ReadObject(stream);
 
                                FrozenColumnCount = loaded.FrozenColumnCount;
 
                                ColumnSettings.Clear();
                                foreach (ColumnSetting cs in loaded.ColumnSettings)
                                {
                                    ColumnSettings.Add(cs);
                                }
 
                                FilterSettings.Clear();
                                foreach (FilterSetting fs in loaded.FilterSettings)
                                {
                                    FilterSettings.Add(fs);
                                }
 
                                GroupSettings.Clear();
                                foreach (GroupSetting gs in loaded.GroupSettings)
                                {
                                    GroupSettings.Add(gs);
                                }
 
                                SortSettings.Clear();
                                foreach (SortSetting ss in loaded.SortSettings)
                                {
                                    SortSettings.Add(ss);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    //MessageBox.Show(ex.Message);
                }
            }
 
            public void Reset()
            {
                try
                {
                    //using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
                    using (IsolatedStorageFile file=IsolatedStorageFile.GetUserStoreForAssembly())
                    {
                        file.DeleteFile(PersistID);
                        //File.Delete(settingsFile);
                    }
                }
                catch
                {
                    //
                }
            }
            public void Save()
            {
                try
                {
                    //using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
                    using (IsolatedStorageFile file=IsolatedStorageFile.GetUserStoreForAssembly())
                    {
                        using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(PersistID, FileMode.Create, file))
                        //using (FileStream stream=new FileStream(settingsFile, FileMode.Create))
                        {
                            serializer.WriteObject(stream, this);
                        }
                    }
                }
                catch (Exception ex)
                {
                    //
                    MessageBox.Show(ex.Message);
                }
            }
        }
 
        private RadGridView grid = null;
 
        public RadGridViewSettings(RadGridView grid)
        {
            this.grid = grid;
        }
 
        public static readonly DependencyProperty IsEnabledProperty
           = DependencyProperty.RegisterAttached("IsEnabled", typeof(bool), typeof(RadGridViewSettings),
                new PropertyMetadata(new PropertyChangedCallback(OnIsEnabledPropertyChanged)));
 
        public static bool GetIsEnabled(DependencyObject dependencyObject)
        {
            return (bool)dependencyObject.GetValue(IsEnabledProperty);
        }
 
        public static void SetIsEnabled(DependencyObject dependencyObject, bool enabled)
        {
            dependencyObject.SetValue(IsEnabledProperty, enabled);
        }
 
        private static void OnIsEnabledPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
        {
            RadGridView grid = dependencyObject as RadGridView;
            if (grid != null)
            {
                if ((bool)e.NewValue)
                {
                    RadGridViewSettings settings = new RadGridViewSettings(grid);
                    settings.Attach();
                }
            }
        }
 
        public virtual void LoadState()
        {
            try
            {
                Settings.Reload();
            }
            catch
            {
                Settings.Reset();
            }
 
            if (this.grid != null)
            {
                grid.FrozenColumnCount = Settings.FrozenColumnCount;
 
                if (Settings.ColumnSettings.Count > 0)
                {
                    foreach (ColumnSetting setting in Settings.ColumnSettings)
                    {
                        ColumnSetting currentSetting = setting;
 
                        GridViewDataColumn column = (from c in grid.Columns.OfType<GridViewDataColumn>()
                                                     where c.UniqueName == currentSetting.UniqueName
                                                     select c).FirstOrDefault();
 
                        if (column != null)
                        {
                            if (currentSetting.DisplayIndex != null)
                            {
                                column.DisplayIndex = currentSetting.DisplayIndex.Value;
                            }
 
                            if (setting.Width != null)
                            {
                                column.Width = new GridViewLength(setting.Width.Value);
                            }
                        }
                    }
                }
                using (grid.DeferRefresh())
                {
                    if (Settings.SortSettings.Count > 0)
                    {
                        grid.SortDescriptors.Clear();
 
                        foreach (SortSetting setting in Settings.SortSettings)
                        {
                            ColumnSortDescriptor d = new ColumnSortDescriptor();
                            d.Column = (from c in grid.Columns.OfType<GridViewBoundColumnBase>()
                                        where c.GetDataMemberName() == setting.PropertyName
                                        select c).FirstOrDefault();
                            d.SortDirection = setting.SortDirection;
 
                            grid.SortDescriptors.Add(d);
                        }
                    }
 
                    if (Settings.GroupSettings.Count > 0)
                    {
                        grid.GroupDescriptors.Clear();
 
                        foreach (GroupSetting setting in Settings.GroupSettings)
                        {
                            ColumnGroupDescriptor d = new ColumnGroupDescriptor();
                            d.Column = (from c in grid.Columns.OfType<GridViewBoundColumnBase>()
                                        where c.GetDataMemberName() == setting.PropertyName
                                        select c).FirstOrDefault();
                            d.SortDirection = setting.SortDirection;
 
                            grid.GroupDescriptors.Add(d);
                        }
                    }
 
                    if (Settings.FilterSettings.Count > 0)
                    {
                        foreach (FilterSetting setting in Settings.FilterSettings)
                        {
                            FilterSetting currentSetting = setting;
 
                            GridViewDataColumn matchingColumn =
                            (from column in grid.Columns.OfType<GridViewDataColumn>()
                             where column.DataMemberBinding.Path.Path == currentSetting.PropertyName
                             select column).FirstOrDefault();
 
                            if (matchingColumn != null)
                            {
                                ColumnFilterDescriptor cfd = new ColumnFilterDescriptor(matchingColumn);
 
                                if (setting.Filter1 != null)
                                {
                                    cfd.FieldFilter.Filter1.Member = setting.Filter1.Member;
                                    cfd.FieldFilter.Filter1.Operator = setting.Filter1.Operator;
                                    cfd.FieldFilter.Filter1.Value = setting.Filter1.Value;
                                }
 
                                if (setting.Filter2 != null)
                                {
                                    cfd.FieldFilter.Filter2.Member = setting.Filter2.Member;
                                    cfd.FieldFilter.Filter2.Operator = setting.Filter2.Operator;
                                    cfd.FieldFilter.Filter2.Value = setting.Filter2.Value;
                                }
 
                                foreach (FilterDescriptorSetting fds in setting.SelectedDistinctValues)
                                {
                                    Telerik.Windows.Data.FilterDescriptor fd = new Telerik.Windows.Data.FilterDescriptor();
                                    fd.Member = fds.Member;
                                    fd.Operator = fds.Operator;
                                    fd.Value = fds.Value;
                                    cfd.DistinctFilter.FilterDescriptors.Add(fd);
                                }
 
                                this.grid.FilterDescriptors.Add(cfd);
                            }
                        }
                    }
                }
            }
        }
 
        public virtual void ResetState()
        {
            Settings.Reset();
        }
 
        public virtual void SaveState()
        {
            Settings.Reset();
 
            if (grid != null)
            {
                if (grid.Columns != null)
                {
                    Settings.ColumnSettings.Clear();
 
                    foreach (Telerik.Windows.Controls.GridViewColumn column in grid.Columns)
                    {
                        if (column is GridViewDataColumn)
                        {
                            GridViewDataColumn dataColumn = (GridViewDataColumn)column;
 
                            ColumnSetting setting = new ColumnSetting();
                            setting.PropertyName = dataColumn.DataMemberBinding.Path.Path;
                            setting.UniqueName = dataColumn.UniqueName;
                            setting.Header = dataColumn.Header;
                            setting.Width = dataColumn.ActualWidth;
                            setting.DisplayIndex = dataColumn.DisplayIndex;
 
                            Settings.ColumnSettings.Add(setting);
                        }
                    }
                }
 
                if (grid.FilterDescriptors != null)
                {
                    Settings.FilterSettings.Clear();
 
                    foreach (IColumnFilterDescriptor cfd in grid.FilterDescriptors.OfType<IColumnFilterDescriptor>())
                    {
                        FilterSetting setting = new FilterSetting();
 
                        if (cfd.FieldFilter.Filter1.Value != Telerik.Windows.Data.FilterDescriptor.UnsetValue)
                        {
                            setting.Filter1 = new Telerik.Windows.Data.FilterDescriptor();
                            setting.Filter1.Member = cfd.FieldFilter.Filter1.Member;
                            setting.Filter1.Operator = cfd.FieldFilter.Filter1.Operator;
                            setting.Filter1.Value = cfd.FieldFilter.Filter1.Value;
                            setting.Filter1.MemberType = null;
                        }
 
                        if (cfd.FieldFilter.Filter2.Value != Telerik.Windows.Data.FilterDescriptor.UnsetValue)
                        {
                            setting.Filter2 = new Telerik.Windows.Data.FilterDescriptor();
                            setting.Filter2.Member = cfd.FieldFilter.Filter2.Member;
                            setting.Filter2.Operator = cfd.FieldFilter.Filter2.Operator;
                            setting.Filter2.Value = cfd.FieldFilter.Filter2.Value;
                            setting.Filter2.MemberType = null;
                        }
 
                        foreach (Telerik.Windows.Data.FilterDescriptor fd in cfd.DistinctFilter.FilterDescriptors.OfType<Telerik.Windows.Data.FilterDescriptor>())
                        {
                            if (fd.Value == Telerik.Windows.Data.FilterDescriptor.UnsetValue)
                            {
                                continue;
                            }
 
                            FilterDescriptorSetting fds = new FilterDescriptorSetting();
                            fds.Member = fd.Member;
                            fds.Operator = fd.Operator;
                            fds.Value = fd.Value;
                            setting.SelectedDistinctValues.Add(fds);
                        }
 
                        setting.PropertyName = cfd.Column.DataMemberBinding.Path.Path;
 
                        Settings.FilterSettings.Add(setting);
                    }
                }
 
                if (grid.SortDescriptors != null)
                {
                    Settings.SortSettings.Clear();
 
                    foreach (ColumnSortDescriptor d in grid.SortDescriptors.OfType<ColumnSortDescriptor>())
                    {
                        SortSetting setting = new SortSetting();
 
                        setting.PropertyName = ((GridViewDataColumn)d.Column).GetDataMemberName();
                        setting.SortDirection = d.SortDirection;
 
                        Settings.SortSettings.Add(setting);
                    }
                }
 
                if (grid.GroupDescriptors != null)
                {
                    Settings.GroupSettings.Clear();
 
                    foreach (ColumnGroupDescriptor d in grid.GroupDescriptors.OfType<ColumnGroupDescriptor>())
                    {
                        GroupSetting setting = new GroupSetting();
 
                        setting.PropertyName = ((GridViewDataColumn)d.Column).GetDataMemberName();
                        setting.SortDirection = d.SortDirection;
 
                        Settings.GroupSettings.Add(setting);
                    }
                }
 
                Settings.FrozenColumnCount = grid.FrozenColumnCount;
            }
 
            Settings.Save();
        }
 
        private void Attach()
        {
            if (this.grid != null)
            {
                this.grid.LayoutUpdated += new EventHandler(LayoutUpdated);
                this.grid.Loaded += Loaded;
                Application.Current.Exit += Current_Exit;
            }
        }
 
        void Current_Exit(object sender, EventArgs e)
        {
            SaveState();
        }
 
        void Loaded(object sender, EventArgs e)
        {
            LoadState();
        }
 
        void LayoutUpdated(object sender, EventArgs e)
        {
            if (grid.Parent == null)
            {
                SaveState();
            }
        }
 
        private RadGridViewApplicationSettings gridViewApplicationSettings = null;
 
        protected virtual RadGridViewApplicationSettings CreateRadGridViewApplicationSettingsInstance()
        {
            return new RadGridViewApplicationSettings(this);
        }
 
        protected RadGridViewApplicationSettings Settings
        {
            get
            {
                if (gridViewApplicationSettings == null)
                {
                    gridViewApplicationSettings = CreateRadGridViewApplicationSettingsInstance();
                }
                return gridViewApplicationSettings;
            }
        }
    }
 
    public class PropertySetting
    {
        string _PropertyName;
        public string PropertyName
        {
            get
            {
                return _PropertyName;
            }
            set
            {
                _PropertyName = value;
            }
        }
    }
 
    public class SortSetting : PropertySetting
    {
        ListSortDirection _SortDirection;
        public ListSortDirection SortDirection
        {
            get
            {
                return _SortDirection;
            }
            set
            {
                _SortDirection = value;
            }
        }
    }
 
    public class GroupSetting : PropertySetting
    {
        ListSortDirection? _SortDirection;
        public ListSortDirection? SortDirection
        {
            get
            {
                return _SortDirection;
            }
            set
            {
                _SortDirection = value;
            }
        }
    }
 
    public class FilterSetting : PropertySetting
    {
        List<FilterDescriptorSetting> _SelectedDistinctValues;
        public List<FilterDescriptorSetting> SelectedDistinctValues
        {
            get
            {
                if (_SelectedDistinctValues == null)
                {
                    _SelectedDistinctValues = new List<FilterDescriptorSetting>();
                }
                return _SelectedDistinctValues;
            }
        }
 
        Telerik.Windows.Data.FilterDescriptor _Filter1;
        public Telerik.Windows.Data.FilterDescriptor Filter1
        {
            get
            {
                return _Filter1;
            }
            set
            {
                _Filter1 = value;
            }
        }
 
        Telerik.Windows.Data.FilterDescriptor _Filter2;
        public Telerik.Windows.Data.FilterDescriptor Filter2
        {
            get
            {
                return _Filter2;
            }
            set
            {
                _Filter2 = value;
            }
        }
    }
 
    public class FilterDescriptorSetting
    {
        string _Member;
        public string Member
        {
            get
            {
                return _Member;
            }
            set
            {
                _Member = value;
            }
        }
 
        Telerik.Windows.Data.FilterOperator _Operator;
        public Telerik.Windows.Data.FilterOperator Operator
        {
            get
            {
                return _Operator;
            }
            set
            {
                _Operator = value;
            }
        }
 
        object _Value;
        public object Value
        {
            get
            {
                return _Value;
            }
            set
            {
                _Value = value;
            }
        }
 
        bool _IsCaseSensitive;
        public bool IsCaseSensitive
        {
            get
            {
                return _IsCaseSensitive;
            }
            set
            {
                _IsCaseSensitive = value;
            }
        }
    }
 
    public class ColumnSetting : PropertySetting
    {
        string _UniqueName;
        public string UniqueName
        {
            get
            {
                return _UniqueName;
            }
            set
            {
                _UniqueName = value;
            }
        }
 
        object _Header;
        public object Header
        {
            get
            {
                return _Header;
            }
            set
            {
                _Header = value;
            }
        }
 
        double? _Width;
        public double? Width
        {
            get
            {
                return _Width;
            }
            set
            {
                _Width = value;
            }
        }
 
        int? _DisplayIndex;
        public int? DisplayIndex
        {
            get
            {
                return _DisplayIndex;
            }
            set
            {
                _DisplayIndex = value;
            }
        }
    }
}
GridView
Apoorva
Top achievements
Rank 1
 asked on 26 Sep 2011
2 answers
173 views
Required ReadOnly Treeview with CheckBox
Is there any way to display Rad TreeView with ItemsOptionListType as CheckList and that particular TreeView should be a Read only kind of...???


Simply my requirement is to display Read only TreeView with checkbox's (not with Disabled mode)



TreeView
Balaji
Top achievements
Rank 1
 answered on 26 Sep 2011
1 answer
108 views
Persisting TileView Items
I would like to persist the state and position of my Tileview to Isolated Storage, but am not sure of the best approach for this?

Can you steer me in the right direction?

Many Thanks

Greg
PersistenceFramework
Alex Fidanov
Telerik team
 answered on 26 Sep 2011
1 answer
167 views
On setting gridview.SelectedItem programmatically its not resetting it to correct view
Hi,

I have a WPF radgridview, on a particular event (say button click) I want to change the selection on the grid to a different row based on some parameters. The grid is bound to a datatableview. I am setting it as

grid.SelectedItem = ((

 

DataView)grid.ItemsSource).Table.Rows[count];

 

 

grid.CurrentItem = ((

 

DataView)grid.ItemsSource).Table.Rows[count];

 

 

grid.BringIndexIntoView(count);


where count is the index of the row I want to select. Can you please tell me how to do it.
GridView
Pavel Pavlov
Telerik team
 answered on 26 Sep 2011
1 answer
157 views
DropQuery and DragQuery events not fired
Good morning
As the title say, RadDragAndDropManager dont fire the DropQuery and DragQuery events.
in XAML:

                dragDrop:RadDragAndDropManager.DropQuery="rTreeListView_DropQuery"
                dragDrop:RadDragAndDropManager.DropInfo="rTreeListView_DropInfo"
                dragDrop:RadDragAndDropManager.DragQuery="rTreeListView_DragQuery"
                dragDrop:RadDragAndDropManager.DragInfo="rTreeListView_DragInfo" 
 
and, in code behind, there is the implementation of events.
Setting a breakpoint into the events, it's never hit.
Need the DropQuery event because, in my application, there are rules that allow or not 
the drop of an element under another element;
and (as i read from help) i would like to set the QueryResult to false, cancelling drop.
The second question is:
I would like to show an icon (like denial of access)  when the DragCueItem is on an item 
on which drop operation is not allowed.
 



DragAndDrop
Dimitrina
Telerik team
 answered on 26 Sep 2011
1 answer
135 views
Issue on remove then add a column
Hi,

Assembly version :2011.2.823.40

I've got a weird issue on telerik radgridview:
i create and destroy columns on view code behind by the code :
myGrid.Columns.RemoveAt(i);
...
myGrid.Columns.Add(NewColumns);

when i rebind my grid, the new column is systematiquely at the place of the removed column but the header is wrong, the new header is at the end of the grid.

is someone had the issue before and know how to resolve that?

thanks by advance
GridView
Vera
Telerik team
 answered on 26 Sep 2011
3 answers
121 views
Programmatically Set HighlightedElement?
Is there any way to get or set the HighlightedElement with the RadComboBox?  The HighlightedElement seems to follow the SelectedItem when there is a SelectedItem, but the highlight does not go away when SelectedItem is null.

Thanks.
ComboBox
Valeri Hristov
Telerik team
 answered on 26 Sep 2011
Narrow your results
Done
Selected tags
Tags
GridView
General Discussions
Chart
RichTextBox
Docking
ScheduleView
ChartView
TreeView
Diagram
Map
ComboBox
TreeListView
Window
RibbonView and RibbonWindow
PropertyGrid
DragAndDrop
TabControl
TileView
Carousel
DataForm
PDFViewer
MaskedInput (Numeric, DateTime, Text, Currency)
AutoCompleteBox
DatePicker
Buttons
ListBox
GanttView
PivotGrid
Spreadsheet
Gauges
NumericUpDown
PanelBar
DateTimePicker
DataFilter
Menu
ContextMenu
TimeLine
Calendar
Installer and Visual Studio Extensions
ImageEditor
BusyIndicator
Expander
Slider
TileList
PersistenceFramework
DataPager
Styling
TimeBar
OutlookBar
TransitionControl
Book
FileDialogs
ToolBar
ColorPicker
TimePicker
SyntaxEditor
MultiColumnComboBox
VirtualGrid
Wizard
ExpressionEditor
NavigationView (Hamburger Menu)
DesktopAlert
WatermarkTextBox
BarCode
SpellChecker
DataServiceDataSource
EntityFrameworkDataSource
RadialMenu
ChartView3D
Data Virtualization
BreadCrumb
ProgressBar
Sparkline
LayoutControl
TabbedWindow
ToolTip
CloudUpload
ColorEditor
TreeMap and PivotMap
EntityFrameworkCoreDataSource (.Net Core)
HeatMap
Chat (Conversational UI)
VirtualizingWrapPanel
Calculator
NotifyIcon
TaskBoard
TimeSpanPicker
BulletGraph
Licensing
WebCam
CardView
DataBar
FilePathPicker
PasswordBox
Rating
SplashScreen
Accessibility
Callout
CollectionNavigator
Localization
AutoSuggestBox
VirtualKeyboard
HighlightTextBlock
Security
TouchManager
StepProgressBar
Badge
OfficeNavigationBar
ExpressionParser
CircularProgressBar
SvgImage
PipsPager
SlideView
AI Coding Assistant
+? more
Top users last month
Rob
Top achievements
Rank 3
Bronze
Iron
Iron
Sergii
Top achievements
Rank 1
Iron
Iron
Dedalus
Top achievements
Rank 1
Iron
Iron
Lan
Top achievements
Rank 1
Iron
Doug
Top achievements
Rank 1
Want to show your ninja superpower to fellow developers?
Learn how
1928 1929
1930
1931 1932
Top users last month
Rob
Top achievements
Rank 3
Bronze
Iron
Iron
Sergii
Top achievements
Rank 1
Iron
Iron
Dedalus
Top achievements
Rank 1
Iron
Iron
Lan
Top achievements
Rank 1
Iron
Doug
Top achievements
Rank 1
Want to show your ninja superpower to fellow developers?
Learn how
Want to show your ninja superpower to fellow developers?
Learn how