Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Channel Catalog


Channel Description:

XAML team's blog

older | 1 | (Page 2)

    0 0

    If you want to filter a column that is data-bound to a custom type, you need to make sure that your custom type meets certain criteria. We will use the type Person as an example.

    public class Person
    {
        private readonly string name;
        private int age;

        public string Name
        {
            get { return this.name; }
        }

        public int Age
        {
            get { return this.age; }
            set { this.age = value; }
        }

        public Person(string name)
        {
            this.name = name;
        }
    }

    Implement IEquatable<T>

    The first thing that you need to do is implement the IEquatable<T> interface. It has a single method called Equals.

    public class Person : IEquatable<Person>
    {
        private readonly string name;
        private int age;

        public string Name
        {
            get { return this.name; }
        }

        public int Age
        {
            get { return this.age; }
            set { this.age = value; }
        }

        public Person(string name)
        {
            this.name = name;
        }

        bool IEquatable<Person>.Equals(Person other)
        {
            if (other == null)
            {
                return false;
            }

            return StringComparer.Ordinal.Equals(this.Name, other.Name);
        }
    }

    Override Object.Equals(Object) and Object.GetHashCode

    Next, you need to override Object.Equals(Object) and Object.GetHashCode. MSDN states that if you implement IEquatable<T>, you should also override the base class implementations of Object.Equals(Object) and Object.GetHashCode so that their behavior is consistent with that of the IEquatable<T>.Equals method. If you do override Object.Equals(Object), your overridden implementation is also called in calls to the static Equals(System.Object, System.Object) method on your class. This ensures that all invocations of the Equals method return consistent results. Furthermore, the GetHashCode method will be used by the framework when the distinct values need to be discovered.

    public override bool Equals(object obj)
    {
        return ((IEquatable<Person>)this).Equals(obj as Person);
    }

    public override int GetHashCode()
    {
        return this.Name.GetHashCode() ^ this.Age.GetHashCode();
    }

    Override ToString

    You need to override the ToString method of your type so that distinct values and grid cells display a friendly representation of your class.

    public override string ToString()
    {
        return this.Name;
    }

    Define a TypeConverter for string conversions

    When RadGridView encounters a custom type it will use a plain TextBox for the field filter editors. The strings that user enters have to be converted to your custom type and vice versa. This can be achieved by specifying a TypeConverter on your class.

    public class PersonConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(string))
            {
                return true;
            }
            
            return base.CanConvertFrom(context, sourceType);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            var stringValue = value as string;
            if (stringValue != null)
            {
                return new Person(stringValue);
            }
            
            return base.ConvertFrom(context, culture, value);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                return true;
            }

            return base.CanConvertTo(context, destinationType);
        }

        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                return ((Person)value).ToString();
            }

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }

    [TypeConverter(typeof(PersonConverter))]
    public class Person : IEquatable<Person>

    If the plain TextBox does not suit your needs, you can provide your own field filter editor by overriding the GridViewColumn.CreateFieldFilterEditor method. You will no longer need a TypeConverter if your custom field filter editor is able to produce instances of your custom type. You only need to data-bind your editor’s significant property to a property called Value residing on its DataContext. The UnsetValue singleton is used for deactivating a filter. Here is what a custom field filter editor may look like:

    public class MyDateTimeColumn : GridViewColumn
    {
        public override FrameworkElement CreateFieldFilterEditor()
        {
            var dateTimePicker = new RadDateTimePicker();
            dateTimePicker.InputMode = InputMode.DatePicker;
            dateTimePicker.IsTooltipEnabled = false;

            var selectedValueBinding = new Binding("Value")
            {
                Mode = BindingMode.TwoWay,
                FallbackValue = null,
                Converter = new DateTimeFilterEditorConverter()
            };
            dateTimePicker.SetBinding(RadDateTimePicker.SelectedValueProperty, selectedValueBinding);

            return dateTimePicker;
        }

        private class DateTimeFilterEditorConverter : IValueConverter
        {
            public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
            {
                if (value == FilterDescriptor.UnsetValue)
                {
                    return null;
                }

                return value;
            }

            public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
            {
                if (value == null)
                {
                    return FilterDescriptor.UnsetValue;
                }

                return value;
            }
        }
    }
    Of course, you don’t need to do that for a DateTime column, since RadGridView does it out-of-the-box. This is just an illustration of how to wire your custom field filter editor.

    Override the Comparison Operators (Optional)

    If you want to see the comparison filter operators (Is Less Than, etc.) you should override your custom type’s comparison operators.

    public static bool operator <(Person left, Person right)
    {
        return left.Age < right.Age;
    }

    public static bool operator <=(Person left, Person right)
    {
        return left.Age <= right.Age;
    }

    public static bool operator >(Person left, Person right)
    {
        return left.Age > right.Age;
    }

    public static bool operator >=(Person left, Person right)
    {
        return left.Age >= right.Age;
    }

    This is all you need to do in order to enable filtering for your custom type.


    0 0

    Or How to Store Semantic Information In Documents Through Custom Annotations

    When we develop RadRichTextBox’s API, we always try to make it as extensible as possible. One of the most popular demands was the option to store “meta” information about parts of the document which is not directly visible by the user.

    The technique that most developers attempted to implement was to extend the document model and use custom document elements (Spans, Paragraphs, etc.). This approach, however, is not quite reliable, because RadDocument controls the lifecycle of all document elements while editing the content in RadRichTextBox and the document structure is only concerned with formatting. For example, when using the features Bold, Italic, fore color, etc., Spans are added and removed, split and merged and the semantic information that they carry can be lost. Moreover, there are no certain rules that can be used to identify when this information should be preserved and when removed when the document element is edited or deleted. The behavior on rich-text copy/paste in terms of duplicating or ignoring the semantics is also undefined. 

    We have addressed the demand for preserving meta-information in the document by implementing custom annotation ranges. They are specifically designed to store such semantic data and are fully customizable in terms of the behavior they take on selection and deletion.

    We have created a demo on how custom annotation ranges can be used to store semantic information in the document. The example, which is available here, shows an editor for a semantically tagged document in the form of a recipe. To best show how that information can be used, we have implemented conversion between the hRecipe microformat and RadDocument with special annotations to mark the position of various hRecipe properties. To achieve this, we have used a combination of features: custom annotations, document protection and a custom format provider.

    The blue regions (custom annotations) in the picture above indicate the areas that the user can edit (implemented using document protection). These parts of the document are then extracted by a custom format provider and exported to HTML.

    Custom Annotations

    There are basically two types of annotations in RadDocument – annotation markers and annotation ranges. The first type can be used by inheriting AnnotationMarkerBase and are meant to be used for single objects such as images. The second type can be used to mark parts of the document. The start and end of the range are marked by inline document elements inheriting from AnnotationRangeStart and AnnotationRangeEnd for the start/end respectively. Whichever you choose, there are some abstract methods that you will have to override, such as CreateNewElementInstance and CopyContentOverride.

    By default all annotations are markup-only in the sense that they do not have any appearance. If you want to display a highlight, range brackets or anything else, you can use the UI layers feature of RadRichTextBox. The demo uses the built-in protection range decoration layer with a custom color.

    Example custom inline range start

    public class SemanticRangeStart : AnnotationRangeStart
    {
        [XamlSerializable]

        public string Name { getset; } 

        public SemanticRangeStart()
        {
        } 

        public SemanticRangeStart(string name)
        {
            this.Name = name;
        } 

        public override bool SkipPositionBefore
        {
            get { return true; }
        } 

        protected override void CopyContentFromOverride(DocumentElement fromElement)
        {
            this.Name = ((SemanticRangeStart)fromElement).Name;
        } 

        protected override DocumentElement CreateNewElementInstance()
        {
            return new SemanticRangeStart();
        }
    }

    Here you can see a class that inherits from AnnotationRangeStart. The overridden methods and properties enable RadRichTextBox to treat the annotation range start as an inline. In order to customize the ranges more finely, you can also have your class derive from FieldRangeStart. In this way, you could specify the behavior when using the cursor to position the caret inside the custom range, deleting the range through backspace or delete, etc. The Name property is serialized in XAML, as seen by the XamlSerializable attribute.

    Implementing annotation range end is analogical.

    Serialization

    Of the default document format providers, custom annotations are supported only in XAML. The other formats do not offer such extensibility. When triggering export XamlFormatProvider will generate prefixes for each custom annotation namespace (custom1, custom2, etc.) which ensures that they can be successfully imported afterwards.

    In order to serialize the appropriate attributes, the following two attributes can be used: XamlSerializable – indicates that the property should be serialized as an inline property, and XamlCompositePropertySerializable – serialized as XAML composite property.

    Custom Format Provider

    The demo uses a custom format provider to export a semantically tagged RadDocuments to an hRecipe-tagged HTML document and vice-versa. The implementation is contained in the HRecipeFormatProvider class. It has two parts:

    • Export: the format provider first extracts the semantic regions from the document. For each part of the hRecipe specification it supports, it looks for SemanticRangeStart/SemanticRangeEnd pairs with the respective names and then creates a respective fragment. Then it proceeds to export these parts to HTML and fill them inside an HTML template prepared for the hRecipe content.
    • Import: the format provider scans the document for nodes tagged as hRecipe properties, imports them using HtmlFormatProvider and then fills in the previously-prepared placeholders.

    Document Protection

    In order to allow the user to edit only the content of the recipe and not the reserved spaces – labels and such, document protection is used. The document is in protected mode and the unprotect button has been removed from the ribbon. By default, when the document is protected, the ranges which the user has permission to edit are yellowish, however, for the purposes of this demo, it has been changed to blue using the EnforcedPermissionRangeBrush.


    0 0

    Programming with the new GanttView control

    As many of you already know with Q1 2012 we introduced a RadGanttView for Silverlight and WPF - a control designed with MVVM-friendly API.

    In this blog post we will set-up a sample project with RadGanttView to get you started.

    First, to add RadGanttView to a new or existing application we need to add references to the following assemblies:

    Telerik.Windows.Controls

    Telerik.Windows.Controls.GanttView

    Telerik.Windows.Scheduling.Core

    Now, let’s add the telerik namespace:

    xmlns:telerik=http://schemas.telerik.com/2008/xaml/presentation

    Аnd add a sample definition of the control:

    <telerik:RadGanttView/>

    Here is a screenshot of what you should see after running the project:

     

    Now, we will create a data source in our ViewModel and bind it to the control: First we will create an observable collection of GanttTask objects

    private IEnumerable <GanttTask> tasks;

    public IEnumerable<GanttTask> Tasks

    {
        get
       
    {
           return tasks;
        }
        set
       
    {
           tasks = value;
           OnPropertyChanged(() => Tasks);
        }
    }

    And populate it in the constructor of the ViewModel:

    var date = DateTime.Now;
    var iterationTask = new GanttTask() { Start = date, End = date.AddDays(2), Title = "1/11/2012 - 1/12/2012 Iteration" };

    var ganttAPI = new GanttTask() { Start = date, End = date.AddHours(16), Title = "Design public API" };

    var ganttDemos = new GanttTask() { Start = date.AddHours(18), End = date.AddDays(1), Title = "Gantt Demos" };
    var ganttRendering = new GanttTask() { Start = date.AddDays(1).AddHours(5), End = date.AddDays(2), Title = "Gantt Rendering" };

    var milestone = new GanttTask() { Start = date.AddDays(2), End = date.AddDays(2).AddHours(1), Title = "Review", IsMilestone = true };

    ganttAPI.SetRelations(new List<Relation>() { new Relation() { Task = ganttDemos } });

    ganttDemos.SetRelations(new List<Relation>() { new Relation() { Task = ganttRendering } });

    iterationTask.SetChildren(new ObservableCollection<GanttTask>() { ganttAPI, ganttDemos, ganttRendering, milestone });

    var gTasks = new ObservableCollection<GanttTask>();

    gTasks.Add(iterationTask);

    this.Tasks = gTasks;

    Now, we will bind the Tasks collection to the TaskSource property of GanttView:

     <telerik:RadGanttView TasksSource="{Binding Tasks}"/>

    And after running the project we will see the image below:

     

    As you can see the last item is not visible in the task panel, because it is outside the VisibleRange. We can change this by configuring the VisibleRange property of Gantt control.

    Configuring the VisibleRange property of Gantt control

    To do this we will add a VisbleRange property in the ViewModel:

    private VisibleRange visibleRange;

    public VisibleRange VisibleRange
    {
        get
       
    {
           return visibleRange;
        }
        set
       
    {
           if (visibleRange != value)
           {
               visibleRange = value;
               OnPropertyChanged(() => VisibleRange);
           }
         }
    }

    Set it in the constructor:

    this.VisibleRange = new VisibleRange(date, date.AddDays(9));

    Аnd bind it in the XAML:

    <telerik:RadGanttView TasksSource="{Binding Tasks}"

                           VisibleRange="{Binding VisibleRange}"/> 

    Now, all items are visible:

     

    Configuring the grid panel

    Now let’s add some more details than Title about the tasks in the grid panel. Let’s add their Start and End fields: To do this we should add columns for every task’s property that we want to display: 

    <telerik:RadGanttView TasksSource="{Binding Tasks}" VisibleRange="{Binding VisibleRange}">

                         <telerik:RadGanttView.Columns>

                               <telerik:ColumnDefinition MemberBinding="{Binding Start}" Header="Start" ColumnWidth="140" />

                               <telerik:ColumnDefinition MemberBinding="{Binding End}" Header="End" ColumnWidth="140" />

                         </telerik:RadGanttView.Columns>

                  </telerik:RadGanttView>

    Result:


     

    Finally let’s allow the editing of Start and End fields by adding a CellEditTemplate. We’d like to use the RadDateTimePicker control, so we will need a reference to Telerik.Windows.Controls.Input.dll assembly as it contains this control.

    <telerik:ColumnDefinition MemberBinding="{Binding Start}" Header="Start" ColumnWidth="140" >

                                      <telerik:ColumnDefinition.CellEditTemplate>

                                             <DataTemplate>

                                                    <telerik:RadDateTimePicker SelectedValue="{Binding Start}" />

                                             </DataTemplate>

                                      </telerik:ColumnDefinition.CellEditTemplate>

                               </telerik:ColumnDefinition>

                               <telerik:ColumnDefinition MemberBinding="{Binding End}" Header="End" ColumnWidth="140">

                                      <telerik:ColumnDefinition.CellEditTemplate>

                                             <DataTemplate>

                                                    <telerik:RadDateTimePicker SelectedValue="{Binding End}" />

                                             </DataTemplate>

                                      </telerik:ColumnDefinition.CellEditTemplate>

                               </telerik:ColumnDefinition>

     

    With this post we setup our first basic project with RadGanttView.

     

    You can download the project here. With next posts we will discover more about how to customize the look and feel of the control, set a theme, configure the TimeRuler and add custom gantt tasks. Meanwhile, you can review our documentation and online demos for more details how to configure the GanttView.

    Stay tuned!


    0 0

    by Miroslav Nedyalkov

    Moving forward to BETA

    After one Q in CTP stage the RadGanttView control is now BETA. This means that most of the core features are already implemented and the rest of the features we are going to add are considered marginal and will not affect its internal architecture neither its API a lot. We reconsidered the public API of the data objects (IGanttTask) and did some changes which we believe will enhance the experience of the control.

    What’s new?

    We developed some core features which add greater interaction to RadGanttView:

    • Drag & drop – the user is now able to drag and resize the tasks and summaries using the mouse. We also enabled comprehensive customization of the drag and resize operations allowing you to specify in great details how they should work in a straightforward way. We’ve added the following properties to the GanttView control:
      • DragDropBehavior – allows you to customize how tasks are moved using the mouse. Using this behavior you may disable dragging of some tasks, disable an area in the timeline in which the tasks cannot be dropped or perform some custom action when a task is dropped (for example you can update its parent like in MSProject)
      • ResizeBehavior – allows you to customize how the tasks are resized using the mouse. With this behavior you can disable resizing of some tasks, or disallow making tasks shorter than a specific duration. You will also be able to perform some custom action like adding some extra duration if the end of the task is dropped over a weekend day
    • Filtering time ruler items – with this feature you will be able to hide some time intervals from the timeline setting the TimeLineFilteringBehavior property. This feature might be useful for hiding non-working time or days from the timeline. The behavior should point the intervals to be shown, and not the ones to be hidden.
    • Highlighting special slots – with this feature you will be able to color parts of the timeline. This could be done for different reasons: to mark the range as disabled, to drive user’s attention to a specific range, to mark the weekend days, to mark intervals containing events which are not actual tasks from the GanttView. This feature can be used by setting the SpecialSlotsGenerator property. The generator should point the intervals to be highlighted.

    Both properties are of type IRangeGenerator so here are some implementations of the interface we included:

    • EmptyRangeGenerator – this generator generates no ranges
    • SingleRangeGenerator – this generator generates a single range coincident with the visible range
    • WeekDaysGenerator – this generator generates ranges using a weekly pattern by a specified start day and count of days. The generated ranges are all part of the visible range.

    We considered these generators to be the most common ones, but we are planning to add even more cool built-in range generators that can be used in more specific scenarios.

    New examples

    To demonstrate the newly created features some examples are available online:

    Demo

    These are the cool features we developed this Q for the GanttView control. I’ve created an example which uses data from our release history for the purpose of a simple demonstration. The data contains past and future items and only the future events are editable. Optionally, you can show a highlight over the past timeslots as an indication that tasks cannot be changed. You will also find configurations for the visibility of the weekend days and state of the timeline -  zoomed-in or out. Click here to see the demo.

    You can download its WPF and Silverlight (shared) source code from here.


    0 0

     After another 4 months of hard working I am pleased to present to you the latest XAML release for Silverlight and WPF Q2 2012. Again, we put a lot of love and effort in our components and the result is 2 brand new controls, one of our existing components “grew” from its Beta to an official version and of course a numerous new features and improvements across all controls.

    Our new RadHeatMap control is in its Beta stage, but I hope you’ll find it as exciting as I do.

    Heat map first look

    Heatmaps are a matrix like controls which use color to encode a value along two axes. They are preferred for their really compact size and ability to visualize trends within cyclical data effectively. They are also extremely potent tools for spotting outliers and trends in your data.

    The other brand new control - RadCollectionNavigator - provides UI for the execution of basic editing and navigation operations over a collection of items. Its internal logic entirely relies on the ICollectionView and IEditableCollectionView’s implementation.

    It will be hard to choose the most important new features across RadControls for Silverlight and RadControls for WPF, but I’ll try to put the accents:

    -         RadRichTextBox now has TrackChanges functionality

    -         Complete UI virtualization for RadPDFViewer

    -         You can now drag and drop tasks in RadGantView

    -         The additions in RadDiagram are so many and so exciting that I’ll just say – Check this blog post

    -         Major performance optimizations in RadTreeLIstView

    -         A brand new built-in filter row in RadGridView

    -         UI virtualization and support for empty values in RadChartView

    I can continue further but you can check all by yourselves the What’s new sections for Silverlight and WPF on Telerik.com. You can download and enjoy the new Q2 2012 official release from Your Account and don’t forget to have a look at the detailed release notes of all improvements and enhancements for Silverlight and WPF.

    I hope you will not be surprised if I tell you that we are preparing a series of new blogs which will cover everything exciting in deeper details, so stay tuned.

     

     


    0 0

    Special thanks to all those that attended today’s webinar.  We hope you enjoyed the unveiling of new controls, features, and improvements.  For a comprehensive review, be sure to check the team blog posts on What’s New For Silverlight & WPF in Q2 and What’s New For Windows Phone in Q2.

    Slide Deck ,  Source Code & Recorded Webinar

    You can get the slide deck to the XAML Webinar here  and the accompanying source code here.  For those that missed the webinar, the recording is here.

    Silverlight and WPF

    Our Q2 XAML Webinar focused on three key elements:

    There are many more enhancements to existing controls so make sure to check them out in the release notes:

    HeatMap is a concise way to envision data by placing a range of data on a color spectrum.  Trends are easy to identify and it outliers are immediately identifiable.  The HeatMap control utilizes immediate mode bitmap-based rendering with our own proprietary hit testing and lay-out algorithms, which allows it to render an incredible amount of visual detail without slowing down and without sacrificing interactivity.

    GanttView brings a host of new features, including Drag and Drop of tasks, summaries and milestones as well as resizing of tasks and summaries with the mouse.  GanttView also now provides filtering of the time ruler items and drawing special slots using the SpecialSlotsGenerator property. 

    Diagram almost has too many features to list.  We covered a great many in detail in the Webinar, including support for MVVM, groups, custom connectors, printing, scroll bars, Bezier connections, adding Rulers, the Toolbox, and a good bit more.

    Windows Phone 7

    We then turned our attention to what’s new for Windows Phone 7.  The big features that we covered were:

    • DataBoundListBox improvements
    • ImageButtons
    • More than 20 new Metro templates

    DataBoundListBox – the key improvements are:  1) Pull-to-Refresh, which allows you to use the mouse to pull down the data and have the data list refresh, and 2) Incredible support for re-ordering the databound listbox with one line of XAML.

    ImageButtons inherit from Button and retain all the functionality of a button, but are represented by one or more images.  Management of View State (e.g., button Pressed) is as simple as assigning an image to the state, and letting Telerik take care of the rest.

    More than 20 New Metro Templates – There are over twenty incredibly useful templates for handling everything from subscription reminders to debugging to adding galleries to your Windows Phone application.  All you have to do is add the template and then personalize the data to your own needs.

    What did you like/not like?

    Telerik XAMLflix for WPF controlsWe are continually trying to improve our webinars.  As many of you know this was the first time we tried them pre-recorded…with live Q&A—thanks, Michael Crump!

    Please take moment to comment below.  Did you find the webinar useful?  What would you have liked to see more of?  Was it easy to follow?  Basically, on a scale of 1-5 (5 being the best), how did you enjoy this webinar?

    Thanks again to all who attended!


    0 0

    It is gone… Merged in Telerik.Windows.Controls.Input.xaml. But you can still extract it, just read on.

    A while back ago we have released the styles for all our controls and themes of the RadControls for Silverlight and WPF suites as ResourceDictionary xaml files containing implicit styles. Currently they could be merged in the App.xaml files of your application and would apply globally. Of course there is more information available in the help sections:

    Some of the benefits are that the styles are no longer hidden in a dll’s resources but rather exposed in your application. And so it is easier to re-style some of the controls or base your styles on the theme’s styles. Working with a .xaml file should be no brainer for any WPF or Silverlight developer and the cost difference between managing a dll reference and a xaml file (in case it is not modified) should be minimal.

    One of the downsides though in the implementation of the implicit styles was that we had to create a xaml file per control assembly. We decided to do so to reduce the overhead of duplication of resources such as Brushes, as well as decreased count of merged dictionaries required in your App.xaml. With the increasing count of our controls some of these xaml files got a little bigger. Should you work with 3000 lines of xaml to edit a control that is small part of it? What if you do not use all controls there and want to remove some of the extra xaml?

    So we get to the problem - “I want my ComboBox.xaml file”

    How do you extract the RadComboBox’s Style from the Telerik.Windows.Control.Input.xaml? You could go there find the Style with TargetType of RadComboBox and copy that in a separate ResourceDictionary. Then you find it has some StaticResource references and copy these resources in the dictionary too. One of the resources was a ControlTemplate that had further StaticResources. Eventually when you do that recursively two or three times you would give up.

    With the XAML being an XML however it is incredibly easy to automate that task.

    The attached tool can do the job. Run the project then click “Open”. Navigate to “C:\Program Files (x86)\Telerik\RadControls for Silverlight Q1 2012 SP1\Themes.Implicit\OfficeSilver\Themes” (note the version and location could vary) and open the “Telerik.Windows.Controls.Input.xaml” file. You should get a screen such as:

    All resources from that file would be listed in the left hand area. You can select some of the resources there and a ResourceDictionary would be generated with the selection to the right. Note you could multi-select holding the Ctrl key, Ctrl + All should work too. Click the drop down stating “Show All” and switch to “Implicit Style”. The list will be filtered. Now Select:

    • Style: {x:Type telerikInput:RadComboBox}
    • Style: {x:Type telerikInput:RadComboBoxItem}

    You will see in the right pane that all selected resources including recursive StaticResources were merged:

    You could either select and copy-paste the resources from the ResourceDictionary, click “Save” to export the file in a new xaml file or append the contents to existing dictionary. “Append To…” will try to merge the left hand selection but it may need to override some resources or rename namespaces. It is not tested, it may have difficulties with markup extensions. So consider checking in or backups before modifying files.

    You just have to “Save” as “ComboBox.xaml” now.


    0 0

    In keeping with one of our favorite traditions, it is a great pleasure to announce the first service pack of Q2 for RadControls for Silverlight and RadControls for WPF. As usual, we are shipping numerous improvements across all the controls.  The most exciting news, however, is that the service pack includes the first public CTP version of RadPivotGrid. Our pivot control is a very powerful tool for slicing and dicing your complex data in a meaningful way.

    Check it out…

    RadPivotGrid

    The PivotGrid CTP version comes with the following features:

    • Pivot UI Layouts:  Compact, Outline, Tabular
    • Tooltips
    • UI Virtualization Quick Styles (Easy color customizations)
    • Configurable positions for totals, subtotals, and grandtotals
    • Parallel asynchronous data processing
    • Built-in grouping by property, numeric ranges, and DateTime (PropertyGroupDescription, DoubleGroupDescription, DateTimeGroupDescription)
    • Support for custom grouping through custom GroupDescriptions classes
    • Built-in Aggregates: Sum, Min, Max, Average, Count, Product, StdDev, StdDevP, Vap, VarP
    • Support for custom aggregates through custom AggregateDescriptions classes
    • Built-in Sorting: Sort by group name or group aggregate value
    • Built-in Filtering: Filter by group name or group aggregate value
    • ColumnWidth and RowHeight properties (autosize by default)
    • Expand/collapse through code and UI

    RadPivotFieldList

    • Assign members as row groups, column groups, or Values
    • Deferred update support
    You can download the new control and everything else that comes in Q2 2012 SP1 from Your Account. Also, don’t forget to have a look at the detailed release notes of all improvements and enhancements for Silverlight and WPF.

    0 0

    I am pleased to present you with the second service pack of Q2 for RadControls for Silverlight and RadControls for WPF. We have put a lot of effort into flawless operability inside Visual Studio 2012 and following its UX guidelines. Of course, we are also shipping numerous improvements across all the controls. 

    You can download Q2 2012 SP2 from Your Account. Don’t forget to have a look at the detailed release notes of all improvements and enhancements for Silverlight and WPF.


    0 0

    Earlier this year we introduced two schemes showing the support life cycle of RadControls for WPF and RadControls for Silverlight. With this blog post we would like to remind you that with the Q3 2012 official release you will no longer receive future updates, new features and installations for WPF 3.5 and Silverlight 4 controls.

     

    Since the WPF 4.0 and Silverlight 5 have been around for quite some time now and the public trends are that they are already widely adopted (what is more .NET 4.5 along with WPF 4.5 are also alive), we truly believe that this step will not cause you hassle. Furthermore, our higher versions offer you more features, improvements and more controls. If you are still wondering, the Q3 2012 official release, expected in a couple of weeks, is the perfect release for upgrading your projects.


    0 0

    I will never get tired (just like our fabulous and restless XAML teams) of announcing new and exciting additions to our WPF and Silverlight suites. We’ve had 4 very dynamic months to prepare our Q3 2012 release and give to you a lot of new features. In a nutshell – we are delivering CodedUI test support for our WPF controls, a new touch-enabled theme named Windows8Touch, VS 2012 operational and UX compatibility, the beta version of our RadPivotGrid, and the official versions of three components – RadGanttView, RadAutoCompleteBox and RadHeatmap. Now, please keep on reading for some more details and a quick peek into a few of these…

    With our Windows8Touch theme we throw the gauntlet to our Windows 8 team to deliver a better look and feel in the new platform than we can in WPF and Silverlight. This is only the first step in providing you the right tools to address the upcoming need of Windows 8-like applications for WPF and Silverlight. Below you can see our grid control “dressed” in Windows 8 Style (formerly Metro).

    And now on to one of the most interesting controls – RadPivotGrid. The team has worked hard to deliver OLAP support – new ADOMD and XMLA data providers, support for named sets, attribute hierarchies, and user-defined hierarchies. Additionally, our PivotFieldList now displays all available dimensions, hierarchies, sets, and measures. Another highly requested feature was tooltips for rows, columns and cells:

    Here’s a quick look at our GanttView and its AdvancedTimeline&TimeRulerCustomizations:

    The new light-weight autocomplete component allows your end users to choose single or multiple items from the suggest-list populated based on their input:

    Q3 2012 is stuffed to the brim with a lot of new features and enhancements. I’ll provide the full release history links later but here are some of the highlights:

    • RadChartView is now empowered with light rendering for large data and annotations

    • RadDiagrams will surprise you with HTML5 export, Visual containers, Gliding connectors, Ruler Smart scaling and Freehand & Polygon drawing tools. These are indeed RadDiagrams:

    • Drag reorder of panes in RadDocking
    • You can enjoy the lightning-fast scrolling of the grouped RadGridView and its Column aligned aggregates
    • Support for encrypted documents and annotations in RadPDFViewer
    • Our Timeline component also presents annotations and Expand/Collapse of groups
    • RadRichTextBox now offers Footnotes, End-notes, Stylesheets, Tables formatting with conditional styles and Bibliographic references and citations
    • RadScheduleView will support from now on hourly and minutely recurrences
    • RadBarcode has a new type PDF417

    Here are the promised links for the detailed release story for WPF and Silverlight. You can learn more on our webinar next Tuesday. Please feel free to try the new Q3 2012 release which you can find under Your Account for download. Once you play with it, your thoughts and comments are welcome.

    Important Notes:

    Thank you for your attention.


    0 0

    I will never get tired (just like our fabulous and restless XAML teams) of announcing new and exciting additions to our WPF and Silverlight suites. We’ve had 4 very dynamic months to prepare our Q3 2012 release and give to you a lot of new features. In a nutshell – we are delivering CodedUI test support for our WPF controls, a new touch-enabled theme named Windows8Touch, VS 2012 operational and UX compatibility, the beta version of our RadPivotGrid, and the official versions of three components – RadGanttView, RadAutoCompleteBox and RadHeatmap. Now, please keep on reading for some more details and a quick peek into a few of these…

    With our Windows8Touch theme we throw the gauntlet to our Windows 8 team to deliver a better look and feel in the new platform than we can in WPF and Silverlight. This is only the first step in providing you the right tools to address the upcoming need of Windows 8-like applications for WPF and Silverlight. It is now possible to touch-enable your existing or future application by simply setting the new theme. Below you can see our grid control “dressed” in Windows 8 Style (formerly Metro).

    And now on to one of the most interesting controls – RadPivotGrid. The team has worked hard to deliver OLAP support – new ADOMD and XMLA data providers, support for named sets, attribute hierarchies, and user-defined hierarchies. Additionally, our PivotFieldList now displays all available dimensions, hierarchies, sets, and measures. Another highly requested feature was tooltips for rows, columns and cells:

    Here’s a quick look at our GanttView and its AdvancedTimeline&TimeRulerCustomizations:

    The new light-weight autocomplete component allows your end users to choose single or multiple items from the suggest-list populated based on their input:

    Q3 2012 is stuffed to the brim with a lot of new features and enhancements. I’ll provide the full release history links later but here are some of the highlights:

    • RadChartView is now empowered with light rendering for large data and annotations

    • RadDiagrams will surprise you with HTML5 export, Visual containers, Gliding connectors, Ruler Smart scaling and Freehand & Polygon drawing tools. These are indeed RadDiagrams:

    • Drag reorder of panes in RadDocking
    • You can enjoy the lightning-fast scrolling of the grouped RadGridView and its Column aligned aggregates
    • Support for encrypted documents and annotations in RadPDFViewer
    • Our Timeline component also presents annotations and Expand/Collapse of groups
    • RadRichTextBox now offers Footnotes, End-notes, Stylesheets, Tables formatting with conditional styles and Bibliographic references and citations
    • RadScheduleView will support from now on hourly and minutely recurrences
    • RadBarcode has a new type PDF417

    Here are the promised links for the detailed release story for WPF and Silverlight. You can learn more on our webinar next Tuesday. Please feel free to try the new Q3 2012 release which you can find under Your Account for download. Once you play with it, your thoughts and comments are welcome.

    Important Notes:


    0 0

    It is only a few days since the 2012 Q3 release of RadControls for Silverlight and WPF and we have something new to show you. Here in Telerik we really appreciate feedback from you, the customer. Following this feedback we revamped our ChartDataSource to include the most desired features and we also significantly improved performance.

    Let’s start with a few words on the ChartDataSource itself. If you are familiar with it you can safely skip this section and move directly to the goodies. The ChartDataSource is a companion control, designed to work together with our new charting solution – the RadChartView. Its primary role is to create a view over large sets of data for easier visualization. We call this sampling. Basically, what it does is it divides your data into sets and applies an aggregate function over them. From these sets the final data points, which are used in the RadChartView, are created. For example, if you have a dataset holding 100 000 items, it will be split into 1000 sets of 100 items and 1 data point will be created for each set using the average of these 100 items. I should note that the number of sets generated can be controlled. Great! What could be better? Well, keep reading.

    I am really excited to tell you that we have revamped the ChartDataSource from the ground up to include the most anticipated features. Now you can have multiple series bound to the same data source. This enables scenarios in which you have 1 large data source and you want to create multiple series from it. So basically you need 1 ChartDataSource per each unique data set. Also we now have support for GenericDataPointBindings. The best way to experience the changes is to show them in action.

    Let’s draw the Down Jones data for the last 70 years – in total 20 610 records. I will use a line series for each of the Open, High, Low and Close values. The data will be provided by a view model via the Data property. Here is the definition of the ChartDataSource:

    <telerik:ChartDataSourceName="dataSource"ItemsSource="{Binding Data}"/>

    Having the data source in place we now have sampling over this large data set. Now let’s give the data to our 4 series:

    <telerik:RadCartesianChartName="chart">
        <telerik:RadCartesianChart.VerticalAxis>
            <telerik:LinearAxis/>
        </telerik:RadCartesianChart.VerticalAxis>
        <telerik:RadCartesianChart.HorizontalAxis>
            <telerik:DateTimeContinuousAxis/>
        </telerik:RadCartesianChart.HorizontalAxis>
        <telerik:LineSeriesItemsSource="{Binding ElementName=dataSource}"/>
        <telerik:LineSeriesItemsSource="{Binding ElementName=dataSource}"/>
        <telerik:LineSeriesItemsSource="{Binding ElementName=dataSource}"/>
        <telerik:LineSeriesItemsSource="{Binding ElementName=dataSource}"/>
    </telerik:RadCartesianChart>

    Now the only thing missing is the description of the data for each series. I have done that in code behind, but nothing new there. Remember that now the ChartDataSource supports both property and generic data point bindings. When they are in place we have everything needed to display our graphic.

    Capture

    The new ChartDataSource is not part of the official Q3 release. You can get it today in our latest internal build. It will be included in the SP1 of Q3 release that is due later this month. The complete source code for the demo, together with the binaries containing the new ChartDataSource can be found below, so feel free to give it a try. Also, don’t forget to tell us what you think.


older | 1 | (Page 2)